@skaile/workspaces 6.15.0 → 6.16.1

package/dist/{chunk-YLKOCMU7.js → chunk-U6UFPOEK.js}

@@ -1,38 +1,37 @@
-import { WorkspacePlugin } from './chunk-A3G3FHGB.js';
-import { buildWorkspaceToolDefs } from './chunk-72PPC4SC.js';
-import { findAiAssetsRoot } from './chunk-V2VDTQ7A.js';
-import { startModelEndpoint, ModelEndpointError } from './chunk-FJJEC6O2.js';
-import { WebSocketServerTransport } from './chunk-7K73MCI6.js';
+import { WorkspacePlugin } from './chunk-NNJQQYHY.js';
+import { buildWorkspaceToolDefs } from './chunk-Z23I2JA6.js';
+import { findAiAssetsRoot } from './chunk-3A7JUOY2.js';
+import { startModelEndpoint, ModelEndpointError } from './chunk-3UYKT62L.js';
+import { WebSocketServerTransport } from './chunk-CU5WY6HN.js';
 import { assembleSystemPrompt, buildCapabilitiesPromptSection } from './chunk-W3UDISS2.js';
-import { resolveFlowPath } from './chunk-YDMZWVZN.js';
-import { findAiAssetsRoot as findAiAssetsRoot$1, deployCatalogEntry, undeployCatalogEntry } from './chunk-LQWOU7S2.js';
-import { ConnectFailureCarryOver, registerBuiltinConnectors, listConnectors, buildConnectorPromptSection, findMissingPackages, installNpmPackages, ConnectorManager, buildSdkConnectorTools, fleetMountConnectingMessage, buildLazySdkFlowTools, describeFlowOperations, buildConnectorToolDefs, TRUSTED_GIT_CA_ENV, writeUserGitconfigInclude, buildFlowToolDefs, SessionNodeExecutor, SessionSubpromptRunner, ClassifierSubpromptRunner, SessionInlineSubFlowRunner, driveOrchestratorTurn, buildSdkFlowTools } from './chunk-6VQW2X2F.js';
-import { loadYamlConnectorDeclarations, withMaterializedConnectorDeclarations, SecretProviderChain, ConnectorStartupError, isKnownSecretRef, EnvSecretProvider, PreMintedSecretProvider, InMemorySecretProvider, resolvedConfigToDeclarations, deriveSingleMaterializedConnectorDeclaration } from './chunk-SBAUZ7XH.js';
-import { EventNormalizer } from './chunk-IYXOSBQ4.js';
-import { sessionSurfaceNotice, approvalCardOf, APPROVE_ONCE, DENY, probeResumeTranscript, transcriptStoreForRuntime } from './chunk-TYRAEMWE.js';
-import { codexLoginFallbackNotice, prepareNativePolicy, codexInstanceEnvironment, parseCodexCredential, parseCodexRefreshInput, parseCodexRefreshResult } from './chunk-SXRN27TU.js';
+import { resolveFlowPath } from './chunk-K4763755.js';
+import { findAiAssetsRoot as findAiAssetsRoot$1, deployCatalogEntry, undeployCatalogEntry } from './chunk-SFBLZOV5.js';
+import { ConnectFailureCarryOver, registerBuiltinConnectors, listConnectors, buildConnectorPromptSection, findMissingPackages, installNpmPackages, ConnectorManager, buildSdkConnectorTools, fleetMountConnectingMessage, buildLazySdkFlowTools, describeFlowOperations, buildConnectorToolDefs, TRUSTED_GIT_CA_ENV, writeUserGitconfigInclude, buildFlowToolDefs, SessionNodeExecutor, SessionSubpromptRunner, ClassifierSubpromptRunner, SessionInlineSubFlowRunner, driveOrchestratorTurn, buildSdkFlowTools } from './chunk-QUIK7L3Z.js';
+import { loadYamlConnectorDeclarations, withMaterializedConnectorDeclarations, SecretProviderChain, ConnectorStartupError, isKnownSecretRef, EnvSecretProvider, PreMintedSecretProvider, InMemorySecretProvider, resolvedConfigToDeclarations, deriveSingleMaterializedConnectorDeclaration } from './chunk-H3PY5DFL.js';
+import { EventNormalizer } from './chunk-PRB67LCK.js';
+import { sessionSurfaceNotice, approvalCardOf, APPROVE_ONCE, DENY, probeResumeTranscript, transcriptStoreForRuntime } from './chunk-OD4N5O7V.js';
+import { codexLoginFallbackNotice, prepareNativePolicy, codexInstanceEnvironment, parseCodexCredential, parseCodexRefreshInput, parseCodexRefreshResult } from './chunk-72DYHOO2.js';
 import { CodexNativeStateUnavailable } from './chunk-5KSGZP3E.js';
 import { dispatchCapability } from './chunk-HXST2IYJ.js';
 import { classifyClaudeSdkError } from './chunk-5DE3DGVR.js';
 import { agentExecRequested } from './chunk-7DN6JKP2.js';
-import { toAgentEffort, toMergedRegistry } from './chunk-CWUHUL6W.js';
-import { unresolvedProviderCredentials, harnessCapabilities, createHarness, providerCredentialEnvName, registryCredentialEnv, supportsLiveToolUpdates } from './chunk-U7EJB6LY.js';
+import { toAgentEffort, toMergedRegistry } from './chunk-NAQXDTF3.js';
+import { unresolvedProviderCredentials, harnessCapabilities, createHarness, providerCredentialEnvName, registryCredentialEnv, supportsLiveToolUpdates } from './chunk-S3UOZBGE.js';
 import { catalogLayer, AI_PROVIDER_PRESETS } from './chunk-6UP2EDFN.js';
-import { loadFlow } from './chunk-WDG5IVEA.js';
+import { loadFlow } from './chunk-2ZDZJ7XQ.js';
 import { renderStimulusPrompt } from './chunk-WD3L5QSU.js';
 import { TURN_VISIBILITY_EVENT_TYPES, withActivityLabelJsonSchema, TOOL_ACTIVITY_PROMPT_SECTION, TERMINAL_AGENT_RUN_STATUSES, SESSION_ROOT_CONNECTOR_ID, PLATFORM_BLOCKS_RUNTIME_FEATURE, TURN_VISIBILITY_RUNTIME_FEATURE, TURN_IDS_RUNTIME_FEATURE, PROTOCOL_VERSION, TURN_IDS_MAX_COUNT, TURN_ID_MAX_LENGTH, deliveryClassOf } from './chunk-JPV4WE5L.js';
-import { knowledgeKindProvider, scanLibraryRoot, LocalIndex } from './chunk-7FXOOUOC.js';
-import { createDefaultKindRegistry } from './chunk-DRUAQ7IY.js';
 import { parseFlowDefinition } from './chunk-JRN5QF4C.js';
-import { BindingSchema, effectiveComposes, AgentManifestSchema, AgentTriggerSchema, ANTHROPIC_MODEL_ALIASES } from './chunk-LCXQ4LVP.js';
-import { readLock, buildAgentPromptSections, resolveSettings, loadProviderRegistry, resolveLibraryDir } from './chunk-MEU2HHGV.js';
-import { resolveRuntimeAssets } from './chunk-CJO3XKO7.js';
+import { CompileManifestEntrySchema, resolveBinding, CompositionError, isEmptyKnowledgeIndex, hashContent, loadCompileManifestFromDir, createCompositionContentSource, assembleRunnerAgent, readNativeAgentFile, nativeAgentFilePath, COMPILE_MANIFEST_FILENAME } from './chunk-4ZNKEDYH.js';
+import { resolveSettings, loadProviderRegistry, modelForHarness, AGENT_PROMPT_CARRIER_LABELS, AGENT_PROMPT_CARRIERS, resolveLibraryDir } from './chunk-U7P22GEB.js';
+import { resolveRuntimeAssets } from './chunk-ETGC2MEM.js';
 import { DEFAULT_HARNESS_ID, resolveHarnessPaths } from './chunk-C5HFK34M.js';
-import { matchPin, DEFAULT_AGENT_INSTANCE_ID, effectiveAgentInstances, resolveAgentDefinitionDir, AgentRefResolutionError, resolveSkWorkspaceConfig, resolveAgentDir, agentSourceCacheDir, loadMcpServerDeclarations, COMPACTION_DEFAULTS, resolveCompactionThresholdPercent, getGlobalCacheDir, sourceCacheKey, validateAssetRecipeAttr, deriveSingleMaterializedMcpDeclaration, stageMaterializedSkills, readSkillAllowList, isStagedSkillMarkerFor, unstageSkill, STAGED_SKILL_MARKER } from './chunk-BNLXZXZN.js';
+import { DEFAULT_AGENT_INSTANCE_ID, effectiveAgentInstances, resolveAgentDefinitionDir, AgentRefResolutionError, resolveSkWorkspaceConfig, resolveAgentDir, agentSourceCacheDir, loadMcpServerDeclarations, COMPACTION_DEFAULTS, resolveCompactionThresholdPercent, validateAssetRecipeAttr, deriveSingleMaterializedMcpDeclaration, stageMaterializedSkills, readSkillAllowList, isStagedSkillMarkerFor, unstageSkill, STAGED_SKILL_MARKER } from './chunk-BRAOB37W.js';
 import { globalSkaileDir, globalCacheRoot } from './chunk-L5VSIPQD.js';
 import { harnessNameForHarnessId, SUPPORTED_HARNESSES, HARNESS_TARGETS } from './chunk-VTETQCR6.js';
-import { withFsDeadline, FsDeadlineError, fsDeadlineMs, parseFrontmatter, tryWithFsDeadline } from './chunk-VS6XC5JE.js';
-import { parseAssetRef } from './chunk-7HRZACI4.js';
+import { withFsDeadline, FsDeadlineError, fsDeadlineMs, parseFrontmatter, tryWithFsDeadline } from './chunk-2MTRRK37.js';
+import { parseAssetRef } from './chunk-HW4BDJPC.js';
+import { effectiveComposes, AgentManifestSchema, AgentTriggerSchema } from './chunk-LCXQ4LVP.js';
 import { portableSpawnSync } from './chunk-VSX2G7LA.js';
 import { pickRegistryEntries, registryEntries, resolveEntryBaseUrl, parseModelRef, isEntryEnabled, parseCredentialRef } from './chunk-RXGPFAMN.js';
 import { resolveLogStoreConfig, createLogStoreFromConfig, OnLogBridgeSink, WsLogSink, resolveLogsRetention, enforceLogsRetention, ensureRunStateIgnored, scrubLogText } from './chunk-RZL4TOK3.js';
