feat: add bounded TCS brains and channel continuity

tcs-core/shared-kernels/kernel-runtime.mjs

@@ -0,0 +1,70 @@
+import { readFileSync } from "node:fs";
+import { dirname, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const moduleDir = dirname(fileURLToPath(import.meta.url));
+const repoRoot = resolve(moduleDir, "../..");
+const registryPath = resolve(moduleDir, "kernel-registry.json");
+
+function readJson(path) {
+  return JSON.parse(readFileSync(path, "utf8"));
+}
+
+function resolveRepoPath(relativePath) {
+  const absolute = resolve(repoRoot, relativePath);
+  if (!absolute.startsWith(`${repoRoot}/`)) throw new Error("kernel path escapes repository root");
+  return absolute;
+}
+
+function loadBounded(relativePath, maxBytes) {
+  const absolute = resolveRepoPath(relativePath);
+  const body = readFileSync(absolute);
+  if (body.byteLength > maxBytes) throw new Error(`kernel exceeds byte budget: ${relativePath}`);
+  return { relative_path: relativePath, bytes: body.byteLength, value: JSON.parse(body.toString("utf8")) };
+}
+
+export function loadKernelRegistry() {
+  return readJson(registryPath);
+}
+
+export function canonicalPersonaId(personaId, registry = loadKernelRegistry()) {
+  if (registry.personas[personaId]) return personaId;
+  for (const [canonical, entry] of Object.entries(registry.personas)) {
+    if (entry.aliases?.includes(personaId)) return canonical;
+  }
+  throw new Error(`unregistered persona: ${personaId}`);
+}
+
+export function resolvePersonaChannelRuntime({ personaId, channelId, environmentId } = {}) {
+  if (typeof personaId !== "string" || personaId.length === 0) throw new TypeError("personaId is required");
+  const registry = loadKernelRegistry();
+  const canonical = canonicalPersonaId(personaId, registry);
+  const persona = registry.personas[canonical];
+  const maxBytes = registry.rules.resident_kernel_max_bytes;
+  const systemCore = loadBounded(registry.system_core.path, maxBytes);
+  const selfKernel = loadBounded(persona.self_kernel, maxBytes);
+  const selectedEnvironment = environmentId ?? persona.default_environment ?? null;
+  const environment = selectedEnvironment
+    ? loadBounded(registry.environments[selectedEnvironment].path, maxBytes)
+    : null;
+  const memoryRoot = channelId
+    ? persona.channel_memory_roots?.[channelId]
+    : persona.default_memory_root;
+  if (!memoryRoot) {
+    throw new Error(`no memory root registered for persona ${canonical} in channel ${channelId ?? "<default>"}`);
+  }
+  return {
+    schema: "guanghu.persona-channel-runtime-projection/v1",
+    persona_id: canonical,
+    channel_id: channelId ?? null,
+    load_order: [
+      { kind: "RULE_ORDER_SYSTEM_CORE", ...systemCore },
+      ...(environment ? [{ kind: "CHANNEL_ENVIRONMENT", ...environment }] : []),
+      { kind: "PERSONA_SELF_KERNEL", ...selfKernel },
+      { kind: "HLDP_MEMORY_ROOT", ref: memoryRoot, retrieval_max_paths: registry.rules.memory_retrieval_max_paths },
+    ],
+    self_kernel_path: selfKernel.relative_path,
+    memory_root: memoryRoot,
+    environment_path: environment?.relative_path ?? null,
+  };
+}