@skaile/workspaces 0.8.5

package/dist/chunk-NYJKXVG6.js

@@ -0,0 +1,4166 @@
+import { WorkspacePlugin } from './chunk-MJHLQRJJ.js';
+import { PROTOCOL_VERSION } from './chunk-O5AE4QDX.js';
+import { WebSocketServerTransport } from './chunk-XOSBNBB6.js';
+import { EventNormalizer } from './chunk-CCKGX5AS.js';
+import { classifyClaudeSdkError } from './chunk-EWP5HZBV.js';
+import { createDriver } from './chunk-MBBTBKAS.js';
+import { deployCatalogEntry, undeployCatalogEntry } from './chunk-LV2HPH3C.js';
+import { registerBuiltinConnectorAdapters, registerBuiltinMountDrivers, findMissingPackages, installNpmPackages, MountManager, MountStartupError, ConnectorManager, buildMountPromptSection, buildConnectorPromptSection, buildSdkConnectorTools } from './chunk-3W7Z74ZP.js';
+import { loadMountDeclarations, loadConnectorDeclarations, PreMintedSecretProvider, InMemorySecretProvider } from './chunk-Q5URN24L.js';
+import { renderStimulusPrompt, buildOrchestratorPrompt } from './chunk-GZWJGNNN.js';
+import { resolveSettings, resolveApiKey, providerEnvKey } from './chunk-65CYXYUW.js';
+import { resolveRuntimeAssets } from './chunk-XEGHWFAX.js';
+import { loadMcpServerDeclarations, resolveSkWorkspaceConfig, resolveAgentDir, validateAssetRecipeAttr, COMPACTION_DEFAULTS } from './chunk-CSUBFKAN.js';
+import { getLogStore, resolveLogStoreConfig, createLogStoreFromConfig, OnLogBridgeSink, WsLogSink, registerLogStore, resetLogStore, createLogger } from './chunk-V37HONL7.js';
+import { __require } from './chunk-NSBPE2FW.js';
+import pc from 'picocolors';
+import { Marked } from 'marked';
+import { markedTerminal } from 'marked-terminal';
+import { readdirSync, existsSync, readFileSync, unlinkSync, writeFileSync, statSync, mkdirSync, watch, openSync, readSync, closeSync } from 'fs';
+import path4, { join, resolve, basename, dirname, relative } from 'path';
+import { homedir } from 'os';
+import * as z4 from 'zod';
+import { z } from 'zod';
+import { zodToJsonSchema } from 'zod-to-json-schema';
+import fs4, { mkdir, writeFile, rename } from 'fs/promises';
+import { createHash, randomUUID } from 'crypto';
+import { execFile, spawnSync } from 'child_process';
+import { promisify } from 'util';
+import { parse } from 'yaml';
+import mime from 'mime';
+
+// runner/src/logging-bootstrap.ts
+var PreInitRingSink = class {
+  ring = [];
+  cap;
+  constructor(cap = 200) {
+    this.cap = cap;
+  }
+  write(entry) {
+    process.stdout.write(formatForStdout(entry));
+    this.ring.push(entry);
+    if (this.ring.length > this.cap) this.ring.shift();
+  }
+  writeBatch(entries) {
+    for (const entry of entries) this.write(entry);
+  }
+  /** Optional query (no-op) — satisfies the LogSink contract. */
+  query(_q) {
+    return { entries: this.ring.slice() };
+  }
+  /** Close hook — clears the ring so subsequent writes are dropped. */
+  close() {
+    this.ring.length = 0;
+  }
+  /** Number of entries currently buffered (capped at {@link cap}). */
+  size() {
+    return this.ring.length;
+  }
+  /** Snapshot of the currently-buffered entries. Used for diagnostics. */
+  entries() {
+    return this.ring.slice();
+  }
+  /** Discard all buffered entries. Called by `bootstrapRunnerLogStore`. */
+  clear() {
+    this.ring.length = 0;
+  }
+};
+function formatForStdout(entry) {
+  const ts = entry.timestamp ?? (/* @__PURE__ */ new Date()).toISOString();
+  const where = [entry.source?.kind, entry.source?.subkind, entry.source?.instance].filter(Boolean).join(":");
+  const dataStr = entry.data ? ` ${JSON.stringify(entry.data)}` : "";
+  return `[${ts}] [${entry.level}] [${where}] ${entry.message}${dataStr}
+`;
+}
+var activePreInitSink = null;
+function installPreInitRingSink(cap = 200) {
+  if (activePreInitSink) return activePreInitSink;
+  activePreInitSink = new PreInitRingSink(cap);
+  return activePreInitSink;
+}
+function getPreInitRingSink() {
+  return activePreInitSink;
+}
+function clearPreInitRingSink() {
+  activePreInitSink = null;
+}
+var currentSessionId = null;
+function bootstrapRunnerLogStore(opts) {
+  const existing = getLogStore();
+  if (existing && currentSessionId === opts.sessionId) {
+    return { store: existing, dispose: () => disposeStore(existing) };
+  }
+  const cfg = resolveLogStoreConfig({
+    sessionId: opts.sessionId,
+    workspacePath: opts.projectDir,
+    // The skaile.yaml `logging:` block is loosely typed at the workspace-config
+    // layer; the resolver validates `mode` / `level` strings at runtime.
+    yamlBlock: opts.yamlBlock
+  });
+  const store = createLogStoreFromConfig(cfg);
+  if (opts.onLog) {
+    store.addSink(new OnLogBridgeSink(opts.onLog));
+  }
+  if (opts.transportSend) {
+    store.addSink(new WsLogSink({ send: opts.transportSend }));
+  }
+  if (existing) disposeStore(existing);
+  registerLogStore(store);
+  currentSessionId = opts.sessionId;
+  const preInit = getPreInitRingSink();
+  if (preInit) preInit.clear();
+  return {
+    store,
+    dispose: () => {
+      disposeStore(store);
+      currentSessionId = null;
+    }
+  };
+}
+function resetRunnerLogStore() {
+  const s = getLogStore();
+  if (s) disposeStore(s);
+  resetLogStore();
+  currentSessionId = null;
+}
+function disposeStore(store) {
+  try {
+    store.flush();
+    store.close();
+  } catch {
+  }
+}
+var marked = new Marked(markedTerminal());
+var MarkdownStreamer = class {
+  buffer = "";
+  committedSource = "";
+  // biome-ignore lint/correctness/noUnusedPrivateClassMembers: write-only accumulator kept for future diff-based rendering
+  committedRender = "";
+  output;
+  constructor(output = process.stdout) {
+    this.output = output;
+  }
+  write(chunk) {
+    this.buffer += chunk;
+    this.flush();
+  }
+  /** Render any remaining content and reset state. */
+  end() {
+    if (this.buffer.length > this.committedSource.length) {
+      const tail = this.buffer.slice(this.committedSource.length);
+      if (tail.trim()) {
+        const rendered = this.render(tail);
+        this.output.write(rendered);
+      }
+    }
+    this.buffer = "";
+    this.committedRender = "";
+    this.committedSource = "";
+  }
+  flush() {
+    const uncommitted = this.buffer.slice(this.committedSource.length);
+    const boundary = uncommitted.lastIndexOf("\n\n");
+    if (boundary === -1) return;
+    const complete = uncommitted.slice(0, boundary + 2);
+    const rendered = this.render(complete);
+    this.output.write(rendered);
+    this.committedSource += complete;
+    this.committedRender += rendered;
+  }
+  render(src) {
+    try {
+      const result = marked.parse(src);
+      if (typeof result === "string") return result;
+      return String(result);
+    } catch {
+      return src;
+    }
+  }
+};
+
+// runner/src/context.ts
+var PLATFORM_DESCRIPTIONS = {
+  skaile: "You are an AI assistant operating within the Skaile platform, an enterprise AI workspace. Users interact with you through a chat interface in their browser."
+};
+function buildContextSection(context) {
+  if (!context) return void 0;
+  const hasAny = context.platform !== void 0 || context.multi_user !== void 0 || context.session_model !== void 0;
+  if (!hasAny) return void 0;
+  const lines = ["## Platform", ""];
+  if (context.platform) {
+    const description = PLATFORM_DESCRIPTIONS[context.platform];
+    if (description) {
+      lines.push(description);
+    } else {
+      lines.push(`You are running inside the ${context.platform} platform.`);
+    }
+    lines.push("");
+  }
+  if (context.multi_user === true) {
+    lines.push(
+      "Multiple users may participate in the same session. Be aware that messages in this conversation may come from different users."
+    );
+    lines.push("");
+  } else if (context.multi_user === false) {
+    lines.push("This is a single-user session.");
+    lines.push("");
+  }
+  if (context.session_model === "persistent") {
+    lines.push(
+      "Your work persists across interactions. Files you create or modify in the workspace are saved and available in future sessions."
+    );
+    lines.push("");
+  } else if (context.session_model === "ephemeral") {
+    lines.push(
+      "This session is ephemeral. Work you do does not persist beyond the current interaction."
+    );
+    lines.push("");
+  }
+  while (lines.length > 0 && lines[lines.length - 1] === "") lines.pop();
+  return lines.join("\n");
+}
+function defineCapability(args) {
+  const inputSchema = zodToJsonSchema(args.input, { $refStrategy: "none" });
+  const outputSchema = args.output ? zodToJsonSchema(args.output, { $refStrategy: "none" }) : void 0;
+  return {
+    name: args.name,
+    displayName: args.displayName,
+    description: args.description,
+    inputSchema,
+    outputSchema,
+    side: args.side,
+    origin: args.origin,
+    scope: args.scope,
+    fireAndForget: args.fireAndForget,
+    requiresApproval: args.requiresApproval,
+    kind: args.kind,
+    userInvokable: args.userInvokable,
+    audience: args.audience,
+    promptFragment: args.promptFragment,
+    render: args.render,
+    inputZod: args.input,
+    outputZod: args.output,
+    handler: args.handler
+  };
+}
+async function resolveMixin(ref, defaultKind, agentDir, repos) {
+  if (ref.startsWith(".") || ref.startsWith("/")) {
+    const absPath = ref.startsWith("/") ? ref : path4.join(agentDir, ref);
+    if (defaultKind === "knowledge") {
+      return loadKnowledgeDir(absPath);
+    }
+    const content = await readFileSafe(absPath);
+    if (!content) return null;
+    return { content: stripFrontmatter(content).trim(), source: absPath };
+  }
+  const { kind, name, repoQualifier } = parseRef(ref, defaultKind);
+  const entry = findInRepos(repos, kind, name, repoQualifier);
+  if (!entry) return null;
+  if (entry.kind === "knowledge") {
+    return loadKnowledgeDir(path4.dirname(entry.source));
+  }
+  const raw = await readFileSafe(entry.source);
+  if (!raw) return null;
+  return { content: stripFrontmatter(raw).trim(), source: entry.source };
+}
+async function resolveAgentMixins(manifest, agentDir, repos) {
+  const resolve3 = (refs, kind) => Promise.all((refs ?? []).map((r) => resolveMixin(r, kind, agentDir, repos)));
+  const [personaResults, rulesResults, knowledgeResults] = await Promise.all([
+    resolve3(manifest.persona, "persona"),
+    resolve3(manifest.rules, "ruleset"),
+    resolve3(manifest.knowledge, "knowledge")
+  ]);
+  return {
+    personas: personaResults.filter((r) => r !== null),
+    rules: rulesResults.filter((r) => r !== null),
+    knowledge: knowledgeResults.filter((r) => r !== null)
+  };
+}
+async function readFileSafe(filePath) {
+  try {
+    return await fs4.readFile(filePath, "utf-8");
+  } catch {
+    return "";
+  }
+}
+function stripFrontmatter(text) {
+  return text.replace(/^---\s*\n[\s\S]*?\n---\s*\n?/, "");
+}
+function parseRef(ref, defaultKind) {
+  let rest = ref.trim();
+  let kind = defaultKind;
+  const colonIdx = rest.indexOf(":");
+  if (colonIdx !== -1) {
+    kind = rest.slice(0, colonIdx).trim();
+    rest = rest.slice(colonIdx + 1).trim();
+  }
+  const hashIdx = rest.indexOf("#");
+  if (hashIdx !== -1) rest = rest.slice(0, hashIdx).trim();
+  let repoQualifier;
+  const atIdx = rest.indexOf("@");
+  if (atIdx !== -1) {
+    repoQualifier = rest.slice(atIdx + 1).trim() || void 0;
+    rest = rest.slice(0, atIdx).trim();
+  }
+  return { kind, name: rest, repoQualifier };
+}
+function findInRepos(repos, kind, name, repoQualifier) {
+  const searchRepos = repoQualifier ? repos[repoQualifier] ? [repos[repoQualifier]] : [] : Object.values(repos);
+  for (const entries of searchRepos) {
+    const found = entries.find((e) => e.kind === kind && e.name === name);
+    if (found) return found;
+  }
+  return void 0;
+}
+async function loadKnowledgeDir(dir) {
+  let entries;
+  try {
+    entries = readdirSync(dir).filter((e) => e.endsWith(".md"));
+  } catch {
+    return null;
+  }
+  const priorityMap = {};
+  const indexContent = await readFileSafe(path4.join(dir, "index.yaml"));
+  if (indexContent) {
+    const pathMatches = [...indexContent.matchAll(/path:\s*(\S+)/g)];
+    const priorityMatches = [...indexContent.matchAll(/priority:\s*(\d+)/g)];
+    pathMatches.forEach((m, i) => {
+      const filename = m[1];
+      if (!filename) return;
+      const priority = priorityMatches[i] ? parseInt(priorityMatches[i][1] ?? "99", 10) : 99;
+      priorityMap[filename] = priority;
+    });
+  }
+  const docs = await Promise.all(
+    entries.map(async (filename) => ({
+      filename,
+      priority: priorityMap[filename] ?? 99,
+      content: (await readFileSafe(path4.join(dir, filename))).trim()
+    }))
+  );
+  const sorted = docs.filter((d) => d.content).sort((a, b) => a.priority - b.priority || a.filename.localeCompare(b.filename));
+  if (sorted.length === 0) return null;
+  return {
+    content: sorted.map((d) => d.content).join("\n\n---\n\n"),
+    source: dir
+  };
+}
+
+// runner/src/composition/types.ts
+var KIND_BINDING_DEFAULTS = {
+  soul: "inline-snapshot",
+  persona: "inline-snapshot",
+  ruleset: "inline-live",
+  skill: "discoverable",
+  knowledge: "discoverable",
+  connector: "discoverable",
+  mount: "discoverable",
+  prompt: "inline-live",
+  flow: "discoverable",
+  "mcp-server": "discoverable",
+  contract: "inline-live"
+};
+function resolveBinding(item) {
+  if (item.binding) return item.binding;
+  return KIND_BINDING_DEFAULTS[item.kind] ?? "discoverable";
+}
+
+// runner/src/composition/compile.ts
+var COMPILE_MANIFEST_FILENAME = "compile_manifest.json";
+async function compileComposition(opts) {
+  const { agentDir, items, loadContent, resolveVersion } = opts;
+  const manifestPath = path4.join(agentDir, COMPILE_MANIFEST_FILENAME);
+  const warnings = [];
+  const existing = await loadCompileManifest(manifestPath);
+  const nextVersion = (existing?.prompt_version ?? 0) + 1;
+  const entries = [];
+  for (const item of items) {
+    const binding = resolveBinding(item);
+    const content = await loadContent(item.ref, item.kind);
+    if (!content) {
+      warnings.push(`"${item.ref}" (${item.kind}): content not found \u2014 skipped`);
+      continue;
+    }
+    const hash = createHash("sha256").update(content).digest("hex");
+    const version = resolveVersion ? await resolveVersion(item.ref) : null;
+    entries.push({
+      asset_ref: item.ref,
+      version,
+      hash,
+      binding,
+      resolved_at: (/* @__PURE__ */ new Date()).toISOString()
+    });
+  }
+  const manifest = {
+    schema_version: 1,
+    prompt_version: nextVersion,
+    entries,
+    compiled_at: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  const tmpPath = `${manifestPath}.tmp`;
+  await fs4.writeFile(tmpPath, `${JSON.stringify(manifest, null, 2)}
+`, "utf-8");
+  await fs4.rename(tmpPath, manifestPath);
+  return {
+    manifest,
+    manifestPath,
+    resolvedCount: entries.length,
+    warnings
+  };
+}
+async function loadCompileManifest(manifestPath) {
+  try {
+    const raw = await fs4.readFile(manifestPath, "utf-8");
+    const parsed = JSON.parse(raw);
+    if (parsed?.schema_version === 1 && typeof parsed.prompt_version === "number") {
+      return parsed;
+    }
+    return void 0;
+  } catch {
+    return void 0;
+  }
+}
+async function loadCompileManifestFromDir(agentDir) {
+  return loadCompileManifest(path4.join(agentDir, COMPILE_MANIFEST_FILENAME));
+}
+async function resolveComposition(opts) {
+  const { items, library, compileManifest, loadContent } = opts;
+  const result = {
+    inlineBlocks: [],
+    discoverableEntries: [],
+    warnings: []
+  };
+  for (const item of items) {
+    const binding = resolveBinding(item);
+    try {
+      switch (binding) {
+        case "inline-snapshot":
+          await resolveInlineSnapshot(item, binding, compileManifest, loadContent, result);
+          break;
+        case "inline-live":
+          await resolveInlineLive(item, binding, loadContent, result);
+          break;
+        case "discoverable":
+          await resolveDiscoverable(item, library, loadContent, result);
+          break;
+      }
+    } catch (err) {
+      result.warnings.push(
+        `Failed to resolve "${item.ref}" (${item.kind}): ${err instanceof Error ? err.message : String(err)}`
+      );
+    }
+  }
+  return result;
+}
+async function resolveInlineSnapshot(item, binding, compileManifest, loadContent, result) {
+  if (compileManifest) {
+    const entry = compileManifest.entries.find(
+      (e) => e.asset_ref === item.ref && e.binding === "inline-snapshot"
+    );
+    if (entry) {
+      const content2 = await loadContent(item.ref, item.kind);
+      if (content2) {
+        const hash = createHash("sha256").update(content2).digest("hex");
+        if (hash !== entry.hash) {
+          result.warnings.push(
+            `"${item.ref}" (${item.kind}) content has changed since last rebuild (expected ${entry.hash.slice(0, 8)}\u2026, got ${hash.slice(0, 8)}\u2026). Run "skaile rebuild" to update the snapshot.`
+          );
+        }
+        result.inlineBlocks.push({ ref: item.ref, kind: item.kind, content: content2, binding });
+        return;
+      }
+    }
+  }
+  const content = await loadContent(item.ref, item.kind);
+  if (content) {
+    result.warnings.push(
+      `"${item.ref}" (${item.kind}) is binding=inline-snapshot but no compile_manifest.json found \u2014 using live content. Run "skaile rebuild" to freeze.`
+    );
+    result.inlineBlocks.push({ ref: item.ref, kind: item.kind, content, binding });
+  } else {
+    result.warnings.push(`"${item.ref}" (${item.kind}): content not found`);
+  }
+}
+async function resolveInlineLive(item, binding, loadContent, result) {
+  const content = await loadContent(item.ref, item.kind);
+  if (content) {
+    result.inlineBlocks.push({ ref: item.ref, kind: item.kind, content, binding });
+  } else {
+    result.warnings.push(`"${item.ref}" (${item.kind}): content not found`);
+  }
+}
+async function resolveDiscoverable(item, library, loadContent, result) {
+  const assetDef = await library.getAssetDef(item.ref);
+  const name = buildToolName(item);
+  const description = assetDef?.description ?? `${item.kind}: ${item.ref}`;
+  const content = await loadContent(item.ref, item.kind);
+  if (content) {
+    result.discoverableEntries.push({
+      ref: item.ref,
+      kind: item.kind,
+      name,
+      description,
+      content
+    });
+  } else {
+    result.warnings.push(`"${item.ref}" (${item.kind}): content not found for discoverable entry`);
+  }
+}
+function buildToolName(item) {
+  const lastSlash = item.ref.lastIndexOf("/");
+  let refNoVersion;
+  if (lastSlash !== -1) {
+    const afterSlash = item.ref.slice(lastSlash + 1);
+    const versionAt = afterSlash.indexOf("@");
+    refNoVersion = versionAt !== -1 ? item.ref.slice(0, lastSlash + 1 + versionAt) : item.ref;
+  } else {
+    const versionAt = item.ref.indexOf("@");
+    refNoVersion = versionAt !== -1 ? item.ref.slice(0, versionAt) : item.ref;
+  }
+  const cleaned = refNoVersion.replace(/^@/, "");
+  return cleaned.replace(/\//g, "__");
+}
+
+// runner/src/composition/bootstrap.ts
+async function resolveAgentComposition(opts) {
+  const { agentDir, manifest, repos = {}, log } = opts;
+  const items = manifest.composes;
+  if (!items || items.length === 0) return null;
+  const compileManifest = await loadCompileManifestFromDir(agentDir);
+  const loadContent = async (ref, kind) => {
+    try {
+      const resolved = await resolveMixin(ref, kind, agentDir, repos);
+      return resolved?.content ?? null;
+    } catch {
+      return null;
+    }
+  };
+  const library = await openLocalLibraryIfAvailable(log);
+  const result = await resolveComposition({
+    items,
+    library,
+    compileManifest,
+    loadContent
+  });
+  if (log && result.warnings.length > 0) {
+    for (const warning of result.warnings) {
+      log.warn(warning);
+    }
+  }
+  return result;
+}
+function registerCompositionCapabilities(registry, entries) {
+  for (const entry of entries) {
+    const cap = defineCapability({
+      name: entry.name,
+      displayName: `${entry.kind}: ${entry.ref}`,
+      description: entry.description,
+      side: "agent",
+      origin: { kind: "skill", skillId: entry.ref },
+      scope: "session",
+      kind: "query",
+      userInvokable: false,
+      input: z4.object({}).strict(),
+      handler: async (_args, ctx) => {
+        ctx.log.info("loading composed asset content", {
+          ref: entry.ref,
+          kind: entry.kind
+        });
+        return { content: entry.content, ref: entry.ref, kind: entry.kind };
+      }
+    });
+    registry.register(cap, "agent");
+  }
+}
+var STUB_LIBRARY = {
+  getAssetDef: async () => null,
+  listAssetDefs: async () => [],
+  createInstance: async () => ({}),
+  getInstance: async () => null,
+  listInstances: async () => [],
+  updateInstance: async () => ({}),
+  deleteInstance: async () => {
+  },
+  subscribe: async () => ({}),
+  unsubscribe: async () => {
+  },
+  listSubscriptions: async () => [],
+  getConsumptionGraph: async () => []
+};
+async function openLocalLibraryIfAvailable(log) {
+  const libraryDir = process.env.SKAILE_LIBRARY_DIR ?? join(homedir(), ".skaile", "library");
+  const dbPath = join(libraryDir, "lib.db");
+  if (!existsSync(dbPath)) {
+    return STUB_LIBRARY;
+  }
+  try {
+    const { LocalLibrary } = await import('./library/index.js');
+    return new LocalLibrary(libraryDir);
+  } catch (err) {
+    log?.debug(`Could not open LocalLibrary at ${libraryDir}: ${err.message}`);
+    return STUB_LIBRARY;
+  }
+}
+var execFileAsync = promisify(execFile);
+var PROBE_TIMEOUT_MS = 1500;
+var VERSION_PROBES = [
+  { label: "Python", bin: "python3", args: ["--version"] },
+  { label: "Node.js", bin: "node", args: ["--version"] },
+  { label: "Bun", bin: "bun", args: ["--version"] },
+  { label: "Git", bin: "git", args: ["--version"] },
+  { label: "npm", bin: "npm", args: ["--version"] },
+  {
+    label: "pip",
+    bin: "pip",
+    args: ["--version"],
+    extract: (out) => out.split(" ").slice(0, 2).join(" ")
+  }
+];
+var PRESENCE_PROBES = ["curl", "jq", "ssh", "wget", "rg"];
+async function runProbe(bin, args) {
+  try {
+    const { stdout } = await execFileAsync(bin, args, { timeout: PROBE_TIMEOUT_MS });
+    return stdout.trim().split("\n")[0] ?? null;
+  } catch {
+    return null;
+  }
+}
+async function checkPresence(bin) {
+  try {
+    await execFileAsync("which", [bin], { timeout: PROBE_TIMEOUT_MS });
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function buildEnvironmentSection(projectDir) {
+  const versionResults = await Promise.allSettled(
+    VERSION_PROBES.map(async (probe) => {
+      const raw = await runProbe(probe.bin, probe.args);
+      if (!raw) return null;
+      const version = probe.extract ? probe.extract(raw) : raw;
+      return { label: probe.label, version };
+    })
+  );
+  const presenceResults = await Promise.allSettled(PRESENCE_PROBES.map(checkPresence));
+  const runtimes = [];
+  for (const result of versionResults) {
+    if (result.status === "fulfilled" && result.value) {
+      runtimes.push(`${result.value.label} (${result.value.version})`);
+    }
+  }
+  const tools = [];
+  for (let i = 0; i < PRESENCE_PROBES.length; i++) {
+    const result = presenceResults[i];
+    if (result?.status === "fulfilled" && result.value) {
+      tools.push(PRESENCE_PROBES[i]);
+    }
+  }
+  if (runtimes.length === 0 && tools.length === 0) return void 0;
+  const lines = [
+    "## Environment",
+    "",
+    "You are running inside an isolated container with the following tools available:",
+    ""
+  ];
+  if (runtimes.length > 0) {
+    lines.push("**Runtimes:**");
+    for (const r of runtimes) lines.push(`- ${r}`);
+    lines.push("");
+  }
+  if (tools.length > 0) {
+    lines.push(`**Tools:** ${tools.join(", ")}`);
+    lines.push("");
+  }
+  const shell = process.env.SHELL ?? "sh";
+  lines.push(`**Shell:** ${shell}`);
+  lines.push(`**Working directory:** ${projectDir}`);
+  return lines.join("\n");
+}
+async function agentDefinitionExists(agentDir) {
+  try {
+    await fs4.access(path4.join(agentDir, "agent.yaml"));
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function loadAgentManifest(agentDir) {
+  const agentYamlPath = path4.join(agentDir, "agent.yaml");
+  let content;
+  try {
+    content = await fs4.readFile(agentYamlPath, "utf-8");
+  } catch {
+    return void 0;
+  }
+  if (!content.trim()) return void 0;
+  try {
+    return parse(content);
+  } catch {
+    return void 0;
+  }
+}
+
+// runner/src/prompt-assembly.ts
+function assembleSystemPrompt(parts) {
+  const filtered = parts.filter((p) => !!p);
+  if (filtered.length === 0) return void 0;
+  return filtered.join("\n\n---\n\n");
+}
+function buildCapabilitiesPromptSection(registry) {
+  const body = registry.composePromptSection();
+  if (!body) return void 0;
+  return `<CAPABILITIES>
+${body}
+</CAPABILITIES>`;
+}
+var RecipeUnavailableError = class extends Error {
+  constructor(flakeRef, attr, cause) {
+    super(
+      `Recipe unavailable: ${flakeRef}#${attr}${cause instanceof Error ? ` - ${cause.message}` : ""}`
+    );
+    this.flakeRef = flakeRef;
+    this.attr = attr;
+    this.name = "RecipeUnavailableError";
+  }
+  flakeRef;
+  attr;
+};
+function createRecipeCache() {
+  return /* @__PURE__ */ new Map();
+}
+function resolveRecipePath(flakeRef, attr, cache) {
+  const key = `${flakeRef}#${attr}`;
+  const cached = cache.get(key);
+  if (cached) return cached;
+  try {
+    validateAssetRecipeAttr(attr);
+  } catch (err) {
+    throw new RecipeUnavailableError(
+      flakeRef,
+      attr,
+      err instanceof Error ? err : new Error(String(err))
+    );
+  }
+  const log = createLogger({ kind: "mcp", subkind: "recipe-resolve" });
+  log.debug("resolving recipe", { flakeRef, attr });
+  const result = spawnSync("nix", ["path-info", "--offline", `${flakeRef}#${attr}`], {
+    encoding: "utf8"
+  });
+  if (result.error) throw new RecipeUnavailableError(flakeRef, attr, result.error);
+  if (result.status !== 0) {
+    throw new RecipeUnavailableError(
+      flakeRef,
+      attr,
+      new Error(`nix path-info exited ${result.status}: ${result.stderr.trim()}`)
+    );
+  }
+  const outPath = result.stdout.trim().split("\n")[0];
+  if (!outPath?.startsWith("/nix/store/")) {
+    throw new RecipeUnavailableError(
+      flakeRef,
+      attr,
+      new Error(`Unexpected output: ${result.stdout}`)
+    );
+  }
+  cache.set(key, outPath);
+  log.info("resolved recipe", { flakeRef, attr, outPath });
+  return outPath;
+}
+var RECIPE_MARKER = /\$\{recipe:([a-z0-9_-]+)(?::([a-z0-9_/.-]+))?\}/g;
+function substituteRecipeTemplating(value, recipeOutPaths) {
+  return value.replace(RECIPE_MARKER, (_match, id, sub) => {
+    const outPath = recipeOutPaths.get(id);
+    if (!outPath) {
+      return _match;
+    }
+    if (!sub) return `${outPath}/bin`;
+    return `${outPath}/${sub}`;
+  });
+}
+function substituteRecipeMap(obj, recipeOutPaths) {
+  if (!obj) return obj;
+  const out = {};
+  for (const [k, v] of Object.entries(obj)) {
+    out[k] = substituteRecipeTemplating(v, recipeOutPaths);
+  }
+  return out;
+}
+function validateSubstitutedPaths(command, args) {
+  const missing = [];
+  if (command?.startsWith("/nix/store/") && !existsSync(command)) {
+    missing.push({
+      field: "command",
+      path: command,
+      error: `resolved path does not exist: ${command}`
+    });
+  }
+  const firstArg = args?.[0];
+  if (firstArg?.startsWith("/nix/store/") && !existsSync(firstArg)) {
+    missing.push({
+      field: "args[0]",
+      path: firstArg,
+      error: `resolved path does not exist: ${firstArg}`
+    });
+  }
+  return missing;
+}
+
+// runner/src/resources.ts
+async function buildAgentResources(projectDir, driverType, _onLog, watch, secretProvider, sessionMeta, tokenMediator, preMintedSecrets) {
+  const resLog = createLogger({
+    kind: "runner",
+    subkind: "resources",
+    instance: sessionMeta?.sessionId ?? "no-session"
+  });
+  const noopResult = {
+    resourceManager: null,
+    mountManager: null,
+    resourcePromptSection: "",
+    mcpServers: void 0,
+    runtimeAssets: null,
+    dispose: async () => {
+    },
+    startWatching: () => {
+    }
+  };
+  try {
+    registerBuiltinConnectorAdapters();
+    registerBuiltinMountDrivers();
+    const runtimeAssets = await resolveRuntimeAssets(projectDir);
+    for (const w of runtimeAssets.warnings) {
+      resLog.warn("runtime asset warning", { code: w.code, message: w.message });
+    }
+    if (process.env.SKAILE_AUTO_INSTALL_DEPS === "true") {
+      const required = runtimeAssets.requiredNpmDeps.required;
+      if (required.length > 0) {
+        const missing = findMissingPackages(required, projectDir);
+        if (missing.length > 0) {
+          resLog.info("installing missing npm peer deps", { packages: missing });
+          const r = await installNpmPackages(missing, projectDir);
+          if (!r.success) resLog.error("npm install failed", void 0, { output: r.output });
+        }
+      }
+    }
+    const mountDeclarations = loadMountDeclarations(projectDir);
+    let mountMgr = null;
+    if (mountDeclarations.length > 0) {
+      mountMgr = new MountManager(projectDir, {
+        secrets: secretProvider,
+        catalogEntries: runtimeAssets.catalogEntries,
+        tokenMediator,
+        preMintedSecrets
+      });
+      try {
+        const mountReport = await mountMgr.mountAll(mountDeclarations, {
+          failOnReadWriteError: true
+        });
+        for (const r of mountReport.results) {
+          if (r.mounted) {
+            resLog.info("mount ok", { id: r.id, mountPath: r.mountPath });
+          } else {
+            resLog.error("mount failed", void 0, { id: r.id, error: r.error });
+          }
+        }
+      } catch (err) {
+        if (err instanceof MountStartupError) {
+          for (const r of err.report.results) {
+            if (r.mounted) {
+              resLog.info("mount ok", { id: r.id, mountPath: r.mountPath });
+            } else {
+              resLog.error("mount failed", void 0, { id: r.id, error: r.error });
+            }
+          }
+        }
+        throw err;
+      }
+    }
+    const connectorDeclarations = loadConnectorDeclarations(projectDir);
+    let resourceManager = null;
+    if (connectorDeclarations.length > 0) {
+      resourceManager = new ConnectorManager(secretProvider, {
+        catalogEntries: runtimeAssets.catalogEntries
+      });
+      const report = await resourceManager.connectAll(connectorDeclarations);
+      for (const r of report.results) {
+        if (r.connected) {
+          resLog.info("connector ok", { id: r.id });
+        } else {
+          resLog.error("connector failed", void 0, { id: r.id, error: r.error });
+        }
+      }
+    }
+    const promptParts = [];
+    if (mountMgr) {
+      promptParts.push(buildMountPromptSection(mountMgr));
+    }
+    if (resourceManager) {
+      promptParts.push(buildConnectorPromptSection(resourceManager, driverType));
+    }
+    const resourcePromptSection = promptParts.filter(Boolean).join("\n\n");
+    const mcpLog = createLogger({
+      kind: "mcp",
+      subkind: "wiring",
+      instance: sessionMeta?.sessionId ?? "no-session"
+    });
+    let mcpServers;
+    let workspacePluginToShutdown = null;
+    if (driverType === "claude-sdk") {
+      if (resourceManager) {
+        const connectorsLog = createLogger({ kind: "mcp", subkind: "skaile-connectors" });
+        try {
+          const server = await buildSdkConnectorTools(resourceManager, { z: z });
+          if (server) {
+            mcpServers = { "skaile-connectors": server };
+            connectorsLog.info("server constructed", {
+              connectorCount: resourceManager.listConnectors().length
+            });
+          } else {
+            connectorsLog.debug("server skipped (no tools to expose)");
+          }
+        } catch (err) {
+          connectorsLog.error("server construction failed", err);
+          throw err;
+        }
+      }
+      const workspacePlugin = new WorkspacePlugin({
+        projectDir,
+        mountManager: mountMgr ?? void 0,
+        connectorManager: resourceManager ?? void 0,
+        driver: driverType,
+        provider: sessionMeta?.provider,
+        model: sessionMeta?.model
+      });
+      const wsServer = await workspacePlugin.buildWorkspaceMcpServer();
+      if (wsServer) {
+        mcpServers = { ...mcpServers ?? {}, "skaile-workspace": wsServer };
+      }
+      workspacePluginToShutdown = workspacePlugin;
+      const mcpDeclarations = loadMcpServerDeclarations(projectDir);
+      mcpLog.debug("loaded MCP declarations", { count: mcpDeclarations.length });
+      const recipeCache = createRecipeCache();
+      const nixFlakeRef = process.env.SKAILE_NIX_FLAKE_REF ?? "/etc/skaile/flake";
+      for (const decl of mcpDeclarations) {
+        if (RESERVED_MCP_SERVER_IDS.has(decl.id)) {
+          mcpLog.warn("MCP server skipped: reserved id", { id: decl.id });
+          continue;
+        }
+        let resolvedDecl = decl;
+        if (decl.recipe) {
+          try {
+            const outPath = resolveRecipePath(nixFlakeRef, decl.recipe.attr, recipeCache);
+            const outPaths = /* @__PURE__ */ new Map([[decl.id, outPath]]);
+            const resolvedCommand = decl.command ? substituteRecipeTemplating(decl.command, outPaths) : decl.command;
+            const resolvedArgs = decl.args?.map((a) => substituteRecipeTemplating(a, outPaths));
+            const resolvedEnv = substituteRecipeMap(decl.env, outPaths);
+            resolvedDecl = {
+              ...decl,
+              command: resolvedCommand,
+              args: resolvedArgs,
+              env: resolvedEnv
+            };
+            const allResolved = [
+              resolvedCommand ?? "",
+              ...resolvedArgs ?? [],
+              ...Object.values(resolvedEnv ?? {})
+            ];
+            for (const v of allResolved) {
+              if (v.includes("${recipe:")) {
+                const recipeLog2 = createLogger({
+                  kind: "mcp",
+                  subkind: decl.id,
+                  instance: "recipe-resolve"
+                });
+                recipeLog2.warn("unresolved recipe marker after substitution", {
+                  value: v,
+                  declId: decl.id
+                });
+              }
+            }
+            const missingPaths = validateSubstitutedPaths(resolvedCommand, resolvedArgs);
+            if (missingPaths.length > 0) {
+              const recipeLog2 = createLogger({
+                kind: "mcp",
+                subkind: decl.id,
+                instance: "recipe-resolve"
+              });
+              recipeLog2.error("MCP server skipped: substituted path does not exist", void 0, {
+                id: decl.id,
+                attr: decl.recipe.attr,
+                missing: missingPaths
+              });
+              continue;
+            }
+            const recipeLog = createLogger({
+              kind: "mcp",
+              subkind: decl.id,
+              instance: "recipe-resolve"
+            });
+            recipeLog.info("recipe substitution complete", {
+              attr: decl.recipe.attr,
+              outPath
+            });
+          } catch (err) {
+            const recipeLog = createLogger({
+              kind: "mcp",
+              subkind: decl.id,
+              instance: "recipe-resolve"
+            });
+            recipeLog.error("MCP server skipped: recipe resolution failed", err, {
+              id: decl.id,
+              attr: decl.recipe.attr,
+              flakeRef: nixFlakeRef
+            });
+            continue;
+          }
+        }
+        const serverConfig = toSdkMcpServerConfig(
+          resolvedDecl,
+          secretProvider
+        );
+        if (serverConfig) {
+          mcpServers = { ...mcpServers ?? {}, [decl.id]: serverConfig };
+          const declLog = createLogger({ kind: "mcp", subkind: decl.id });
+          declLog.info("MCP server registered", {
+            transport: decl.transport ?? "stdio",
+            ...decl.transport === "stdio" || !decl.transport ? { command: resolvedDecl.command, args: resolvedDecl.args } : { url: decl.url }
+          });
+        } else {
+          mcpLog.error("MCP server config invalid (translation returned null)", void 0, {
+            id: decl.id,
+            transport: decl.transport
+          });
+        }
+      }
+    }
+    if (!mountMgr && !resourceManager && driverType !== "claude-sdk") return noopResult;
+    const startWatching = () => {
+      if (mountMgr && watch?.onMountChanged) {
+        mountMgr.watchAll((mountId, event) => {
+          watch.onMountChanged(mountId, event);
+        });
+      }
+      if (resourceManager && watch?.onFileChanged) {
+        const dedupTtlMs = watch.dedupTtlMs ?? 500;
+        const recentlyEmitted = /* @__PURE__ */ new Map();
+        resourceManager.watchAll((connectorId, event) => {
+          const dedupKey = `${connectorId}:${event.path}`;
+          const now = Date.now();
+          const lastEmit = recentlyEmitted.get(dedupKey);
+          if (lastEmit && now - lastEmit < dedupTtlMs) return;
+          recentlyEmitted.set(dedupKey, now);
+          if (recentlyEmitted.size > 200) {
+            for (const [key, ts] of recentlyEmitted) {
+              if (now - ts > dedupTtlMs) recentlyEmitted.delete(key);
+            }
+          }
+          watch.onFileChanged(connectorId, event);
+        });
+      }
+    };
+    const dispose = async () => {
+      if (workspacePluginToShutdown) {
+        try {
+          await workspacePluginToShutdown.shutdown();
+        } catch {
+        }
+      }
+      try {
+        await mountMgr?.unmountAll();
+      } catch {
+      }
+      try {
+        await resourceManager?.disconnectAll();
+      } catch {
+      }
+    };
+    return {
+      resourceManager,
+      mountManager: mountMgr,
+      resourcePromptSection,
+      mcpServers,
+      runtimeAssets,
+      dispose,
+      startWatching
+    };
+  } catch {
+    return noopResult;
+  }
+}
+var RESERVED_MCP_SERVER_IDS = /* @__PURE__ */ new Set(["skaile-connectors", "skaile-workspace"]);
+function resolveRecordSecrets(record, secrets) {
+  if (!secrets) return record;
+  const resolved = {};
+  for (const [k, v] of Object.entries(record)) {
+    resolved[k] = secrets.resolve(v) ?? v;
+  }
+  return resolved;
+}
+function toSdkMcpServerConfig(decl, secrets) {
+  const transport = decl.transport ?? "stdio";
+  if (transport === "stdio") {
+    if (!decl.command) return null;
+    const cfg = { type: "stdio", command: decl.command };
+    if (decl.args?.length) cfg.args = decl.args;
+    if (decl.env && Object.keys(decl.env).length > 0) {
+      cfg.env = resolveRecordSecrets(decl.env, secrets);
+    }
+    return cfg;
+  }
+  if (transport === "sse" || transport === "http") {
+    if (!decl.url) return null;
+    const cfg = { type: transport, url: decl.url };
+    if (decl.headers && Object.keys(decl.headers).length > 0) {
+      cfg.headers = resolveRecordSecrets(decl.headers, secrets);
+    }
+    return cfg;
+  }
+  return null;
+}
+
+// runner/src/session-builder.ts
+async function createAgentSession(config) {
+  const {
+    projectDir,
+    cwd: cwdOverride,
+    agentDir,
+    driver: driverOverride,
+    model: modelOverride,
+    provider: providerOverride,
+    sessionId,
+    resumeSessionId,
+    externalPromptFile,
+    wsConfig: wsConfigOverride,
+    maxTurns: maxTurnsOverride,
+    watch,
+    secretProvider,
+    onLog,
+    telemetry,
+    trace
+  } = config;
+  const agentCwd = cwdOverride ?? projectDir;
+  const sessionLog = createLogger({
+    kind: "runner",
+    subkind: "session",
+    instance: sessionId ?? "no-session"
+  });
+  const settings = await resolveSettings(projectDir, {
+    driver: driverOverride,
+    provider: providerOverride,
+    model: modelOverride
+  });
+  const driverType = settings.driver ?? "omp";
+  const provider = settings.provider;
+  const model = settings.model;
+  const apiKey = config.apiKey ?? resolveApiKey(provider ?? "anthropic", settings);
+  const manifest = agentDir ? await loadAgentManifest(agentDir) : void 0;
+  const {
+    resourceManager,
+    mountManager,
+    resourcePromptSection,
+    mcpServers,
+    runtimeAssets,
+    dispose,
+    startWatching
+  } = await buildAgentResources(
+    projectDir,
+    driverType,
+    onLog,
+    watch,
+    secretProvider,
+    {
+      provider,
+      model,
+      sessionId
+    },
+    config.tokenMediator,
+    config.preMintedSecrets
+  );
+  const wsConfig = wsConfigOverride ?? resolveSkWorkspaceConfig(projectDir);
+  const contextSection = buildContextSection(wsConfig.agent?.context);
+  const userPromptSection = wsConfig.agent?.prompt?.trim();
+  const environmentSection = await buildEnvironmentSection(projectDir);
+  const promptExtensions = loadPromptExtensions(
+    wsConfig.agent?.["prompt-extensions"],
+    projectDir,
+    sessionLog
+  );
+  if (externalPromptFile) {
+    sessionLog.warn(
+      "externalPromptFile is deprecated and no longer injected; use agent.prompt-extensions in skaile.yaml instead"
+    );
+  }
+  let composition = null;
+  if (agentDir && manifest?.composes?.length) {
+    composition = await resolveAgentComposition({
+      agentDir,
+      manifest,
+      log: sessionLog
+    });
+  } else if (manifest?.composes?.length && !agentDir) {
+    sessionLog.debug("skipping composition resolution \u2014 no agentDir available");
+  }
+  const compositionBlocks = composition?.inlineBlocks ?? [];
+  const additionalSections = config.additionalPromptSections ?? [];
+  const systemPromptSections = [];
+  if (contextSection) systemPromptSections.push({ label: "context", value: contextSection });
+  if (userPromptSection) systemPromptSections.push({ label: "prompt", value: userPromptSection });
+  if (environmentSection)
+    systemPromptSections.push({ label: "environment", value: environmentSection });
+  if (resourcePromptSection)
+    systemPromptSections.push({ label: "resources", value: resourcePromptSection });
+  for (const ext of promptExtensions) {
+    systemPromptSections.push({
+      label: "prompt-extensions",
+      value: ext.value,
+      source: ext.source
+    });
+  }
+  for (const block of compositionBlocks) {
+    systemPromptSections.push({
+      label: "composition",
+      value: block.content,
+      source: block.ref
+    });
+  }
+  additionalSections.forEach((value, idx) => {
+    systemPromptSections.push({
+      label: "additional",
+      value,
+      source: `additional[${idx}]`
+    });
+  });
+  const systemPrompt = assembleSystemPrompt([
+    contextSection,
+    userPromptSection,
+    environmentSection,
+    resourcePromptSection,
+    ...promptExtensions.map((e) => e.value),
+    ...compositionBlocks.map((b) => b.content),
+    ...additionalSections
+  ]);
+  if (process.env.SKAILE_LOG_SYSTEM_PROMPT !== "0") {
+    const length = systemPrompt?.length ?? 0;
+    sessionLog.debug("assembled system prompt", { length });
+    sessionLog.debug("system prompt content", { content: systemPrompt ?? "(empty)" });
+  }
+  const thinking = config.thinking ?? wsConfig.agent_config?.default?.thinking;
+  const effort = config.effort ?? wsConfig.agent_config?.default?.effort;
+  const maxTurns = maxTurnsOverride ?? manifest?.runtime?.max_turns;
+  const driver = await createDriver(driverType, {
+    cwd: agentCwd,
+    provider,
+    model: model ?? manifest?.model?.preferred,
+    maxTurns,
+    apiKeys: apiKey ? { [provider ?? "anthropic"]: apiKey } : void 0,
+    systemPrompt,
+    tools: manifest?.tools,
+    ...thinking ? { thinking } : {},
+    ...effort ? { effort } : {},
+    ...sessionId ? { sessionId } : {},
+    ...resumeSessionId ? { resumeSessionId } : {},
+    ...mcpServers ? { mcpServers } : {},
+    // Protocol v2 capability dispatch hooks. When provided, the driver builds
+    // a synthetic `skaile-capabilities` MCP server alongside any existing
+    // mcpServers so capability invocations route through the registry's
+    // `invoke()` (which logs + validates + handles fire-and-forget / render).
+    ...config.capabilities ? { capabilities: config.capabilities } : {},
+    ...config.aiProviderConfigId ? { aiProviderConfigId: config.aiProviderConfigId } : {},
+    ...config.onAuthError ? { onAuthError: config.onAuthError } : {},
+    // Always forward agentDir/agentName for native identity handling
+    ...agentDir ? { agentDir, agentName: manifest?.name } : {}
+  });
+  if (telemetry && trace) {
+    driver.setTelemetry(telemetry, trace);
+  }
+  return {
+    driver,
+    resourceManager,
+    mountManager,
+    runtimeAssets,
+    composition,
+    manifest,
+    driverType,
+    provider,
+    model,
+    dispose,
+    startWatching,
+    telemetry,
+    systemPromptSections
+  };
+}
+function loadPromptExtensions(paths, projectDir, log) {
+  if (!paths?.length) return [];
+  const result = [];
+  for (const relPath of paths) {
+    const absPath = resolve(projectDir, relPath);
+    if (!existsSync(absPath)) {
+      log.warn("prompt-extension file not found", { relPath });
+      continue;
+    }
+    try {
+      const content = readFileSync(absPath, "utf-8").trim();
+      if (content.length > 0) result.push({ value: content, source: relPath });
+    } catch (err) {
+      log.warn("could not read prompt-extension", {
+        relPath,
+        error: err.message
+      });
+    }
+  }
+  return result;
+}
+
+// runner/src/agent.ts
+var PROMPT_AGENT = `${pc.magenta(pc.bold("agent"))} ${pc.dim("\u25B6")} `;
+async function runAgentChat(opts) {
+  const sessionId = `chat-${Date.now().toString(36)}`;
+  const { dispose: disposeLogStore } = bootstrapRunnerLogStore({
+    sessionId,
+    projectDir: opts.projectDir,
+    onLog: opts.onLog
+  });
+  const chatLog = createLogger({
+    kind: "runner",
+    subkind: "session",
+    instance: sessionId
+  });
+  const agentSession = await buildDriver(opts);
+  const driver = agentSession.driver;
+  await driver.start();
+  let firstChunk = true;
+  const mdStream = new MarkdownStreamer();
+  driver.on("agent-event", (event) => {
+    opts.onEvent?.(event);
+    if (event.type === "message_update") {
+      const delta = event._textDelta;
+      if (delta) {
+        if (firstChunk) {
+          process.stdout.write(PROMPT_AGENT);
+          firstChunk = false;
+        }
+        mdStream.write(delta);
+      }
+    }
+  });
+  let message = opts.message;
+  if (opts.skill) {
+    message = `Skill: ${opts.skill}
+
+${message}`;
+  }
+  try {
+    await new Promise((resolve3, reject) => {
+      const onEvent = (event) => {
+        if (event.type === "agent_end") {
+          driver.off("agent-event", onEvent);
+          mdStream.end();
+          process.stdout.write("\n");
+          driver.kill();
+          resolve3();
+        } else if (event.type === "error") {
+          driver.off("agent-event", onEvent);
+          const err = new Error(String(event.error));
+          chatLog.error("agent emitted error event", err);
+          driver.kill();
+          reject(err);
+        }
+      };
+      driver.on("agent-event", onEvent);
+      driver.prompt(message).catch((err) => {
+        driver.off("agent-event", onEvent);
+        chatLog.error("prompt failed", err);
+        driver.kill();
+        reject(err);
+      });
+    });
+  } finally {
+    await agentSession.dispose();
+    disposeLogStore();
+  }
+}
+async function buildDriver(opts) {
+  const agentDir = opts.agentDir ?? resolveAgentDir(opts.projectDir);
+  return createAgentSession({
+    projectDir: opts.projectDir,
+    agentDir,
+    driver: opts.driver,
+    model: opts.model,
+    provider: opts.provider,
+    promptsDir: opts.promptsDir,
+    onLog: opts.onLog
+  });
+}
+async function handleResourceRequest(command, manager, emit) {
+  const { requestId, connectorId, operation, path: path5, options, content } = command;
+  try {
+    let data;
+    switch (operation) {
+      case "list":
+        data = await manager.list(
+          connectorId,
+          path5,
+          options
+        );
+        break;
+      case "read":
+        data = await manager.read(connectorId, path5);
+        break;
+      case "write":
+        await manager.write(connectorId, path5, content);
+        data = true;
+        break;
+      case "delete":
+        data = await manager.delete(connectorId, path5);
+        break;
+      case "search":
+        data = await manager.search(
+          connectorId,
+          path5,
+          options
+        );
+        break;
+    }
+    emit({ type: "resource_response", requestId, resourceId: connectorId, operation, data });
+  } catch (err) {
+    emit({
+      type: "resource_response",
+      requestId,
+      resourceId: connectorId,
+      operation,
+      error: err instanceof Error ? err.message : String(err)
+    });
+  }
+}
+function getMimeType(filename) {
+  return mime.getType(filename) ?? "application/octet-stream";
+}
+function isBinaryFile(filePath) {
+  try {
+    const fd = openSync(filePath, "r");
+    const buf = Buffer.alloc(8192);
+    const bytesRead = readSync(fd, buf, 0, 8192, 0);
+    closeSync(fd);
+    for (let i = 0; i < bytesRead; i++) {
+      if (buf[i] === 0) return true;
+    }
+    return false;
+  } catch {
+    return false;
+  }
+}
+function handleMountResourceRequest(command, volManager, emit) {
+  const { requestId, connectorId: mountId, operation, path: reqPath, content, options } = command;
+  if (options?._customOp === "resolveWebUrl") {
+    void (async () => {
+      try {
+        const vol = volManager.get(mountId);
+        const driver = vol.driver;
+        const url = typeof driver.resolveWebUrl === "function" ? await driver.resolveWebUrl(vol.handle, reqPath ?? "") : null;
+        emit({ type: "resource_response", requestId, resourceId: mountId, operation, data: url });
+      } catch (err) {
+        emit({
+          type: "resource_response",
+          requestId,
+          resourceId: mountId,
+          operation,
+          error: err instanceof Error ? err.message : String(err)
+        });
+      }
+    })();
+    return;
+  }
+  try {
+    const vol = volManager.get(mountId);
+    const mountPath = vol.handle.mountPath;
+    const targetPath = reqPath ? resolve(mountPath, reqPath) : mountPath;
+    if (!targetPath.startsWith(mountPath)) {
+      throw new Error("Path traversal outside mount");
+    }
+    let data;
+    switch (operation) {
+      case "list": {
+        const entries = readdirSync(targetPath, { withFileTypes: true });
+        data = entries.filter((e) => !e.name.startsWith(".")).map((e) => {
+          const entryPath = reqPath ? join(reqPath, e.name) : e.name;
+          const result = {
+            name: e.name,
+            path: entryPath,
+            type: e.isDirectory() ? "directory" : "file"
+          };
+          if (!e.isDirectory()) {
+            try {
+              result.size = statSync(join(targetPath, e.name)).size;
+            } catch {
+            }
+          }
+          return result;
+        });
+        break;
+      }
+      case "read": {
+        const contentType = getMimeType(basename(targetPath));
+        if (isBinaryFile(targetPath)) {
+          const buf = readFileSync(targetPath);
+          data = {
+            data: buf.toString("base64"),
+            contentType,
+            encoding: "binary"
+          };
+        } else {
+          data = {
+            data: readFileSync(targetPath, "utf-8"),
+            contentType,
+            encoding: "utf-8"
+          };
+        }
+        break;
+      }
+      case "write": {
+        const writeContent = typeof content === "string" ? content : content?.data ?? "";
+        writeFileSync(targetPath, writeContent, "utf-8");
+        data = true;
+        break;
+      }
+      case "delete": {
+        unlinkSync(targetPath);
+        data = true;
+        break;
+      }
+      default:
+        throw new Error(`Unsupported operation for mount: ${operation}`);
+    }
+    emit({ type: "resource_response", requestId, resourceId: mountId, operation, data });
+  } catch (err) {
+    emit({
+      type: "resource_response",
+      requestId,
+      resourceId: mountId,
+      operation,
+      error: err instanceof Error ? err.message : String(err)
+    });
+  }
+}
+
+// runner/src/refresh-flag-dispatcher.ts
+async function dispatchRefreshToExposedGitMounts(mountManager, log) {
+  if (!mountManager) return;
+  let gitMounts;
+  try {
+    gitMounts = mountManager.listGitMounts();
+  } catch (err) {
+    log.warn("listGitMounts failed during refresh-flag dispatch", {
+      error: err instanceof Error ? err.message : String(err)
+    });
+    return;
+  }
+  const eligible = gitMounts.filter((m) => m.exposeAccessToken === true && m.auth === "backend");
+  if (eligible.length === 0) {
+    log.debug("refresh-flag fired but no eligible git mounts (Tier-2 backend) found");
+    return;
+  }
+  log.info("refresh-flag fired -- dispatching backend mediation", {
+    mountIds: eligible.map((m) => m.id)
+  });
+  await Promise.all(
+    eligible.map(async (m) => {
+      try {
+        const entry = mountManager.get(m.id);
+        if (typeof entry.driver.refreshExposedCredential !== "function") {
+          log.debug("driver lacks refreshExposedCredential -- skipping", {
+            mountId: m.id
+          });
+          return;
+        }
+        await entry.driver.refreshExposedCredential(m.id, entry.handle);
+      } catch (err) {
+        log.warn("refresh-flag dispatch failed for mount", {
+          mountId: m.id,
+          error: err instanceof Error ? err.message : String(err)
+        });
+      }
+    })
+  );
+}
+function keywordSearch(capabilities, query, limit) {
+  const tokens = query.toLowerCase().split(/\s+/).filter((t) => t.length > 0);
+  if (tokens.length === 0) return capabilities.slice(0, limit);
+  const scored = capabilities.map((cap) => {
+    const haystack = [cap.name, cap.description, cap.promptFragment ?? ""].join(" ").toLowerCase();
+    let score = 0;
+    for (const token of tokens) {
+      if (haystack.includes(token)) score += 1;
+    }
+    return { cap, score };
+  }).filter((x) => x.score > 0).sort((a, b) => b.score - a.score);
+  return scored.slice(0, limit).map((x) => x.cap);
+}
+function builtinCapabilities(registry) {
+  const listFilterSchema = z4.object({
+    side: z4.enum(["client", "agent"]).optional(),
+    originKind: z4.enum(["framework", "client", "agent", "flow", "skill", "mcp", "connector", "mount"]).optional(),
+    scope: z4.enum(["session", "turn"]).optional()
+  }).strict();
+  return [
+    defineCapability({
+      name: "__capabilities.list",
+      displayName: "List capabilities",
+      description: "List available capabilities in this session. Optionally filter by side, origin kind, or scope.",
+      side: "agent",
+      origin: { kind: "framework" },
+      kind: "query",
+      userInvokable: false,
+      input: listFilterSchema,
+      handler: async (args) => registry.list({
+        side: args.side,
+        origin: args.originKind,
+        scope: args.scope
+      })
+    }),
+    defineCapability({
+      name: "__capabilities.search",
+      displayName: "Search capabilities",
+      description: "Keyword search across capability names, descriptions, and prompt fragments. Returns the top matches by score (substring match count).",
+      side: "agent",
+      origin: { kind: "framework" },
+      kind: "query",
+      userInvokable: false,
+      input: z4.object({
+        query: z4.string(),
+        limit: z4.number().int().positive().optional()
+      }).strict(),
+      handler: async ({ query, limit }) => keywordSearch(registry.list(), query, limit ?? 10)
+    }),
+    defineCapability({
+      name: "__capabilities.describe",
+      displayName: "Describe capability",
+      description: "Return the full Capability descriptor for a single capability by name.",
+      side: "agent",
+      origin: { kind: "framework" },
+      kind: "query",
+      userInvokable: false,
+      input: z4.object({ name: z4.string() }).strict(),
+      handler: async ({ name }) => {
+        const cap = registry.resolve(name);
+        if (!cap) return null;
+        const wire = registry.list().find((c) => c.name === name);
+        return wire ?? null;
+      }
+    })
+  ];
+}
+function bootstrapCapabilityRegistry(registry) {
+  for (const cap of builtinCapabilities(registry)) {
+    registry.register(cap, "agent");
+  }
+}
+var CLAUDE_CODE_CREDENTIALS_KEY = "CLAUDE_CODE_CREDENTIALS_JSON";
+async function writeClaudeCodeCredentialsFile(home, json) {
+  const claudeDir = join(home, ".claude");
+  await mkdir(claudeDir, { recursive: true, mode: 448 });
+  const finalPath = join(claudeDir, ".credentials.json");
+  const tmpPath = `${finalPath}.tmp.${process.pid}.${Date.now()}.${Math.random().toString(36).slice(2)}`;
+  await writeFile(tmpPath, json, { mode: 384 });
+  await rename(tmpPath, finalPath);
+  return finalPath;
+}
+async function mergeAndRewriteCredentialsFile(home, accessToken, expiresAt) {
+  const credPath = join(home, ".claude", ".credentials.json");
+  let merged = {};
+  if (existsSync(credPath)) {
+    try {
+      merged = JSON.parse(readFileSync(credPath, "utf-8"));
+    } catch {
+      merged = {};
+    }
+  }
+  const oauthBlock = merged.claudeAiOauth ?? {};
+  oauthBlock.accessToken = accessToken;
+  if (expiresAt) oauthBlock.expiresAt = expiresAt;
+  merged.claudeAiOauth = oauthBlock;
+  merged.accessToken = accessToken;
+  return writeClaudeCodeCredentialsFile(home, JSON.stringify(merged));
+}
+var DEFAULT_AUDIENCE = ["llm", "user"];
+function audienceOf(cap) {
+  return cap.audience ?? DEFAULT_AUDIENCE;
+}
+function hasAudience(cap, target) {
+  return audienceOf(cap).includes(target);
+}
+var ORIGIN_PROMPT_ORDER = [
+  "framework",
+  "client",
+  "agent",
+  "flow",
+  "skill",
+  "mcp",
+  "connector",
+  "mount"
+];
+var CapabilityRegistry = class {
+  byName = /* @__PURE__ */ new Map();
+  logger;
+  remoteInvoker;
+  constructor(logger) {
+    this.logger = logger ?? createLogger({ kind: "runner", subkind: "capability-registry" });
+  }
+  /**
+   * Install the platform-bound invoker used by {@link invokeRemote}.
+   *
+   * The runner wires this up after the transport is connected and the
+   * per-session pending-call map is in place. Idempotent — repeated calls
+   * replace the prior invoker.
+   *
+   * @category Runtime
+   * @since 3.0.0
+   */
+  setRemoteInvoker(invoker) {
+    this.remoteInvoker = invoker;
+  }
+  /**
+   * Invoke a `host.*` (or other peer-side) capability on the platform.
+   *
+   * Composes a `capability_invoked` event under the hood and resolves with
+   * the matching `capability_result` payload. Infrastructure failures
+   * (timeout, schema mismatch, transport disconnect) reject with `Error`;
+   * domain failures (e.g. `{ ok: false, code }` for credential mints) ride
+   * in the resolved payload.
+   *
+   * @category Runtime
+   * @since 3.0.0
+   */
+  async invokeRemote(name, input) {
+    if (!this.remoteInvoker) {
+      throw new Error(
+        `Capability '${name}' invoked remotely but no remote invoker is wired. Call CapabilityRegistry.setRemoteInvoker(...) before dispatch.`
+      );
+    }
+    return this.remoteInvoker(name, input);
+  }
+  /**
+   * Register a capability. Validates that the registering `source` is
+   * permitted to declare the capability's `origin.kind`; mismatches are
+   * dropped with a warning so untrusted callers cannot impersonate other
+   * registration sources.
+   *
+   * Allowed combinations:
+   * - source `'agent'`: origins `framework | agent | flow | skill | mcp | connector | mount`
+   * - source `'client'`: origin `client` only
+   *
+   * @param cap - capability to register (typically built via {@link defineCapability})
+   * @param source - which side is doing the registration
+   */
+  register(cap, source) {
+    if (!this.isOriginAllowed(source, cap.origin)) {
+      this.logger.warn("capability registration rejected (origin mismatch)", {
+        name: cap.name,
+        source,
+        originKind: cap.origin.kind
+      });
+      return;
+    }
+    this.byName.set(cap.name, cap);
+    this.logger.info("capability registered", {
+      name: cap.name,
+      side: cap.side,
+      originKind: cap.origin.kind
+    });
+  }
+  /**
+   * Remove a capability by name. No-op when the name is unknown.
+   *
+   * @param name - capability name
+   */
+  deregister(name) {
+    if (this.byName.delete(name)) {
+      this.logger.info("capability deregistered", { name });
+    }
+  }
+  /**
+   * List capabilities, optionally filtering by `side`, `origin` kind, or
+   * `scope`. Returns the wire-format {@link Capability} shape (no internal
+   * Zod schemas or handlers).
+   */
+  list(filter) {
+    const all = Array.from(this.byName.values());
+    const matching = filter ? all.filter(
+      (c) => (filter.side === void 0 || c.side === filter.side) && (filter.origin === void 0 || c.origin.kind === filter.origin) && (filter.scope === void 0 || c.scope === filter.scope)
+    ) : all;
+    return matching.map((c) => this.toWire(c));
+  }
+  /**
+   * Resolve a capability by name. Returns the full {@link DefinedCapability}
+   * (including the original Zod schemas + handler) for use by the bridge.
+   *
+   * @returns the capability or `null` when the name is not registered
+   */
+  resolve(name) {
+    return this.byName.get(name) ?? null;
+  }
+  /**
+   * Build LLM tool descriptors for every registered capability whose
+   * audience includes `'llm'` (the default when {@link Capability.audience}
+   * is omitted). Bridge drivers consume this output directly when
+   * assembling the tool list passed to the underlying LLM SDK.
+   *
+   * Capabilities scoped to `'runtime'` only (e.g. `host.refresh_credential`,
+   * `runner.add_mount`) are filtered out so they never reach the model.
+   */
+  composeLLMTools() {
+    return Array.from(this.byName.values()).filter((c) => hasAudience(c, "llm")).map((c) => ({
+      name: c.name,
+      description: c.description,
+      parameters: c.inputSchema
+    }));
+  }
+  /**
+   * Compose a deterministic prompt section from every registered
+   * capability whose audience includes `'llm'`. Ordering matches
+   * `ORIGIN_PROMPT_ORDER` (framework first, then client, then agent-side
+   * surfaces) so the agent sees a stable layout. Capabilities without a
+   * `promptFragment` are skipped.
+   */
+  composePromptSection() {
+    const groups = /* @__PURE__ */ new Map();
+    for (const cap of this.byName.values()) {
+      if (!cap.promptFragment) continue;
+      if (!hasAudience(cap, "llm")) continue;
+      const arr = groups.get(cap.origin.kind) ?? [];
+      arr.push(cap.promptFragment);
+      groups.set(cap.origin.kind, arr);
+    }
+    const lines = [];
+    for (const kind of ORIGIN_PROMPT_ORDER) {
+      const fragments = groups.get(kind);
+      if (!fragments?.length) continue;
+      for (const fragment of fragments) {
+        lines.push(fragment);
+      }
+    }
+    return lines.join("\n\n");
+  }
+  /**
+   * Serialize the registry to wire-format capabilities for hibernation. The
+   * runtime fields (`inputZod`, `outputZod`, `handler`) are dropped; only
+   * the wire shape is kept.
+   */
+  serialize() {
+    return Array.from(this.byName.values()).map((c) => this.toWire(c));
+  }
+  /**
+   * Replay a wire snapshot taken via {@link serialize}. Wire-only capabilities
+   * (no handler) are stored so {@link list} / {@link composeLLMTools} return
+   * a complete picture; agent-side surfaces are expected to re-register
+   * fully (with handlers) from their original sources on wake.
+   *
+   * Per the v2 design, only `client`-side capabilities are persisted across
+   * hibernation by this method — agent-side ones come back via the
+   * skill / flow / connector / mount adapters. Snapshot entries from other
+   * origins are skipped on hydrate.
+   */
+  hydrate(snapshot) {
+    for (const cap of snapshot) {
+      if (cap.origin.kind !== "client") continue;
+      const stub = {
+        ...cap,
+        inputZod: HYDRATED_PASSTHROUGH_ZOD,
+        outputZod: void 0,
+        handler: HYDRATED_REJECT_HANDLER
+      };
+      this.byName.set(cap.name, stub);
+    }
+    this.logger.info("capability registry hydrated", { count: snapshot.length });
+  }
+  /**
+   * Invoke a registered capability. Validates the input against the Zod
+   * schema, builds the per-handler logger, and runs the handler. Logs
+   * `info "invoking"` and `info "ok"` (or `error "failed"`) under the
+   * `capability:<origin>:<name>` slice for every call.
+   *
+   * @throws when the capability is unknown or the input fails validation
+   */
+  async invoke(name, input, baseCtx) {
+    const cap = this.resolve(name);
+    if (!cap) {
+      throw new Error(`Unknown capability: ${name}`);
+    }
+    const log = createLogger({
+      kind: "capability",
+      subkind: cap.origin.kind,
+      instance: cap.name
+    });
+    log.info("invoking", { input });
+    try {
+      const validated = cap.inputZod.parse(input);
+      const result = await cap.handler(validated, { ...baseCtx, log });
+      log.info("ok", { output: result });
+      return result;
+    } catch (err) {
+      log.error("failed", err);
+      throw err;
+    }
+  }
+  /** True when `source` is allowed to register the given `origin`. */
+  isOriginAllowed(source, origin) {
+    if (source === "client") {
+      return origin.kind === "client";
+    }
+    return origin.kind !== "client";
+  }
+  /** Strip the runtime-only fields from a {@link DefinedCapability}. */
+  toWire(cap) {
+    return {
+      name: cap.name,
+      displayName: cap.displayName,
+      description: cap.description,
+      inputSchema: cap.inputSchema,
+      outputSchema: cap.outputSchema,
+      side: cap.side,
+      origin: cap.origin,
+      scope: cap.scope,
+      fireAndForget: cap.fireAndForget,
+      requiresApproval: cap.requiresApproval,
+      kind: cap.kind,
+      userInvokable: cap.userInvokable,
+      audience: cap.audience,
+      promptFragment: cap.promptFragment,
+      render: cap.render
+    };
+  }
+};
+function computeCapabilitySignature(caps) {
+  const canonical = caps.slice().sort((a, b) => a.name.localeCompare(b.name)).map((c) => ({
+    name: c.name,
+    origin: c.origin.kind,
+    schemaSha256: sha256(JSON.stringify(c.inputSchema ?? {}))
+  }));
+  return sha256(JSON.stringify(canonical));
+}
+function sha256(input) {
+  return createHash("sha256").update(input).digest("hex");
+}
+var HYDRATED_PASSTHROUGH_ZOD = {
+  parse: (v) => v
+  // The full Zod surface is not required here — `parse` is the only method
+  // used by `invoke`, and hydrated stubs are not expected to be invoked
+  // before the platform resends the live capability via configure.
+};
+var HYDRATED_REJECT_HANDLER = async () => {
+  throw new Error(
+    "Hydrated capability stub cannot be invoked \u2014 re-register via ConfigureCommand on wake."
+  );
+};
+
+// runner/src/capability-roundtrip.ts
+var DEFAULT_CAPABILITY_CALL_TIMEOUT_MS = 6e4;
+function buildClientCapabilityHandler(args) {
+  const timeoutMs = args.timeoutMs ?? DEFAULT_CAPABILITY_CALL_TIMEOUT_MS;
+  const gen = args.generateCallId ?? (() => `cap-${Date.now()}-${Math.floor(Math.random() * 1e9)}`);
+  return async (input) => {
+    const callId = gen();
+    if (args.wire.fireAndForget) {
+      args.emit({
+        type: "capability_invoked",
+        callId,
+        name: args.wire.name,
+        input,
+        invokedBy: "agent"
+      });
+      return {};
+    }
+    return new Promise((resolve3, reject) => {
+      const timer = setTimeout(() => {
+        args.pending.delete(callId);
+        reject(
+          new Error(
+            `Capability ${args.wire.name} (callId=${callId}) timed out after ${timeoutMs}ms`
+          )
+        );
+      }, timeoutMs);
+      args.pending.set(callId, { resolve: resolve3, reject, timer });
+      args.emit({
+        type: "capability_invoked",
+        callId,
+        name: args.wire.name,
+        input,
+        invokedBy: "agent"
+      });
+    });
+  };
+}
+function resolveCapabilityResult(pending, cmd) {
+  const entry = pending.get(cmd.callId);
+  if (!entry) return false;
+  clearTimeout(entry.timer);
+  pending.delete(cmd.callId);
+  const result = cmd.result;
+  if (result && typeof result === "object" && "error" in result) {
+    entry.reject(new Error(String(result.error)));
+  } else {
+    entry.resolve(result);
+  }
+  return true;
+}
+function rejectCapabilityOnApprovalDeny(pending, callId, feedback) {
+  const entry = pending.get(callId);
+  if (!entry) return false;
+  clearTimeout(entry.timer);
+  pending.delete(callId);
+  entry.reject(new Error(feedback ?? "declined by user"));
+  return true;
+}
+
+// runner/src/compaction/strategy.ts
+var TokenThresholdStrategy = class {
+  thresholdPercent;
+  minCooldownMs;
+  constructor(opts) {
+    this.thresholdPercent = opts.thresholdPercent;
+    this.minCooldownMs = opts.minCooldownMs;
+  }
+  shouldCompact(context) {
+    const fillPercent = context.estimatedTokens / context.contextWindow * 100;
+    if (fillPercent < this.thresholdPercent) return false;
+    if (context.timeSinceLastCompaction !== null && context.timeSinceLastCompaction < this.minCooldownMs) {
+      return false;
+    }
+    return true;
+  }
+};
+
+// runner/src/compaction/prompt.ts
+var DEFAULT_COMPACTION_PROMPT = `You are being asked to compact this conversation into a structured summary.
+This summary will replace the full conversation history when the session
+is restored. Produce a summary that lets you continue working effectively
+without access to the original messages.
+
+## Rules
+
+PRESERVE (include verbatim):
+- Current task/goal and its status
+- All file paths that were read, created, or modified
+- Function/class/variable names that are relevant to ongoing work
+- Key decisions made and the reasoning behind them
+- Errors encountered and how they were resolved
+- Active flow node and state (if any)
+- Unresolved questions or pending user input
+- User names and who said/requested what (multi-user sessions)
+- Test commands and verification criteria
+- Any explicit user instructions about preferences or constraints
+
+COMPRESS (summarize in one line each):
+- Tool call / tool result pairs
+- Intermediate reasoning steps
+- Exploration paths that informed a decision
+
+DROP (omit entirely):
+- Full file contents (can be re-read from disk)
+- Verbose command output (build logs, test suite output)
+- Exploration that led nowhere and didn't inform decisions
+- Redundant back-and-forth (corrections already applied)
+- Transient UI state
+
+## Format
+
+Write a structured summary using these sections. Omit any section that
+has no content.
+
+### Goal
+What the user is trying to accomplish.
+
+### Progress
+What has been done so far, organized by sub-task.
+
+### Key Decisions
+Decisions made and why, as a bulleted list.
+
+### Active State
+Current work in progress -- what was happening when compaction triggered.
+
+### Files
+All relevant file paths with a one-line note on each.
+
+### Pending
+What still needs to be done or is waiting on user input.
+
+### Context
+User preferences, constraints, or instructions that must carry forward.`;
+function buildCompactionPrompt(opts) {
+  const base = opts.agentPrompt ?? DEFAULT_COMPACTION_PROMPT;
+  const parts = [base];
+  const allDirectives = [...opts.skillDirectives ?? [], ...opts.mcpDirectives ?? []];
+  if (allDirectives.length > 0) {
+    parts.push(
+      `
+
+## Additional Compaction Directives
+${allDirectives.map((d) => `- ${d}`).join("\n")}`
+    );
+  }
+  if (opts.focus) {
+    parts.push(`
+
+## Focus
+${opts.focus}`);
+  }
+  return parts.join("");
+}
+
+// runner/src/compaction/orchestrator.ts
+var MIN_SUMMARY_CHARS = 200;
+var MAX_COMPRESSION_RATIO = 0.9;
+var RATE_LIMIT_TEXT_MAX_CHARS = 1500;
+var RATE_LIMIT_TEXT_PATTERNS = [
+  /you('?| ha)ve hit your (rate |usage )?limit/i,
+  /you('?| ha)ve reached your (usage |rate )?limit/i,
+  /you('?| ha)ve been rate[\s-]?limited/i,
+  /rate limit (exceeded|reached|hit)/i,
+  /usage limit (exceeded|reached)/i,
+  /quota (exceeded|reached)/i,
+  /claude (ai )?usage limit reached/i
+];
+function detectRateLimitInSummary(text) {
+  if (text.length > RATE_LIMIT_TEXT_MAX_CHARS) return false;
+  return RATE_LIMIT_TEXT_PATTERNS.some((p) => p.test(text));
+}
+function validateCompactionOutput(text, tokensBefore, tokensAfter) {
+  if (!text.trim()) return { ok: false, errorCode: "empty" };
+  if (detectRateLimitInSummary(text)) return { ok: false, errorCode: "rate_limit" };
+  if (text.length < MIN_SUMMARY_CHARS) return { ok: false, errorCode: "too_short" };
+  if (tokensBefore > 0 && tokensAfter / tokensBefore > MAX_COMPRESSION_RATIO) {
+    return { ok: false, errorCode: "poor_ratio" };
+  }
+  return { ok: true };
+}
+var CompactionOrchestrator = class {
+  driver;
+  strategy;
+  config;
+  opts;
+  _isCompacting = false;
+  lastCompactionSeq = null;
+  lastCompactionTime = null;
+  currentSeq = 0;
+  messagesSinceCompaction = 0;
+  constructor(opts) {
+    this.driver = opts.driver;
+    this.opts = opts;
+    this.config = { ...COMPACTION_DEFAULTS, ...opts.config };
+    this.strategy = new TokenThresholdStrategy({
+      thresholdPercent: this.config.thresholdPercent,
+      minCooldownMs: this.config.minCooldownMs
+    });
+  }
+  get hasNewMessagesSinceCompaction() {
+    return this.messagesSinceCompaction > 0;
+  }
+  trackMessage(seq) {
+    this.currentSeq = seq;
+    this.messagesSinceCompaction++;
+  }
+  shouldCompact() {
+    if (!this.config.enabled) return false;
+    const usage = this.driver.getTokenUsage();
+    const contextWindow = this.driver.getContextWindow();
+    if (!usage || !contextWindow || usage.inputTokens === void 0) return false;
+    return this.strategy.shouldCompact({
+      estimatedTokens: usage.inputTokens,
+      contextWindow,
+      messageCount: this.messagesSinceCompaction,
+      lastCompactionSeq: this.lastCompactionSeq,
+      timeSinceLastCompaction: this.lastCompactionTime !== null ? Date.now() - this.lastCompactionTime : null
+    });
+  }
+  async compact(trigger, focus) {
+    if (this._isCompacting) return null;
+    this._isCompacting = true;
+    try {
+      return await this._doCompact(trigger, focus);
+    } finally {
+      this._isCompacting = false;
+    }
+  }
+  async _doCompact(trigger, focus) {
+    const tokensBefore = this.driver.getTokenUsage()?.inputTokens ?? 0;
+    const driverSessionId = this.driver.runtimeSessionId ?? null;
+    const driverModel = this.driver.getModel() ?? null;
+    const driverProvider = this.driver.driverInfo?.id ?? null;
+    const coversFromSeq = this.lastCompactionSeq ?? 0;
+    const capabilitySignatureAtCompaction = this.opts.getCurrentCapabilitySignature?.() ?? null;
+    this.opts.onCompactionStart?.(trigger);
+    this.opts.onLog?.(`[compaction] Starting (trigger=${trigger}, tokens=${tokensBefore})`);
+    const prompt = buildCompactionPrompt({
+      agentPrompt: this.opts.agentCompactionPrompt,
+      skillDirectives: this.opts.skillDirectives,
+      mcpDirectives: this.opts.mcpDirectives,
+      focus
+    });
+    let summaryText = "";
+    const captureHandler = (raw) => {
+      const event = raw;
+      if (event.type === "text") {
+        summaryText += event.content ?? "";
+        return;
+      }
+      if (event.type === "message_update") {
+        const delta = event._textDelta;
+        if (delta) summaryText += delta;
+        return;
+      }
+      if (event.type === "message_start" || event.type === "message_end") {
+        const msg = event.message;
+        if (!msg?.content) return;
+        const blocks = Array.isArray(msg.content) ? msg.content : [];
+        for (const b of blocks) {
+          if (b.type === "text" && b.text) summaryText += b.text;
+        }
+      }
+    };
+    let promptError = null;
+    try {
+      this.driver.on("agent-event", captureHandler);
+      await this.driver.prompt(prompt);
+    } catch (err) {
+      promptError = err;
+    } finally {
+      this.driver.removeListener("agent-event", captureHandler);
+    }
+    if (promptError !== null) {
+      const classified = classifyClaudeSdkError(
+        promptError instanceof Error ? promptError.message : String(promptError)
+      );
+      const errorCode = classified.category === "rate_limit" ? "rate_limit" : classified.category === "auth" ? "auth" : classified.category === "network" ? "timeout" : classified.category === "validation" ? "parse_error" : classified.category;
+      this.opts.onLog?.(`[compaction] Failed: ${classified.message} (${errorCode})`);
+      this.opts.onCompactionAttempt?.({
+        type: "compaction_attempt",
+        status: "failed",
+        errorCode,
+        trigger,
+        summary: "",
+        model: driverModel,
+        provider: driverProvider,
+        inputTokens: tokensBefore,
+        outputTokens: 0,
+        coversFromSeq,
+        coversToSeq: this.currentSeq,
+        driverSessionIdAtCompaction: driverSessionId,
+        modelAtCompaction: driverModel,
+        capabilitySignatureAtCompaction,
+        validatedAt: null
+      });
+      this.opts.onCompactionEnd?.();
+      return null;
+    }
+    const actualUsage = this.driver.getTokenUsage();
+    const tokensAfter = actualUsage?.outputTokens ?? Math.ceil(summaryText.length / 4);
+    const validation = validateCompactionOutput(summaryText, tokensBefore, tokensAfter);
+    if (!validation.ok) {
+      this.opts.onLog?.(
+        `[compaction] Output failed validation (${validation.errorCode}); recording failed attempt`
+      );
+      this.opts.onCompactionAttempt?.({
+        type: "compaction_attempt",
+        status: "failed",
+        errorCode: validation.errorCode,
+        trigger,
+        summary: "",
+        model: driverModel,
+        provider: driverProvider,
+        inputTokens: tokensBefore,
+        outputTokens: tokensAfter,
+        coversFromSeq,
+        coversToSeq: this.currentSeq,
+        driverSessionIdAtCompaction: driverSessionId,
+        modelAtCompaction: driverModel,
+        capabilitySignatureAtCompaction,
+        validatedAt: null
+      });
+      this.opts.onCompactionEnd?.();
+      return null;
+    }
+    const validatedAt = (/* @__PURE__ */ new Date()).toISOString();
+    const snapshot = {
+      type: "snapshot",
+      summary: summaryText,
+      trigger,
+      coversFromSeq,
+      coversToSeq: this.currentSeq,
+      tokensBefore,
+      tokensAfter
+    };
+    this.opts.onCompactionAttempt?.({
+      type: "compaction_attempt",
+      status: "success",
+      errorCode: null,
+      trigger,
+      summary: summaryText,
+      model: driverModel,
+      provider: driverProvider,
+      inputTokens: tokensBefore,
+      outputTokens: tokensAfter,
+      coversFromSeq,
+      coversToSeq: this.currentSeq,
+      driverSessionIdAtCompaction: driverSessionId,
+      modelAtCompaction: driverModel,
+      capabilitySignatureAtCompaction,
+      validatedAt
+    });
+    this.opts.onSnapshot?.(snapshot);
+    this.lastCompactionSeq = this.currentSeq + 1;
+    this.lastCompactionTime = Date.now();
+    this.messagesSinceCompaction = 0;
+    this.opts.onCompactionEnd?.();
+    if (trigger !== "hibernate") {
+      this.opts.onLog?.("[compaction] Resetting driver session");
+      await this.driver.resetSession();
+      await this.driver.prompt(
+        `<session_snapshot>
+${summaryText}
+</session_snapshot>
+
+The conversation has been compacted. The above snapshot contains the full context of our work so far. Continue from where we left off.`
+      );
+    }
+    this.opts.onLog?.(
+      `[compaction] Complete (${tokensBefore} -> ${tokensAfter} tokens, ratio=${(tokensAfter / Math.max(tokensBefore, 1) * 100).toFixed(1)}%)`
+    );
+    return snapshot;
+  }
+  initFromSnapshot(lastSnapshotSeq, lastSnapshotTime) {
+    this.lastCompactionSeq = lastSnapshotSeq;
+    this.lastCompactionTime = lastSnapshotTime;
+    this.messagesSinceCompaction = 0;
+  }
+};
+function rewriteFileChangedPath(event, cwd, mounts) {
+  if (event.type !== "file_changed") return event;
+  if (event.mountId) return event;
+  const rawPath = event.path;
+  if (!rawPath) return event;
+  const absPath = resolve(cwd, rawPath);
+  for (const mount of mounts) {
+    const rel = relative(mount.mountPath, absPath);
+    if (rel === "" || rel.startsWith("..") || rel.startsWith("/")) continue;
+    return { ...event, path: rel, mountId: mount.id };
+  }
+  return event;
+}
+var RUNNER_CAP_ORIGIN = { kind: "framework" };
+function notImplemented(name) {
+  return {
+    ok: false,
+    code: "not_implemented",
+    message: `${name} handler not configured`
+  };
+}
+var requiredUnknown = z4.unknown().refine(() => true);
+var preMintedTokenSchema = z4.object({
+  token: z4.string(),
+  expiresAt: z4.string().nullable().optional()
+}).optional();
+var mountDeclarationInput = z4.object({
+  declaration: requiredUnknown,
+  preMintedToken: preMintedTokenSchema
+}).strict();
+var connectorDeclarationInput = z4.object({
+  declaration: requiredUnknown,
+  preMintedToken: preMintedTokenSchema
+}).strict();
+var removeResourceInput = z4.object({
+  id: z4.string()
+}).strict();
+var updateCredentialInput = z4.object({
+  kind: z4.enum(["mount", "connector"]),
+  id: z4.string(),
+  // `CredentialMint` is a discriminated union from `@skaile/workspaces/types`.
+  // We accept it as `z.unknown()` here because Zod can't easily mirror
+  // a discriminated TypeScript union without duplicating the schema —
+  // the platform side has already validated the shape before sending.
+  mint: requiredUnknown
+}).strict();
+var setLogLevelInput = z4.object({
+  level: z4.enum(["silent", "error", "warn", "info", "debug", "trace"])
+}).strict();
+var setStateInput = z4.object({
+  store: z4.string(),
+  key: z4.string(),
+  value: requiredUnknown
+}).strict();
+var lifecycleInput = z4.object({
+  action: z4.enum(["hibernate", "close", "shutdown"])
+}).strict();
+var VALID_LOG_STORE_LEVELS = /* @__PURE__ */ new Set(["debug", "info", "warn", "error"]);
+function buildRunnerCapabilities(handlers) {
+  return [
+    defineCapability({
+      name: "runner.add_mount",
+      displayName: "Add mount",
+      description: "Mount a volume into the live session. Used by the platform to attach data sources mid-session.",
+      side: "agent",
+      origin: RUNNER_CAP_ORIGIN,
+      audience: ["runtime"],
+      kind: "effect",
+      input: mountDeclarationInput,
+      handler: async (input) => {
+        if (!handlers.addMount) return notImplemented("runner.add_mount");
+        return handlers.addMount({
+          declaration: input.declaration,
+          preMintedToken: input.preMintedToken
+        });
+      }
+    }),
+    defineCapability({
+      name: "runner.add_connector",
+      displayName: "Add connector",
+      description: "Connect a tool-providing connector into the live session. Used by the platform to attach databases, APIs, etc. mid-session.",
+      side: "agent",
+      origin: RUNNER_CAP_ORIGIN,
+      audience: ["runtime"],
+      kind: "effect",
+      input: connectorDeclarationInput,
+      handler: async (input) => {
+        if (!handlers.addConnector) return notImplemented("runner.add_connector");
+        return handlers.addConnector({
+          declaration: input.declaration,
+          preMintedToken: input.preMintedToken
+        });
+      }
+    }),
+    defineCapability({
+      name: "runner.remove_resource",
+      displayName: "Remove resource",
+      description: "Detach a mount or connector by id. The id namespace is shared across both kinds.",
+      side: "agent",
+      origin: RUNNER_CAP_ORIGIN,
+      audience: ["runtime"],
+      kind: "effect",
+      input: removeResourceInput,
+      handler: async (input) => {
+        if (!handlers.removeResource) return notImplemented("runner.remove_resource");
+        return handlers.removeResource(input);
+      }
+    }),
+    defineCapability({
+      name: "runner.update_credential",
+      displayName: "Update credential",
+      description: "Replace the pre-minted credential on an existing mount or connector. Used for proactive rotation before TTL expiry.",
+      side: "agent",
+      origin: RUNNER_CAP_ORIGIN,
+      audience: ["runtime"],
+      kind: "effect",
+      input: updateCredentialInput,
+      handler: async (input) => {
+        if (!handlers.updateCredential) return notImplemented("runner.update_credential");
+        return handlers.updateCredential({
+          kind: input.kind,
+          id: input.id,
+          mint: input.mint
+        });
+      }
+    }),
+    defineCapability({
+      name: "runner.set_log_level",
+      displayName: "Set log level",
+      description: "Live-update the in-container LogStore minimum level without restarting the session.",
+      side: "agent",
+      origin: RUNNER_CAP_ORIGIN,
+      audience: ["runtime"],
+      kind: "effect",
+      input: setLogLevelInput,
+      handler: async (input) => {
+        if (handlers.setLogLevel) {
+          return handlers.setLogLevel(input);
+        }
+        const candidate = input.level;
+        if (VALID_LOG_STORE_LEVELS.has(candidate)) {
+          getLogStore()?.setLevel(candidate);
+        }
+        return { ok: true };
+      }
+    }),
+    defineCapability({
+      name: "runner.set_state",
+      displayName: "Set state",
+      description: "Write into the session shared state store. Shape matches the legacy state_action command body.",
+      side: "agent",
+      origin: RUNNER_CAP_ORIGIN,
+      audience: ["runtime"],
+      kind: "effect",
+      input: setStateInput,
+      handler: async (input) => {
+        if (!handlers.setState) {
+          return notImplemented("runner.set_state");
+        }
+        return handlers.setState({
+          store: input.store,
+          key: input.key,
+          value: input.value
+        });
+      }
+    }),
+    defineCapability({
+      name: "runner.lifecycle",
+      displayName: "Session lifecycle",
+      description: "Transition the session lifecycle: hibernate to disk, close the active flow, or shut down the runner.",
+      side: "agent",
+      origin: RUNNER_CAP_ORIGIN,
+      audience: ["runtime"],
+      kind: "effect",
+      input: lifecycleInput,
+      handler: async (input) => {
+        if (!handlers.lifecycle) {
+          return notImplemented("runner.lifecycle");
+        }
+        return handlers.lifecycle(input);
+      }
+    })
+  ];
+}
+
+// runner/src/session-stimulus.ts
+var DEFAULT_COALESCE_MS = 50;
+function createSessionStimulusBus(opts) {
+  const { driveTurn, defaultCoalesceMs = DEFAULT_COALESCE_MS, log } = opts;
+  const queues = /* @__PURE__ */ new Map();
+  function getQueue(connectorId) {
+    let q = queues.get(connectorId);
+    if (!q) {
+      q = { pending: [], timer: null, inFlight: false };
+      queues.set(connectorId, q);
+    }
+    return q;
+  }
+  function startTimerIfNeeded(connectorId, q, coalesceMs) {
+    if (q.timer != null) return;
+    if (q.inFlight) return;
+    q.timer = setTimeout(() => {
+      q.timer = null;
+      void flushQueue(connectorId, q);
+    }, coalesceMs);
+  }
+  async function flushQueue(connectorId, q) {
+    if (q.pending.length === 0) return;
+    const batch = q.pending;
+    q.pending = [];
+    q.inFlight = true;
+    const fragments = batch.map((e) => e.signal.promptFragment);
+    const metas = batch.map((e) => e.signal.meta).filter((m) => m !== void 0);
+    const joined = fragments.join("\n\n");
+    log?.debug("turn driving", {
+      connectorId,
+      count: batch.length,
+      fragmentLength: joined.length
+    });
+    try {
+      await driveTurn(joined, metas);
+      log?.debug("turn drained", {
+        connectorId,
+        count: batch.length,
+        fragmentLength: joined.length
+      });
+      for (const entry of batch) entry.resolve();
+    } catch (err) {
+      log?.debug("turn failed", {
+        connectorId,
+        count: batch.length,
+        fragmentLength: joined.length,
+        error: err instanceof Error ? err.message : String(err)
+      });
+      for (const entry of batch) entry.reject(err);
+    } finally {
+      q.inFlight = false;
+      if (q.pending.length > 0) {
+        const nextWindow = q.pending[q.pending.length - 1]?.signal.coalesceMs ?? defaultCoalesceMs;
+        startTimerIfNeeded(connectorId, q, nextWindow);
+      }
+    }
+  }
+  return {
+    signal(connectorId, sig) {
+      const coalesceMs = sig.coalesceMs ?? defaultCoalesceMs;
+      log?.debug("stimulus signaled", {
+        connectorId,
+        fragmentLength: sig.promptFragment.length
+      });
+      return new Promise((resolve3, reject) => {
+        const q = getQueue(connectorId);
+        q.pending.push({ signal: sig, resolve: resolve3, reject });
+        startTimerIfNeeded(connectorId, q, coalesceMs);
+      });
+    }
+  };
+}
+
+// runner/src/serve.ts
+function getSessionCatalogEntries(session) {
+  return session?.runtimeAssets?.catalogEntries ?? [];
+}
+function emitSystemPromptComposed(agentSession, sendEvent) {
+  sendEvent({
+    type: "system_prompt_composed",
+    sections: agentSession.systemPromptSections,
+    composedAt: (/* @__PURE__ */ new Date()).toISOString()
+  });
+}
+var FRAMEWORK_PACKAGES = [
+  "@skaile/workspaces/runner",
+  "@skaile/workspaces/bridge",
+  "@skaile/workspaces/core",
+  "@skaile/workspaces/types",
+  "@skaile/workspaces/base-assets",
+  "@skaile/workspaces/connectors",
+  "@skaile/workspaces/resolver",
+  "@skaile/workspaces/transport",
+  "@skaile/workspaces/workspace-plugin"
+];
+var _frameworkVersions = null;
+function getFrameworkVersions() {
+  if (_frameworkVersions) return _frameworkVersions;
+  const versions = {};
+  for (const pkg of FRAMEWORK_PACKAGES) {
+    try {
+      const pjPath = __require.resolve(`${pkg}/package.json`);
+      const pj = JSON.parse(readFileSync(pjPath, "utf-8"));
+      versions[pkg.replace("@skaile/", "")] = pj.version;
+    } catch {
+    }
+  }
+  _frameworkVersions = versions;
+  return versions;
+}
+function findAiAssetsRoot(startDir) {
+  let dir = startDir;
+  for (let i = 0; i < 6; i++) {
+    const candidate = join(dir, "ai-assets");
+    if (existsSync(candidate)) return candidate;
+    dir = join(dir, "..");
+  }
+  return null;
+}
+function ensureGitConfigInclude(managedGitconfigPath) {
+  const home = process.env.HOME ?? homedir();
+  if (!home) return;
+  const gitconfigPath = join(home, ".gitconfig");
+  let existing = "";
+  try {
+    existing = readFileSync(gitconfigPath, "utf-8");
+  } catch {
+  }
+  const sectionRe = /^\s*\[([^\]\s]+)(?:\s+"[^"]*")?\]\s*$/;
+  const pathKeyRe = /^\s*path\s*=\s*(.+?)\s*$/;
+  let currentSection = null;
+  for (const line of existing.split(/\r?\n/)) {
+    const sectionMatch = line.match(sectionRe);
+    if (sectionMatch) {
+      currentSection = sectionMatch[1]?.toLowerCase() ?? null;
+      continue;
+    }
+    if (currentSection !== "include" && currentSection !== "includeif") continue;
+    const pathMatch = line.match(pathKeyRe);
+    if (pathMatch?.[1] === managedGitconfigPath) return;
+  }
+  if (!existsSync(dirname(gitconfigPath))) {
+    mkdirSync(dirname(gitconfigPath), { recursive: true });
+  }
+  const block = `${existing.trimEnd()}
+# skaile-runner: managed-gitconfig include
+[include]
+	path = ${managedGitconfigPath}
+`;
+  writeFileSync(gitconfigPath, block, { mode: 420 });
+}
+async function startAgentServer(opts) {
+  const port = opts.port ?? 8080;
+  const sessionId = opts.sessionId ?? process.env.SKAILE_SESSION_ID ?? "session-unknown";
+  const resumeSessionId = opts.resumeSessionId ?? process.env.SKAILE_RESUME_SESSION_ID;
+  const wsConfig = resolveSkWorkspaceConfig(opts.projectDir);
+  const { store: logStore, dispose: disposeLogStore } = bootstrapRunnerLogStore({
+    sessionId,
+    projectDir: opts.projectDir,
+    yamlBlock: wsConfig.logging,
+    onLog: opts.onLog
+  });
+  const serverLog = createLogger({
+    kind: "runner",
+    subkind: "session",
+    instance: sessionId
+  });
+  const log = (line) => serverLog.info(line);
+  const profile = wsConfig.agent_config?.default;
+  const maxTurns = wsConfig.agent?.permissions?.max_turns ?? profile?.max_turns;
+  const managedGitconfigPath = join(opts.projectDir, ".skaile", "managed-gitconfig");
+  process.env.GIT_CONFIG_GLOBAL = managedGitconfigPath;
+  try {
+    ensureGitConfigInclude(managedGitconfigPath);
+  } catch (err) {
+    serverLog.warn("failed to write ~/.gitconfig include \u2014 relying on env only", {
+      error: err instanceof Error ? err.message : String(err)
+    });
+  }
+  const agentDir = opts.agentDir ?? resolveAgentDir(opts.projectDir);
+  if (agentDir) {
+    serverLog.info("agent dir resolved", { agentDir });
+  } else {
+    serverLog.warn("no agent definition found in skaile.yaml");
+  }
+  const transport = opts.transport ?? new WebSocketServerTransport({ port, onLog: log });
+  logStore.addSink(
+    new WsLogSink({
+      send: (event) => {
+        if (transport.connected) transport.send(event);
+      }
+    })
+  );
+  function sendEvent(event) {
+    if (transport.connected) {
+      transport.send(event);
+    }
+  }
+  const capabilityRegistry = new CapabilityRegistry(
+    createLogger({
+      kind: "runner",
+      subkind: "capability-registry",
+      instance: sessionId
+    })
+  );
+  bootstrapCapabilityRegistry(capabilityRegistry);
+  const pendingCapabilityCalls = /* @__PURE__ */ new Map();
+  const remoteCapabilityInvoker = (name, input) => {
+    const callId = typeof crypto?.randomUUID === "function" ? crypto.randomUUID() : `rcap-${Date.now()}-${Math.floor(Math.random() * 1e9)}`;
+    return new Promise((resolve3, reject) => {
+      if (!transport.connected) {
+        reject(new Error(`Transport disconnected; cannot invoke remote capability ${name}`));
+        return;
+      }
+      const timer = setTimeout(() => {
+        pendingCapabilityCalls.delete(callId);
+        reject(new Error(`Remote capability ${name} (callId=${callId}) timed out`));
+      }, DEFAULT_CAPABILITY_CALL_TIMEOUT_MS);
+      pendingCapabilityCalls.set(callId, { resolve: resolve3, reject, timer });
+      transport.send({
+        type: "capability_invoked",
+        callId,
+        name,
+        input,
+        invokedBy: "agent"
+      });
+    });
+  };
+  let aiProviderConfigId;
+  const onAuthError = async (args) => {
+    if (!transport.connected || aiProviderConfigId === void 0) {
+      log("[serve] auth error: no transport or no aiProviderConfigId; surfacing");
+      return {
+        ok: false,
+        code: "not-configured",
+        message: "no transport or aiProviderConfigId; standalone runner cannot mediate refresh"
+      };
+    }
+    const targetConfigId = args.configId || aiProviderConfigId;
+    log("[serve] auth error: invoking host.refresh_credential capability");
+    try {
+      const result = await capabilityRegistry.invokeRemote("host.refresh_credential", {
+        kind: "ai-credentials",
+        id: targetConfigId,
+        reason: "retry-401"
+      });
+      if (!result?.ok) {
+        log(`[serve] auth error: mint failed (code=${result?.code ?? "backend-error"}); surfacing`);
+        return result ?? { ok: false, code: "backend-error", message: "no result from host" };
+      }
+      const home = process.env.HOME ?? homedir();
+      if (!home) {
+        log("[serve] auth error: HOME unset; cannot rewrite credentials file");
+        return {
+          ok: false,
+          code: "backend-error",
+          message: "HOME env var unset; cannot rewrite credentials file"
+        };
+      }
+      await mergeAndRewriteCredentialsFile(home, result.token, result.expiresAt ?? null);
+      log("[serve] auth error: rewrote .credentials.json with mediated accessToken");
+      return result;
+    } catch (err) {
+      const errMsg = err instanceof Error ? err.message : String(err);
+      log(`[serve] auth error: host.refresh_credential threw: ${errMsg}`);
+      return { ok: false, code: "backend-error", message: errMsg };
+    }
+  };
+  const APPROVAL_REQUIRED_CAPABILITY_TIMEOUT_MS = 15 * 60 * 1e3;
+  function buildClientCapabilityHandler2(wire) {
+    return buildClientCapabilityHandler({
+      wire,
+      pending: pendingCapabilityCalls,
+      emit: (event) => sendEvent(event),
+      timeoutMs: wire.requiresApproval ? APPROVAL_REQUIRED_CAPABILITY_TIMEOUT_MS : DEFAULT_CAPABILITY_CALL_TIMEOUT_MS
+    });
+  }
+  function buildCapabilityHooks() {
+    return {
+      sessionId,
+      composeTools: () => capabilityRegistry.composeLLMTools(),
+      resolve: (name) => {
+        const cap = capabilityRegistry.resolve(name);
+        if (!cap) return null;
+        return capabilityRegistry.list().find((c) => c.name === name) ?? null;
+      },
+      invoke: (name, input) => capabilityRegistry.invoke(name, input, { sessionId }),
+      emitRender: (event) => sendEvent(event),
+      emitText: (text) => sendEvent({
+        type: "text",
+        content: text
+      })
+    };
+  }
+  function registerSessionComposition(session) {
+    if (session.composition?.discoverableEntries.length) {
+      registerCompositionCapabilities(capabilityRegistry, session.composition.discoverableEntries);
+      log(
+        `[serve] registered ${session.composition.discoverableEntries.length} composition capabilities`
+      );
+    }
+  }
+  const secretsMode = wsConfig.secrets?.provider ?? "env";
+  wsConfig.secrets?.timeoutMs ?? 3e4;
+  function buildSessionConfig(secretProvider2, apiKey) {
+    return {
+      projectDir: opts.projectDir,
+      agentDir,
+      driver: opts.driver,
+      model: opts.model,
+      provider: opts.provider,
+      promptsDir: opts.promptsDir,
+      sessionId,
+      resumeSessionId,
+      maxTurns,
+      wsConfig,
+      externalPromptFile: process.env.SKAILE_SYSTEM_PROMPT_FILE,
+      secretProvider: secretProvider2,
+      onAuthError,
+      ...apiKey ? { apiKey } : {},
+      // Protocol v2 `<CAPABILITIES>` block — joins each registered capability's
+      // `promptFragment` (framework first, then client, then agent-side
+      // surfaces). Built lazily inside `buildSessionConfig` so newly registered
+      // capabilities (e.g. via mid-session `capability_register` commands) are
+      // reflected on the next session rebuild.
+      additionalPromptSections: (() => {
+        const sections = [];
+        const capSection = buildCapabilitiesPromptSection(capabilityRegistry);
+        if (capSection) sections.push(capSection);
+        return sections.length > 0 ? sections : void 0;
+      })(),
+      watch: {
+        onSyncStatus: (mountId, status) => {
+          sendEvent({
+            type: "sync_status",
+            mountId,
+            ...status,
+            phase: status.phase
+          });
+          if (status.phase === "stubs_ready") {
+            log(
+              `[serve] ${mountId}: file tree ready (${status.totalFiles} files, ${status.stubFiles} stubs)`
+            );
+          } else if (status.phase === "initial_sync_complete") {
+            log(
+              `[serve] ${mountId}: sync complete (${status.downloadedFiles}/${status.totalFiles} downloaded)`
+            );
+          }
+        },
+        onFileChanged: (_connectorId, event) => {
+          sendEvent({
+            type: "file_changed",
+            path: event.path,
+            action: event.action
+          });
+        },
+        onMountChanged: (volId, event) => {
+          sendEvent({
+            type: "file_changed",
+            path: event.path,
+            action: event.action,
+            mountId: volId
+          });
+        }
+      },
+      onLog: (line) => log(`[serve] ${line}`),
+      capabilities: buildCapabilityHooks(),
+      // v3: pre-minted credentials replace the tokenMediator for initial mints.
+      // Refresh routes through `host.refresh_credential` (invoked from the
+      // bridge driver's onAuthError callback). The legacy `tokenMediator`
+      // wire is gone.
+      ...preMintedSecrets ? { preMintedSecrets } : {},
+      ...aiProviderConfigId ? { aiProviderConfigId } : {}
+    };
+  }
+  let resolveSessionReady;
+  let rejectSessionReady;
+  const sessionReady = new Promise((resolve3, reject) => {
+    resolveSessionReady = resolve3;
+    rejectSessionReady = reject;
+  });
+  let sessionConfig;
+  let agentSession;
+  let secretProvider;
+  let runtimeIdentity;
+  let preMintedSecrets;
+  if (secretsMode === "provisioned") {
+    log("[serve] secrets mode: provisioned \u2014 waiting for provision_secrets command");
+  } else {
+    sessionConfig = buildSessionConfig();
+    agentSession = await createAgentSession(sessionConfig);
+    emitSystemPromptComposed(agentSession, sendEvent);
+    registerSessionComposition(agentSession);
+    resolveSessionReady();
+  }
+  let resourceManager = secretsMode === "env" ? agentSession.resourceManager : null;
+  let mountManager = secretsMode === "env" ? agentSession.mountManager : null;
+  if (secretsMode === "env") {
+    if (!agentSession.provider) {
+      log(
+        `[serve] WARNING: no API key found for ${agentSession.provider ?? "anthropic"} \u2014 agent calls will fail`
+      );
+      log(`[serve] Pass via env var (e.g. ANTHROPIC_API_KEY) or .skaile/settings.json`);
+    }
+    if (resourceManager) {
+      const watched = resourceManager.watchedResources ?? [];
+      if (watched.length > 0) {
+        log(`[serve] watching ${watched.length} resource(s): ${watched.join(", ")}`);
+      }
+    }
+  }
+  if (secretsMode === "env" && agentSession.runtimeAssets) {
+    for (const w of agentSession.runtimeAssets.warnings) {
+      const asset = w.code === "missing_driver" && w.declarationId ? `${w.declarationId} \u2192 ${w.name ?? "unknown"}` : w.name ?? w.code;
+      log(`[serve] validation_warning: ${w.code}: ${w.message}`);
+      sendEvent({
+        type: "validation_warning",
+        asset,
+        reason: w.code,
+        suggestion: w.message
+      });
+    }
+  }
+  try {
+    const wsConfig2 = resolveSkWorkspaceConfig(opts.projectDir);
+    const aiResources = wsConfig2.ai_resources;
+    if (aiResources) {
+      for (const res of Array.isArray(aiResources) ? aiResources : [aiResources]) {
+        const deps = res.dependencies;
+        if (Array.isArray(deps)) {
+          for (const dep of deps) {
+            const ref = typeof dep === "string" ? dep : dep?.ref ?? dep?.name;
+            if (ref) {
+              const skillDir = join(
+                opts.projectDir,
+                ".claude",
+                "skills",
+                ref.replace(/^skill:/, "")
+              );
+              if (!existsSync(skillDir)) {
+                log(
+                  `[serve] validation_warning: dependency "${ref}" not found \u2014 continuing without it`
+                );
+                sendEvent({
+                  type: "validation_warning",
+                  asset: ref,
+                  reason: "not_found",
+                  suggestion: "Sync the catalog and re-add this asset"
+                });
+              }
+            }
+          }
+        }
+      }
+    }
+  } catch {
+  }
+  const normalizer = new EventNormalizer();
+  function forwardNormalizedEvent(event) {
+    if (compacting) return;
+    const isTransient = event.type === "status" || event.type === "sync_status" || event.type === "resources_available" || event.type === "resource_response" || event.type === "commands_available";
+    if (!isTransient) {
+      eventSeq++;
+      compactionOrchestrator?.trackMessage(eventSeq);
+    }
+    if (event.type === "finished") {
+      if (!compacting && compactionOrchestrator?.shouldCompact()) {
+        compactionOrchestrator.compact("threshold").catch((err) => {
+          log(
+            `[serve] auto-compaction failed: ${err instanceof Error ? err.message : String(err)}`
+          );
+        });
+      }
+    }
+    if (!mountManager) {
+      sendEvent(event);
+      return;
+    }
+    const mounts = mountManager.listMounts().map(
+      (info) => ({
+        id: info.id,
+        mountPath: mountManager.get(info.id).handle.mountPath
+      })
+    );
+    sendEvent(rewriteFileChangedPath(event, opts.projectDir, mounts));
+  }
+  let driverStarted = false;
+  let driver = secretsMode === "env" ? agentSession.driver : void 0;
+  let secretsProvisioned = secretsMode === "env";
+  let eventSeq = 0;
+  let compacting = false;
+  let compactionOrchestrator = null;
+  const compactionConfig = wsConfig.compaction;
+  function rebuildCompactionOrchestrator() {
+    if (!driver) return;
+    compactionOrchestrator = new CompactionOrchestrator({
+      driver,
+      config: compactionConfig,
+      onCompactionStart: (trigger) => {
+        compacting = true;
+        sendEvent({ type: "status", phase: "compacting" });
+        log(`[serve] compaction started (trigger=${trigger})`);
+      },
+      onSnapshot: (snapshot) => {
+        sendEvent(snapshot);
+      },
+      onCompactionAttempt: (event) => {
+        sendEvent(event);
+      },
+      onCompactionEnd: () => {
+        compacting = false;
+        sendEvent({ type: "status", phase: "idle" });
+      },
+      onLog: (line) => log(`[serve] ${line}`),
+      // Phase 3: stamp every CompactionAttemptEvent with the registry's
+      // current signature so wake-time tier-1 selection has the input it
+      // needs. The registry exists for the entire serve lifetime, so this
+      // closure is safe across orchestrator rebuilds.
+      getCurrentCapabilitySignature: () => computeCapabilitySignature(capabilityRegistry.list())
+    });
+  }
+  if (secretsMode === "env" && driver) {
+    rebuildCompactionOrchestrator();
+  }
+  const activeFlows = /* @__PURE__ */ new Map();
+  let stimulusBus = null;
+  const FLOW_TURN_TIMEOUT_MS = 4 * 60 * 60 * 1e3;
+  function getOnlyActiveFlow() {
+    const iter = activeFlows.values().next();
+    return iter.done ? null : iter.value;
+  }
+  function getOrCreateStimulusBus() {
+    if (stimulusBus) return stimulusBus;
+    stimulusBus = createSessionStimulusBus({
+      driveTurn: async (promptFragment, metas) => {
+        const lastMeta = metas[metas.length - 1] ?? {};
+        const runId = typeof lastMeta.runId === "string" ? lastMeta.runId : null;
+        const entry = runId ? activeFlows.get(runId) : getOnlyActiveFlow();
+        if (!entry) {
+          serverLog.warn("driveTurn fired with no active flow", { runId });
+          return;
+        }
+        const lastKind = lastMeta.kind;
+        let stimulus;
+        if (lastKind === "flow_started") {
+          stimulus = { kind: "flow_started" };
+        } else if (lastKind === "user_message" && typeof lastMeta.text === "string") {
+          stimulus = {
+            kind: "user_message",
+            text: String(lastMeta.text),
+            senderId: String(lastMeta.senderId ?? "user")
+          };
+        } else {
+          stimulus = { kind: "state_changed" };
+        }
+        const fullPrompt = buildOrchestratorPrompt(
+          entry.flowDef,
+          entry.adapter.getExecution(entry.handle),
+          stimulus
+        );
+        if (!driverStarted) {
+          await driver.start();
+          driverStarted = true;
+          driver.on("agent-event", (event) => {
+            const normalized = normalizer.normalize(event);
+            for (const e of normalized) forwardNormalizedEvent(e);
+          });
+          driver.on("error", (err) => {
+            log(`[serve] driver error: ${err.message}`);
+            sendEvent({ type: "error", message: err.message, fatal: true });
+          });
+        }
+        await awaitFlowAgentEnd(fullPrompt, FLOW_TURN_TIMEOUT_MS);
+      },
+      log: serverLog
+    });
+    return stimulusBus;
+  }
+  function awaitFlowAgentEnd(prompt, timeoutMs) {
+    return new Promise((resolve3, reject) => {
+      let settled = false;
+      const onEvent = (event) => {
+        if (event.type === "agent_end") done();
+        else if (event.type === "error") {
+          const msg = event.error ?? event.message ?? "Agent error";
+          done(new Error(msg));
+        }
+      };
+      const done = (err) => {
+        if (settled) return;
+        settled = true;
+        clearTimeout(timer);
+        driver.off?.(
+          "agent-event",
+          onEvent
+        ) ?? driver.removeListener("agent-event", onEvent);
+        if (err) reject(err);
+        else resolve3();
+      };
+      const timer = setTimeout(
+        () => done(new Error(`Flow turn timed out after ${timeoutMs / 1e3}s`)),
+        timeoutMs
+      );
+      driver.on("agent-event", onEvent);
+      driver.prompt(prompt).catch(done);
+    });
+  }
+  async function createActiveFlow(flowDef, seedOrExecution) {
+    if (!resourceManager) {
+      registerBuiltinConnectorAdapters();
+      resourceManager = new ConnectorManager(void 0, {
+        catalogEntries: getSessionCatalogEntries(agentSession)
+      });
+      log("[serve] created ConnectorManager for flow execution (no other connectors declared)");
+    }
+    const bus = getOrCreateStimulusBus();
+    const baseOptions = {
+      stimulusBus: bus,
+      useBusForStimulus: true
+    };
+    const options = "execution" in seedOrExecution ? { flow: flowDef, execution: seedOrExecution.execution, ...baseOptions } : { flow: flowDef, seed: seedOrExecution.seed, ...baseOptions };
+    const seedRunId = "execution" in seedOrExecution ? seedOrExecution.execution.runId : seedOrExecution.seed.runId;
+    const connectorId = `flow:${seedRunId}`;
+    const handle = await resourceManager.connect({
+      id: connectorId,
+      driver: "flow",
+      access: "read-write",
+      options
+    });
+    const adapter = resourceManager.get(connectorId).adapter;
+    const runId = adapter.getExecution(handle).runId;
+    adapter.onStateChange(handle, (state) => {
+      sendEvent({
+        type: "state_changed",
+        store: `flow:${state.runId}`,
+        state
+      });
+    });
+    if (agentSession?.driverType === "claude-sdk") {
+      try {
+        const server = await buildSdkConnectorTools(resourceManager, { z: z });
+        if (server) {
+          if (driverStarted) {
+            const prevSessionId = driver.runtimeSessionId;
+            log(
+              `[serve] restarting driver to register flow connector tools (resume=${prevSessionId ?? "none"})`
+            );
+            await agentSession.dispose();
+            agentSession = await createAgentSession({
+              ...sessionConfig,
+              resumeSessionId: prevSessionId
+            });
+            emitSystemPromptComposed(agentSession, sendEvent);
+            driver = agentSession.driver;
+            normalizer.reset();
+            driverStarted = false;
+            rebuildCompactionOrchestrator();
+          }
+          driver.config.mcpServers = { "skaile-connectors": server };
+          log(`[serve] rebuilt MCP connector tools for flow ${connectorId}`);
+        } else {
+          log(`[serve] buildSdkConnectorTools returned null for flow ${connectorId}`);
+        }
+      } catch (err) {
+        const errMsg = err instanceof Error ? err.message : String(err);
+        log(`[serve] failed to rebuild MCP tools for flow: ${errMsg}`);
+      }
+    }
+    const entry = { runId, flowDef, adapter, handle, connectorId };
+    activeFlows.set(runId, entry);
+    return entry;
+  }
+  const refreshFlagPath = join(opts.projectDir, ".skaile", "refresh-request");
+  try {
+    mkdirSync(join(opts.projectDir, ".skaile"), { recursive: true });
+    if (!existsSync(refreshFlagPath)) {
+      writeFileSync(refreshFlagPath, "", { mode: 432, flag: "a" });
+    }
+  } catch (err) {
+    serverLog.warn("failed to pre-create refresh-flag \u2014 wake-mid-401 disabled", {
+      error: err instanceof Error ? err.message : String(err)
+    });
+  }
+  let lastRefreshAt = 0;
+  const REFRESH_DEBOUNCE_MS = 2e3;
+  let refreshFlagWatcher = null;
+  try {
+    refreshFlagWatcher = watch(refreshFlagPath, (event) => {
+      if (event !== "change") return;
+      const now = Date.now();
+      if (now - lastRefreshAt < REFRESH_DEBOUNCE_MS) return;
+      lastRefreshAt = now;
+      void dispatchRefreshToExposedGitMounts(mountManager, serverLog);
+    });
+  } catch (err) {
+    serverLog.warn("fs.watch on refresh-flag failed \u2014 wake-mid-401 disabled", {
+      error: err instanceof Error ? err.message : String(err)
+    });
+  }
+  async function cleanup() {
+    try {
+      await Promise.race([
+        sessionReady,
+        new Promise((resolve3) => {
+          const t = setTimeout(resolve3, 2e3);
+          t.unref?.();
+        })
+      ]);
+    } catch {
+    }
+    try {
+      driver?.kill();
+    } catch {
+    }
+    for (const [callId, pending] of pendingCapabilityCalls) {
+      clearTimeout(pending.timer);
+      pending.reject(new Error(`Session terminated before capability_result (callId=${callId})`));
+    }
+    pendingCapabilityCalls.clear();
+    try {
+      refreshFlagWatcher?.close();
+    } catch {
+    }
+    refreshFlagWatcher = null;
+    if (agentSession) {
+      try {
+        await agentSession.dispose();
+      } catch {
+      }
+    }
+  }
+  async function handleCommand(cmd) {
+    switch (cmd.type) {
+      case "session_init": {
+        if (cmd.protocolVersion.major !== PROTOCOL_VERSION.major) {
+          log(
+            `[serve] incompatible protocol: agent=${PROTOCOL_VERSION.major} platform=${cmd.protocolVersion.major}`
+          );
+          sendEvent({
+            type: "incompatible_protocol",
+            agentVersion: PROTOCOL_VERSION,
+            platformVersion: cmd.protocolVersion
+          });
+          await cleanup();
+          disposeLogStore();
+          return;
+        }
+        if (runtimeIdentity && runtimeIdentity.containerId !== cmd.identity.containerId) {
+          log(
+            `[serve] session_init_mismatch: expected=${runtimeIdentity.containerId} received=${cmd.identity.containerId}`
+          );
+          sendEvent({
+            type: "session_init_mismatch",
+            expectedContainerId: runtimeIdentity.containerId,
+            receivedContainerId: cmd.identity.containerId
+          });
+          await cleanup();
+          disposeLogStore();
+          return;
+        }
+        runtimeIdentity = cmd.identity;
+        const incoming = cmd.capabilities ?? [];
+        for (const wire of incoming) {
+          if (wire.audience && !wire.audience.includes("llm") && !wire.audience.includes("user")) {
+            continue;
+          }
+          const stub = {
+            ...wire,
+            inputZod: { parse: (v) => v },
+            outputZod: void 0,
+            handler: buildClientCapabilityHandler2(wire)
+          };
+          capabilityRegistry.register(stub, "client");
+        }
+        sendEvent({ type: "protocol_info", version: PROTOCOL_VERSION });
+        preMintedSecrets = new PreMintedSecretProvider(cmd.credentials);
+        if (cmd.secrets) {
+          const ccdValue = cmd.secrets[CLAUDE_CODE_CREDENTIALS_KEY];
+          if (ccdValue) {
+            const home = process.env.HOME ?? homedir();
+            if (home) {
+              try {
+                await writeClaudeCodeCredentialsFile(home, ccdValue);
+                log(
+                  `[serve] wrote Claude Code credentials file to ${home}/.claude/.credentials.json (mode 0600)`
+                );
+              } catch (err) {
+                const errMsg = err instanceof Error ? err.message : String(err);
+                log(`[serve] failed to write Claude Code credentials file: ${errMsg}`);
+              }
+            }
+          }
+          const otherSecrets = Object.fromEntries(
+            Object.entries(cmd.secrets).filter(([k]) => k !== CLAUDE_CODE_CREDENTIALS_KEY)
+          );
+          const provider = new InMemorySecretProvider();
+          provider.provision(otherSecrets);
+          secretProvider = provider;
+          secretsProvisioned = true;
+        }
+        try {
+          const effectiveProvider = opts.provider ?? "anthropic";
+          const envKey = providerEnvKey(effectiveProvider);
+          const apiKeyFromSecrets = cmd.secrets?.[envKey];
+          sessionConfig = buildSessionConfig(secretProvider, apiKeyFromSecrets);
+          if (!agentSession) {
+            agentSession = await createAgentSession(sessionConfig);
+            emitSystemPromptComposed(agentSession, sendEvent);
+            resourceManager = agentSession.resourceManager;
+            mountManager = agentSession.mountManager;
+            driver = agentSession.driver;
+            rebuildCompactionOrchestrator();
+            registerSessionComposition(agentSession);
+            const mountList = mountManager?.listMounts?.() ?? [];
+            const connectorList = resourceManager?.listConnectors?.() ?? [];
+            sendEvent({
+              type: "resources_available",
+              mounts: mountList,
+              connectors: connectorList
+            });
+            agentSession.startWatching();
+            capabilityRegistry.setRemoteInvoker(remoteCapabilityInvoker);
+            const runnerCaps = buildRunnerCapabilities({
+              // setLogLevel is left undefined — the cap's built-in fallback
+              // calls `getLogStore()?.setLevel(...)` directly, which matches
+              // the legacy `set_log_level` AgentCommand body 1:1.
+              // Other handlers (addMount / addConnector / removeResource /
+              // updateCredential / setState / lifecycle) remain stubs;
+              // wiring is tracked under AF-PV3 / F-RUNNER-CAPS.
+            });
+            for (const cap of runnerCaps) {
+              capabilityRegistry.register(cap, "agent");
+            }
+            resolveSessionReady();
+            log("[serve] session built from session_init envelope");
+          }
+        } catch (err) {
+          const errMsg = err instanceof Error ? err.message : String(err);
+          log(`[serve] session_init failed to build session: ${errMsg}`);
+          sendEvent({ type: "error", message: errMsg, fatal: true });
+          rejectSessionReady(err instanceof Error ? err : new Error(errMsg));
+        }
+        if (cmd.resolvedConfig.aiProviderConfigId) {
+          aiProviderConfigId = cmd.resolvedConfig.aiProviderConfigId;
+          log(`[serve] stashed aiProviderConfigId=${aiProviderConfigId}`);
+        }
+        const cfg = {
+          aiResources: cmd.resolvedConfig.aiResources,
+          subagents: cmd.resolvedConfig.subagents,
+          sharedState: cmd.sharedState,
+          resumeSessionId: cmd.resume?.sessionId,
+          expectedCapabilitySignature: cmd.resume?.expectedCapabilitySignature,
+          aiProviderConfigId: cmd.resolvedConfig.aiProviderConfigId
+        };
+        log(
+          `[serve] configure cfg keys=${Object.keys(cfg).join(",")} sharedState=${cfg.sharedState ? cfg.sharedState.length : "undefined"} resourceManager=${resourceManager ? "set" : "null"}`
+        );
+        if (cfg.aiProviderConfigId) {
+          aiProviderConfigId = cfg.aiProviderConfigId;
+          log(`[serve] stashed aiProviderConfigId=${aiProviderConfigId}`);
+        }
+        let pendingResumeSessionId;
+        const cfgResumeSessionId = cfg.resumeSessionId;
+        const cfgExpectedSig = cfg.expectedCapabilitySignature;
+        if (cfgResumeSessionId) {
+          const currentSig = computeCapabilitySignature(capabilityRegistry.list());
+          if (cfgExpectedSig && cfgExpectedSig !== currentSig) {
+            log(
+              `[serve] tier-1 resume rejected: signature mismatch (expected=${cfgExpectedSig.slice(0, 12)} current=${currentSig.slice(0, 12)})`
+            );
+            sendEvent({
+              type: "resume_failed",
+              resumeSessionId: cfgResumeSessionId,
+              reason: "signature_mismatch"
+            });
+          } else {
+            log(`[serve] tier-1 resume attempted: resumeSessionId=${cfgResumeSessionId}`);
+            sendEvent({
+              type: "resume_attempted",
+              resumeSessionId: cfgResumeSessionId,
+              capabilitySignature: currentSig
+            });
+            pendingResumeSessionId = cfgResumeSessionId;
+          }
+        }
+        if (pendingResumeSessionId || cfg.subagents) {
+          await agentSession.dispose();
+          agentSession = await createAgentSession({
+            ...sessionConfig,
+            ...aiProviderConfigId ? { aiProviderConfigId } : {},
+            ...pendingResumeSessionId ? { resumeSessionId: pendingResumeSessionId } : {}
+          });
+          emitSystemPromptComposed(agentSession, sendEvent);
+          driver = agentSession.driver;
+          normalizer.reset();
+          driverStarted = false;
+          rebuildCompactionOrchestrator();
+        }
+        if (cfg.sharedState) {
+          if (!resourceManager) {
+            try {
+              registerBuiltinConnectorAdapters();
+              resourceManager = new ConnectorManager(void 0, {
+                catalogEntries: getSessionCatalogEntries(agentSession)
+              });
+              log("[serve] created ConnectorManager for sharedState (no connectors were declared)");
+            } catch (err) {
+              const errMsg = err instanceof Error ? err.message : String(err);
+              log(`[serve] failed to create ConnectorManager: ${errMsg}`);
+              sendEvent({ type: "configured" });
+              break;
+            }
+          }
+          let storesRegistered = 0;
+          for (const stateConfig of cfg.sharedState) {
+            try {
+              if (resourceManager.has(stateConfig.id)) {
+                try {
+                  const snapshot = await resourceManager.executeOp(stateConfig.id, "get", {});
+                  const state = snapshot ? JSON.parse(snapshot) : {};
+                  sendEvent({
+                    type: "state_changed",
+                    store: stateConfig.id,
+                    state
+                  });
+                  log(
+                    `[serve] sharedState ${stateConfig.id} already registered \u2014 re-emitted current state`
+                  );
+                } catch {
+                  log(
+                    `[serve] sharedState ${stateConfig.id} already registered \u2014 skipping (could not read state)`
+                  );
+                }
+                continue;
+              }
+              const handle = await resourceManager.connect({
+                id: stateConfig.id,
+                driver: stateConfig.adapter,
+                access: "read-write",
+                options: {
+                  ...stateConfig.definition ?? {},
+                  initial: stateConfig.initialState ?? {}
+                }
+              });
+              const entry = resourceManager.get(stateConfig.id);
+              if (typeof entry.adapter.onStoreChange === "function") {
+                entry.adapter.onStoreChange(handle, (snapshot) => {
+                  sendEvent({
+                    type: "state_changed",
+                    store: stateConfig.id,
+                    state: snapshot
+                  });
+                });
+              }
+              log(`[serve] sharedState registered: ${stateConfig.id} (${stateConfig.adapter})`);
+              storesRegistered++;
+              sendEvent({
+                type: "state_changed",
+                store: stateConfig.id,
+                state: stateConfig.initialState ?? {}
+              });
+            } catch (err) {
+              const errMsg = err instanceof Error ? err.message : String(err);
+              log(`[serve] sharedState registration failed for ${stateConfig.id}: ${errMsg}`);
+              sendEvent({
+                type: "error",
+                message: `sharedState ${stateConfig.id}: ${errMsg}`,
+                fatal: false
+              });
+            }
+          }
+          if (storesRegistered > 0 && !driverStarted && agentSession?.driverType === "claude-sdk") {
+            try {
+              const server = await buildSdkConnectorTools(resourceManager, { z: z });
+              if (server) {
+                driver.config.mcpServers = { "skaile-connectors": server };
+                log(`[serve] rebuilt MCP connector tools (${storesRegistered} new store(s))`);
+              } else {
+                log(`[serve] buildSdkConnectorTools returned null`);
+              }
+            } catch (err) {
+              const errMsg = err instanceof Error ? err.message : String(err);
+              log(`[serve] failed to rebuild MCP tools: ${errMsg}`);
+            }
+          }
+        }
+        if (cfg.aiResources) {
+          const catalogActions = cfg.aiResources.filter((a) => a.action);
+          if (catalogActions.length > 0) {
+            log(`[serve] aiResources catalog actions: ${catalogActions.length}`);
+            try {
+              const skillsDir = join(
+                sessionConfig.projectDir ?? process.cwd(),
+                ".claude",
+                "skills"
+              );
+              const assetsRoot = process.env.SKAILE_ASSETS_ROOT ?? findAiAssetsRoot(sessionConfig.projectDir ?? process.cwd()) ?? "/app/ai-assets";
+              for (const res of catalogActions) {
+                if (res.action === "add" && res.entry) {
+                  const entry = res.entry;
+                  const result = deployCatalogEntry(entry, {
+                    assetsRoot,
+                    skillsDir,
+                    context: res.context
+                  });
+                  if (result.success) {
+                    log(`[serve] deployed skill: ${entry.name ?? res.name}`);
+                  } else {
+                    log(
+                      `[serve] failed to deploy skill ${entry.name ?? res.name}: ${result.error}`
+                    );
+                  }
+                } else if (res.action === "remove") {
+                  const removed = undeployCatalogEntry(res.name, skillsDir);
+                  log(`[serve] ${removed ? "removed" : "not found"} skill: ${res.name}`);
+                }
+              }
+              if (driverStarted) {
+                const prevSessionId = driver.runtimeSessionId;
+                log(
+                  `[serve] restarting driver to pick up skill changes (resume=${prevSessionId ?? "none"})`
+                );
+                await agentSession.dispose();
+                agentSession = await createAgentSession({
+                  ...sessionConfig,
+                  resumeSessionId: prevSessionId
+                });
+                emitSystemPromptComposed(agentSession, sendEvent);
+                driver = agentSession.driver;
+                normalizer.reset();
+                driverStarted = false;
+                rebuildCompactionOrchestrator();
+                sendEvent({
+                  type: "skills_changed",
+                  skills: catalogActions.map((a) => ({
+                    name: a.entry?.name ?? a.name,
+                    action: a.action ?? "add"
+                  }))
+                });
+              } else {
+                log(
+                  "[serve] aiResources applied before driver start \u2014 skills discovered on first prompt"
+                );
+              }
+            } catch (err) {
+              const errMsg = err instanceof Error ? err.message : String(err);
+              log(`[serve] aiResources handling failed: ${errMsg}`);
+              sendEvent({
+                type: "error",
+                message: `aiResources: ${errMsg}`,
+                fatal: false
+              });
+            }
+          }
+        }
+        sendEvent({
+          type: "session_init_ack",
+          capabilitySignature: computeCapabilitySignature(capabilityRegistry.list())
+        });
+        break;
+      }
+      case "prompt": {
+        try {
+          await sessionReady;
+        } catch (err) {
+          sendEvent({
+            type: "error",
+            message: `Session not available: ${err.message}`,
+            fatal: true
+          });
+          break;
+        }
+        if (!secretsProvisioned) {
+          log("[serve] prompt received before secrets provisioned \u2014 rejecting");
+          sendEvent({
+            type: "error",
+            message: "Secrets not yet provisioned \u2014 send provision_secrets first",
+            fatal: false
+          });
+          break;
+        }
+        log(`[serve] prompt: ${cmd.prompt.slice(0, 80)}...`);
+        const activeFlow = getOnlyActiveFlow();
+        if (activeFlow) {
+          sendEvent({ type: "status", phase: "thinking" });
+          try {
+            const bus = getOrCreateStimulusBus();
+            const userStimulus = {
+              kind: "user_message",
+              text: cmd.prompt,
+              senderId: "user"
+            };
+            await bus.signal(activeFlow.connectorId, {
+              promptFragment: renderStimulusPrompt(userStimulus),
+              meta: {
+                kind: "user_message",
+                runId: activeFlow.runId,
+                text: cmd.prompt,
+                senderId: "user"
+              }
+            });
+          } catch (err) {
+            const errMsg = err instanceof Error ? err.message : String(err);
+            log(`[serve] flow user-message turn failed: ${errMsg}`);
+            sendEvent({ type: "error", message: `Flow turn failed: ${errMsg}`, fatal: false });
+          }
+          break;
+        }
+        if (!driverStarted) {
+          try {
+            await driver.start();
+            driverStarted = true;
+          } catch (err) {
+            const errMsg = err instanceof Error ? err.message : String(err);
+            log(`[serve] driver start failed: ${errMsg}`);
+            sendEvent({ type: "error", message: `Driver start failed: ${errMsg}`, fatal: true });
+            break;
+          }
+          driver.on("agent-event", (event) => {
+            const normalized = normalizer.normalize(event);
+            for (const e of normalized) {
+              forwardNormalizedEvent(e);
+            }
+          });
+          driver.on("error", (err) => {
+            log(`[serve] driver error: ${err.message}`);
+            sendEvent({ type: "error", message: err.message, fatal: true });
+          });
+        }
+        sendEvent({ type: "status", phase: "thinking" });
+        try {
+          await driver.prompt(cmd.prompt);
+        } catch (err) {
+          const errMsg = err instanceof Error ? err.message : String(err);
+          log(`[serve] prompt failed: ${errMsg}`);
+          sendEvent({ type: "error", message: `Prompt failed: ${errMsg}`, fatal: true });
+        }
+        break;
+      }
+      case "reply": {
+        try {
+          await sessionReady;
+        } catch (err) {
+          sendEvent({
+            type: "error",
+            message: `Session not available: ${err.message}`,
+            fatal: true
+          });
+          break;
+        }
+        log(`[serve] reply: ${cmd.answer.slice(0, 80)}...`);
+        try {
+          await driver.prompt(cmd.answer);
+        } catch (err) {
+          sendEvent({
+            type: "error",
+            message: `Reply failed: ${err instanceof Error ? err.message : String(err)}`,
+            fatal: false
+          });
+        }
+        break;
+      }
+      case "cancel": {
+        try {
+          await sessionReady;
+        } catch (err) {
+          sendEvent({
+            type: "error",
+            message: `Session not available: ${err.message}`,
+            fatal: true
+          });
+          break;
+        }
+        log("[serve] cancel");
+        try {
+          await driver.abort();
+        } catch (err) {
+          log(`[serve] cancel failed: ${err}`);
+        }
+        break;
+      }
+      // v3: compact + lifecycle removed — reachable via runner.lifecycle capability
+      // (the v3 `runner.lifecycle` cap takes `{ phase: 'hibernate' | 'close' | 'compact' }`).
+      case "resource_request": {
+        try {
+          await sessionReady;
+        } catch (err) {
+          sendEvent({
+            type: "error",
+            message: `Session not available: ${err.message}`,
+            fatal: true
+          });
+          break;
+        }
+        if (mountManager?.has(cmd.connectorId)) {
+          handleMountResourceRequest(cmd, mountManager, sendEvent);
+          break;
+        }
+        if (!resourceManager) {
+          sendEvent({
+            type: "resource_response",
+            requestId: cmd.requestId,
+            resourceId: cmd.connectorId,
+            operation: cmd.operation,
+            error: "No resources available \u2014 no mounts or connectors configured"
+          });
+          break;
+        }
+        void handleResourceRequest(cmd, resourceManager, sendEvent);
+        break;
+      }
+      // v3: state_action removed — reachable via the runner.set_state capability.
+      // ── Generic connector dispatch (Protocol 2.2) ──────────────────────
+      // The 6 typed flow commands (`start_flow`, `approve_flow_node`,
+      // `provide_flow_input`, `cancel_flow`, `set_flow_autonomous_mode`,
+      // `retry_flow_node`) were removed in Phase 4 of the flow-connector
+      // extraction. Hosts now drive flow execution exclusively through
+      // `connector_mutate` against the `flow` connector. See
+      // `MIGRATION-flow-connector.md` for the per-op mapping table.
+      case "connector_mutate": {
+        try {
+          if (!resourceManager) throw new Error("connector_mutate before resources ready");
+          const targetEntry = resourceManager.has?.(cmd.id) ? resourceManager.get(cmd.id) : null;
+          const isExistingFlow = targetEntry?.adapter?.name === "flow";
+          const isBareFlowId = cmd.id === "flow";
+          if (cmd.op === "start") {
+            if (isExistingFlow || isBareFlowId) {
+              const payload = cmd.payload ?? {};
+              const flowDef = payload.flow;
+              const seed = payload.seed;
+              if (flowDef?.id && seed?.runId && seed?.startedBy) {
+                if (activeFlows.size > 0) {
+                  serverLog.warn("connector_mutate flow.start: another flow already active", {
+                    activeRunIds: Array.from(activeFlows.keys())
+                  });
+                  break;
+                }
+                const entry = await createActiveFlow(flowDef, { seed });
+                serverLog.info("connector_mutate flow.start", {
+                  runId: entry.runId,
+                  flowId: flowDef.id
+                });
+                break;
+              }
+            }
+          }
+          let dispatchId = cmd.id;
+          if (!targetEntry && isBareFlowId) {
+            const onlyActive = getOnlyActiveFlow();
+            if (onlyActive) {
+              dispatchId = onlyActive.connectorId;
+            }
+          }
+          await resourceManager.executeOp(dispatchId, cmd.op, cmd.payload ?? {});
+        } catch (err) {
+          serverLog.warn("connector_mutate failed", {
+            id: cmd.id,
+            op: cmd.op,
+            error: err instanceof Error ? err.message : String(err)
+          });
+        }
+        break;
+      }
+      case "connector_query": {
+        let ok = true;
+        let result;
+        let error;
+        try {
+          if (!resourceManager) throw new Error("connector_query before resources ready");
+          let dispatchId = cmd.id;
+          if (!resourceManager.has?.(cmd.id) && cmd.id === "flow") {
+            const onlyActive = getOnlyActiveFlow();
+            if (onlyActive) {
+              dispatchId = onlyActive.connectorId;
+            }
+          }
+          result = await resourceManager.executeOp(dispatchId, cmd.op, cmd.payload ?? {});
+        } catch (err) {
+          ok = false;
+          error = err instanceof Error ? err.message : String(err);
+        }
+        sendEvent({
+          type: "connector_query_response",
+          requestId: cmd.requestId,
+          ok,
+          ...result !== void 0 ? { result } : {},
+          ...error !== void 0 ? { error } : {}
+        });
+        break;
+      }
+      case "debug": {
+        try {
+          await sessionReady;
+        } catch (err) {
+          sendEvent({
+            type: "error",
+            message: `Session not available: ${err.message}`,
+            fatal: true
+          });
+          break;
+        }
+        log(`[serve] debug query=${cmd.query}`);
+        let result;
+        try {
+          switch (cmd.query) {
+            case "tools": {
+              const mcpServers = Object.keys(driver?.config?.mcpServers ?? {});
+              const allowedTools = driver?.config?.allowedTools ?? null;
+              result = { mcpServers, allowedTools, driverStarted };
+              break;
+            }
+            case "connectors": {
+              result = resourceManager?.listConnectors?.() ?? [];
+              break;
+            }
+            case "mcp": {
+              const servers = Object.entries(driver?.config?.mcpServers ?? {}).map(
+                ([name]) => ({ name })
+              );
+              result = { servers };
+              break;
+            }
+            case "config": {
+              const liveModel = driver?.getModel() ?? agentSession?.model;
+              result = {
+                driver: agentSession?.driverType,
+                model: liveModel,
+                provider: agentSession?.provider,
+                maxTurns,
+                secretsMode,
+                driverStarted,
+                projectDir: opts.projectDir,
+                versions: getFrameworkVersions()
+              };
+              break;
+            }
+            case "state": {
+              const storeId = cmd.args?.store;
+              if (storeId) {
+                try {
+                  const snapshot = await resourceManager?.executeOp(storeId, "get", {});
+                  result = snapshot ? JSON.parse(snapshot) : null;
+                } catch (err) {
+                  result = { error: err instanceof Error ? err.message : String(err) };
+                }
+              } else {
+                const all = resourceManager?.listConnectors?.() ?? [];
+                result = { stores: all.map((c) => c.id) };
+              }
+              break;
+            }
+            case "commands": {
+              const commands = driver?.getSlashCommands?.() ?? [];
+              result = { commands, driverType: agentSession?.driverType };
+              break;
+            }
+            default:
+              result = { error: `Unknown debug query: ${cmd.query}` };
+          }
+        } catch (err) {
+          result = { error: err instanceof Error ? err.message : String(err) };
+        }
+        sendEvent({ type: "debug_result", query: cmd.query, data: result });
+        break;
+      }
+      // -----------------------------------------------------------------------
+      // -----------------------------------------------------------------------
+      // v3: add_resource, remove_resource, remount_mount, set_log_level,
+      // reconfigure_agent removed from AgentCommand union.
+      // Reachable now via the `runner.set_log_level` and `runner.reconfigure`
+      // capability invocations (audience: ['runtime']) — the platform calls
+      // them through invokeRunnerCapability on the gateway. Handler bodies
+      // live in the runner.* capability registrations.
+      case "shutdown": {
+        log("[serve] shutdown requested");
+        await cleanup();
+        if (transport instanceof WebSocketServerTransport) {
+          await transport.close();
+        }
+        disposeLogStore();
+        process.exit(0);
+      }
+      // Protocol v2 — capability round-trip results from the platform.
+      case "capability_result": {
+        const matched = resolveCapabilityResult(pendingCapabilityCalls, cmd);
+        if (!matched) {
+          log(
+            `[serve] capability_result for unknown callId=${cmd.callId} (timed out or already resolved); dropping`
+          );
+        }
+        break;
+      }
+      // Protocol v2 — additional capability lifecycle commands. The platform
+      // can register / deregister capabilities mid-session (e.g. when a user
+      // installs an extension after `configure`). Approval routing is reserved
+      // for a later phase; we accept the command shape for forward
+      // compatibility and log it.
+      case "capability_register": {
+        for (const raw of cmd.capabilities) {
+          const wire = raw;
+          capabilityRegistry.register(
+            {
+              ...wire,
+              inputZod: { parse: (v) => v },
+              outputZod: void 0,
+              handler: buildClientCapabilityHandler2(wire)
+            },
+            "client"
+          );
+        }
+        break;
+      }
+      case "capability_deregister": {
+        for (const name of cmd.names) {
+          capabilityRegistry.deregister(name);
+        }
+        break;
+      }
+      case "capability_approve": {
+        if (cmd.decision === "rejected") {
+          const matched = rejectCapabilityOnApprovalDeny(
+            pendingCapabilityCalls,
+            cmd.callId,
+            cmd.feedback
+          );
+          if (!matched) {
+            log(
+              `[serve] capability_approve(rejected) for unknown callId=${cmd.callId} (already resolved or timed out); dropping`
+            );
+          } else {
+            log(
+              `[serve] capability_approve(rejected) callId=${cmd.callId} decidedBy=${cmd.decidedBy}${cmd.feedback ? ` feedback=${JSON.stringify(cmd.feedback)}` : ""}`
+            );
+          }
+        } else {
+          log(
+            `[serve] capability_approve(approved) callId=${cmd.callId} decidedBy=${cmd.decidedBy} (awaiting capability_result)`
+          );
+        }
+        break;
+      }
+    }
+  }
+  transport.onCommand((cmd) => {
+    void handleCommand(cmd);
+  });
+  if (transport instanceof WebSocketServerTransport) {
+    await transport.listen();
+  }
+  if (secretsMode === "env" && agentSession) {
+    agentSession.startWatching();
+  }
+  if (transport instanceof WebSocketServerTransport) {
+    transport.onConnect(() => {
+      if (resourceManager || mountManager) {
+        const mountList = mountManager?.listMounts?.() ?? [];
+        const connectorList = resourceManager?.listConnectors?.() ?? [];
+        log(
+          `[serve] emitting resources_available: ${mountList.length} mounts(s), ${connectorList.length} connector(s)`
+        );
+        sendEvent({
+          type: "resources_available",
+          mounts: mountList,
+          connectors: connectorList
+        });
+      }
+      const commands = driver?.getSlashCommands?.() ?? [];
+      if (commands.length > 0) {
+        log(`[serve] emitting commands_available: ${commands.length} command(s)`);
+        sendEvent({ type: "commands_available", commands });
+      }
+    });
+  }
+  if (secretsMode === "env") {
+    log(
+      `[serve] driver=${agentSession.driverType} model=${agentSession.model ?? "(default)"} provider=${agentSession.provider ?? "(default)"} maxTurns=${maxTurns ?? "(default)"}`
+    );
+  } else {
+    log(`[serve] secrets=provisioned \u2014 session will initialize after provision_secrets`);
+  }
+  log(`[serve] project=${opts.projectDir}`);
+  process.on("uncaughtException", (err) => {
+    log(
+      `[serve] uncaughtException (non-fatal): ${err instanceof Error ? err.stack ?? err.message : String(err)}`
+    );
+  });
+  process.on("unhandledRejection", (reason) => {
+    log(
+      `[serve] unhandledRejection (non-fatal): ${reason instanceof Error ? reason.stack ?? reason.message : String(reason)}`
+    );
+  });
+  const GRACEFUL_SHUTDOWN_TIMEOUT_MS = 5e3;
+  let shuttingDown = false;
+  async function initiateShutdown(signal) {
+    if (shuttingDown) {
+      log(`[serve] ${signal} received again \u2014 forcing exit`);
+      process.exit(130);
+    }
+    shuttingDown = true;
+    log(`[serve] ${signal} received \u2014 shutting down (press Ctrl-C again to force)`);
+    const forceExitTimer = setTimeout(() => {
+      log(`[serve] graceful shutdown exceeded ${GRACEFUL_SHUTDOWN_TIMEOUT_MS}ms \u2014 forcing exit`);
+      process.exit(130);
+    }, GRACEFUL_SHUTDOWN_TIMEOUT_MS);
+    forceExitTimer.unref?.();
+    try {
+      await cleanup();
+    } catch (err) {
+      log(`[serve] cleanup error: ${err.message}`);
+    }
+    try {
+      if (transport instanceof WebSocketServerTransport) {
+        await transport.close();
+      }
+    } catch (err) {
+      log(`[serve] transport close error: ${err.message}`);
+    }
+    clearTimeout(forceExitTimer);
+    log("[serve] shutdown complete");
+    disposeLogStore();
+    process.exit(0);
+  }
+  process.on("SIGTERM", () => {
+    void initiateShutdown("SIGTERM");
+  });
+  process.on("SIGINT", () => {
+    void initiateShutdown("SIGINT");
+  });
+}
+var SESSION_DIR = ".skaile";
+var SESSIONS_SUBDIR = "sessions";
+var CURRENT_FILE = "current";
+var LEGACY_FILE = "session.json";
+function sessionsDir(projectDir) {
+  return path4.join(projectDir, SESSION_DIR, SESSIONS_SUBDIR);
+}
+function sessionFilePath(projectDir, runId) {
+  return path4.join(sessionsDir(projectDir), `${runId}.json`);
+}
+function currentPointerPath(projectDir) {
+  return path4.join(projectDir, SESSION_DIR, CURRENT_FILE);
+}
+function legacySessionPath(projectDir) {
+  return path4.join(projectDir, SESSION_DIR, LEGACY_FILE);
+}
+async function migrateLegacySession(projectDir) {
+  const legacyPath = legacySessionPath(projectDir);
+  try {
+    const raw = await fs4.readFile(legacyPath, "utf-8");
+    const state = JSON.parse(raw);
+    await fs4.mkdir(sessionsDir(projectDir), { recursive: true });
+    await fs4.writeFile(
+      sessionFilePath(projectDir, state.runId),
+      JSON.stringify(state, null, 2),
+      "utf-8"
+    );
+    await fs4.writeFile(currentPointerPath(projectDir), state.runId, "utf-8");
+    await fs4.rm(legacyPath);
+  } catch {
+  }
+}
+async function loadSession(projectDir) {
+  await migrateLegacySession(projectDir);
+  try {
+    const runId = (await fs4.readFile(currentPointerPath(projectDir), "utf-8")).trim();
+    if (!runId) return null;
+    return await loadSessionById(projectDir, runId);
+  } catch {
+    return null;
+  }
+}
+async function loadSessionById(projectDir, runId) {
+  try {
+    const raw = await fs4.readFile(sessionFilePath(projectDir, runId), "utf-8");
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+async function listSessions(projectDir) {
+  await migrateLegacySession(projectDir);
+  const dir = sessionsDir(projectDir);
+  try {
+    const files = await fs4.readdir(dir);
+    const sessions = [];
+    for (const file of files) {
+      if (!file.endsWith(".json")) continue;
+      try {
+        const raw = await fs4.readFile(path4.join(dir, file), "utf-8");
+        sessions.push(JSON.parse(raw));
+      } catch {
+      }
+    }
+    return sessions.sort((a, b) => b.updatedAt.localeCompare(a.updatedAt));
+  } catch {
+    return [];
+  }
+}
+async function saveSession(projectDir, state, setCurrent = true) {
+  await fs4.mkdir(sessionsDir(projectDir), { recursive: true });
+  await fs4.writeFile(
+    sessionFilePath(projectDir, state.runId),
+    JSON.stringify(state, null, 2),
+    "utf-8"
+  );
+  if (setCurrent) {
+    await fs4.writeFile(currentPointerPath(projectDir), state.runId, "utf-8");
+  }
+}
+async function setCurrentSession(projectDir, runId) {
+  const exists = await loadSessionById(projectDir, runId);
+  if (!exists) throw new Error(`Session not found: ${runId}`);
+  await fs4.mkdir(path4.join(projectDir, SESSION_DIR), { recursive: true });
+  await fs4.writeFile(currentPointerPath(projectDir), runId, "utf-8");
+}
+async function deleteSession(projectDir, runId) {
+  try {
+    await fs4.rm(sessionFilePath(projectDir, runId));
+  } catch {
+  }
+  try {
+    const current = (await fs4.readFile(currentPointerPath(projectDir), "utf-8")).trim();
+    if (current === runId) {
+      await fs4.rm(currentPointerPath(projectDir));
+    }
+  } catch {
+  }
+}
+async function clearSession(projectDir) {
+  try {
+    await fs4.rm(currentPointerPath(projectDir));
+  } catch {
+  }
+}
+function newSession(opts) {
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  return { ...opts, runId: randomUUID(), startedAt: now, updatedAt: now, status: "running" };
+}
+function touchSession(state) {
+  return { ...state, updatedAt: (/* @__PURE__ */ new Date()).toISOString() };
+}
+
+export { CLAUDE_CODE_CREDENTIALS_KEY, COMPILE_MANIFEST_FILENAME, CapabilityRegistry, DEFAULT_CAPABILITY_CALL_TIMEOUT_MS, DEFAULT_COALESCE_MS, MarkdownStreamer, PreInitRingSink, agentDefinitionExists, assembleSystemPrompt, bootstrapCapabilityRegistry, bootstrapRunnerLogStore, buildAgentResources, buildCapabilitiesPromptSection, buildClientCapabilityHandler, buildContextSection, buildEnvironmentSection, builtinCapabilities, clearPreInitRingSink, clearSession, compileComposition, computeCapabilitySignature, createAgentSession, createSessionStimulusBus, defineCapability, deleteSession, emitSystemPromptComposed, ensureGitConfigInclude, getPreInitRingSink, handleMountResourceRequest, handleResourceRequest, installPreInitRingSink, listSessions, loadAgentManifest, loadCompileManifest, loadCompileManifestFromDir, loadSession, loadSessionById, newSession, registerCompositionCapabilities, rejectCapabilityOnApprovalDeny, resetRunnerLogStore, resolveAgentComposition, resolveAgentMixins, resolveBinding, resolveCapabilityResult, resolveComposition, resolveMixin, runAgentChat, saveSession, setCurrentSession, startAgentServer, touchSession, writeClaudeCodeCredentialsFile };
+//# sourceMappingURL=chunk-NYJKXVG6.js.map
+//# sourceMappingURL=chunk-NYJKXVG6.js.map