@@ -40,14 +39,14 @@ import { getLogStore, registerLogStore, createLogger, resetLogStore, isUnwritabl
 import { __require } from './chunk-NSBPE2FW.js';
 import { createInterface } from 'readline';
 import pc from 'picocolors';
-import path3, { resolve, basename, join, dirname, relative, sep, isAbsolute } from 'path';
+import path4, { resolve, basename, join, dirname, relative, sep, isAbsolute } from 'path';
 import { Marked } from 'marked';
 import { markedTerminal } from 'marked-terminal';
 import { createHash, randomUUID, randomBytes, timingSafeEqual } from 'crypto';
-import * as z5 from 'zod';
+import * as z4 from 'zod';
 import { z } from 'zod';
-import { constants, unlinkSync, readFileSync, readdirSync, statSync, existsSync, lstatSync, realpathSync, mkdirSync, writeFileSync, renameSync, rmSync, watch, chmodSync, accessSync } from 'fs';
-import fs8, { readFile, readdir, lstat, realpath, rm, unlink, stat, mkdir, writeFile, readlink, rename, open, mkdtemp } from 'fs/promises';
+import { constants, unlinkSync, readFileSync, existsSync, lstatSync, realpathSync, mkdirSync, statSync, writeFileSync, renameSync, rmSync, watch, chmodSync, accessSync } from 'fs';
+import fs5, { readFile, readdir, lstat, realpath, rm, unlink, stat, mkdir, writeFile, readlink, rename, open, mkdtemp } from 'fs/promises';
 import { parse } from 'yaml';
 import { Ajv2020 } from 'ajv/dist/2020.js';
 import { execFile } from 'child_process';
@@ -168,7 +167,7 @@ var currentSessionId = null;
 function bootstrapRunnerLogStore(opts) {
   const existing = getLogStore();
   if (existing && currentSessionId === opts.sessionId) {
-    const reusedPath = opts.projectDir ? path3.join(opts.projectDir, ".skaile", "logs.db") : void 0;
+    const reusedPath = opts.projectDir ? path4.join(opts.projectDir, ".skaile", "logs.db") : void 0;
     return {
       store: existing,
       dispose: () => disposeStore(existing),
@@ -180,7 +179,7 @@ function bootstrapRunnerLogStore(opts) {
     workspacePath: opts.projectDir,
     yamlBlock: opts.yamlBlock
   });
-  const logsDbPath = cfg.mode === "persistent" && cfg.workspacePath ? path3.join(cfg.workspacePath, ".skaile", "logs.db") : void 0;
+  const logsDbPath = cfg.mode === "persistent" && cfg.workspacePath ? path4.join(cfg.workspacePath, ".skaile", "logs.db") : void 0;
   const store = createLogStoreFromConfig(cfg, { stdout: opts.stdout });
   if (opts.onLog) {
     store.addSink(new OnLogBridgeSink(opts.onLog));
@@ -205,7 +204,7 @@ function bootstrapRunnerLogStore(opts) {
   };
 }
 function scheduleRetention(cfg) {
-  const dbPath = path3.join(cfg.workspacePath, ".skaile", "logs.db");
+  const dbPath = path4.join(cfg.workspacePath, ".skaile", "logs.db");
   const policy = resolveLogsRetention(cfg.retention);
   const log = createLogger({ kind: "runner", subkind: "logging", instance: cfg.sessionId });
   return new Promise((resolve5) => setImmediate(resolve5)).then(() => enforceLogsRetention(dbPath, policy)).then(
@@ -297,11 +296,11 @@ var MarkdownStreamer = class {
   }
 };
 function defineCapability(args) {
-  const inputSchema = z5.toJSONSchema(args.input, {
+  const inputSchema = z4.toJSONSchema(args.input, {
     target: "draft-07",
     io: "input"
   });
-  const outputSchema = args.output ? z5.toJSONSchema(args.output, {
+  const outputSchema = args.output ? z4.toJSONSchema(args.output, {
     target: "draft-07",
     io: "output"
   }) : void 0;
@@ -340,7 +339,7 @@ function registerCompositionCapabilities(registry, entries) {
       scope: "session",
       kind: "query",
       userInvokable: false,
-      input: z5.strictObject({}),
+      input: z4.strictObject({}),
       handler: async (_args, ctx) => {
         ctx.log.info("loading composed asset content", {
           ref: entry.ref,
@@ -382,777 +381,14 @@ async function openLocalIndexIfAvailable(log) {
     return STUB_LIBRARY;
   }
   try {
-    const { LocalIndex: LocalIndex2 } = await import('./library/index.js');
-    return new LocalIndex2();
+    const { LocalIndex } = await import('./library/index.js');
+    return new LocalIndex();
   } catch (err) {
     log?.debug(`Could not open LocalIndex at ${indexPath}: ${err.message}`);
     return STUB_LIBRARY;
   }
 }
 
-// runner/src/composition/errors.ts
-var CompositionError = class extends Error {
-  constructor(code, reason, message, ref, moved) {
-    super(message);
-    this.code = code;
-    this.reason = reason;
-    this.ref = ref;
-    this.moved = moved;
-    this.name = "CompositionError";
-  }
-  code;
-  reason;
-  ref;
-  moved;
-};
-function isCompositionError(err, code) {
-  return err instanceof CompositionError && (code === void 0 || err.code === code);
-}
-async function resolveMixin(ref, defaultKind, agentDir, repos) {
-  if (ref.startsWith(".") || ref.startsWith("/")) {
-    const absPath = ref.startsWith("/") ? ref : path3.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(path3.dirname(entry.source));
-  }
-  const raw = await readFileSafe(entry.source);
-  if (!raw) return null;
-  return { content: stripFrontmatter(raw).trim(), source: entry.source };
-}
-async function readFileSafe(filePath) {
-  try {
-    return await fs8.readFile(filePath, "utf-8");
-  } catch {
-    return "";
-  }
-}
-function stripFrontmatter(text2) {
-  return text2.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;
-}
-function isEmptyKnowledgeIndex(text2) {
-  if (!text2) return false;
-  let parsed;
-  try {
-    parsed = parse(text2);
-  } catch {
-    return false;
-  }
-  if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) return false;
-  const documents = parsed.documents;
-  return Array.isArray(documents) && documents.length === 0;
-}
-async function loadKnowledgeDir(dir) {
-  let entries;
-  try {
-    entries = (await fs8.readdir(dir)).filter((e) => e.endsWith(".md"));
-  } catch {
-    return null;
-  }
-  const priorityMap = {};
-  const indexContent = await readFileSafe(path3.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(path3.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 isEmptyKnowledgeIndex(indexContent) ? { content: indexContent, source: dir } : null;
-  }
-  return {
-    content: sorted.map((d) => d.content).join("\n\n---\n\n"),
-    source: dir
-  };
-}
-
-// runner/src/composition/content-source.ts
-function parseCatalogRef(ref) {
-  let rest = ref.trim();
-  const kindPrefix = /^([a-z][a-z0-9-]*):(?!\/\/)/.exec(rest);
-  if (kindPrefix) rest = rest.slice(kindPrefix[0].length);
-  let pin;
-  const hash = rest.indexOf("#");
-  if (hash !== -1) {
-    pin = rest.slice(hash + 1).trim() || void 0;
-    rest = rest.slice(0, hash);
-  }
-  const scoped = /^@([^/@]+)\/([^@]+)(?:@(.+))?$/.exec(rest);
-  if (scoped) {
-    return { publisher: scoped[1], name: scoped[2], pin: pin ?? scoped[3]?.trim() };
-  }
-  const at = rest.indexOf("@");
-  if (at !== -1) {
-    return { publisher: rest.slice(at + 1) || void 0, name: rest.slice(0, at), pin };
-  }
-  return { name: rest, pin };
-}
-var LOCK_KEY_RE = /^([a-z][a-z0-9-]*):@([^/]+)\/([^#]+)#(.+)$/;
-var barePublisher = (p) => p.startsWith("@") ? p.slice(1) : p;
-var sha256Of = (text2) => createHash("sha256").update(text2).digest("hex");
-var CatalogScanner = class {
-  constructor(projectDir, registry, explicitRoots) {
-    this.projectDir = projectDir;
-    this.registry = registry;
-    this.roots = explicitRoots;
-  }
-  projectDir;
-  registry;
-  scans = /* @__PURE__ */ new Map();
-  roots;
-  /** Every discovered asset of `kind` named `name` under one root (any root, declared or not). */
-  findIn(root, kind, name) {
-    return this.scan(root).filter((hit) => hit.asset.kind === kind && hit.asset.name === name);
-  }
-  /** Every discovered asset of `kind` named `name`, across all roots. */
-  find(kind, name) {
-    const out = [];
-    for (const root of this.resolveRoots()) {
-      for (const hit of this.scan(root)) {
-        if (hit.asset.kind === kind && hit.asset.name === name) out.push(hit);
-      }
-    }
-    return out;
-  }
-  scan(root) {
-    let cached = this.scans.get(root);
-    if (!cached) {
-      try {
-        cached = scanLibraryRoot(root, this.registry).assets.map((asset) => ({ asset, root }));
-      } catch {
-        cached = [];
-      }
-      this.scans.set(root, cached);
-    }
-    return cached;
-  }
-  resolveRoots() {
-    if (!this.roots) this.roots = defaultCatalogRoots(this.projectDir);
-    return this.roots;
-  }
-};
-function defaultCatalogRoots(projectDir) {
-  const roots = /* @__PURE__ */ new Set();
-  const add = (dir2) => {
-    if (!dir2 || !existsSync(dir2)) return;
-    try {
-      if (statSync(dir2).isDirectory()) roots.add(realpathSync(dir2));
-    } catch {
-    }
-  };
-  let dir = path3.resolve(projectDir);
-  for (let i = 0; i < 8; i++) {
-    const candidate = path3.join(dir, "ai-assets");
-    if (existsSync(candidate)) {
-      add(candidate);
-      break;
-    }
-    const parent = path3.resolve(dir, "..");
-    if (parent === dir) break;
-    dir = parent;
-  }
-  try {
-    for (const source of resolveSkWorkspaceConfig(projectDir).sources ?? []) {
-      add(path3.join(getGlobalCacheDir(), sourceCacheKey(source.url)));
-    }
-  } catch {
-  }
-  const projectSources = path3.join(projectDir, ".skaile", "cache", "sources");
-  try {
-    for (const entry of readdirSync(projectSources)) add(path3.join(projectSources, entry));
-  } catch {
-  }
-  return [...roots];
-}
-function normalizeRemote(url) {
-  return url.trim().replace(/^git@([^:]+):/, "https://$1/").replace(/^[a-z]+:\/\//i, "").replace(/\/+$/, "").replace(/\.git$/i, "").replace(/\/+$/, "").toLowerCase();
-}
-async function registeredLibraryRoots(origin) {
-  let index;
-  try {
-    index = new LocalIndex();
-    const libraries = await index.listSources();
-    const byName = libraries.filter((l) => l.name === origin.name);
-    const byUrl = byName.length === 0 && origin.url ? libraries.filter((l) => {
-      const url = l.backendConfig.url;
-      return typeof url === "string" && normalizeRemote(url) === normalizeRemote(origin.url ?? "");
-    }) : [];
-    return [...byName, ...byUrl].map((l) => l.path).filter((dir) => existsSync(dir));
-  } catch {
-    return [];
-  } finally {
-    index?.close();
-  }
-}
-function createCompositionContentSource(opts) {
-  const registry = opts.registry ?? createDefaultKindRegistry([knowledgeKindProvider]);
-  const scanner = new CatalogScanner(opts.projectDir, registry, opts.catalogRoots);
-  return new DefaultCompositionContentSource(
-    path3.resolve(opts.agentDir),
-    path3.resolve(opts.projectDir),
-    registry,
-    scanner
-  );
-}
-var DefaultCompositionContentSource = class _DefaultCompositionContentSource {
-  constructor(agentDir, projectDir, registry, scanner) {
-    this.agentDir = agentDir;
-    this.projectDir = projectDir;
-    this.registry = registry;
-    this.scanner = scanner;
-  }
-  agentDir;
-  projectDir;
-  registry;
-  scanner;
-  lockLoaded = false;
-  lockAssets = {};
-  scoped(agentDir) {
-    return new _DefaultCompositionContentSource(
-      path3.resolve(agentDir),
-      this.projectDir,
-      this.registry,
-      this.scanner
-    );
-  }
-  async load(ref, kind) {
-    if (ref.startsWith(".") || ref.startsWith("/")) return this.loadLocal(ref, kind);
-    const parsed = parseCatalogRef(ref);
-    if (!parsed.name) {
-      throw new CompositionError(
-        "composition_asset_missing",
-        "missing",
-        `"${ref}" (${kind}): not a resolvable ref`,
-        ref
-      );
-    }
-    const locked = this.lockCandidate(ref, kind, parsed);
-    if (locked) return this.loadLocked(ref, kind, locked);
-    return this.loadFromCatalog(ref, kind, parsed);
-  }
-  // ── local ────────────────────────────────────────────────────────────────
-  async loadLocal(ref, kind) {
-    const absPath = ref.startsWith("/") ? ref : path3.join(this.agentDir, ref);
-    let target = absPath;
-    let resolved = await resolveMixin(ref, kind, this.agentDir, {});
-    if (!resolved && kind !== "knowledge" && isDirectory(absPath)) {
-      const manifest = this.manifestInDir(kind, absPath);
-      if (manifest) {
-        target = manifest;
-        resolved = await resolveMixin(manifest, kind, this.agentDir, {});
-      }
-    }
-    if (!resolved) {
-      throw new CompositionError(
-        "composition_asset_missing",
-        "missing",
-        `"${ref}" (${kind}): no content at ${absPath}`,
-        ref
-      );
-    }
-    return {
-      canonicalRef: `local:${this.relativeToProject(target)}`,
-      kind,
-      version: null,
-      sha256: sha256Of(resolved.content),
-      content: resolved.content,
-      location: resolved.source
-    };
-  }
-  manifestInDir(kind, dir) {
-    const provider = this.registry.getProvider(kind);
-    for (const name of readdirSync(dir).sort()) {
-      const matches = provider ? provider.matchesPath(name) : name === `${kind.toUpperCase()}.md`;
-      if (matches && statSync(path3.join(dir, name)).isFile()) return path3.join(dir, name);
-    }
-    return void 0;
-  }
-  relativeToProject(abs) {
-    const rel = path3.relative(this.projectDir, abs).split(path3.sep).join("/");
-    return rel.startsWith("..") ? abs : rel;
-  }
-  // ── lock pin ─────────────────────────────────────────────────────────────
-  lockCandidate(ref, kind, parsed) {
-    if (!this.lockLoaded) {
-      this.lockLoaded = true;
-      try {
-        this.lockAssets = readLock(path3.join(this.projectDir, "skaile.lock.yaml"))?.assets ?? {};
-      } catch (err) {
-        throw new CompositionError(
-          "composition_conflict",
-          "stale_manifest",
-          `skaile.lock.yaml is unreadable: ${err instanceof Error ? err.message : String(err)}`,
-          ref
-        );
-      }
-    }
-    const matches = [];
-    for (const [key, entry] of Object.entries(this.lockAssets)) {
-      const m = LOCK_KEY_RE.exec(key);
-      if (!m || m[1] !== kind || m[3] !== parsed.name) continue;
-      if (parsed.publisher && barePublisher(parsed.publisher) !== m[2]) continue;
-      if (parsed.pin && !matchPin(parsed.pin, m[4])) continue;
-      matches.push({ key, publisher: m[2], name: m[3], version: m[4], entry });
-    }
-    if (matches.length > 1) {
-      throw new CompositionError(
-        "composition_conflict",
-        "ambiguous",
-        `"${ref}" (${kind}): skaile.lock.yaml pins ${matches.length} matching assets (${matches.map((x) => x.key).join(", ")}) \u2014 qualify the ref with a publisher and version`,
-        ref
-      );
-    }
-    return matches[0] ?? null;
-  }
-  async loadLocked(ref, kind, pin) {
-    const { entry } = pin;
-    const storeDir = path3.join(
-      this.projectDir,
-      ".skaile",
-      "cache",
-      "store",
-      pin.publisher,
-      kind,
-      pin.name,
-      pin.version
-    );
-    const prefix = commonDirPrefix(entry.files.map((f) => f.path));
-    const strip = (p) => prefix && p.startsWith(`${prefix}/`) ? p.slice(prefix.length + 1) : p;
-    if (isDirectory(storeDir) && entry.files.length > 0) {
-      await this.verifyFiles(ref, pin.key, entry, (p) => path3.join(storeDir, strip(p)));
-      const primary = this.primaryOf(
-        kind,
-        entry.files.map((f) => f.path)
-      );
-      return this.readAsset(
-        kind,
-        pin.key,
-        pin.version,
-        path3.join(storeDir, strip(primary)),
-        storeDir
-      );
-    }
-    const holdsPin = (h) => h.asset.version === pin.version && barePublisher(h.asset.publisher) === pin.publisher;
-    let hit = this.scanner.find(kind, pin.name).find(holdsPin);
-    if (!hit && entry.library) {
-      for (const root of await registeredLibraryRoots(entry.library)) {
-        hit = this.scanner.findIn(root, kind, pin.name).find(holdsPin);
-        if (hit) break;
-      }
-    }
-    if (!hit) {
-      let moved;
-      if (entry.library) {
-        for (const root of await registeredLibraryRoots(entry.library)) {
-          const other = this.scanner.findIn(root, kind, pin.name).find((h) => barePublisher(h.asset.publisher) === pin.publisher);
-          if (other?.asset.version) {
-            moved = {
-              key: pin.key,
-              library: entry.library.name,
-              libraryVersion: other.asset.version,
-              lockedVersion: pin.version
-            };
-            break;
-          }
-        }
-      }
-      throw new CompositionError(
-        "composition_asset_missing",
-        "missing",
-        moved ? `"${ref}" (${kind}): skaile.lock.yaml pins ${pin.key} but library "${moved.library}" is at ${moved.libraryVersion} \u2014 run \`skaile update\` to move the lock to it` : `"${ref}" (${kind}): skaile.lock.yaml pins ${pin.key} but no bytes for it are on disk \u2014 run \`skaile install\``,
-        ref,
-        moved
-      );
-    }
-    const assetRoot = hit.asset.fileFilter.assetRoot;
-    if (entry.files.length > 0) {
-      await this.verifyFiles(ref, pin.key, entry, (p) => path3.join(assetRoot, strip(p)));
-    } else if (entry.library?.sha256 && entry.library.sha256 !== hit.asset.sha256) {
-      throw new CompositionError(
-        "composition_conflict",
-        "hash_mismatch",
-        `"${ref}" (${kind}): ${pin.key} was locked from a library at ${entry.library.sha256.slice(0, 12)}\u2026 but the catalog now holds ${hit.asset.sha256.slice(0, 12)}\u2026`,
-        ref
-      );
-    }
-    return this.readAsset(kind, pin.key, pin.version, hit.asset.manifestPath, assetRoot);
-  }
-  async verifyFiles(ref, key, entry, locate) {
-    for (const file of entry.files) {
-      const abs = locate(file.path);
-      let bytes;
-      try {
-        bytes = await fs8.readFile(abs);
-      } catch {
-        throw new CompositionError(
-          "composition_asset_missing",
-          "missing",
-          `"${ref}": ${key} lists ${file.path} but ${abs} is missing \u2014 run \`skaile install\``,
-          ref
-        );
-      }
-      const actual = sha256Of(bytes);
-      if (actual !== file.sha256) {
-        throw new CompositionError(
-          "composition_conflict",
-          "hash_mismatch",
-          `"${ref}": ${file.path} of ${key} is ${actual.slice(0, 12)}\u2026 on disk but skaile.lock.yaml pins ${file.sha256.slice(0, 12)}\u2026 \u2014 run \`skaile install\` to restore it`,
-          ref
-        );
-      }
-    }
-  }
-  primaryOf(kind, paths) {
-    const provider = this.registry.getProvider(kind);
-    const hit = provider ? paths.find((p) => provider.matchesPath(p)) : void 0;
-    return hit ?? paths[0] ?? "";
-  }
-  // ── catalog ──────────────────────────────────────────────────────────────
-  async loadFromCatalog(ref, kind, parsed) {
-    const wantPublisher = parsed.publisher ? barePublisher(parsed.publisher) : void 0;
-    const candidates = this.scanner.find(kind, parsed.name).filter((h) => !wantPublisher || barePublisher(h.asset.publisher) === wantPublisher).filter((h) => matchPin(parsed.pin, h.asset.version));
-    const distinct = /* @__PURE__ */ new Map();
-    for (const c of candidates) {
-      distinct.set(`${c.asset.publisher}/${c.asset.name}#${c.asset.version}:${c.asset.sha256}`, c);
-    }
-    if (distinct.size === 0) {
-      throw new CompositionError(
-        "composition_asset_missing",
-        "missing",
-        `"${ref}" (${kind}): not in skaile.lock.yaml and not found in the local catalog`,
-        ref
-      );
-    }
-    if (distinct.size > 1) {
-      throw new CompositionError(
-        "composition_conflict",
-        "ambiguous",
-        `"${ref}" (${kind}): ${distinct.size} catalog assets match (${[...distinct.values()].map((c) => `@${barePublisher(c.asset.publisher)}/${c.asset.name}#${c.asset.version}`).join(", ")}) \u2014 qualify the ref with a publisher and version`,
-        ref
-      );
-    }
-    const { asset } = [...distinct.values()][0];
-    const canonical2 = `${kind}:@${barePublisher(asset.publisher)}/${asset.name}#${asset.version}`;
-    return this.readAsset(
-      kind,
-      canonical2,
-      asset.version,
-      asset.manifestPath,
-      asset.fileFilter.assetRoot
-    );
-  }
-  // ── shared read ──────────────────────────────────────────────────────────
-  async readAsset(kind, canonicalRef, version, primaryPath, assetRoot) {
-    let content;
-    let location = primaryPath;
-    if (kind === "knowledge") {
-      const dir = path3.basename(primaryPath) === "knowledge.yaml" ? path3.dirname(primaryPath) : assetRoot;
-      const loaded = await loadKnowledgeDir(dir);
-      if (!loaded) {
-        throw new CompositionError(
-          "composition_asset_missing",
-          "missing",
-          `"${canonicalRef}": knowledge directory ${dir} holds no documents`,
-          canonicalRef
-        );
-      }
-      content = loaded.content;
-      location = dir;
-    } else {
-      let raw;
-      try {
-        raw = await fs8.readFile(primaryPath, "utf-8");
-      } catch {
-        throw new CompositionError(
-          "composition_asset_missing",
-          "missing",
-          `"${canonicalRef}": ${primaryPath} is not readable`,
-          canonicalRef
-        );
-      }
-      content = stripFrontmatter(raw).trim();
-    }
-    return { canonicalRef, kind, version, sha256: sha256Of(content), content, location };
-  }
-};
-function isDirectory(p) {
-  try {
-    return statSync(p).isDirectory();
-  } catch {
-    return false;
-  }
-}
-function commonDirPrefix(paths) {
-  if (paths.length === 0) return "";
-  const split = paths.map((p) => p.split("/").slice(0, -1));
-  const first = split[0];
-  let n = first.length;
-  for (const parts of split) {
-    let i = 0;
-    while (i < n && i < parts.length && parts[i] === first[i]) i++;
-    n = i;
-  }
-  return first.slice(0, n).join("/");
-}
-function hashContent(content) {
-  return sha256Of(content);
-}
-
-// runner/src/composition/types.ts
-var KIND_BINDING_DEFAULTS = {
-  soul: "inline-snapshot",
-  persona: "inline-snapshot",
-  ruleset: "inline-live",
-  skill: "discoverable",
-  knowledge: "discoverable",
-  connector: "discoverable",
-  prompt: "inline-live",
-  flow: "discoverable",
-  "mcp-server": "discoverable",
-  contract: "inline-live",
-  agent: "delegate"
-};
-var UnknownCompositionKindError = class extends Error {
-  constructor(kind, ref) {
-    super(`composes item "${ref}" has unknown asset kind "${kind}" and no explicit binding`);
-    this.kind = kind;
-    this.ref = ref;
-    this.name = "UnknownCompositionKindError";
-  }
-  kind;
-  ref;
-  code = "unknown_asset_kind";
-};
-function resolveBinding(item) {
-  if (item.binding) return item.binding;
-  if (!Object.hasOwn(KIND_BINDING_DEFAULTS, item.kind)) {
-    throw new UnknownCompositionKindError(item.kind, item.ref);
-  }
-  return KIND_BINDING_DEFAULTS[item.kind];
-}
-
-// runner/src/composition/compile.ts
-var COMPILE_MANIFEST_FILENAME = "compile_manifest.json";
-var CompileManifestEntrySchema = z5.object({
-  asset_ref: z5.string().min(1),
-  kind: z5.string().min(1),
-  resolved_ref: z5.string().min(1),
-  version: z5.string().nullable(),
-  hash: z5.string().regex(/^[0-9a-f]{64}$/),
-  binding: BindingSchema,
-  resolved_at: z5.string(),
-  content: z5.string()
-});
-var CompileManifestSchema = z5.object({
-  schema_version: z5.literal(2),
-  prompt_version: z5.number().int().nonnegative(),
-  compiled_at: z5.string(),
-  entries: z5.array(CompileManifestEntrySchema)
-});
-var StaleSchemaMarker = z5.object({ schema_version: z5.literal(1) });
-var NestedAgentComposes = z5.object({ composes: z5.array(z5.unknown()) });
-var NestedAgentItem = z5.object({ kind: z5.literal("agent"), ref: z5.string() });
-async function compileComposition(opts) {
-  const { agentDir, items, source } = opts;
-  const manifestPath = path3.join(agentDir, COMPILE_MANIFEST_FILENAME);
-  const nextVersion = await readPromptVersion(manifestPath) + 1;
-  const loaded = /* @__PURE__ */ new Map();
-  const entries = [];
-  const resolvedAt = (/* @__PURE__ */ new Date()).toISOString();
-  for (const item of items) {
-    const binding = resolveBinding(item);
-    const cacheKey = `${item.kind}\0${item.ref}`;
-    let asset = loaded.get(cacheKey);
-    if (!asset) {
-      asset = await source.load(item.ref, item.kind);
-      loaded.set(cacheKey, asset);
-    }
-    entries.push({
-      asset_ref: item.ref,
-      kind: item.kind,
-      resolved_ref: asset.canonicalRef,
-      version: asset.version,
-      hash: asset.sha256,
-      binding,
-      resolved_at: resolvedAt,
-      content: asset.content
-    });
-  }
-  await assertAcyclicSubagents(agentDir, items, source);
-  const manifest = {
-    schema_version: 2,
-    prompt_version: nextVersion,
-    entries,
-    compiled_at: (/* @__PURE__ */ new Date()).toISOString()
-  };
-  const tmpPath = `${manifestPath}.tmp`;
-  await fs8.writeFile(tmpPath, `${JSON.stringify(manifest, null, 2)}
-`, "utf-8");
-  await fs8.rename(tmpPath, manifestPath);
-  return { manifest, manifestPath, resolvedCount: entries.length };
-}
-async function isCompilePinCurrent(opts) {
-  let pinned;
-  try {
-    pinned = await loadCompileManifestFromDir(opts.agentDir);
-  } catch {
-    return false;
-  }
-  if (!pinned || pinned.entries.length !== opts.items.length) return false;
-  for (const [i, item] of opts.items.entries()) {
-    const entry = pinned.entries[i];
-    if (entry.asset_ref !== item.ref || entry.kind !== item.kind) return false;
-    if (entry.binding !== resolveBinding(item)) return false;
-    const asset = await opts.source.load(item.ref, item.kind);
-    if (asset.sha256 !== entry.hash) return false;
-  }
-  return true;
-}
-async function loadCompileManifest(manifestPath) {
-  let raw;
-  try {
-    raw = await fs8.readFile(manifestPath, "utf-8");
-  } catch {
-    return void 0;
-  }
-  let json;
-  try {
-    json = JSON.parse(raw);
-  } catch {
-    throw new CompositionError(
-      "composition_rebuild_required",
-      "stale_manifest",
-      `${manifestPath} is not valid JSON \u2014 run \`skaile rebuild\``
-    );
-  }
-  if (StaleSchemaMarker.safeParse(json).success) {
-    throw new CompositionError(
-      "composition_rebuild_required",
-      "stale_manifest",
-      `${manifestPath} is a schema-1 compile manifest (hashes only, no captured content) \u2014 run \`skaile rebuild\``
-    );
-  }
-  const parsed = CompileManifestSchema.safeParse(json);
-  if (!parsed.success) {
-    throw new CompositionError(
-      "composition_rebuild_required",
-      "stale_manifest",
-      `${manifestPath} is malformed (${parsed.error.issues[0]?.path.join(".") || "root"}: ${parsed.error.issues[0]?.message}) \u2014 run \`skaile rebuild\``
-    );
-  }
-  for (const entry of parsed.data.entries) {
-    const actual = hashContent(entry.content);
-    if (actual !== entry.hash) {
-      throw new CompositionError(
-        "composition_conflict",
-        "hash_mismatch",
-        `${manifestPath}: captured content of "${entry.asset_ref}" (${entry.kind}) hashes to ${actual.slice(0, 12)}\u2026 but the manifest records ${entry.hash.slice(0, 12)}\u2026 \u2014 the file was edited; run \`skaile rebuild\``,
-        entry.asset_ref
-      );
-    }
-  }
-  return parsed.data;
-}
-async function loadCompileManifestFromDir(agentDir) {
-  return loadCompileManifest(path3.join(agentDir, COMPILE_MANIFEST_FILENAME));
-}
-async function readPromptVersion(manifestPath) {
-  try {
-    const parsed = JSON.parse(await fs8.readFile(manifestPath, "utf-8"));
-    return typeof parsed?.prompt_version === "number" ? parsed.prompt_version : 0;
-  } catch {
-    return 0;
-  }
-}
-var identityOf = (file) => {
-  try {
-    return realpathSync(file);
-  } catch {
-    return file;
-  }
-};
-async function assertAcyclicSubagents(agentDir, items, source) {
-  const manifestFile = path3.join(agentDir, "agent.yaml");
-  const root = existsSync(manifestFile) ? identityOf(manifestFile) : identityOf(agentDir);
-  const visit = async (children, src, chain) => {
-    for (const item of children) {
-      if (item.kind !== "agent") continue;
-      const asset = await src.load(item.ref, "agent");
-      const identity = asset.location ? identityOf(asset.location) : asset.canonicalRef;
-      if (chain.includes(identity)) {
-        throw new CompositionError(
-          "composition_conflict",
-          "cycle",
-          `"${item.ref}" (agent): sub-agent composition loops (${[...chain, identity].map((p) => path3.basename(path3.dirname(p)) || p).join(" \u2192 ")})`,
-          item.ref
-        );
-      }
-      const nested = NestedAgentComposes.safeParse(parseYamlSafe(asset.content));
-      if (!nested.success || !asset.location) continue;
-      const subagents = nested.data.composes.flatMap((c) => {
-        const parsedItem = NestedAgentItem.safeParse(c);
-        return parsedItem.success ? [parsedItem.data] : [];
-      });
-      if (subagents.length === 0) continue;
-      await visit(subagents, src.scoped(path3.dirname(asset.location)), [...chain, identity]);
-    }
-  };
-  await visit(items, source, [root]);
-}
-function parseYamlSafe(text2) {
-  try {
-    return parse(text2);
-  } catch {
-    return null;
-  }
-}
-
 // runner/src/composition/resolve.ts
 async function resolveComposition(opts) {
   const { items, library, source, compileManifest, runSnapshot, implicit, lockPinned } = opts;
@@ -1341,18 +577,18 @@ async function hashAgentFiles(agentDir) {
   const walk = async (dir, prefix) => {
     let entries;
     try {
-      entries = await fs8.readdir(dir, { withFileTypes: true });
+      entries = await fs5.readdir(dir, { withFileTypes: true });
     } catch {
       return;
     }
     for (const entry of entries) {
       if (entry.name.startsWith(".") || SKIPPED_NAMES.has(entry.name)) continue;
       const rel = prefix ? `${prefix}/${entry.name}` : entry.name;
-      const abs = path3.join(dir, entry.name);
+      const abs = path4.join(dir, entry.name);
       if (entry.isDirectory()) {
         await walk(abs, rel);
       } else if (entry.isFile()) {
-        const bytes = await fs8.readFile(abs);
+        const bytes = await fs5.readFile(abs);
         out.push({ path: rel, sha256: createHash("sha256").update(bytes).digest("hex") });
       }
     }
@@ -1360,23 +596,23 @@ async function hashAgentFiles(agentDir) {
   await walk(agentDir, "");
   return out.sort((a, b) => a.path < b.path ? -1 : a.path > b.path ? 1 : 0);
 }
-var RunSnapshotSchema = z5.object({
-  schema_version: z5.literal(1),
-  session_id: z5.string().min(1),
-  captured_at: z5.string(),
-  prompt_version: z5.number().int().nonnegative().nullable(),
-  items: z5.array(CompileManifestEntrySchema)
+var RunSnapshotSchema = z4.object({
+  schema_version: z4.literal(1),
+  session_id: z4.string().min(1),
+  captured_at: z4.string(),
+  prompt_version: z4.number().int().nonnegative().nullable(),
+  items: z4.array(CompileManifestEntrySchema)
 });
-var RUN_SNAPSHOT_DIR = path3.join(".skaile", "composition-runs");
+var RUN_SNAPSHOT_DIR = path4.join(".skaile", "composition-runs");
 var safeFileName = (sessionId) => `${sessionId.replace(/[^\w.-]/g, "_")}.json`;
 function compositionRunSnapshotPath(projectDir, sessionId) {
-  return path3.join(projectDir, RUN_SNAPSHOT_DIR, safeFileName(sessionId));
+  return path4.join(projectDir, RUN_SNAPSHOT_DIR, safeFileName(sessionId));
 }
 async function loadCompositionRunSnapshot(projectDir, sessionId) {
   const file = compositionRunSnapshotPath(projectDir, sessionId);
   let raw;
   try {
-    raw = await fs8.readFile(file, "utf-8");
+    raw = await fs5.readFile(file, "utf-8");
   } catch {
     return void 0;
   }
@@ -1432,27 +668,27 @@ function buildCompositionRunSnapshot(sessionId, items, promptVersion) {
 }
 var MAX_RUN_SNAPSHOTS = 20;
 async function pruneRunSnapshots(projectDir, except, keep) {
-  const dir = path3.join(projectDir, RUN_SNAPSHOT_DIR);
+  const dir = path4.join(projectDir, RUN_SNAPSHOT_DIR);
   try {
-    const names = (await fs8.readdir(dir)).filter((n) => n.endsWith(".json"));
+    const names = (await fs5.readdir(dir)).filter((n) => n.endsWith(".json"));
     const dated = await Promise.all(
       names.map(async (name) => ({
-        file: path3.join(dir, name),
-        mtime: (await fs8.stat(path3.join(dir, name))).mtimeMs
+        file: path4.join(dir, name),
+        mtime: (await fs5.stat(path4.join(dir, name))).mtimeMs
       }))
     );
     const stale = dated.filter((d) => d.file !== except).sort((a, b) => b.mtime - a.mtime).slice(Math.max(keep - 1, 0));
-    await Promise.all(stale.map((d) => fs8.rm(d.file, { force: true })));
+    await Promise.all(stale.map((d) => fs5.rm(d.file, { force: true })));
   } catch {
   }
 }
 async function saveCompositionRunSnapshot(projectDir, snapshot) {
   const file = compositionRunSnapshotPath(projectDir, snapshot.session_id);
-  await fs8.mkdir(path3.dirname(file), { recursive: true });
+  await fs5.mkdir(path4.dirname(file), { recursive: true });
   const tmp = `${file}.tmp`;
-  await fs8.writeFile(tmp, `${JSON.stringify(snapshot, null, 2)}
+  await fs5.writeFile(tmp, `${JSON.stringify(snapshot, null, 2)}
 `, "utf-8");
-  await fs8.rename(tmp, file);
+  await fs5.rename(tmp, file);
   ensureRunStateIgnored(projectDir);
   await pruneRunSnapshots(projectDir, file, MAX_RUN_SNAPSHOTS);
 }
@@ -1463,11 +699,11 @@ function isLockPinnedAgentDir(projectDir, agentDir) {
     try {
       return realpathSync(p);
     } catch {
-      return path3.resolve(p);
+      return path4.resolve(p);
     }
   };
   const dir = real(agentDir);
-  return [agentSourceCacheDir(projectDir), path3.join(projectDir, ".skaile", "assets", "agent")].map(real).some((root) => dir === root || dir.startsWith(root + path3.sep));
+  return [agentSourceCacheDir(projectDir), path4.join(projectDir, ".skaile", "assets", "agent")].map(real).some((root) => dir === root || dir.startsWith(root + path4.sep));
 }
 function instanceForSession(config, instanceId, agentDir) {
   const id = instanceId ?? DEFAULT_AGENT_INSTANCE_ID;
@@ -1498,8 +734,8 @@ function resolveInstanceAgentDir(projectDir, config, instanceId) {
     if (!(error instanceof AgentRefResolutionError)) throw error;
     throw new Error(`Agent instance "${instanceId}": ${error.message}`);
   }
-  if (dir && path3.basename(dir) === "agent.yaml") dir = path3.dirname(dir);
-  if (!dir || !existsSync(path3.join(dir, "agent.yaml"))) {
+  if (dir && path4.basename(dir) === "agent.yaml") dir = path4.dirname(dir);
+  if (!dir || !existsSync(path4.join(dir, "agent.yaml"))) {
     throw new Error(
       `Agent instance "${instanceId}": "${instance.ref}" does not resolve to an agent directory with agent.yaml${dir ? ` (looked in ${dir})` : ""}`
     );
@@ -1698,7 +934,7 @@ async function resolveMemoryBlocks(manifest, agentDir, scopeOverride, resolvedIt
         seed = pinned.content;
       } else {
         try {
-          seed = (await fs8.readFile(path3.join(agentDir, block.source), "utf-8")).trim();
+          seed = (await fs5.readFile(path4.join(agentDir, block.source), "utf-8")).trim();
         } catch {
           warnings.push(`memory block "${block.name}": source "${block.source}" not found`);
         }
@@ -1754,17 +990,17 @@ function checkCapabilities(manifest, items, slots, content, host, dryRun, warnin
 }
 async function agentDefinitionExists(agentDir) {
   try {
-    await fs8.access(path3.join(agentDir, "agent.yaml"));
+    await fs5.access(path4.join(agentDir, "agent.yaml"));
     return true;
   } catch {
     return false;
   }
 }
 async function loadAgentManifest(agentDir) {
-  const agentYamlPath = path3.join(agentDir, "agent.yaml");
+  const agentYamlPath = path4.join(agentDir, "agent.yaml");
   let content;
   try {
-    content = await fs8.readFile(agentYamlPath, "utf-8");
+    content = await fs5.readFile(agentYamlPath, "utf-8");
   } catch {
     return void 0;
   }
@@ -1856,15 +1092,15 @@ async function loadAgentRunTargets(opts) {
       );
       continue;
     }
-    const isLocal = sub.ref.startsWith("./") || sub.ref.startsWith("../") || path3.isAbsolute(sub.ref);
-    const dir = isLocal ? path3.resolve(opts.current.agentDir, sub.ref) : workspaceDir(opts.projectDir, sub.ref);
+    const isLocal = sub.ref.startsWith("./") || sub.ref.startsWith("../") || path4.isAbsolute(sub.ref);
+    const dir = isLocal ? path4.resolve(opts.current.agentDir, sub.ref) : workspaceDir(opts.projectDir, sub.ref);
     targets.push(
       await resolveTarget(
         opts,
         sub.as,
         { ref: sub.ref, lifecycle: "role" },
         "composed",
-        dir && path3.basename(dir) === "agent.yaml" ? path3.dirname(dir) : dir,
+        dir && path4.basename(dir) === "agent.yaml" ? path4.dirname(dir) : dir,
         sub.ref
       )
     );
@@ -1965,9 +1201,9 @@ function asReply(value, what) {
   }
   return failure("host_error", `the host answered ${what} with an unexpected payload`);
 }
-var budgetSchema = z5.object({
-  max_turns: z5.number().int().positive().optional(),
-  max_tokens: z5.number().int().positive().optional()
+var budgetSchema = z4.object({
+  max_turns: z4.number().int().positive().optional(),
+  max_tokens: z4.number().int().positive().optional()
 }).describe("Optional limits for this run; the instance's own limits still apply.");
 function registerAgentSurface(deps) {
   const { registry, hosts, targets } = deps;
@@ -2032,7 +1268,7 @@ function registerAgentSurface(deps) {
       defineCapability({
         name: "agent.list",
         description: "List the agent instances of this workspace: id, lifecycle (standing identity or role), description, whether the instance takes typed input / returns typed output, and whether it can be started.",
-        input: z5.object({}),
+        input: z4.object({}),
         side: "agent",
         origin: ORIGIN,
         scope: "session",
@@ -2042,12 +1278,12 @@ function registerAgentSurface(deps) {
       defineCapability({
         name: "agent.run",
         description: "Run an agent instance of this workspace with the given input. A role takes the input its `io.input` schema describes and returns output matching `io.output`. `mode: sync` (default) waits for the run; `mode: async` returns the runId at once - poll `agent.status` or fetch `agent.result`. A run of an instance that needs approval returns `waiting_approval` and an approvalId.",
-        input: z5.object({
-          instance: z5.string().min(1).describe("Instance id from `agent.list`."),
-          input: z5.unknown().optional().describe(
+        input: z4.object({
+          instance: z4.string().min(1).describe("Instance id from `agent.list`."),
+          input: z4.unknown().optional().describe(
             "Input for the run; must match the role's `io.input`. Pass the value itself (e.g. an object), not its JSON text."
           ),
-          mode: z5.enum(["sync", "async"]).optional(),
+          mode: z4.enum(["sync", "async"]).optional(),
           budget: budgetSchema.optional()
         }),
         side: "agent",
@@ -2127,7 +1363,7 @@ function registerAgentSurface(deps) {
       defineCapability({
         name: "agent.status",
         description: "Status of a run started with `agent.run`.",
-        input: z5.object({ runId: z5.string().min(1) }),
+        input: z4.object({ runId: z4.string().min(1) }),
         side: "agent",
         origin: ORIGIN,
         scope: "session",
@@ -2137,7 +1373,7 @@ function registerAgentSurface(deps) {
       defineCapability({
         name: "agent.cancel",
         description: "Cancel a run started with `agent.run`; runs it started are cancelled too.",
-        input: z5.object({ runId: z5.string().min(1) }),
+        input: z4.object({ runId: z4.string().min(1) }),
         side: "agent",
         origin: ORIGIN,
         scope: "session",
@@ -2147,7 +1383,7 @@ function registerAgentSurface(deps) {
       defineCapability({
         name: "agent.result",
         description: "The result of a run: its output once it succeeded (matching the role's `io.output`), or why it failed. `wait: true` waits for a running run to end.",
-        input: z5.object({ runId: z5.string().min(1), wait: z5.boolean().optional() }),
+        input: z4.object({ runId: z4.string().min(1), wait: z4.boolean().optional() }),
         side: "agent",
         origin: ORIGIN,
         scope: "session",
@@ -2166,7 +1402,7 @@ function registerAgentSurface(deps) {
         name: "approval.decide",
         displayName: "Decide a run approval",
         description: "Approve or deny the one operation a run is waiting on (`waiting_approval`). Invoked by the user, never by the model.",
-        input: z5.object({ approvalId: z5.string().min(1), decision: z5.enum(["approve", "deny"]) }),
+        input: z4.object({ approvalId: z4.string().min(1), decision: z4.enum(["approve", "deny"]) }),
         side: "agent",
         origin: ORIGIN,
         scope: "session",
@@ -2226,7 +1462,7 @@ function registerAgentSurface(deps) {
       defineCapability({
         name: "memory.read",
         description: "Read a memory block of this agent (its current stored content).",
-        input: z5.object({ block: z5.string().min(1) }),
+        input: z4.object({ block: z4.string().min(1) }),
         side: "agent",
         origin: ORIGIN,
         scope: "session",
@@ -2240,7 +1476,7 @@ function registerAgentSurface(deps) {
       defineCapability({
         name: "memory.write",
         description: "Replace the content of a memory block. The host enforces the block's size cap.",
-        input: z5.object({ block: z5.string().min(1), content: z5.string() }),
+        input: z4.object({ block: z4.string().min(1), content: z4.string() }),
         side: "agent",
         origin: ORIGIN,
         scope: "session",
@@ -2261,7 +1497,7 @@ function registerAgentSurface(deps) {
       defineCapability({
         name: "memory.append",
         description: "Append text to a memory block. The host enforces the block's size cap.",
-        input: z5.object({ block: z5.string().min(1), content: z5.string() }),
+        input: z4.object({ block: z4.string().min(1), content: z4.string() }),
         side: "agent",
         origin: ORIGIN,
         scope: "session",
@@ -2282,7 +1518,7 @@ function registerAgentSurface(deps) {
       defineCapability({
         name: "memory.list",
         description: "List the memory blocks of this agent with scope, size cap and current size.",
-        input: z5.object({}),
+        input: z4.object({}),
         side: "agent",
         origin: ORIGIN,
         scope: "session",
@@ -2318,12 +1554,12 @@ function registerAgentSurface(deps) {
       );
       return typeof reply === "object" && reply !== null ? reply : failure("host_error", "the host answered trigger with an unexpected payload");
     };
-    const triggerId = z5.string().regex(/^[a-z][a-z0-9_-]*$/, "trigger id must match [a-z][a-z0-9_-]*");
+    const triggerId = z4.string().regex(/^[a-z][a-z0-9_-]*$/, "trigger id must match [a-z][a-z0-9_-]*");
     caps.push(
       defineCapability({
         name: "trigger.list",
         description: "List the triggers of this agent (schedules, webhooks, channel and event triggers) with their source (`asset`, `workspace` or `runtime`) and whether they are enabled.",
-        input: z5.object({}),
+        input: z4.object({}),
         side: "agent",
         origin: ORIGIN,
         scope: "session",
@@ -2333,15 +1569,15 @@ function registerAgentSurface(deps) {
       defineCapability({
         name: "trigger.upsert",
         description: "Create or update a runtime trigger of this agent. A `schedule` needs `cron`; the trigger's `prompt` is what the agent is asked when it fires. The user approves the change.",
-        input: z5.object({
+        input: z4.object({
           id: triggerId,
-          kind: z5.enum(["schedule", "webhook", "channel", "event"]),
-          cron: z5.string().min(1).optional(),
-          prompt: z5.string().min(1).optional(),
-          timezone: z5.string().min(1).optional(),
-          when: z5.string().min(1).optional(),
-          event: z5.string().min(1).optional(),
-          enabled: z5.boolean().optional()
+          kind: z4.enum(["schedule", "webhook", "channel", "event"]),
+          cron: z4.string().min(1).optional(),
+          prompt: z4.string().min(1).optional(),
+          timezone: z4.string().min(1).optional(),
+          when: z4.string().min(1).optional(),
+          event: z4.string().min(1).optional(),
+          enabled: z4.boolean().optional()
         }),
         side: "agent",
         origin: ORIGIN,
@@ -2369,7 +1605,7 @@ function registerAgentSurface(deps) {
       defineCapability({
         name: "trigger.toggle",
         description: "Enable or disable a trigger of this agent. The user approves the change.",
-        input: z5.object({ id: triggerId, enabled: z5.boolean() }),
+        input: z4.object({ id: triggerId, enabled: z4.boolean() }),
         side: "agent",
         origin: ORIGIN,
         scope: "session",
@@ -2410,10 +1646,10 @@ function keywordSearch(capabilities, query, limit) {
   return scored.slice(0, limit).map((x) => x.cap);
 }
 function builtinCapabilities(registry) {
-  const listFilterSchema = z5.strictObject({
-    side: z5.enum(["client", "agent"]).optional(),
-    originKind: z5.enum(["framework", "client", "agent", "flow", "skill", "mcp", "connector"]).optional(),
-    scope: z5.enum(["session", "turn"]).optional()
+  const listFilterSchema = z4.strictObject({
+    side: z4.enum(["client", "agent"]).optional(),
+    originKind: z4.enum(["framework", "client", "agent", "flow", "skill", "mcp", "connector"]).optional(),
+    scope: z4.enum(["session", "turn"]).optional()
   });
   return [
     defineCapability({
@@ -2439,9 +1675,9 @@ function builtinCapabilities(registry) {
       origin: { kind: "framework" },
       kind: "query",
       userInvokable: false,
-      input: z5.strictObject({
-        query: z5.string(),
-        limit: z5.number().int().positive().optional()
+      input: z4.strictObject({
+        query: z4.string(),
+        limit: z4.number().int().positive().optional()
       }),
       handler: async ({ query, limit }) => keywordSearch(registry.list(), query, limit ?? 10)
     }),
@@ -2453,7 +1689,7 @@ function builtinCapabilities(registry) {
       origin: { kind: "framework" },
       kind: "query",
       userInvokable: false,
-      input: z5.strictObject({ name: z5.string() }),
+      input: z4.strictObject({ name: z4.string() }),
       handler: async ({ name }) => {
         const cap = registry.resolve(name);
         if (!cap) return null;
@@ -2857,22 +2093,6 @@ var HYDRATED_REJECT_HANDLER = async () => {
   );
 };
 
-// runner/src/composition/prompt-sections.ts
-function buildRunnerAgentSections(resolved, promptExtensions, options = {}) {
-  const blocks = resolved?.inlineBlocks ?? [];
-  const memory = resolved?.memoryBlocks ?? [];
-  const seedsFromSoul = memory.some((m) => m.source?.replace(/^\.\//, "") === "SOUL.md");
-  const soul = options.includeSoul && !seedsFromSoul ? blocks.filter((block) => block.implicit && block.kind === "soul").map((block) => block.content.trim()).filter(Boolean).join("\n\n") : "";
-  const duties = blocks.filter((block) => block.implicit && block.kind === "prompt").map((block) => block.content.trim()).filter(Boolean).join("\n\n");
-  return buildAgentPromptSections({
-    soul,
-    memory,
-    duties,
-    composed: blocks.filter((block) => !block.implicit).map((block) => ({ text: block.content, source: block.ref })),
-    promptExtensions: promptExtensions.map((e) => ({ text: e.value, source: e.source }))
-  });
-}
-
 // 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."
@@ -3221,7 +2441,7 @@ function registerCodexToolDefinitions(registry, namespace, tools) {
     (tool) => defineCapability({
       name: `${namespace}.${tool.name}`,
       description: tool.description,
-      input: z5.object(tool.inputSchema),
+      input: z4.object(tool.inputSchema),
       side: "agent",
       origin: { kind: "framework" },
       audience: ["llm"],
@@ -3238,20 +2458,20 @@ function registerCodexToolDefinitions(registry, namespace, tools) {
   };
 }
 function contains(root, target) {
-  const path11 = relative(root, target);
-  return path11 === "" || !path11.startsWith("..") && !isAbsolute(path11);
+  const path8 = relative(root, target);
+  return path8 === "" || !path8.startsWith("..") && !isAbsolute(path8);
 }
-async function canonical(path11) {
+async function canonical(path8) {
   try {
-    return await realpath(path11);
+    return await realpath(path8);
   } catch (error) {
     if (error.code !== "ENOENT") throw error;
-    const parent = dirname(path11);
-    if (parent === path11) throw error;
-    return resolve(await canonical(parent), relative(parent, path11));
+    const parent = dirname(path8);
+    if (parent === path8) throw error;
+    return resolve(await canonical(parent), relative(parent, path8));
   }
 }
-async function assertScopedTree(path11, root) {
+async function assertScopedTree(path8, root) {
   let remaining = 1e4;
   async function visit(entry) {
     if (--remaining < 0) throw new Error("CODEX_RESOURCE_SCOPE_INVALID");
@@ -3267,7 +2487,7 @@ async function assertScopedTree(path11, root) {
     if (stat4.isDirectory())
       for (const child of await readdir(entry)) await visit(join(entry, child));
   }
-  await visit(path11);
+  await visit(path8);
 }
 async function registerCodexResourceTools(options) {
   const project = await realpath(options.projectDir);
@@ -3403,7 +2623,7 @@ function resolveHomeConfig(raw) {
       problems.push(`${at}: ${pathProblem}; ignored`);
       return;
     }
-    const path11 = entry.path;
+    const path8 = entry.path;
     const maxChars = entry["max-chars"];
     if (typeof maxChars !== "number" || !Number.isInteger(maxChars) || maxChars < 1 || maxChars > HOME_MAX_CHARS) {
       problems.push(`${at}: max-chars must be an integer from 1 to ${HOME_MAX_CHARS}; ignored`);
@@ -3414,7 +2634,7 @@ function resolveHomeConfig(raw) {
       problems.push(`${at}: from must be 'head' or 'tail'; ignored`);
       return;
     }
-    let label = basename(path11).replace(/\.md$/, "");
+    let label = basename(path8).replace(/\.md$/, "");
     if (entry.label !== void 0) {
       if (typeof entry.label !== "string" || entry.label.length === 0 || /[\r\n]/.test(entry.label)) {
         problems.push(`${at}: label must be a one-line string; ignored`);
@@ -3422,12 +2642,12 @@ function resolveHomeConfig(raw) {
       }
       label = entry.label;
     }
-    if (seen.has(path11)) {
-      problems.push(`${at}: duplicate path ${path11}; ignored`);
+    if (seen.has(path8)) {
+      problems.push(`${at}: duplicate path ${path8}; ignored`);
       return;
     }
-    seen.add(path11);
-    files.push({ path: path11, label, maxChars, from });
+    seen.add(path8);
+    files.push({ path: path8, label, maxChars, from });
   });
   return { tag, intro, files, problems };
 }
@@ -3679,9 +2899,9 @@ function toolAllowlistRefusal(allowlist, harness) {
     return "Prompt refused: toolAllowlist must be an array of tool names.";
   if (harness?.enforcesToolAllowlist !== true || typeof harness.unknownAllowlistedTools !== "function")
     return "Prompt refused: this agent harness cannot enforce a tool allowlist.";
-  const unknown4 = harness.unknownAllowlistedTools(allowlist);
-  if (unknown4.length > 0)
-    return `Prompt refused: unknown tool(s) in toolAllowlist: ${unknown4.join(", ")}.`;
+  const unknown3 = harness.unknownAllowlistedTools(allowlist);
+  if (unknown3.length > 0)
+    return `Prompt refused: unknown tool(s) in toolAllowlist: ${unknown3.join(", ")}.`;
   return null;
 }
 
@@ -3713,8 +2933,8 @@ var DEFAULT_MAX_DIRS = 256;
 function isStructuralAction(action) {
   return action === "create" || action === "delete";
 }
-function parentDirOf(path11) {
-  return path11.includes("/") ? path11.slice(0, path11.lastIndexOf("/")) : "";
+function parentDirOf(path8) {
+  return path8.includes("/") ? path8.slice(0, path8.lastIndexOf("/")) : "";
 }
 var FileChangedCoalescer = class {
   windowMs;
@@ -3896,7 +3116,7 @@ async function readMcpToolsSnapshot(decl) {
   return file.tools;
 }
 async function writeMcpToolsSnapshot(decl, tools) {
-  const path11 = snapshotPath(decl);
+  const path8 = snapshotPath(decl);
   const body = {
     format: SNAPSHOT_FORMAT,
     id: decl.id,
@@ -3907,11 +3127,11 @@ async function writeMcpToolsSnapshot(decl, tools) {
       ...t.inputSchema !== void 0 ? { inputSchema: t.inputSchema } : {}
     }))
   };
-  const tmp = `${path11}.${process.pid}.${Date.now()}.tmp`;
+  const tmp = `${path8}.${process.pid}.${Date.now()}.tmp`;
   try {
     await mkdir(mcpToolsSnapshotDir(), { recursive: true });
     await writeFile(tmp, JSON.stringify(body), "utf8");
-    await rename(tmp, path11);
+    await rename(tmp, path8);
     return true;
   } catch {
     return false;
@@ -3954,22 +3174,22 @@ function recipeMapPath() {
 var recipeMapMemo = null;
 var recipeMapInFlight = null;
 async function loadRecipeMap() {
-  const path11 = recipeMapPath();
+  const path8 = recipeMapPath();
   const mtimeMs = await tryWithFsDeadline(
-    `stat ${path11}`,
-    async () => (await stat(path11)).mtimeMs,
+    `stat ${path8}`,
+    async () => (await stat(path8)).mtimeMs,
     null
   );
   if (mtimeMs === null) {
-    recipeMapMemo = { path: path11, mtimeMs: -1, map: null };
+    recipeMapMemo = { path: path8, mtimeMs: -1, map: null };
     return null;
   }
-  if (recipeMapMemo && recipeMapMemo.path === path11 && recipeMapMemo.mtimeMs === mtimeMs) {
+  if (recipeMapMemo && recipeMapMemo.path === path8 && recipeMapMemo.mtimeMs === mtimeMs) {
     return recipeMapMemo.map;
   }
-  const key = `${path11}:${mtimeMs}`;
+  const key = `${path8}:${mtimeMs}`;
   if (recipeMapInFlight?.key === key) return recipeMapInFlight.promise;
-  const promise = readRecipeMap(path11, mtimeMs);
+  const promise = readRecipeMap(path8, mtimeMs);
   recipeMapInFlight = { key, promise };
   try {
     return await promise;
@@ -3977,21 +3197,21 @@ async function loadRecipeMap() {
     if (recipeMapInFlight?.key === key) recipeMapInFlight = null;
   }
 }
-async function readRecipeMap(path11, mtimeMs) {
+async function readRecipeMap(path8, mtimeMs) {
   let map = null;
   try {
     const parsed = JSON.parse(
-      await withFsDeadline(`readFile ${path11}`, () => readFile(path11, "utf8"))
+      await withFsDeadline(`readFile ${path8}`, () => readFile(path8, "utf8"))
     );
     map = parsed && typeof parsed === "object" ? parsed : null;
   } catch (err) {
     createLogger({ kind: "mcp", subkind: "recipe-resolve" }).warn(
       "recipe map malformed \u2014 falling back to nix path-info",
-      { path: path11, error: err instanceof Error ? err.message : String(err) }
+      { path: path8, error: err instanceof Error ? err.message : String(err) }
     );
     map = null;
   }
-  recipeMapMemo = { path: path11, mtimeMs, map };
+  recipeMapMemo = { path: path8, mtimeMs, map };
   return map;
 }
 var MapRecipeProducer = class {
@@ -4278,6 +3498,8 @@ function warnUnresolvedRecipeMarkers(recipeLog, declId, resolvedCommand, resolve
 var PASSTHROUGH_INPUT_ZOD = {
   parse: (v) => v
 };
+var MCP_TOOL_CALL_TIMEOUT_MS = 15 * 6e4;
+var MCP_TOOL_CALL_MAX_TOTAL_MS = 2 * 60 * 6e4;
 function isMcpAuthError(err) {
   if (!err || typeof err !== "object") return false;
   const code = err.code ?? err.status;
@@ -4430,7 +3652,8 @@ var ExternalMcpManager = class {
     const snapshot = lazy ? await readMcpToolsSnapshot(decl) : void 0;
     if (snapshot) return this.registerFromSnapshot(decl, snapshot);
     const client = await this.connectWithReauth(decl);
-    const server = { id: decl.id, decl, client, tools: [], toolNames: [] };
+    const server = { id: decl.id, decl, tools: [], toolNames: [] };
+    this.adoptClient(server, client);
     const toolNames = [];
     try {
       const { tools } = await client.listTools();
@@ -4443,6 +3666,7 @@ var ExternalMcpManager = class {
       if (lazy) await writeMcpToolsSnapshot(decl, tools);
     } catch (err) {
       for (const name of toolNames) this.registry.deregister(name);
+      server.removed = true;
       try {
         await client.close();
       } catch {
@@ -4484,25 +3708,27 @@ var ExternalMcpManager = class {
     return { id: decl.id, toolNames: [...server.toolNames] };
   }
   /**
-   * The server's live client, starting a lazy server on first use. Concurrent
-   * first calls share one connect; a failed connect is not cached, so the next
-   * call tries again.
+   * The server's live client, starting it on first use (a lazy server) or after
+   * its connection closed. Concurrent calls share one connect; a failed connect
+   * is not cached, so the next call tries again.
    */
   ensureClient(server) {
     if (server.client) return Promise.resolve(server.client);
     if (server.removed) return Promise.reject(new Error(`MCP server '${server.id}' was removed`));
-    server.connectInFlight ??= this.startLazyServer(server).finally(() => {
+    server.connectInFlight ??= this.startServer(server).finally(() => {
       server.connectInFlight = void 0;
     });
     return server.connectInFlight;
   }
-  async startLazyServer(server) {
+  async startServer(server) {
+    const restart = server.closedAt !== void 0;
+    const what = restart ? "restart" : "lazy start";
     let client;
     let tools;
     try {
       client = await this.connectWithReauth(server.decl);
     } catch (err) {
-      this.log.error("MCP server lazy start failed", err, { id: server.id });
+      this.log.error(`MCP server ${what} failed`, err, { id: server.id });
       throw new Error(`MCP server '${server.id}' failed to start: ${errMessage(err)}`);
     }
     try {
@@ -4510,28 +3736,54 @@ var ExternalMcpManager = class {
     } catch (err) {
       await client.close().catch(() => {
       });
-      this.log.error("MCP server lazy start failed", err, { id: server.id });
+      this.log.error(`MCP server ${what} failed`, err, { id: server.id });
       throw new Error(`MCP server '${server.id}' failed to start: ${errMessage(err)}`);
     }
-    server.client = client;
+    const downMs = restart ? Date.now() - server.closedAt : void 0;
+    this.adoptClient(server, client);
     if (server.removed) throw new Error(`MCP server '${server.id}' was removed`);
     if (!sameToolList(server.tools, tools)) this.reregisterTools(server, tools);
-    this.log.info("MCP server registered (runner-managed)", {
-      id: server.id,
-      transport: "stdio",
-      toolCount: server.toolNames.length,
-      tools: server.toolNames,
-      lazy: true,
-      started: true
-    });
+    this.log.info(
+      restart ? "MCP server restarted (runner-managed)" : "MCP server registered (runner-managed)",
+      {
+        id: server.id,
+        transport: server.decl.transport ?? "stdio",
+        toolCount: server.toolNames.length,
+        tools: server.toolNames,
+        ...restart ? { downMs } : { lazy: true, started: true }
+      }
+    );
     return client;
   }
+  /**
+   * Make `client` the server's live client and watch it: when its transport
+   * closes on its own (the stdio process exited), drop it so the next tool call
+   * starts the server again instead of failing with `Not connected` for the
+   * rest of the session. The client it replaces (401 reconnect, or a restart
+   * racing one) is closed, and its close is ignored.
+   */
+  adoptClient(server, client) {
+    const previous = server.client;
+    server.client = client;
+    server.closedAt = void 0;
+    if (previous && previous !== client) void previous.close().catch(() => {
+    });
+    client.onclose = () => {
+      if (server.client !== client || server.removed) return;
+      server.client = void 0;
+      server.closedAt = Date.now();
+      this.log.warn("MCP server connection closed; the next tool call restarts it", {
+        id: server.id,
+        transport: server.decl.transport ?? "stdio"
+      });
+    };
+  }
   /**
    * The snapshot disagreed with what the started server advertises: replace the
    * registered capabilities with the live list and rewrite the snapshot.
    */
   reregisterTools(server, tools) {
-    this.log.warn("MCP tools snapshot is stale; re-registering from the live server", {
+    this.log.warn("MCP tool list changed; re-registering from the live server", {
       id: server.id,
       snapshotCount: server.tools.length,
       liveCount: tools.length
@@ -4544,7 +3796,7 @@ var ExternalMcpManager = class {
       this.registry.register(cap, "agent");
       server.toolNames.push(cap.name);
     }
-    void writeMcpToolsSnapshot(server.decl, tools);
+    if (isLazyDeclaration(server.decl)) void writeMcpToolsSnapshot(server.decl, tools);
   }
   /**
    * Deregister a running MCP server's tools and close its client.
@@ -4628,12 +3880,7 @@ var ExternalMcpManager = class {
       this.log.warn("MCP reconnect after 401 failed", { id: server.id, error: errMessage(err) });
       return false;
     }
-    const old = server.client;
-    server.client = next;
-    try {
-      await old?.close();
-    } catch {
-    }
+    this.adoptClient(server, next);
     this.log.info("MCP server reconnected after 401 re-mint", { id: server.id });
     return true;
   }
@@ -4664,7 +3911,14 @@ var ExternalMcpManager = class {
         const call = { name: tool.name, arguments: input ?? {} };
         const invoke = async () => {
           const client = await untilAborted(this.ensureClient(server), ctx.signal);
-          return ctx.signal ? client.callTool(call, void 0, { signal: ctx.signal }) : client.callTool(call);
+          return client.callTool(call, void 0, {
+            ...ctx.signal ? { signal: ctx.signal } : {},
+            timeout: MCP_TOOL_CALL_TIMEOUT_MS,
+            resetTimeoutOnProgress: true,
+            maxTotalTimeout: MCP_TOOL_CALL_MAX_TOTAL_MS,
+            onprogress: () => {
+            }
+          });
         };
         let result;
         try {
@@ -5424,9 +4678,17 @@ async function createAgentSession(config) {
     log: sessionLog
   }) : null;
   composition = await withHostMemory(composition, config.loadHostMemory, sessionLog);
-  const agentSections = buildRunnerAgentSections(composition, promptExtensions, {
-    includeSoul: harnessType === "omp"
+  const nativeFileId = config.instanceId ?? DEFAULT_AGENT_INSTANCE_ID;
+  const assembled = assembleRunnerAgent(composition, promptExtensions, {
+    harness: harnessType,
+    nativeFile: readNativeAgentFile(agentCwd, harnessType, nativeFileId)
   });
+  const agentSections = assembled.runnerSections;
+  for (const block of assembled.stale) {
+    sessionLog.warn(
+      `${nativeAgentFilePath(agentCwd, harnessType, nativeFileId)}: ${block.label} is out of date; run skaile install`
+    );
+  }
   const disposeManagedTools = managed ? await registerCodexResourceTools({
     registry: config.capabilityRegistry,
     manager: resourceManager,
@@ -5694,10 +4956,6 @@ function logAssembledSystemPrompt(systemPrompt, log) {
     log.debug("system prompt content", { content: systemPrompt ?? "(empty)" });
   }
 }
-function modelForHarness(preferred, harnessType) {
-  if (!preferred || harnessType === "claude-sdk") return preferred;
-  return ANTHROPIC_MODEL_ALIASES.includes(preferred) ? void 0 : preferred;
-}
 function manifestModelForHarness(manifest, harnessType) {
   return modelForHarness(manifest?.model?.preferred, harnessType);
 }
@@ -7308,6 +6566,7 @@ function describeComposition(resolved) {
   return (resolved.manifest.composes ?? []).map((item) => {
     const binding = item.kind === "agent" ? subagents.find((s) => s.ref === item.ref)?.binding ?? resolveBinding(item) : resolveBinding(item);
     const hit = byKey.get(`${item.kind}\0${item.ref}`);
+    const implicit = resolved.inlineBlocks.find((b) => b.ref === item.ref && b.kind === item.kind)?.implicit === true;
     return {
       ref: item.ref,
       kind: item.kind,
@@ -7315,19 +6574,28 @@ function describeComposition(resolved) {
       version: hit?.version,
       hash: hit?.hash,
       resolvedRef: hit?.resolvedRef,
-      support: supportFor(item, binding)
+      support: supportFor(item, binding, sectionOf(item, implicit))
     };
   });
 }
-function supportFor(item, binding) {
+function sectionOf(item, implicit) {
+  if (!implicit) return "composed";
+  if (item.kind === "soul") return "soul";
+  if (item.kind === "ruleset") return "constraints";
+  if (item.kind === "prompt") return "duties";
+  return "composed";
+}
+function supportFor(item, binding, section) {
   const out = {};
   for (const target of SUPPORTED_HARNESSES) {
-    out[target] = deliveryFor(item, binding, target);
+    out[target] = deliveryFor(item, binding, target, section);
   }
   return out;
 }
-function deliveryFor(item, binding, target) {
-  if (binding === "inline-snapshot" || binding === "inline-live") return "system prompt";
+function deliveryFor(item, binding, target, section) {
+  if (binding === "inline-snapshot" || binding === "inline-live") {
+    return AGENT_PROMPT_CARRIER_LABELS[AGENT_PROMPT_CARRIERS[target][section]];
+  }
   if (binding === "discoverable") return "capability (loaded on demand)";
   if (binding === "run") return "agent.run capability (host-executed)";
   if (binding === "delegate" && item.kind === "agent") {
@@ -7392,31 +6660,31 @@ function errorResponse(command, resourceId, err) {
   };
 }
 async function handleResourceRequest(command, manager, emit) {
-  const { requestId, connectorId, operation, path: path11, options, content } = command;
+  const { requestId, connectorId, operation, path: path8, options, content } = command;
   try {
     let data;
     switch (operation) {
       case "list":
         data = await manager.list(
           connectorId,
-          path11,
+          path8,
           options
         );
         break;
       case "read":
-        data = await manager.read(connectorId, path11);
+        data = await manager.read(connectorId, path8);
         break;
       case "write":
-        await manager.write(connectorId, path11, content);
+        await manager.write(connectorId, path8, content);
         data = true;
         break;
       case "delete":
-        data = await manager.delete(connectorId, path11);
+        data = await manager.delete(connectorId, path8);
         break;
       case "search":
         data = await manager.search(
           connectorId,
-          path11,
+          path8,
           options
         );
         break;
@@ -8177,31 +7445,31 @@ function validateCodexInit(cmd, supported, previous) {
   if (cmd.secrets && Object.keys(cmd.secrets).some((key) => /openai|codex/i.test(key)))
     throw new Error("Conflicting managed AI credential delivery");
 }
-var text = z5.string().min(1).max(4096);
-var timeout = z5.number().int().positive().max(18e5).optional();
-var zHost = z5.object({
-  schemaVersion: z5.literal(1),
-  sessionId: z5.string().min(1).max(128),
-  runtime: z5.object({
+var text = z4.string().min(1).max(4096);
+var timeout = z4.number().int().positive().max(18e5).optional();
+var zHost = z4.object({
+  schemaVersion: z4.literal(1),
+  sessionId: z4.string().min(1).max(128),
+  runtime: z4.object({
     executable: text,
-    executableArgs: z5.array(text).max(64).optional(),
+    executableArgs: z4.array(text).max(64).optional(),
     privateDirectory: text,
     privateRoot: text,
-    environment: z5.record(z5.string(), z5.string()),
-    instructionFiles: z5.array(text).max(64).optional(),
+    environment: z4.record(z4.string(), z4.string()),
+    instructionFiles: z4.array(text).max(64).optional(),
     skillsDirectory: text.optional(),
     requestTimeoutMs: timeout,
     turnTimeoutMs: timeout,
     interactionTimeoutMs: timeout
   }).strict(),
-  requiredTools: z5.array(z5.string().min(1).max(256)).min(1).max(1024),
-  approvalPolicy: z5.enum(["never", "on-request", "untrusted"]),
-  sandboxMode: z5.enum(["read-only", "workspace-write"]),
-  reasoningEffort: z5.enum(["minimal", "low", "medium", "high", "xhigh"]),
-  subpromptModels: z5.object({
+  requiredTools: z4.array(z4.string().min(1).max(256)).min(1).max(1024),
+  approvalPolicy: z4.enum(["never", "on-request", "untrusted"]),
+  sandboxMode: z4.enum(["read-only", "workspace-write"]),
+  reasoningEffort: z4.enum(["minimal", "low", "medium", "high", "xhigh"]),
+  subpromptModels: z4.object({
     small: text,
     deep: text,
-    available: z5.array(text).min(1).max(1024)
+    available: z4.array(text).min(1).max(1024)
   }).strict()
 }).strict();
 var refused = () => new Error("CODEX_MANAGED_BOOTSTRAP_INVALID");
@@ -8863,24 +8131,24 @@ function createCoalescedRestartScheduler(deps) {
 }
 async function recordStagedSkills(staged, projectDir, skillsDir, names, timeoutMs) {
   for (const name of names) {
-    const path11 = join(projectDir, skillsDir, name);
-    const st = await tryWithFsDeadline(`lstat ${path11}`, () => lstat(path11), null, timeoutMs);
+    const path8 = join(projectDir, skillsDir, name);
+    const st = await tryWithFsDeadline(`lstat ${path8}`, () => lstat(path8), null, timeoutMs);
     staged.set(
       name,
-      st?.isDirectory() && st.birthtimeMs > 0 ? { path: path11, dev: st.dev, ino: st.ino, birthtimeMs: st.birthtimeMs } : null
+      st?.isDirectory() && st.birthtimeMs > 0 ? { path: path8, dev: st.dev, ino: st.ino, birthtimeMs: st.birthtimeMs } : null
     );
   }
 }
-async function isStillOurs(record2, path11, timeoutMs) {
-  if (!record2 || record2.path !== path11) return false;
-  const st = await tryWithFsDeadline(`lstat ${path11}`, () => lstat(path11), null, timeoutMs);
+async function isStillOurs(record2, path8, timeoutMs) {
+  if (!record2 || record2.path !== path8) return false;
+  const st = await tryWithFsDeadline(`lstat ${path8}`, () => lstat(path8), null, timeoutMs);
   return st?.isDirectory() === true && st.dev === record2.dev && st.ino === record2.ino && st.birthtimeMs === record2.birthtimeMs;
 }
 async function recordLoadedSkillDigests(loaded, projectDir, skillsDir, names, opts) {
   for (const name of names) {
     if (opts.harnessUp && opts.previouslyStaged.has(name)) continue;
-    const path11 = join(projectDir, skillsDir, name);
-    loaded.set(name, { path: path11, digest: await stagedSkillDigest(path11) });
+    const path8 = join(projectDir, skillsDir, name);
+    loaded.set(name, { path: path8, digest: await stagedSkillDigest(path8) });
   }
 }
 var DIGEST_DEADLINE_FACTOR = 4;
@@ -8893,11 +8161,11 @@ async function stagedSkillDigest(dir, timeoutMs) {
     async () => {
       const hash = createHash("sha256");
       let budget = DIGEST_MAX_BYTES;
-      const hashFile = async (path11) => {
-        const fh = await open(path11, DIGEST_OPEN_FLAGS);
+      const hashFile = async (path8) => {
+        const fh = await open(path8, DIGEST_OPEN_FLAGS);
         try {
           const st = await fh.stat();
-          if (!st.isFile()) throw new Error(`not a regular file: ${path11}`);
+          if (!st.isFile()) throw new Error(`not a regular file: ${path8}`);
           if (st.size > budget) throw new Error("skill too large to digest");
           const buf = Buffer.alloc(DIGEST_CHUNK_BYTES);
           let total = 0;
@@ -8921,17 +8189,17 @@ async function stagedSkillDigest(dir, timeoutMs) {
         entries.sort((a, b) => a.name < b.name ? -1 : a.name > b.name ? 1 : 0);
         for (const entry of entries) {
           if (!rel && entry.name === STAGED_SKILL_MARKER) continue;
-          const path11 = rel ? `${rel}/${entry.name}` : entry.name;
+          const path8 = rel ? `${rel}/${entry.name}` : entry.name;
           if (entry.isDirectory()) {
-            hash.update(`d\0${path11}\0`);
-            await walk(path11);
+            hash.update(`d\0${path8}\0`);
+            await walk(path8);
           } else if (entry.isSymbolicLink()) {
-            hash.update(`l\0${path11}\0${await readlink(join(dir, path11))}\0`);
+            hash.update(`l\0${path8}\0${await readlink(join(dir, path8))}\0`);
           } else if (entry.isFile()) {
-            hash.update(`f\0${path11}\0`);
-            await hashFile(join(dir, path11));
+            hash.update(`f\0${path8}\0`);
+            await hashFile(join(dir, path8));
           } else {
-            hash.update(`o\0${path11}\0`);
+            hash.update(`o\0${path8}\0`);
           }
         }
       };
@@ -9019,9 +8287,9 @@ async function detachStagedSkill(deps, name) {
     };
   }
 }
-async function pathState(path11) {
+async function pathState(path8) {
   try {
-    await withFsDeadline(`lstat ${path11}`, () => lstat(path11));
+    await withFsDeadline(`lstat ${path8}`, () => lstat(path8));
     return "present";
   } catch (err) {
     return err?.code === "ENOENT" ? "absent" : "unknown";
@@ -12043,12 +11311,12 @@ async function readSkillListings(skillsDir) {
   }
   const listings = await Promise.all(
     entries.map(async (dir) => {
-      const path11 = join(skillsDir, dir, "SKILL.md");
+      const path8 = join(skillsDir, dir, "SKILL.md");
       try {
-        const { data } = parseFrontmatter(await readFile(path11, "utf8"));
+        const { data } = parseFrontmatter(await readFile(path8, "utf8"));
         const name = typeof data.name === "string" ? data.name : dir;
         const description = typeof data.description === "string" ? data.description : "";
-        return { name, frontmatter: `${name}: ${description}`, source: path11 };
+        return { name, frontmatter: `${name}: ${description}`, source: path8 };
       } catch {
         return null;
       }
@@ -12415,64 +11683,64 @@ function notImplemented(name) {
     message: `${name} handler not configured`
   };
 }
-var requiredUnknown = z5.unknown().refine(() => true);
-var preMintedTokenSchema = z5.object({
-  token: z5.string(),
-  expiresAt: z5.string().nullable().optional()
+var requiredUnknown = z4.unknown().refine(() => true);
+var preMintedTokenSchema = z4.object({
+  token: z4.string(),
+  expiresAt: z4.string().nullable().optional()
 }).optional();
-var mountDeclarationInput = z5.strictObject({
+var mountDeclarationInput = z4.strictObject({
   declaration: requiredUnknown,
   preMintedToken: preMintedTokenSchema,
   // The platform attaches a workspace-migration directive on add_mount; the
   // handler ignores it for now (replace-workspace hot-migration is a follow-up).
   // Accepted here so a real platform add_mount payload validates.
-  migration: z5.unknown().optional()
+  migration: z4.unknown().optional()
 });
-var connectorDeclarationInput = z5.strictObject({
+var connectorDeclarationInput = z4.strictObject({
   declaration: requiredUnknown,
   preMintedToken: preMintedTokenSchema
 });
-var addMcpServerInputSchema = z5.strictObject({
+var addMcpServerInputSchema = z4.strictObject({
   declaration: requiredUnknown,
   preMintedToken: preMintedTokenSchema
 });
-var attachInstanceInputSchema = z5.strictObject({
-  kind: z5.string(),
-  name: z5.string(),
+var attachInstanceInputSchema = z4.strictObject({
+  kind: z4.string(),
+  name: z4.string(),
   preMintedToken: preMintedTokenSchema
 });
-var detachInstanceInputSchema = z5.strictObject({
-  kind: z5.string(),
-  name: z5.string()
+var detachInstanceInputSchema = z4.strictObject({
+  kind: z4.string(),
+  name: z4.string()
 });
-var removeResourceInput = z5.strictObject({
-  id: z5.string()
+var removeResourceInput = z4.strictObject({
+  id: z4.string()
 });
-var updateCredentialInput = z5.strictObject({
-  kind: z5.enum(["mount", "connector"]),
-  id: z5.string(),
+var updateCredentialInput = z4.strictObject({
+  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
 });
-var setLogLevelInput = z5.strictObject({
-  level: z5.enum(["silent", "error", "warn", "info", "debug", "trace"])
+var setLogLevelInput = z4.strictObject({
+  level: z4.enum(["silent", "error", "warn", "info", "debug", "trace"])
 });
-var setStateInput = z5.strictObject({
-  store: z5.string(),
-  key: z5.string(),
+var setStateInput = z4.strictObject({
+  store: z4.string(),
+  key: z4.string(),
   value: requiredUnknown
 });
-var lifecycleInput = z5.strictObject({
-  phase: z5.enum(["hibernate", "close", "compact"]),
-  trigger: z5.enum(["manual", "hibernate"]).optional()
+var lifecycleInput = z4.strictObject({
+  phase: z4.enum(["hibernate", "close", "compact"]),
+  trigger: z4.enum(["manual", "hibernate"]).optional()
 });
-var reconfigureInputSchema = z5.strictObject({
-  model: z5.string().trim().min(1).optional(),
-  thinking: z5.enum(["adaptive", "enabled", "disabled"]).optional(),
-  effort: z5.enum(["low", "medium", "high", "xhigh", "max"]).optional()
+var reconfigureInputSchema = z4.strictObject({
+  model: z4.string().trim().min(1).optional(),
+  thinking: z4.enum(["adaptive", "enabled", "disabled"]).optional(),
+  effort: z4.enum(["low", "medium", "high", "xhigh", "max"]).optional()
 }).refine((p) => p.model !== void 0 || p.thinking !== void 0 || p.effort !== void 0, {
   message: "a reconfigure names at least one of model, thinking, effort"
 });
@@ -13100,7 +12368,7 @@ var TurnStatusTracker = class {
 var WS_AUTH_TOKEN_ENV = "SKAILE_WS_AUTH_TOKEN";
 var WS_AUTH_TOKEN_FILE_ENV = "SKAILE_WS_AUTH_TOKEN_FILE";
 var nodeFs = { readFileSync: readFileSync, unlinkSync };
-function takeRunnerWsAuthToken(env = process.env, fs9 = nodeFs) {
+function takeRunnerWsAuthToken(env = process.env, fs6 = nodeFs) {
   const filePath = env[WS_AUTH_TOKEN_FILE_ENV];
   const envToken = env[WS_AUTH_TOKEN_ENV];
   delete env[WS_AUTH_TOKEN_FILE_ENV];
@@ -13108,14 +12376,14 @@ function takeRunnerWsAuthToken(env = process.env, fs9 = nodeFs) {
   if (filePath) {
     let token;
     try {
-      token = fs9.readFileSync(filePath, "utf8").trim();
+      token = fs6.readFileSync(filePath, "utf8").trim();
     } catch (err) {
       const code = err.code ?? "unknown";
       throw new Error(`${WS_AUTH_TOKEN_FILE_ENV} is set but the file cannot be read (${code})`);
     }
     if (!token) throw new Error(`${WS_AUTH_TOKEN_FILE_ENV} names an empty file`);
     try {
-      fs9.unlinkSync(filePath);
+      fs6.unlinkSync(filePath);
       return { token, source: "file" };
     } catch (err) {
       return {
@@ -13337,8 +12605,8 @@ async function buildStoreSnapshotReplay(manager, activeFlows) {
 }
 async function guardClaudeAiConnectors(home, serverLog) {
   try {
-    const path11 = await ensureClaudeSettingsDisablesConnectors(home);
-    serverLog.info("claude.ai connectors disabled in user settings", { path: path11 });
+    const path8 = await ensureClaudeSettingsDisablesConnectors(home);
+    serverLog.info("claude.ai connectors disabled in user settings", { path: path8 });
   } catch (err) {
     serverLog.warn(
       "failed to disable claude.ai connectors in user settings \u2014 relying on env only",
@@ -17023,16 +16291,16 @@ var SESSIONS_SUBDIR = "sessions";
 var CURRENT_FILE = "current";
 var LEGACY_FILE = "session.json";
 function sessionsDir(projectDir) {
-  return path3.join(projectDir, SESSION_DIR, SESSIONS_SUBDIR);
+  return path4.join(projectDir, SESSION_DIR, SESSIONS_SUBDIR);
 }
 function sessionFilePath(projectDir, runId) {
-  return path3.join(sessionsDir(projectDir), `${runId}.json`);
+  return path4.join(sessionsDir(projectDir), `${runId}.json`);
 }
 function currentPointerPath(projectDir) {
-  return path3.join(projectDir, SESSION_DIR, CURRENT_FILE);
+  return path4.join(projectDir, SESSION_DIR, CURRENT_FILE);
 }
 function legacySessionPath(projectDir) {
-  return path3.join(projectDir, SESSION_DIR, LEGACY_FILE);
+  return path4.join(projectDir, SESSION_DIR, LEGACY_FILE);
 }
 function parseSessionFile(raw) {
   const { driver, driverSessionId, ...rest } = JSON.parse(raw);
@@ -17046,23 +16314,23 @@ function parseSessionFile(raw) {
 async function migrateLegacySession(projectDir) {
   const legacyPath = legacySessionPath(projectDir);
   try {
-    const raw = await fs8.readFile(legacyPath, "utf-8");
+    const raw = await fs5.readFile(legacyPath, "utf-8");
     const state = parseSessionFile(raw);
-    await fs8.mkdir(sessionsDir(projectDir), { recursive: true });
-    await fs8.writeFile(
+    await fs5.mkdir(sessionsDir(projectDir), { recursive: true });
+    await fs5.writeFile(
       sessionFilePath(projectDir, state.runId),
       JSON.stringify(state, null, 2),
       "utf-8"
     );
-    await fs8.writeFile(currentPointerPath(projectDir), state.runId, "utf-8");
-    await fs8.rm(legacyPath);
+    await fs5.writeFile(currentPointerPath(projectDir), state.runId, "utf-8");
+    await fs5.rm(legacyPath);
   } catch {
   }
 }
 async function loadSession(projectDir) {
   await migrateLegacySession(projectDir);
   try {
-    const runId = (await fs8.readFile(currentPointerPath(projectDir), "utf-8")).trim();
+    const runId = (await fs5.readFile(currentPointerPath(projectDir), "utf-8")).trim();
     if (!runId) return null;
     return await loadSessionById(projectDir, runId);
   } catch {
@@ -17071,7 +16339,7 @@ async function loadSession(projectDir) {
 }
 async function loadSessionById(projectDir, runId) {
   try {
-    const raw = await fs8.readFile(sessionFilePath(projectDir, runId), "utf-8");
+    const raw = await fs5.readFile(sessionFilePath(projectDir, runId), "utf-8");
     return parseSessionFile(raw);
   } catch {
     return null;
@@ -17081,7 +16349,7 @@ async function resolveSessionId(projectDir, idOrPrefix) {
   if (!idOrPrefix || /[\\/]/.test(idOrPrefix) || idOrPrefix.includes("..")) return null;
   let files;
   try {
-    files = await fs8.readdir(sessionsDir(projectDir));
+    files = await fs5.readdir(sessionsDir(projectDir));
   } catch {
     return null;
   }
@@ -17100,12 +16368,12 @@ async function listSessions(projectDir) {
   await migrateLegacySession(projectDir);
   const dir = sessionsDir(projectDir);
   try {
-    const files = await fs8.readdir(dir);
+    const files = await fs5.readdir(dir);
     const sessions = [];
     for (const file of files) {
       if (!file.endsWith(".json")) continue;
       try {
-        const raw = await fs8.readFile(path3.join(dir, file), "utf-8");
+        const raw = await fs5.readFile(path4.join(dir, file), "utf-8");
         sessions.push(parseSessionFile(raw));
       } catch {
       }
@@ -17116,38 +16384,38 @@ async function listSessions(projectDir) {
   }
 }
 async function saveSession(projectDir, state, setCurrent = true) {
-  await fs8.mkdir(sessionsDir(projectDir), { recursive: true });
-  await fs8.writeFile(
+  await fs5.mkdir(sessionsDir(projectDir), { recursive: true });
+  await fs5.writeFile(
     sessionFilePath(projectDir, state.runId),
     JSON.stringify(state, null, 2),
     "utf-8"
   );
   if (setCurrent) {
-    await fs8.writeFile(currentPointerPath(projectDir), state.runId, "utf-8");
+    await fs5.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 fs8.mkdir(path3.join(projectDir, SESSION_DIR), { recursive: true });
-  await fs8.writeFile(currentPointerPath(projectDir), runId, "utf-8");
+  await fs5.mkdir(path4.join(projectDir, SESSION_DIR), { recursive: true });
+  await fs5.writeFile(currentPointerPath(projectDir), runId, "utf-8");
 }
 async function deleteSession(projectDir, runId) {
   try {
-    await fs8.rm(sessionFilePath(projectDir, runId));
+    await fs5.rm(sessionFilePath(projectDir, runId));
   } catch {
   }
   try {
-    const current = (await fs8.readFile(currentPointerPath(projectDir), "utf-8")).trim();
+    const current = (await fs5.readFile(currentPointerPath(projectDir), "utf-8")).trim();
     if (current === runId) {
-      await fs8.rm(currentPointerPath(projectDir));
+      await fs5.rm(currentPointerPath(projectDir));
     }
   } catch {
   }
 }
 async function clearSession(projectDir) {
   try {
-    await fs8.rm(currentPointerPath(projectDir));
+    await fs5.rm(currentPointerPath(projectDir));
   } catch {
   }
 }
@@ -17159,6 +16427,6 @@ function touchSession(state) {
   return { ...state, updatedAt: (/* @__PURE__ */ new Date()).toISOString() };
 }
 
-export { AgentRunError, CLAUDE_CODE_CREDENTIALS_KEY, COMPILE_MANIFEST_FILENAME, CONNECTOR_MUTATE_NOT_READY, CapabilityRegistry, CompileManifestEntrySchema, CompositionError, DEFAULT_CAPABILITY_CALL_TIMEOUT_MS, DEFAULT_COALESCE_MS, DEFAULT_FLOW_MUTATE_CONNECTOR_WAIT_MS, DEFAULT_MAX_FINISHED_TREES, DEFAULT_RUN_LIMITS, MOUNT_LIST_MAX_DEPTH, MOUNT_LIST_MAX_ENTRIES, MOUNT_READ_DEADLINE_FACTOR, MOUNT_READ_MAX_CHUNK_BYTES, MOUNT_STAT_BUDGET_MS, MOUNT_STAT_MAX_ENTRIES, MOUNT_TREE_OP_DEADLINE_FACTOR, MOUNT_WRITE_MAX_CHUNK_BYTES, MarkdownStreamer, PreInitRingSink, ResourceOperationError, SESSION_ROOT_WRITABLE_DIRS, SESSION_ROOT_WRITABLE_FILES, UnknownCompositionKindError, WRITE_RANGE_PARTIAL_TTL_MS, WS_AUTH_TOKEN_ENV, WS_AUTH_TOKEN_FILE_ENV, agentDefinitionExists, bootstrapCapabilityRegistry, bootstrapRunnerLogStore, buildAgentResources, buildClientCapabilityHandler, buildCompositionRunSnapshot, buildConnectorTokenMediator, buildContextSection, buildEnvironmentSection, buildResourcesAvailablePayload, buildRunnerAgentSections, buildStoreSnapshotReplay, builtinCapabilities, canonicalJson, capabilityLogInstance, capabilitySignatureInputs, clearPreInitRingSink, clearSession, compileComposition, compositionRunSnapshotPath, computeCapabilitySignature, computeDirectoryTotals, computeRevisionHash, connectorRefreshKind, createAgentSession, createCompositionContentSource, createFinalTextFallback, createFlowConnectorReadiness, createInMemoryRunStore, createManagedCodexSubpromptHarness, createRunController, createSessionStimulusBus, defineCapability, deleteSession, describeComposition, dispatchResourceRequest, dispatchRunnerCapabilityInvocation, emitSystemPromptComposed, ensureClaudeSettingsDisablesConnectors, ensureGitConfigInclude, executeConnectorMutate, extractClaudeAiOauthExpiresAt, flowStartNeedsHarnessRestart, getPreInitRingSink, handleMountResourceRequest, handleResourceRequest, handleSessionRootResourceRequest, harnessActiveAfterTurnEnd, hasNonTerminalFlow, hashAgentFiles, hashContent, hostOpResumeStimulus, installPreInitRingSink, instanceForSession, instanceSessionOverrides, isCompilePinCurrent, isCompositionError, isEmptyKnowledgeIndex, isSessionRootPathAllowed, listSessions, loadAgentManifest, loadCompileManifest, loadCompileManifestFromDir, loadCompositionRunSnapshot, loadKnowledgeDir, loadManagedCodexHostConfig, loadSession, loadSessionById, logConnectorReport, manifestModelForHarness, mcpAuthSecretKey, modelForHarness, newSession, nulTailPaddingLength, pickChatFlowTarget, pickFlowToolTarget, pickRepointedManager, planFlowMutate, prepareCodexTools, reconcilePendingDecisions, reconnectedRunNeedsAgentTurn, recreateKeepingLiveFlows, registerActiveFlow, registerCompositionCapabilities, rejectCapabilityOnApprovalDeny, rejectPendingCapabilityCallsOnDisconnect, resetRunnerLogStore, resolveAgentInstance, resolveBinding, resolveCapabilityCallTimeoutMs, resolveCapabilityResult, resolveComposition, resolveFlowMutateConnectorWaitMs, resolveInstanceAgentDir, resolveMixin, resolveSessionId, restoredRunHasWorkToResume, runAgentChat, saveCompositionRunSnapshot, saveSession, setCurrentSession, setUpFlowConnector, startAgentServer, stimulusFromMetas, stripFrontmatter, takeRunnerWsAuthToken, toActiveFlowTarget, touchSession, unresolvedCredentialNotices, validateInputResponse, verifyConventionItems, writeClaudeCodeCredentialsFile, writeRangeChunk, writeRangePartialPath };
-//# sourceMappingURL=chunk-YLKOCMU7.js.map
-//# sourceMappingURL=chunk-YLKOCMU7.js.map
+export { AgentRunError, CLAUDE_CODE_CREDENTIALS_KEY, CONNECTOR_MUTATE_NOT_READY, CapabilityRegistry, DEFAULT_CAPABILITY_CALL_TIMEOUT_MS, DEFAULT_COALESCE_MS, DEFAULT_FLOW_MUTATE_CONNECTOR_WAIT_MS, DEFAULT_MAX_FINISHED_TREES, DEFAULT_RUN_LIMITS, MOUNT_LIST_MAX_DEPTH, MOUNT_LIST_MAX_ENTRIES, MOUNT_READ_DEADLINE_FACTOR, MOUNT_READ_MAX_CHUNK_BYTES, MOUNT_STAT_BUDGET_MS, MOUNT_STAT_MAX_ENTRIES, MOUNT_TREE_OP_DEADLINE_FACTOR, MOUNT_WRITE_MAX_CHUNK_BYTES, MarkdownStreamer, PreInitRingSink, ResourceOperationError, SESSION_ROOT_WRITABLE_DIRS, SESSION_ROOT_WRITABLE_FILES, WRITE_RANGE_PARTIAL_TTL_MS, WS_AUTH_TOKEN_ENV, WS_AUTH_TOKEN_FILE_ENV, agentDefinitionExists, bootstrapCapabilityRegistry, bootstrapRunnerLogStore, buildAgentResources, buildClientCapabilityHandler, buildCompositionRunSnapshot, buildConnectorTokenMediator, buildContextSection, buildEnvironmentSection, buildResourcesAvailablePayload, buildStoreSnapshotReplay, builtinCapabilities, canonicalJson, capabilityLogInstance, capabilitySignatureInputs, clearPreInitRingSink, clearSession, compositionRunSnapshotPath, computeCapabilitySignature, computeDirectoryTotals, computeRevisionHash, connectorRefreshKind, createAgentSession, createFinalTextFallback, createFlowConnectorReadiness, createInMemoryRunStore, createManagedCodexSubpromptHarness, createRunController, createSessionStimulusBus, defineCapability, deleteSession, describeComposition, dispatchResourceRequest, dispatchRunnerCapabilityInvocation, emitSystemPromptComposed, ensureClaudeSettingsDisablesConnectors, ensureGitConfigInclude, executeConnectorMutate, extractClaudeAiOauthExpiresAt, flowStartNeedsHarnessRestart, getPreInitRingSink, handleMountResourceRequest, handleResourceRequest, handleSessionRootResourceRequest, harnessActiveAfterTurnEnd, hasNonTerminalFlow, hashAgentFiles, hostOpResumeStimulus, installPreInitRingSink, instanceForSession, instanceSessionOverrides, isSessionRootPathAllowed, listSessions, loadAgentManifest, loadCompositionRunSnapshot, loadManagedCodexHostConfig, loadSession, loadSessionById, logConnectorReport, manifestModelForHarness, mcpAuthSecretKey, newSession, nulTailPaddingLength, pickChatFlowTarget, pickFlowToolTarget, pickRepointedManager, planFlowMutate, prepareCodexTools, reconcilePendingDecisions, reconnectedRunNeedsAgentTurn, recreateKeepingLiveFlows, registerActiveFlow, registerCompositionCapabilities, rejectCapabilityOnApprovalDeny, rejectPendingCapabilityCallsOnDisconnect, resetRunnerLogStore, resolveAgentInstance, resolveCapabilityCallTimeoutMs, resolveCapabilityResult, resolveComposition, resolveFlowMutateConnectorWaitMs, resolveInstanceAgentDir, resolveSessionId, restoredRunHasWorkToResume, runAgentChat, saveCompositionRunSnapshot, saveSession, setCurrentSession, setUpFlowConnector, startAgentServer, stimulusFromMetas, takeRunnerWsAuthToken, toActiveFlowTarget, touchSession, unresolvedCredentialNotices, validateInputResponse, verifyConventionItems, writeClaudeCodeCredentialsFile, writeRangeChunk, writeRangePartialPath };
+//# sourceMappingURL=chunk-U6UFPOEK.js.map
+//# sourceMappingURL=chunk-U6UFPOEK.js.map