@vostride/agent-qa-agent-local 0.0.1 → 0.2.1

package/dist/index.js

@@ -0,0 +1,3875 @@
+// src/composition/run-composition.ts
+import { createHash } from "node:crypto";
+import { dirname, isAbsolute, resolve } from "node:path";
+import { detectExecutionContext } from "@vostride/agent-qa-safety-local";
+import { guardToolOutput } from "@vostride/agent-qa-model";
+import {
+  FsEventLog,
+  FsEvidenceArtifactStore,
+  FsHandoffStore,
+  FsRunArtifactStore,
+  nextBuildOrdinal,
+  recordBuildTag,
+  RUNS_SUBDIR,
+  slugBranch,
+  SharpScreenshotCompressor
+} from "@vostride/agent-qa-runner-local";
+import {
+  coerceRunJSResult,
+  createMemoryTools,
+  createRecordLedger,
+  liveStreamFor,
+  resolveSecretEnv,
+  resolveSecretTemplatesInValue
+} from "@vostride/agent-qa-runner";
+
+// src/composition/knowledge-budgets.ts
+var BRIEF_FRACTION = 0.05;
+var CAUTION_FRACTION = 0.01;
+var MIN_BRIEF = 256;
+var MIN_CAUTION = 64;
+var BRIEF_CEILING = 2048;
+var READ_BODY_FRACTION = 0.1;
+var GLOBAL_RECORD_CAP = 24;
+var WEAK_MODEL_CAP_SCALE = 0.5;
+var MIN_MEMORY_TOOL_CONTEXT_WINDOW = 16384;
+function floorFinite(value) {
+  if (Number.isNaN(value)) return 0;
+  if (value === Number.POSITIVE_INFINITY) return Number.MAX_SAFE_INTEGER;
+  if (value === Number.NEGATIVE_INFINITY) return Number.MIN_SAFE_INTEGER;
+  return Math.floor(value);
+}
+function clamp(value, minimum, maximum) {
+  return Math.min(maximum, Math.max(minimum, value));
+}
+function computeKnowledgeBudgets(input) {
+  const usableContext = input.contextWindow - input.reservedOutput - input.qaRulesTokens - input.workingContextTokens;
+  const brief = clamp(
+    floorFinite(usableContext * BRIEF_FRACTION),
+    MIN_BRIEF,
+    BRIEF_CEILING
+  );
+  const caution = Math.max(MIN_CAUTION, floorFinite(usableContext * CAUTION_FRACTION));
+  const readBody = Math.max(MIN_BRIEF, floorFinite(usableContext * READ_BODY_FRACTION));
+  const searchResults = brief;
+  return { brief, searchResults, caution, readBody, recordCap: GLOBAL_RECORD_CAP };
+}
+function memoryToolGate(capabilities) {
+  return capabilities.toolCalling && capabilities.vision && capabilities.contextWindow >= MIN_MEMORY_TOOL_CONTEXT_WINDOW;
+}
+function scaledRecordCap(capabilities) {
+  if (memoryToolGate(capabilities)) return GLOBAL_RECORD_CAP;
+  return Math.max(1, Math.floor(GLOBAL_RECORD_CAP * WEAK_MODEL_CAP_SCALE));
+}
+
+// src/composition/knowledge-reader.ts
+import { openKnowledgeReader } from "@vostride/agent-qa-knowledge-local/reader";
+function createFrozenKnowledgeReader(reader) {
+  const briefs = /* @__PURE__ */ new Map();
+  const scopeKey = (scope) => JSON.stringify([scope.tier, scope.key]);
+  return {
+    getRunBrief(scope, budget) {
+      const key = scopeKey(scope);
+      const existing = briefs.get(key);
+      if (existing !== void 0) return existing;
+      const brief = reader.getRunBrief(scope, budget);
+      briefs.set(key, brief);
+      return brief;
+    },
+    search: (query, options) => reader.search(query, options),
+    read: (id, options) => reader.read(id, options),
+    getCautions: (anchors, budget) => reader.getCautions(anchors, budget),
+    getProcedure: (intent, screenState, availability) => reader.getProcedure(intent, screenState, availability),
+    emitCanaryOutcome: (payload) => reader.emitCanaryOutcome(payload)
+  };
+}
+function constructKnowledgeReader(input) {
+  return createFrozenKnowledgeReader(openKnowledgeReader({
+    ...input.resolveTrustPriors === void 0 ? {} : { priors: input.resolveTrustPriors() },
+    knowledgeRoot: input.knowledgeRoot,
+    ...input.product === void 0 ? {} : { product: input.product },
+    scopeDefaults: {
+      asOfBuild: input.asOfBuild,
+      ...input.parentScopes === void 0 ? {} : { parentScopes: input.parentScopes }
+    },
+    budgets: { recordCap: input.recordCap }
+  }));
+}
+
+// src/composition/run-composition.ts
+function openRunKnowledgeComposition(input) {
+  const ceilings = input.accounting.getCeilings();
+  const qaRulesTokens = input.accounting.estimate([
+    { role: "system", content: input.qaRulesText }
+  ]);
+  const workingContextTokens = input.accounting.estimate([
+    { role: "user", content: input.workingContextText }
+  ]);
+  const computed = computeKnowledgeBudgets({
+    contextWindow: ceilings.contextWindow,
+    reservedOutput: ceilings.maxOutput,
+    qaRulesTokens,
+    workingContextTokens
+  });
+  const budgets = {
+    ...computed,
+    recordCap: scaledRecordCap(input.capabilities)
+  };
+  const reader = constructKnowledgeReader({
+    ...input.resolveTrustPriors === void 0 ? {} : { resolveTrustPriors: input.resolveTrustPriors },
+    knowledgeRoot: input.knowledgeRoot,
+    ...input.product === void 0 ? {} : { product: input.product },
+    ...input.parentScopes === void 0 ? {} : { parentScopes: input.parentScopes },
+    asOfBuild: input.asOfBuild,
+    recordCap: budgets.recordCap
+  });
+  const retrievalRung = input.resolveRetrievalRung({
+    knowledgeRoot: input.knowledgeRoot,
+    ...input.agentQaRoot === void 0 ? {} : { agentQaRoot: input.agentQaRoot }
+  });
+  retrievalRung.catch(() => void 0);
+  const channel2Enabled = memoryToolGate(input.capabilities);
+  const recordLedger = createRecordLedger({
+    cap: budgets.recordCap,
+    budget: budgets.brief + budgets.caution + (channel2Enabled ? budgets.searchResults : 0),
+    seedRecords: []
+  });
+  const memory = channel2Enabled ? createMemoryTools({
+    reader,
+    scope: input.scope,
+    asOfBuild: input.asOfBuild,
+    searchResultBudget: budgets.searchResults,
+    readBodyBudget: budgets.readBody,
+    recordLedger,
+    estimateTokens: (text) => input.accounting.estimate([
+      { role: "user", content: text }
+    ])
+  }) : void 0;
+  return {
+    reader,
+    budgets,
+    retrievalRung,
+    recordLedger,
+    nonActionTools: memory?.tools,
+    beginMemoryTurn: memory?.beginTurn,
+    drainMemoryReadTraces: memory?.drainReadTraces
+  };
+}
+function digest16(input) {
+  return createHash("sha256").update(input, "utf8").digest("hex").slice(0, 16);
+}
+function computeRunConfigDigests(input) {
+  const perMember = input.members.map((m) => ({
+    suiteConfigDigest: digest16(input.configContent + "\n" + (m.suiteFileContent ?? "")),
+    testConfigDigest: digest16(m.testFileContent)
+  }));
+  if (perMember.length === 1) {
+    return { runLevel: { ...perMember[0] }, perMember };
+  }
+  const distinctSuiteDigests = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const pair of perMember) {
+    if (!seen.has(pair.suiteConfigDigest)) {
+      seen.add(pair.suiteConfigDigest);
+      distinctSuiteDigests.push(pair.suiteConfigDigest);
+    }
+  }
+  const runLevel = {
+    suiteConfigDigest: digest16(distinctSuiteDigests.join("\n")),
+    testConfigDigest: digest16(perMember.map((p) => p.testConfigDigest).join("\n"))
+  };
+  return { runLevel, perMember };
+}
+function resolveRunExecutionContext(override) {
+  return detectExecutionContext(override);
+}
+function buildRunPorts(input) {
+  const root = resolve(input.configDir, ".agent-qa");
+  return {
+    eventLog: new FsEventLog({ root, runId: input.runId }),
+    handoffStore: new FsHandoffStore({ root, runId: input.runId }),
+    runArtifactStore: new FsRunArtifactStore({ root, runId: input.runId }),
+    evidenceArtifacts: new FsEvidenceArtifactStore({ root, runId: input.runId }),
+    // A NAMED, observable, non-durable destination: greppable by code, visible to a test through
+    // `process.once('warning', …)`, and no `console.` call in a package that makes none.
+    onSubscriberFault: (code, message) => {
+      process.emitWarning(message, { code });
+    }
+  };
+}
+function buildScreenshotCompressor(logger) {
+  return new SharpScreenshotCompressor(logger);
+}
+function resolveBuildTagSetting(input) {
+  for (const value of [input.flag, input.env, input.use?.buildTag]) {
+    const trimmed = value?.trim();
+    if (trimmed) return trimmed;
+  }
+  return void 0;
+}
+async function resolveRunBuildOrdinal(input) {
+  const root = resolve(input.configDir, ".agent-qa");
+  const ordinal = await nextBuildOrdinal({ root, product: input.product });
+  if (input.buildTag !== void 0) {
+    await recordBuildTag({
+      root,
+      product: input.product,
+      tag: input.buildTag,
+      ordinal
+    });
+  }
+  return ordinal;
+}
+var SUITE_LIFECYCLE_LANE = "suite-lifecycle";
+var SuiteBoundaryWhileLiveError = class extends Error {
+  constructor(activeSuiteKey, requestedSuiteKey, liveMembers) {
+    super(
+      `Cannot enter suite "${requestedSuiteKey}": suite "${activeSuiteKey}" still has ${liveMembers} live member(s). Suite boundaries are serialized.`
+    );
+    this.activeSuiteKey = activeSuiteKey;
+    this.requestedSuiteKey = requestedSuiteKey;
+    this.liveMembers = liveMembers;
+    this.name = "SuiteBoundaryWhileLiveError";
+  }
+};
+function createSuiteLifecycle() {
+  let activeKey;
+  let activeSetup;
+  let activeTeardown;
+  let liveMembers = 0;
+  const tearDownActive = async () => {
+    const teardown = activeTeardown;
+    activeKey = void 0;
+    activeSetup = void 0;
+    activeTeardown = void 0;
+    liveMembers = 0;
+    if (teardown) await teardown();
+  };
+  return {
+    async ensureReady(suiteKey, hooks) {
+      if (activeKey !== void 0 && activeKey !== suiteKey) {
+        if (liveMembers > 0) {
+          throw new SuiteBoundaryWhileLiveError(activeKey, suiteKey, liveMembers);
+        }
+        await tearDownActive();
+      }
+      if (activeKey !== suiteKey) {
+        activeKey = suiteKey;
+        activeTeardown = hooks.teardown;
+        activeSetup = (async () => {
+          try {
+            await hooks.setup();
+          } catch (error) {
+            activeTeardown = void 0;
+            throw error;
+          }
+        })();
+      }
+      const setup = activeSetup;
+      liveMembers += 1;
+      let released = false;
+      const lease = {
+        release() {
+          if (released) return;
+          released = true;
+          liveMembers -= 1;
+        }
+      };
+      try {
+        await setup;
+      } catch (error) {
+        lease.release();
+        throw error;
+      }
+      return lease;
+    },
+    async finalize() {
+      await tearDownActive();
+    }
+  };
+}
+function registerAdapterLiveStream(ctx, adapter) {
+  const registration = liveStreamFor(adapter);
+  ctx.registerLiveStream?.(registration?.capability, registration?.fallback);
+}
+function buildSuiteMemberExecutor(input) {
+  return async (member, ctx) => {
+    const binding = input.bindings[ctx.testIndex];
+    if (!binding) {
+      throw new Error(`No suite-member binding for testIndex ${ctx.testIndex} (testId ${member.testId})`);
+    }
+    const lease = await input.lifecycle.ensureReady(binding.suiteKey, binding.hooks);
+    try {
+      registerAdapterLiveStream(ctx, binding.adapter);
+      return await binding.run(ctx);
+    } finally {
+      lease.release();
+    }
+  };
+}
+function runDirFor(input) {
+  return resolve(input.configDir, ".agent-qa", RUNS_SUBDIR, slugBranch(input.runId));
+}
+async function captureFailureScreenshotFromAdapter(adapter) {
+  try {
+    const shot = adapter.screenshot;
+    if (typeof shot !== "function") return void 0;
+    return await shot.call(adapter);
+  } catch {
+    return void 0;
+  }
+}
+function buildRunJsHandler(adapter) {
+  return async (code, ctx) => {
+    if (adapter.platform !== "web") {
+      return { value: "[runJS error: runJS is only supported on web platform]", error: "runJS is only supported on web platform" };
+    }
+    const page = "getPage" in adapter ? adapter.getPage() : void 0;
+    if (!page) {
+      return { value: "[runJS error: no browser page available]", error: "no browser page available" };
+    }
+    void ctx;
+    const raw = await page.evaluate(code);
+    return { value: coerceRunJSResult(raw) };
+  };
+}
+function buildAppiumScriptHandler(adapter, secretStore) {
+  return async (action) => adapter.execute(resolveSecretTemplatesInValue(action, secretStore));
+}
+function buildAccessibilityCheckHandler(adapter) {
+  return async (opts) => {
+    const page = "getPage" in adapter ? adapter.getPage() : void 0;
+    if (!page) throw new Error("Accessibility capture requires an active browser page");
+    const web = await import("@vostride/agent-qa-web");
+    return web.runAccessibilityCheck(page, opts);
+  };
+}
+function buildFailureScreenshotWriter(adapter) {
+  return async () => captureFailureScreenshotFromAdapter(adapter);
+}
+function toMemberTest(test, filePath) {
+  return {
+    testId: test["test-id"] ?? test.name,
+    name: test.name,
+    filePath,
+    url: test.url,
+    context: test.context,
+    steps: test.steps,
+    meta: test.meta
+  };
+}
+function buildMemberRunConfig(input) {
+  const sandbox = input.sandboxOptions;
+  return {
+    adapter: input.adapter,
+    planner: input.planner,
+    verifier: input.verifier,
+    cache: input.cache,
+    workingMemory: input.workingMemory,
+    storageState: input.storageState,
+    // CTXB-06: model's canonical compaction (compactLogs for log bursts, guardBlob
+    // otherwise) replaces the runner-local ceiling fallback on every tool-output value.
+    guardBlob: guardToolOutput,
+    compressor: input.compressor,
+    knowledgeReader: input.knowledgeReader,
+    knowledgeRetrievalRung: input.knowledgeRetrievalRung,
+    knowledgeBudgets: input.knowledgeBudgets,
+    knowledgeAsOfBuild: input.knowledgeAsOfBuild,
+    recordLedger: input.recordLedger,
+    beginMemoryTurn: input.beginMemoryTurn,
+    drainMemoryReadTraces: input.drainMemoryReadTraces,
+    configDigests: input.configDigests,
+    plannerModel: input.plannerModel,
+    verifierModel: input.verifierModel,
+    stepModelScope: input.stepModelScope,
+    envFileVars: input.envFileVars,
+    inlineVars: input.inlineVars,
+    suiteVars: input.suiteVars,
+    cliVars: input.cliVars,
+    hookSetupVars: input.hookSetupVars,
+    // Inline hooks: the runner-local DockerHookExecutor + sandbox env/authState come off the resolved
+    // sandbox options; the per-run secret env is resolved store-side (never crosses into the runner).
+    hookExecutor: sandbox?.executor,
+    inlineHookDefs: input.inlineHookDefs,
+    hookEnvVars: sandbox?.envVars,
+    hookSecretEnv: resolveSecretEnv(input.secretStore),
+    hookAuthState: sandbox?.authState,
+    runJs: buildRunJsHandler(input.adapter),
+    appiumScript: buildAppiumScriptHandler(input.adapter, input.secretStore),
+    accessibilityCheck: "getPage" in input.adapter && typeof input.adapter.getPage === "function" ? buildAccessibilityCheckHandler(input.adapter) : void 0,
+    persistFailureScreenshot: buildFailureScreenshotWriter(input.adapter),
+    resolveSecrets: (text) => resolveSecretTemplatesInValue(text, input.secretStore),
+    secretStore: input.secretStore,
+    secretRedactor: input.secretRedactor,
+    sink: input.sink,
+    testIndex: input.testIndex,
+    abortSignal: input.abortSignal,
+    evidenceArtifacts: input.evidenceArtifacts,
+    captureScreenshots: input.captureScreenshots,
+    accessibility: input.accessibility,
+    timeouts: input.timeouts,
+    plannerConfig: input.plannerConfig,
+    logger: input.logger,
+    logCapture: input.logCapture,
+    vision: input.vision,
+    visionGate: input.visionGate,
+    contextWindow: input.contextWindow,
+    suiteContext: input.suiteContext,
+    resolveUploadPath: (rawPath) => isAbsolute(rawPath) ? rawPath : resolve(dirname(input.filePath), rawPath)
+  };
+}
+
+// src/composition/run-invocation-core.ts
+import { existsSync } from "node:fs";
+import { dirname as dirname2 } from "node:path";
+import { startRun } from "@vostride/agent-qa-runner";
+
+// src/composition/run-risk.ts
+import {
+  ALLOW_PRODUCTION_OPT_IN,
+  buildProductionRefusal,
+  distinctInFirstOccurrenceOrder
+} from "@vostride/agent-qa-schema";
+
+// src/composition/run-invocation-core.ts
+var REFUSED_RUN_REQUEST_FIELDS = [
+  "scope",
+  "executionContext"
+];
+var RunRequestFieldRefusedError = class extends Error {
+  constructor(refusedFields) {
+    super(
+      `agent-qa cannot start a run with: ${refusedFields.join(", ")}. scope resolves from the config the run is started against, and executionContext is supplied by the composition that owns the door \u2014 a caller-named execution context would be a caller relabelling where its run came from.`
+    );
+    this.refusedFields = refusedFields;
+    this.name = "RunRequestFieldRefusedError";
+  }
+};
+var RunIdNotMintedError = class extends Error {
+  constructor(runId) {
+    super(
+      `agent-qa cannot start a run under ${JSON.stringify(runId)}: a caller-named run id must be one this system minted. Start the run without naming an id and read the id back off the acknowledgment, or name an id \`agent-qa\` handed you.`
+    );
+    this.runId = runId;
+    this.name = "RunIdNotMintedError";
+  }
+};
+var RunIdAlreadyInUseError = class extends Error {
+  constructor(runId) {
+    super(
+      `agent-qa cannot start a run under ${JSON.stringify(runId)}: that id already names a run in this project. Starting a second run under it would append to the first run's event log and overwrite its handoff. Start the run without naming an id.`
+    );
+    this.runId = runId;
+    this.name = "RunIdAlreadyInUseError";
+  }
+};
+var RunDeniedError = class extends Error {
+  constructor(runId, reason) {
+    super(reason);
+    this.runId = runId;
+    this.reason = reason;
+    this.name = "RunDeniedError";
+    this.neutralReason = reason;
+  }
+  neutralReason;
+};
+function refuseProductionWithoutOptIn(runId, declaration) {
+  const production = declaration.productionTargetNames.length > 0 || declaration.targetClass === "production";
+  if (!production || declaration.allowProduction === true) return;
+  const reason = buildProductionRefusal(declaration.productionTargetNames);
+  throw new RunDeniedError(runId, reason);
+}
+function refuseUnavailableRunId(input) {
+  if (!input.isMintedRunId(input.runId)) throw new RunIdNotMintedError(input.runId);
+  if (existsSync(runDirFor({ configDir: input.configDir, runId: input.runId }))) {
+    throw new RunIdAlreadyInUseError(input.runId);
+  }
+}
+function createRunInvocationCore(options) {
+  const configDir = dirname2(options.agentQaRoot);
+  return {
+    async execute(request) {
+      const refused = REFUSED_RUN_REQUEST_FIELDS.filter((field) => request[field] !== void 0);
+      if (refused.length > 0) throw new RunRequestFieldRefusedError(refused);
+      if (request.runId !== void 0) {
+        refuseUnavailableRunId({
+          configDir,
+          runId: request.runId,
+          isMintedRunId: options.isMintedRunId
+        });
+      }
+      const runId = request.runId ?? options.mintRunId();
+      const declaration = await options.resolveTargetDeclaration(request);
+      const targetClass = declaration.targetClass;
+      refuseProductionWithoutOptIn(runId, declaration);
+      await options.afterRefusal?.();
+      const ports = buildRunPorts({ configDir, runId });
+      const postVerdict = options.postVerdict?.({ runId, configDir });
+      const assembled = await options.assembleRun({
+        runId,
+        request,
+        executionContext: options.executionContext,
+        ports: {
+          ...ports,
+          ...postVerdict === void 0 ? {} : { postVerdict }
+        },
+        configDir,
+        configPath: request.configPath ?? options.configPath,
+        targetClass
+      });
+      const session = startRun({
+        ...assembled,
+        runId,
+        ...request.gateRun === true ? { gateRun: true } : {},
+        ...request.excludedFromOutcomes === true ? { excludedFromOutcomes: true } : {}
+      });
+      options.onSession?.(session);
+      await session.done;
+      return { runId };
+    }
+  };
+}
+
+// src/composition/run-drive-vocabulary.ts
+import { runSafetyScope } from "@vostride/agent-qa-safety-local";
+import { mapVerdictToExitCode } from "@vostride/agent-qa-runner";
+
+// src/composition/evidence-blob-reader.ts
+import { existsSync as existsSync2 } from "node:fs";
+import { join } from "node:path";
+import { FsEvidenceArtifactStore as FsEvidenceArtifactStore2, RUNS_SUBDIR as RUNS_SUBDIR2, slugBranch as slugBranch2 } from "@vostride/agent-qa-runner-local";
+var SHA256_HEX_RE = /^[0-9a-f]{64}$/;
+function runDirectoryExists(input, runId) {
+  return existsSync2(join(input.agentQaRoot, RUNS_SUBDIR2, slugBranch2(runId)));
+}
+function lookupEvidenceBlob(input, runId, sha) {
+  if (!SHA256_HEX_RE.test(sha)) return { status: "blob_absent" };
+  if (!runDirectoryExists(input, runId)) return { status: "unknown_run" };
+  const bytes = new FsEvidenceArtifactStore2({ root: input.agentQaRoot, runId }).getBlob(sha);
+  return bytes === void 0 ? { status: "blob_absent" } : { status: "found", bytes };
+}
+function statEvidenceBlob(input, runId, sha) {
+  if (!SHA256_HEX_RE.test(sha)) return "blob_absent";
+  if (!runDirectoryExists(input, runId)) return "unknown_run";
+  return new FsEvidenceArtifactStore2({ root: input.agentQaRoot, runId }).hasBlob(sha) ? "found" : "blob_absent";
+}
+function statEvidenceBlobSize(input, runId, sha) {
+  if (!SHA256_HEX_RE.test(sha)) return { status: "blob_absent" };
+  if (!runDirectoryExists(input, runId)) return { status: "unknown_run" };
+  const byteLength = new FsEvidenceArtifactStore2({ root: input.agentQaRoot, runId }).blobSize(sha);
+  return byteLength === void 0 ? { status: "blob_absent" } : { status: "found", byteLength };
+}
+function readEvidenceBlobRange(input, runId, sha, start, end) {
+  if (!SHA256_HEX_RE.test(sha)) return { status: "blob_absent" };
+  if (!runDirectoryExists(input, runId)) return { status: "unknown_run" };
+  const bytes = new FsEvidenceArtifactStore2({ root: input.agentQaRoot, runId }).readBlobRange(sha, start, end);
+  return bytes === void 0 ? { status: "blob_absent" } : { status: "found", bytes };
+}
+function createEvidenceBlobReader(input) {
+  return {
+    read: (runId, sha) => Promise.resolve(lookupEvidenceBlob(input, String(runId), sha)),
+    has: (runId, sha) => Promise.resolve(statEvidenceBlob(input, String(runId), sha)),
+    stat: (runId, sha) => Promise.resolve(statEvidenceBlobSize(input, String(runId), sha)),
+    readRange: (runId, sha, start, end) => Promise.resolve(readEvidenceBlobRange(input, String(runId), sha, start, end))
+  };
+}
+function readEvidenceBlobBytes(input, runId, sha) {
+  const lookup = lookupEvidenceBlob(input, runId, sha);
+  return lookup.status === "found" ? lookup.bytes : void 0;
+}
+
+// src/composition/quarantine-snapshot.ts
+import { slugBranch as slugBranch3 } from "@vostride/agent-qa-schema";
+import {
+  QUARANTINE_LEDGER_FILENAME,
+  foldQuarantineLedgerState,
+  readQuarantineLedger
+} from "@vostride/agent-qa-knowledge-local/reader";
+function resolveRunQuarantineSnapshot(input) {
+  const warn = input.warn ?? (() => {
+  });
+  const product = slugBranch3(input.product);
+  let read;
+  try {
+    read = readQuarantineLedger(input.knowledgeRoot);
+  } catch (error) {
+    warn(
+      `${QUARANTINE_LEDGER_FILENAME} could not be read (${error instanceof Error ? error.message : String(error)}); no test is quarantined for this run`
+    );
+    return [];
+  }
+  if (read.refusedLines.length > 0) {
+    warn(
+      `${QUARANTINE_LEDGER_FILENAME} has ${read.refusedLines.length} unreadable line(s) \u2014 ${read.refusedLines.map((refused) => `line ${refused.lineNumber}: ${refused.reason}`).join("; ")}`
+    );
+  }
+  return foldQuarantineLedgerState(read.events, input.now).filter((entry) => entry.state === "quarantined" && entry.product === product).map((entry) => ({
+    product: entry.product,
+    filePath: entry.filePath,
+    testName: entry.testName,
+    expiresAt: entry.expiresAt
+  }));
+}
+
+// src/composition/quarantine-vocabulary.ts
+import {
+  QUARANTINE_CLASS_DISPOSITIONS,
+  QUARANTINE_FLOOR_ELIGIBILITY
+} from "@vostride/agent-qa-knowledge-local/reader";
+
+// src/composition/compose-local-agent.ts
+import { randomUUID as randomUUID3 } from "node:crypto";
+import { existsSync as existsSync4, readdirSync as readdirSync3, readFileSync as readFileSync4 } from "node:fs";
+import { createRequire } from "node:module";
+import { dirname as dirname6, join as join7 } from "node:path";
+import { DatabaseSync as DatabaseSync4 } from "node:sqlite";
+import { canaryOutcomeObservationId, planMarkEvidence, projectMarkEvidenceOutcome } from "@vostride/agent-qa-knowledge-local/reader";
+import {
+  AUTHORING_DRAFT_VERIFY_FUNCTION_ID,
+  CHAT_HELP_TEXT,
+  CHAT_RESOLVER_TABLE,
+  createAgentJobQueue,
+  createChatCompactionHook,
+  createChatState,
+  createFunctionRegistry,
+  createPlannerStage,
+  createRealJobKindRegistry,
+  createTurnEngine,
+  deterministicOverrideStrategy,
+  foldFunctionResult,
+  invokeFunction,
+  parseProposeGate1Allowance,
+  projectPlannerTools,
+  PROPOSE_GATE1_ALLOWANCE_CHECKPOINT,
+  RUNS_START_FUNCTION_ID,
+  splitClauses
+} from "@vostride/agent-qa-agent";
+import {
+  ADDRESSING_LEDGER_DB_FILE,
+  acquireEmbedder,
+  acquireWriterLease,
+  classifyIndexFace,
+  countPendingCurationJobs,
+  createMemorySightingSource,
+  createLocalKnowledgeStore,
+  createQuarantineOperations,
+  QUARANTINE_FLAG_FLOOR,
+  describeAllEntities,
+  embedPendingEntities,
+  countRemainingCurationWork,
+  deriveWriterLeaseFreshness,
+  drainQueue,
+  DRAIN_BUDGET_MS,
+  EMBEDDER_WORKER_REGISTRATION_FILE,
+  EMBEDDER_WORKER_START_TIMEOUT_MS,
+  EMBEDDER_WORKER_TERM_GRACE_MS,
+  EmbedderWorkerTimeoutError,
+  embedderWorkerProcessIsAlive,
+  embedderWorkerSocketPath,
+  enqueueCurationCandidateProjection,
+  failureRecurrence,
+  fingerprintRecurrence,
+  listTestsInFile,
+  foldQuarantineLedgerState as foldQuarantineLedgerState2,
+  foldRetrievalRung,
+  foldRunOutcomes,
+  createDraftReceiptsStore,
+  createSuiteFingerprintIndex,
+  indexDbPath,
+  readQuarantineLedger as readQuarantineLedger2,
+  readTestOutcomeHistory,
+  getEntityDescriptor,
+  heartbeatLease,
+  inspectDrainableCurationWork,
+  isLeaseStale,
+  listQueuedCandidates,
+  openAddressingLedger,
+  openEntityIndex,
+  openKnowledgeReader as openKnowledgeReader2,
+  purgeAffectedSetFingerprint,
+  probeEmbedderWorkerSocket,
+  purgeRecord,
+  readCanonicalBundleAnchors,
+  readCanonicalBundleStateDigests,
+  canaryPostureFactsFor,
+  standingReceiptDigestsFor,
+  lowerTrustSharesFor,
+  readEmbedderWorkerRegistration,
+  readWriterLease,
+  rebuildIndex,
+  reconcileRunOutcomesProjection,
+  entityIndexDbPath,
+  resolveEntityRef,
+  sightEntity,
+  refreshWriterLeaseAuthority,
+  releaseLease,
+  removeEmbedderWorkerRegistration,
+  resetEmbedderCapability,
+  resolveEmbedderCapability,
+  resolveProcessIncarnation,
+  verifyEmbedderWorkerIncarnation,
+  resolvePurgeAffectedSet,
+  resolveRollbackAffectedSet,
+  rollbackAffectedSetFingerprint,
+  rollbackCampaign,
+  rollbackCurationJob,
+  runMaintenanceTail,
+  sweepEntityIndex,
+  RUN_OUTCOMES_PROJECTION_VERSION,
+  ENTITY_INDEX_SWEEP_INTERVAL_MS,
+  applyExplicitReview,
+  appendMarkEvidence,
+  triageMark,
+  servedIdsOn,
+  procedureReadOn,
+  applyFeedback,
+  enumerateBundleDirs,
+  loadBundle,
+  verifyBundleIntegrity,
+  createAuthoringReader,
+  openAddressingLedger as openAddressingLedgerForReview,
+  resolveRetrievalRung
+} from "@vostride/agent-qa-knowledge-local";
+import { ReplayIncompleteError } from "@vostride/agent-qa-runner";
+import {
+  getActiveExecutionContext,
+  setActiveExecutionContextResolver
+} from "@vostride/agent-qa-safety";
+import {
+  ARTIFACT_FILE,
+  FsEventLog as FsEventLog2,
+  HANDOFF_FILE,
+  RUNS_SUBDIR as RUNS_SUBDIR3,
+  loadCompletedRunHandoff,
+  slugBranch as slugBranch4
+} from "@vostride/agent-qa-runner-local";
+import {
+  admitAnalysisArtifactForRun,
+  ANALYSIS_FILE,
+  asJobId as asJobId2,
+  DEFAULT_EMBEDDING_PROFILE,
+  guardRunAnalysisArtifact,
+  maskPayloadTree,
+  sha256hex16
+} from "@vostride/agent-qa-schema";
+
+// src/composition/knowledge-review-reader.ts
+import {
+  canaryAttributionsFor,
+  candidateInjectionFor,
+  gateReceiptsFor,
+  diffSince,
+  inspectRecords,
+  listBundles,
+  showRecord,
+  showRecords
+} from "@vostride/agent-qa-knowledge-local/reader";
+function createKnowledgeReaderPort(input) {
+  async function sight(bundleIds) {
+    if (input.sightMemoryEntities === void 0 || bundleIds.length === 0) return;
+    try {
+      await input.sightMemoryEntities(bundleIds);
+    } catch {
+    }
+  }
+  return {
+    // 2026-09-07, 417 D-01: forward the candidate DATA verbatim. Since 441-41 (D-06) nothing here
+    // scans it; the chat and MCP doors mask declared values in every op result.
+    async candidateInjection({ candidateId }) {
+      return candidateInjectionFor({
+        ...input.resolveTrustPriors === void 0 ? {} : { priors: input.resolveTrustPriors() },
+        knowledgeRoot: await input.resolveKnowledgeRoot(),
+        candidateId
+      });
+    },
+    // 416 D-17: the caller supplied the identity; forward the reader's answer verbatim.
+    async gateReceipts({ candidateId }) {
+      return gateReceiptsFor({
+        knowledgeRoot: await input.resolveKnowledgeRoot(),
+        candidateId,
+        resolvePromotionPosture: await input.resolvePromotionPosture?.()
+      });
+    },
+    async listBundles() {
+      const rows = listBundles(await input.resolveKnowledgeRoot(), input.resolveTrustPriors?.());
+      await sight(rows.map((row) => row.bundleId));
+      return rows;
+    },
+    async inspectRecords({ filter }) {
+      const records = inspectRecords({
+        ...input.resolveTrustPriors === void 0 ? {} : { priors: input.resolveTrustPriors() },
+        knowledgeRoot: await input.resolveKnowledgeRoot(),
+        filter
+      });
+      await sight(records.map((record) => record.recordId));
+      return records;
+    },
+    async diffSince({ sinceOrdinal }) {
+      const changes = diffSince({
+        knowledgeRoot: await input.resolveKnowledgeRoot(),
+        sinceOrdinal
+      });
+      await sight(changes.map((change) => change.recordId));
+      return changes;
+    },
+    async showRecord({ recordId }) {
+      const result = showRecord({
+        ...input.resolveTrustPriors === void 0 ? {} : { priors: input.resolveTrustPriors() },
+        knowledgeRoot: await input.resolveKnowledgeRoot(),
+        recordId
+      });
+      await sight(result.kind === "found" ? [result.record.recordId] : []);
+      return result;
+    },
+    // Caller-supplied union IDs are already known, like canary tuples below. Forward
+    // the maintenance batch without address-ledger sightings or per-record scans.
+    async showRecords({ recordIds }) {
+      return showRecords({ knowledgeRoot: await input.resolveKnowledgeRoot(), recordIds });
+    },
+    /**
+     * 407 D-08: what became of the canary lines one run served.
+     *
+     * Resolved per call like its four siblings, and NOT sighted. The caller already holds every
+     * candidate id in the tuples it passes — it read them off its own run's evidence — so a
+     * sighting here would record that the reader was handed ids rather than that an entity was
+     * surfaced to anyone, which is the distinction the ledger exists to keep.
+     *
+     * The reader entry's answer is forwarded VERBATIM, `skippedBundles` included (407-19, REVIEW
+     * WR-03). This binding neither counts nor interprets: how much of the store went unread is a
+     * fact only the walk knows, and a composition that dropped it here would hand the op a
+     * clean-looking answer over a half-read store.
+     */
+    async canaryAttributions({ runId, tuples }) {
+      return canaryAttributionsFor({
+        knowledgeRoot: await input.resolveKnowledgeRoot(),
+        runId,
+        tuples
+      });
+    }
+  };
+}
+
+// src/analysis/persist-analysis.ts
+import { closeSync, fsyncSync, openSync, renameSync, rmSync, writeFileSync } from "node:fs";
+import { randomUUID } from "node:crypto";
+import { dirname as dirname3, join as join2 } from "node:path";
+import { canonicalJson } from "@vostride/agent-qa-schema";
+var ANALYSIS_STAGE_PREFIX = "analysis.json";
+function fsyncFile(file) {
+  const fd = openSync(file, "r");
+  try {
+    fsyncSync(fd);
+  } finally {
+    closeSync(fd);
+  }
+}
+function writeAnalysisArtifact(path, artifact) {
+  const dir = dirname3(path);
+  const staged = join2(dir, `.${ANALYSIS_STAGE_PREFIX}.${randomUUID()}.tmp`);
+  try {
+    writeFileSync(staged, `${canonicalJson(artifact)}
+`, { encoding: "utf8", mode: 384 });
+    fsyncFile(staged);
+    renameSync(staged, path);
+    fsyncFile(dir);
+  } finally {
+    rmSync(staged, { force: true });
+  }
+}
+
+// src/session/jsonl-session-log.ts
+import {
+  closeSync as closeSync3,
+  fsyncSync as fsyncSync3,
+  mkdirSync as mkdirSync2,
+  openSync as openSync3,
+  readSync,
+  readFileSync as readFileSync2,
+  readdirSync,
+  writeFileSync as writeFileSync3
+} from "node:fs";
+import { isAbsolute as isAbsolute3, join as join4 } from "node:path";
+import { repairSession } from "@vostride/agent-qa-agent";
+import { CURRENT_CHAT_SESSION_SCHEMA_VERSION } from "@vostride/agent-qa-schema";
+
+// src/store/job-checkpoint-store.ts
+import { randomUUID as randomUUID2 } from "node:crypto";
+import {
+  closeSync as closeSync2,
+  fsyncSync as fsyncSync2,
+  mkdirSync,
+  openSync as openSync2,
+  readFileSync,
+  renameSync as renameSync2,
+  rmSync as rmSync2,
+  writeFileSync as writeFileSync2
+} from "node:fs";
+import { dirname as dirname4, isAbsolute as isAbsolute2, join as join3 } from "node:path";
+import {
+  canonicalJson as canonicalJson2,
+  asJobId,
+  JOB_CHECKPOINT_SCHEMA_VERSION as JOB_CHECKPOINT_SCHEMA_VERSION2,
+  jobCheckpointEnvelopeSchema
+} from "@vostride/agent-qa-schema";
+
+// src/store/store-errors.ts
+import { JOB_CHECKPOINT_SCHEMA_VERSION } from "@vostride/agent-qa-schema";
+import { QuarantinedJobRequeueError, StaleJobStoreEpochError } from "@vostride/agent-qa-agent";
+var JobStoreSchemaVersionError = class extends Error {
+  constructor(path, expectedVersion, observedVersion) {
+    super(
+      `The agent job store at ${path} is stamped at schema version ${observedVersion}, but this build reads version ${expectedVersion}. There is no migration machinery by design \u2014 clear agent job queue state (delete the agent job database and its checkpoint directory) and re-enqueue.`
+    );
+    this.path = path;
+    this.expectedVersion = expectedVersion;
+    this.observedVersion = observedVersion;
+  }
+  name = "JobStoreSchemaVersionError";
+};
+var UnknownJobRowError = class extends Error {
+  constructor(jobId) {
+    super(`No agent job row with id ${jobId}`);
+    this.jobId = jobId;
+  }
+  name = "UnknownJobRowError";
+};
+var InvalidJobCheckpointIdError = class extends Error {
+  constructor(field, value) {
+    super(
+      `Unusable ${field} for a checkpoint path: ${JSON.stringify(value)}. A checkpoint id becomes a path segment, so it is validated before the path is built rather than after.`
+    );
+    this.field = field;
+    this.value = value;
+  }
+  name = "InvalidJobCheckpointIdError";
+};
+var JobCheckpointSchemaVersionError = class extends Error {
+  constructor(path, observedVersion) {
+    super(
+      `Agent job checkpoint ${path} was written at schema version ${String(observedVersion)}, but this build reads version ${JOB_CHECKPOINT_SCHEMA_VERSION}. There is no migration machinery by design \u2014 clear agent job queue state and re-enqueue.`
+    );
+    this.path = path;
+    this.observedVersion = observedVersion;
+  }
+  name = "JobCheckpointSchemaVersionError";
+};
+
+// src/store/job-checkpoint-store.ts
+var JOB_CHECKPOINT_SUBDIR = ["agent-jobs", "checkpoints"];
+var SAFE_PATH_SEGMENT = /^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/;
+var DIRECTORY_FSYNC_SWALLOWED_CODES = [
+  "ENOENT",
+  "EINVAL",
+  "EISDIR",
+  "EPERM",
+  "ENOTSUP"
+];
+var REAL_JOB_CHECKPOINT_FS = Object.freeze({
+  mkdirSync,
+  openSync: openSync2,
+  writeFileSync: writeFileSync2,
+  fsyncSync: fsyncSync2,
+  closeSync: closeSync2,
+  renameSync: renameSync2,
+  rmSync: rmSync2,
+  readFileSync
+});
+function requireSegment(field, value) {
+  if (!SAFE_PATH_SEGMENT.test(value)) {
+    throw new InvalidJobCheckpointIdError(field, value);
+  }
+  return value;
+}
+function checkpointPath(root, jobId, checkpointId) {
+  if (!isAbsolute2(root)) throw new TypeError("agent job checkpoint root must be absolute");
+  return join3(
+    root,
+    ...JOB_CHECKPOINT_SUBDIR,
+    requireSegment("jobId", jobId),
+    `${requireSegment("checkpointId", checkpointId)}.json`
+  );
+}
+function readEnvelopeOn(fs, root, jobId, checkpointId) {
+  const file = checkpointPath(root, jobId, checkpointId);
+  let text;
+  try {
+    text = fs.readFileSync(file, "utf8");
+  } catch (error) {
+    if (error.code === "ENOENT") return { found: false };
+    throw error;
+  }
+  const raw = JSON.parse(text);
+  if (raw?.schemaVersion !== JOB_CHECKPOINT_SCHEMA_VERSION2) {
+    throw new JobCheckpointSchemaVersionError(file, raw?.schemaVersion);
+  }
+  const envelope = jobCheckpointEnvelopeSchema.parse(raw);
+  if (envelope.jobId !== jobId || envelope.checkpointId !== checkpointId) {
+    throw new TypeError("Agent job checkpoint envelope does not match its address");
+  }
+  return { found: true, envelope };
+}
+function readJobCheckpointEnvelope(options, jobId, checkpointId) {
+  return readEnvelopeOn(REAL_JOB_CHECKPOINT_FS, options.root, jobId, checkpointId);
+}
+function isSwallowableDirectoryFsyncError(error) {
+  const code = error.code;
+  return DIRECTORY_FSYNC_SWALLOWED_CODES.some((allowed) => allowed === code);
+}
+function createJobCheckpointStore(options) {
+  return createJobCheckpointStoreOn(REAL_JOB_CHECKPOINT_FS, options);
+}
+function createJobCheckpointStoreOn(fs, options) {
+  if (!isAbsolute2(options.root)) {
+    throw new TypeError("agent job checkpoint root must be absolute");
+  }
+  const checkpointsRoot = join3(options.root, ...JOB_CHECKPOINT_SUBDIR);
+  function pathFor(jobId, checkpointId) {
+    return checkpointPath(options.root, jobId, checkpointId);
+  }
+  function bestEffortFsyncDirectory(dir) {
+    let fd;
+    try {
+      fd = fs.openSync(dir, "r");
+      fs.fsyncSync(fd);
+    } catch (error) {
+      if (!isSwallowableDirectoryFsyncError(error)) {
+        throw error;
+      }
+    } finally {
+      if (fd !== void 0) fs.closeSync(fd);
+    }
+  }
+  return {
+    checkpointsRoot,
+    checkpointPath: pathFor,
+    publish(jobId, checkpointId, payload) {
+      const file = pathFor(jobId, checkpointId);
+      const envelope = {
+        schemaVersion: JOB_CHECKPOINT_SCHEMA_VERSION2,
+        jobId: asJobId(jobId),
+        checkpointId,
+        payload
+      };
+      fs.mkdirSync(dirname4(file), { recursive: true });
+      const temporary = `${file}.tmp-${randomUUID2()}`;
+      let fd;
+      try {
+        fd = fs.openSync(temporary, "wx");
+        fs.writeFileSync(fd, `${canonicalJson2(envelope)}
+`, "utf8");
+        fs.fsyncSync(fd);
+        fs.closeSync(fd);
+        fd = void 0;
+        fs.renameSync(temporary, file);
+        bestEffortFsyncDirectory(dirname4(file));
+      } finally {
+        if (fd !== void 0) fs.closeSync(fd);
+        fs.rmSync(temporary, { force: true });
+      }
+    },
+    discard(jobId, checkpointId) {
+      fs.rmSync(pathFor(jobId, checkpointId), { force: true });
+    },
+    read(jobId, checkpointId) {
+      const read = readEnvelopeOn(fs, options.root, jobId, checkpointId);
+      return read.found ? { found: true, payload: read.envelope.payload } : read;
+    }
+  };
+}
+
+// src/session/jsonl-session-log.ts
+var CHAT_SESSIONS_SUBDIR = "sessions";
+var SESSION_FILE_SUFFIX = ".jsonl";
+var CHAT_SESSION_READ_CHUNK_BYTES = 64 * 1024;
+var SAFE_PATH_SEGMENT2 = /^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/;
+var InvalidChatSessionIdError = class extends Error {
+  constructor(sessionId) {
+    super(
+      `${JSON.stringify(sessionId)} is not a usable chat session id. Ids are minted by this adapter and are limited to letters, digits, dot, dash and underscore.`
+    );
+    this.sessionId = sessionId;
+  }
+  name = "InvalidChatSessionIdError";
+};
+var UnknownChatSessionError = class extends Error {
+  constructor(sessionId) {
+    super(`No chat session ${sessionId} exists under this project's runtime root.`);
+    this.sessionId = sessionId;
+  }
+  name = "UnknownChatSessionError";
+};
+var ChatSessionBusyError = class extends Error {
+  constructor(sessionId) {
+    super(
+      `Chat session ${sessionId} is already open in this process. One writer at a time: a second handle would interleave two turns in one conversation.`
+    );
+    this.sessionId = sessionId;
+  }
+  name = "ChatSessionBusyError";
+};
+var ChatSessionHeaderError = class extends Error {
+  constructor(sessionId, detail) {
+    super(`The session file for ${sessionId} cannot be read: ${detail}.`);
+    this.sessionId = sessionId;
+    this.detail = detail;
+  }
+  name = "ChatSessionHeaderError";
+};
+var REAL_CHAT_SESSION_FS = Object.freeze({
+  mkdirSync: mkdirSync2,
+  openSync: openSync3,
+  writeFileSync: writeFileSync3,
+  fsyncSync: fsyncSync3,
+  closeSync: closeSync3,
+  readSync,
+  readFileSync: readFileSync2,
+  readdirSync
+});
+function mintChatSessionId(nowIso, random) {
+  const stamp = nowIso.replace(/[-:]/g, "").replace(/\.\d+Z$/, "Z").replace("T", "-").replace("Z", "");
+  const suffix = Math.floor(random() * 36 ** 4).toString(36).padStart(4, "0");
+  return `chat-${stamp}-${suffix}`;
+}
+function requireSessionId(sessionId) {
+  if (!SAFE_PATH_SEGMENT2.test(sessionId)) throw new InvalidChatSessionIdError(sessionId);
+  return sessionId;
+}
+function isSwallowableDirectoryFsyncError2(error) {
+  const code = error.code;
+  return DIRECTORY_FSYNC_SWALLOWED_CODES.some((allowed) => allowed === code);
+}
+function guardHeader(sessionId, line) {
+  let parsed;
+  try {
+    parsed = JSON.parse(line);
+  } catch {
+    throw new ChatSessionHeaderError(sessionId, "its first line is not JSON");
+  }
+  if (parsed === null || typeof parsed !== "object") {
+    throw new ChatSessionHeaderError(sessionId, "its header line is not an object");
+  }
+  const header = parsed;
+  if (header.schemaVersion !== CURRENT_CHAT_SESSION_SCHEMA_VERSION) {
+    throw new ChatSessionHeaderError(
+      sessionId,
+      `it declares schemaVersion ${String(header.schemaVersion)} and this build reads ` + String(CURRENT_CHAT_SESSION_SCHEMA_VERSION)
+    );
+  }
+  if (header.sessionId !== sessionId) {
+    throw new ChatSessionHeaderError(
+      sessionId,
+      `its header names session ${String(header.sessionId)}`
+    );
+  }
+  if (typeof header.createdAt !== "string" || typeof header.model !== "string") {
+    throw new ChatSessionHeaderError(sessionId, "its header names no creation instant or model");
+  }
+  if (header.surface !== void 0 && typeof header.surface !== "string") {
+    throw new ChatSessionHeaderError(
+      sessionId,
+      `its header names a surface of type ${typeof header.surface} and this build reads a string`
+    );
+  }
+  return header;
+}
+function listSessions(root) {
+  if (!isAbsolute3(root)) throw new TypeError("chat session log root must be absolute");
+  const fs = REAL_CHAT_SESSION_FS;
+  const sessionsRoot = join4(root, CHAT_SESSIONS_SUBDIR);
+  let files;
+  try {
+    files = fs.readdirSync(sessionsRoot);
+  } catch (error) {
+    if (error.code === "ENOENT") return { sessions: [], refused: [] };
+    throw error;
+  }
+  const sessions = [];
+  const refused = [];
+  for (const file of [...files].sort()) {
+    if (!file.endsWith(SESSION_FILE_SUFFIX)) continue;
+    const sessionId = file.slice(0, -SESSION_FILE_SUFFIX.length);
+    try {
+      const scanned = scanSessionFile(fs, join4(sessionsRoot, file));
+      if (scanned.headerLine === void 0) {
+        refused.push({ file, reason: "it carries no complete header line" });
+        continue;
+      }
+      const header = guardHeader(sessionId, scanned.headerLine);
+      sessions.push({
+        sessionId: header.sessionId,
+        createdAt: header.createdAt,
+        model: header.model,
+        eventCount: Math.max(scanned.lineCount - 1, 0)
+      });
+    } catch (error) {
+      refused.push({ file, reason: error instanceof Error ? error.message : String(error) });
+    }
+  }
+  return { sessions, refused };
+}
+function scanSessionFile(fs, path) {
+  const fd = fs.openSync(path, "r");
+  try {
+    const buffer = Buffer.allocUnsafe(CHAT_SESSION_READ_CHUNK_BYTES);
+    let headerLine;
+    let headerBytes = "";
+    let lineCount = 0;
+    let read = fs.readSync(fd, buffer, 0, buffer.length, null);
+    while (read > 0) {
+      const chunk = buffer.subarray(0, read);
+      for (let index = 0; index < chunk.length; index += 1) {
+        if (chunk[index] === 10) lineCount += 1;
+      }
+      if (headerLine === void 0) {
+        headerBytes += chunk.toString("utf8");
+        const newline = headerBytes.indexOf("\n");
+        if (newline >= 0) headerLine = headerBytes.slice(0, newline);
+        else if (headerBytes.length > CHAT_SESSION_READ_CHUNK_BYTES) break;
+      }
+      read = fs.readSync(fd, buffer, 0, buffer.length, null);
+    }
+    return { headerLine, lineCount };
+  } finally {
+    fs.closeSync(fd);
+  }
+}
+function createJsonlSessionLog(options) {
+  return createJsonlSessionLogOn(REAL_CHAT_SESSION_FS, options);
+}
+function createJsonlSessionLogOn(fs, options) {
+  if (!isAbsolute3(options.root)) {
+    throw new TypeError("chat session log root must be absolute");
+  }
+  const sessionsRoot = join4(options.root, CHAT_SESSIONS_SUBDIR);
+  const random = options.random ?? Math.random;
+  const liveDescriptors = /* @__PURE__ */ new Map();
+  function pathFor(sessionId) {
+    return join4(sessionsRoot, `${sessionId}.jsonl`);
+  }
+  function bestEffortFsyncDirectory(dir) {
+    let directoryFd;
+    try {
+      directoryFd = fs.openSync(dir, "r");
+      fs.fsyncSync(directoryFd);
+    } catch (error) {
+      if (!isSwallowableDirectoryFsyncError2(error)) throw error;
+    } finally {
+      if (directoryFd !== void 0) fs.closeSync(directoryFd);
+    }
+  }
+  function readLines(sessionId) {
+    let text;
+    try {
+      text = fs.readFileSync(pathFor(sessionId), "utf8");
+    } catch (error) {
+      if (error.code === "ENOENT") return void 0;
+      throw error;
+    }
+    return {
+      // Line numbers are 1-based and count the header, so a refusal names what an editor shows the
+      // person who has to go and look at the file.
+      lines: text.split("\n").map((line, index) => ({ lineNumber: index + 1, text: line })).filter((line) => line.text !== ""),
+      // Every line this adapter writes ends in a newline, so a file that does not is a file whose
+      // last write was cut short. That fact cannot be recovered once the lines are split, and the
+      // append path needs it BEFORE it writes anything (see `terminateTornTail`).
+      terminated: text === "" || text.endsWith("\n")
+    };
+  }
+  function writeEvent(target, event) {
+    fs.writeFileSync(target, `${JSON.stringify(event)}
+`, "utf8");
+  }
+  function handleFor(id, fd, opened) {
+    let live = true;
+    const requireLive = (verb) => {
+      if (!live) {
+        throw new TypeError(
+          `a chat session ${verb} cannot go through a closed handle for ${id}. Open the session again to write to it.`
+        );
+      }
+    };
+    const handle = {
+      header: opened.header,
+      events: opened.events,
+      refusedLines: opened.refusedLines,
+      append(event) {
+        requireLive("event");
+        writeEvent(fd, event);
+        return Promise.resolve();
+      },
+      turnBoundary() {
+        requireLive("turn boundary");
+        fs.fsyncSync(fd);
+        return Promise.resolve();
+      },
+      close() {
+        if (live) {
+          live = false;
+          liveDescriptors.delete(id);
+          fs.closeSync(fd);
+        }
+        return Promise.resolve();
+      }
+    };
+    liveDescriptors.set(id, fd);
+    return handle;
+  }
+  return {
+    open(sessionId) {
+      fs.mkdirSync(sessionsRoot, { recursive: true });
+      if (sessionId !== void 0) {
+        const id2 = requireSessionId(sessionId);
+        if (liveDescriptors.has(id2)) throw new ChatSessionBusyError(id2);
+        const read = readLines(id2);
+        if (read === void 0 || read.lines.length === 0) throw new UnknownChatSessionError(id2);
+        const header2 = guardHeader(id2, read.lines[0].text);
+        const repair = repairSession(read.lines.slice(1), {
+          declaredVersion: header2.schemaVersion,
+          now: options.now
+        });
+        const resumed = fs.openSync(pathFor(id2), "a");
+        let wroteDuringRepair = false;
+        if (!read.terminated) {
+          fs.writeFileSync(resumed, "\n", "utf8");
+          wroteDuringRepair = true;
+        }
+        for (const event of repair.synthesized) {
+          writeEvent(resumed, event);
+          wroteDuringRepair = true;
+        }
+        if (wroteDuringRepair) {
+          fs.fsyncSync(resumed);
+        }
+        return Promise.resolve(
+          handleFor(id2, resumed, {
+            header: header2,
+            events: repair.repaired,
+            refusedLines: repair.refusedLines
+          })
+        );
+      }
+      const createdAt = options.now();
+      const id = mintChatSessionId(createdAt, random);
+      const header = {
+        schemaVersion: CURRENT_CHAT_SESSION_SCHEMA_VERSION,
+        sessionId: id,
+        createdAt,
+        model: options.model(),
+        toolsetHash: options.toolsetHash(),
+        // CONDITIONALLY SPREAD, on the composition's own idiom (400-01) and for its reason: an
+        // unconditional `surface: options.surface` would put `"surface":undefined` through
+        // `JSON.stringify` — which drops it — but would also make an explicit `undefined` and an
+        // unsupplied option two spellings of one state at every call site above. Absent here means
+        // the option was never given, and that is exactly the pre-400 population's meaning.
+        ...options.surface === void 0 ? {} : { surface: options.surface }
+      };
+      const created = fs.openSync(pathFor(id), "wx");
+      try {
+        fs.writeFileSync(created, `${JSON.stringify(header)}
+`, "utf8");
+        fs.fsyncSync(created);
+      } finally {
+        fs.closeSync(created);
+      }
+      bestEffortFsyncDirectory(sessionsRoot);
+      const appendFd = fs.openSync(pathFor(id), "a");
+      return Promise.resolve(handleFor(id, appendFd, { header, events: [], refusedLines: [] }));
+    }
+  };
+}
+
+// src/store/post-processing-reader.ts
+import { existsSync as existsSync3 } from "node:fs";
+import { join as join6 } from "node:path";
+import { DatabaseSync as DatabaseSync3 } from "node:sqlite";
+import { canonicalJson as canonicalJson5, CurationSnapshotSchema, guardRunNotification as guardRunNotification2, isJobKind as isJobKind2, sha256hex as sha256hex3 } from "@vostride/agent-qa-schema";
+
+// src/store/sqlite-job-store.ts
+import { mkdirSync as mkdirSync3 } from "node:fs";
+import { dirname as dirname5 } from "node:path";
+import { DatabaseSync as DatabaseSync2 } from "node:sqlite";
+import {
+  JobCancellationNotRequestedError,
+  MissingIdempotencyKeyError,
+  QuarantinedJobRequeueError as QuarantinedJobRequeueError2,
+  StaleJobStoreEpochError as StaleJobStoreEpochError2
+} from "@vostride/agent-qa-agent";
+import {
+  canonicalJson as canonicalJson4,
+  guardRunNotification,
+  isJobKind,
+  jobSchema,
+  sha256hex as sha256hex2
+} from "@vostride/agent-qa-schema";
+
+// src/store/logical-dump.ts
+import { readdirSync as readdirSync2, readFileSync as readFileSync3 } from "node:fs";
+import { join as join5, relative, sep } from "node:path";
+import "node:sqlite";
+import { canonicalJson as canonicalJson3, sha256hex } from "@vostride/agent-qa-schema";
+var SAFE_IDENTIFIER = /^[A-Za-z_][A-Za-z0-9_]*$/;
+function requireIdentifier(value) {
+  if (!SAFE_IDENTIFIER.test(value)) {
+    throw new TypeError(`unusable sqlite identifier in a logical dump: ${JSON.stringify(value)}`);
+  }
+  return value;
+}
+function orderedSelectSql(table, columns) {
+  if (columns.length === 0) {
+    throw new TypeError(`table ${table} reports no columns, so no order can be stated`);
+  }
+  const order = columns.map((column) => `"${requireIdentifier(column)}" ASC`).join(", ");
+  return `SELECT * FROM "${requireIdentifier(table)}" ORDER BY ${order}`;
+}
+function listStoreTables(db) {
+  return db.prepare(
+    `SELECT name FROM sqlite_master
+       WHERE type = 'table' AND name NOT LIKE 'sqlite_%'
+       ORDER BY name ASC`
+  ).all().map((row) => String(row.name));
+}
+function tableColumns(db, table) {
+  return db.prepare(`PRAGMA table_info("${requireIdentifier(table)}")`).all().map((row) => String(row.name));
+}
+function normalize(value) {
+  if (typeof value === "bigint") return Number(value);
+  if (value instanceof Uint8Array) return { base16: Buffer.from(value).toString("hex") };
+  return value;
+}
+function selectOrderedRows(db, table) {
+  const columns = tableColumns(db, table);
+  const rows = db.prepare(orderedSelectSql(table, columns)).all().map((row) => {
+    const normalized = {};
+    for (const column of columns) normalized[column] = normalize(row[column]);
+    return normalized;
+  });
+  return { table, orderBy: columns, rows };
+}
+function checkpointDigests(checkpointsRoot) {
+  const found = [];
+  function walk(dir) {
+    let entries;
+    try {
+      entries = readdirSync2(dir, { withFileTypes: true });
+    } catch (error) {
+      if (error.code === "ENOENT") return;
+      throw error;
+    }
+    for (const entry of entries) {
+      const path = join5(dir, entry.name);
+      if (entry.isDirectory()) {
+        walk(path);
+        continue;
+      }
+      found.push({
+        path: relative(checkpointsRoot, path).split(sep).join("/"),
+        digest: sha256hex(readFileSync3(path, "utf8"))
+      });
+    }
+  }
+  walk(checkpointsRoot);
+  return found.sort((left, right) => left.path < right.path ? -1 : left.path > right.path ? 1 : 0);
+}
+function createLogicalDump(input) {
+  return {
+    schemaVersion: input.schemaVersion,
+    tables: listStoreTables(input.db).map((table) => selectOrderedRows(input.db, table)),
+    checkpoints: checkpointDigests(input.checkpointsRoot)
+  };
+}
+function canonicalLogicalDump(dump) {
+  return canonicalJson3(dump);
+}
+
+// src/store/sqlite-job-store.ts
+var AGENT_JOB_STORE_USER_VERSION = 2;
+var AGENT_JOB_STORE_BUSY_TIMEOUT_MS = 2e3;
+var AGENT_JOB_STORE_DB_FILE = "agent-jobs.db";
+var SCHEMA_STATEMENTS = [
+  `CREATE TABLE IF NOT EXISTS jobs (
+     id              TEXT PRIMARY KEY,
+     kind            TEXT NOT NULL,
+     idempotency_key TEXT NOT NULL,
+     status          TEXT NOT NULL,
+     summary         TEXT NOT NULL,
+     payload         TEXT NOT NULL,
+     attempts        INTEGER NOT NULL,
+     claimed_at      TEXT,
+     created_at      TEXT NOT NULL,
+     updated_at      TEXT NOT NULL,
+     -- The disposition the engine DECIDED, recorded so a failed job says why it failed.
+     -- Nullable because most rows never fail; written only by recordFailure.
+     last_failure_kind   TEXT,
+     last_failure_reason TEXT,
+     -- When somebody asked this job to stop (D-19). A column rather than a status, for the
+     -- same reason the claim is one: the job status vocabulary describes lifecycle stages,
+     -- and "still queued, but asked to stop" is a fact about a request, not a stage.
+     -- Appended LAST deliberately - a column inserted in the middle would move every
+     -- positional read of this table for no gain.
+     cancel_requested_at TEXT,
+     -- The instant this row was FIRST claimed, kept after the lease is released (425). The
+     -- claim column answers who holds the row now; no column answered how long the work took.
+     -- Written once by the claim, cleared only by the operator requeue. Appended last, as above.
+     started_at TEXT,
+     -- 444.1 D-23: a retrying row is not claimable before this instant. Appended last, as above.
+     not_before TEXT
+   )`,
+  // D-08's dedupe is THIS line. Making it a store-level constraint rather than a check the
+  // caller performs is what turns "two enqueues of the same work produce one job" from a
+  // convention into something no caller, in any process, can get wrong.
+  `CREATE UNIQUE INDEX IF NOT EXISTS jobs_kind_idempotency_key
+     ON jobs (kind, idempotency_key)`,
+  `CREATE TABLE IF NOT EXISTS job_store_fence (
+     id    INTEGER PRIMARY KEY CHECK (id = 1),
+     epoch INTEGER NOT NULL
+   )`,
+  // The row is the authoritative checkpoint. The file remains a durable projection for
+  // cross-process observability, but recovery accepts its bytes only when their digest agrees
+  // with the latest fenced row for this job/checkpoint. Attempt stays in the key so retries
+  // preserve their recorded history while a same-attempt takeover replaces only that attempt.
+  `CREATE TABLE IF NOT EXISTS job_checkpoints (
+     job_id         TEXT NOT NULL,
+     checkpoint_id  TEXT NOT NULL,
+     attempt        INTEGER NOT NULL,
+     payload_json   TEXT NOT NULL,
+     payload_digest TEXT NOT NULL,
+     epoch          INTEGER NOT NULL,
+     PRIMARY KEY (job_id, attempt, checkpoint_id)
+   )`,
+  // 388 D-09: the chain-terminal record, beside the jobs it summarizes rather than in a
+  // second durable medium. `created_at` is written from the injected clock like every other
+  // timestamp in this file — a SQL-side default would leak host time into the D-03 dump and
+  // make two identical histories compare unequal.
+  `CREATE TABLE IF NOT EXISTS notifications (
+     run_id     TEXT NOT NULL,
+     payload    TEXT NOT NULL,
+     created_at TEXT NOT NULL
+   )`,
+  // D-10's dedupe is THIS line, and it is the same idiom as the jobs index above for the same
+  // reason: a crash-replayed chain terminal re-attempts the insert, and "one notification per
+  // run, ever" has to be something no caller — in this process or the next — can get wrong.
+  `CREATE UNIQUE INDEX IF NOT EXISTS notifications_run_id
+     ON notifications (run_id)`
+];
+var TERMINAL_JOB_STATUSES = ["done", "failed", "cancelled"];
+var UNREADABLE_KIND_CONCLUSION = "unreadable_kind";
+var QUARANTINED_UNREADABLE_KIND_REASON = "agent job quarantined at claim: this build does not read the kind recorded for this row, so the row was landed permanently without being parsed. The original kind, id and payload are preserved in the row for inspection.";
+var QUARANTINE_SCAN_BOUND = 1e3;
+function isUnreadableKindRow(row) {
+  return !isJobKind(String(row.kind));
+}
+function quarantineConclusionOf(row) {
+  if (!isUnreadableKindRow(row)) return void 0;
+  if (String(row.status) !== "failed") return void 0;
+  if (String(row.last_failure_kind) !== "permanent") return void 0;
+  if (String(row.last_failure_reason) !== QUARANTINED_UNREADABLE_KIND_REASON) return void 0;
+  return UNREADABLE_KIND_CONCLUSION;
+}
+function runIdOfPayloadColumn(payload) {
+  const record = JSON.parse(String(payload));
+  if (typeof record !== "object" || record === null || Array.isArray(record)) return void 0;
+  const runId = record.runId;
+  return typeof runId === "string" && runId !== "" ? runId : void 0;
+}
+function toNumber(value) {
+  return typeof value === "bigint" ? Number(value) : Number(value);
+}
+function createSqliteJobStore(options) {
+  const { clock, checkpoints, hooks } = options;
+  mkdirSync3(dirname5(options.path), { recursive: true });
+  const db = new DatabaseSync2(options.path, {
+    timeout: options.timeoutMs ?? AGENT_JOB_STORE_BUSY_TIMEOUT_MS
+  });
+  db.exec("PRAGMA journal_mode=WAL");
+  const stampedVersion = toNumber(db.prepare("PRAGMA user_version").get()?.user_version);
+  if (stampedVersion !== 0 && stampedVersion !== AGENT_JOB_STORE_USER_VERSION) {
+    db.close();
+    throw new JobStoreSchemaVersionError(
+      options.path,
+      AGENT_JOB_STORE_USER_VERSION,
+      stampedVersion
+    );
+  }
+  for (const statement of SCHEMA_STATEMENTS) db.exec(statement);
+  if (stampedVersion === 0) {
+    db.exec(`PRAGMA user_version=${AGENT_JOB_STORE_USER_VERSION}`);
+  }
+  const insertJob = db.prepare(
+    `INSERT INTO jobs
+       (id, kind, idempotency_key, status, summary, payload, attempts, claimed_at,
+        created_at, updated_at, last_failure_kind, last_failure_reason,
+        cancel_requested_at, started_at, not_before)
+     VALUES (?, ?, ?, 'queued', ?, ?, 0, NULL, ?, ?, NULL, NULL, NULL, NULL, NULL)
+     ON CONFLICT (kind, idempotency_key) DO NOTHING`
+  );
+  const selectByKey = db.prepare("SELECT * FROM jobs WHERE kind = ? AND idempotency_key = ?");
+  const selectById = db.prepare("SELECT * FROM jobs WHERE id = ?");
+  const selectClaimable = db.prepare(
+    `SELECT * FROM jobs
+     WHERE status = 'queued' AND claimed_at IS NULL
+       AND (not_before IS NULL OR not_before <= ?)
+     ORDER BY created_at ASC, id ASC
+     LIMIT 1`
+  );
+  const selectClaimableExcluding = /* @__PURE__ */ new Map();
+  function claimableStatementFor(excludedCount) {
+    const cached = selectClaimableExcluding.get(excludedCount);
+    if (cached !== void 0) return cached;
+    const placeholders = Array.from({ length: excludedCount }, () => "?").join(", ");
+    const prepared = db.prepare(
+      `SELECT * FROM jobs
+       WHERE status = 'queued' AND claimed_at IS NULL
+         AND (not_before IS NULL OR not_before <= ?) AND kind NOT IN (${placeholders})
+       ORDER BY created_at ASC, id ASC
+       LIMIT 1`
+    );
+    selectClaimableExcluding.set(excludedCount, prepared);
+    return prepared;
+  }
+  const markClaimed = db.prepare(
+    `UPDATE jobs
+     SET claimed_at = ?, started_at = COALESCE(started_at, ?), attempts = attempts + 1,
+         updated_at = ?
+     WHERE id = ?`
+  );
+  const markDone = db.prepare(
+    "UPDATE jobs SET status = 'done', claimed_at = NULL, updated_at = ? WHERE id = ?"
+  );
+  const markQuarantined = db.prepare(
+    `UPDATE jobs
+     SET status = 'failed', claimed_at = NULL, last_failure_kind = 'permanent',
+         last_failure_reason = ?, updated_at = ?
+     WHERE id = ?`
+  );
+  const touchJob = db.prepare("UPDATE jobs SET updated_at = ? WHERE id = ?");
+  const markRetryable = db.prepare(
+    `UPDATE jobs
+     SET claimed_at = NULL, last_failure_kind = 'retry', last_failure_reason = ?,
+         updated_at = ?, not_before = ?
+     WHERE id = ?`
+  );
+  const markInterrupted = db.prepare(
+    `UPDATE jobs
+     SET claimed_at = NULL, attempts = MAX(attempts - 1, 0), updated_at = ?
+     WHERE id = ?`
+  );
+  const markFailed = db.prepare(
+    `UPDATE jobs
+     SET status = 'failed', claimed_at = NULL, last_failure_kind = 'permanent',
+         last_failure_reason = ?, updated_at = ?
+     WHERE id = ?`
+  );
+  const markCancelledNow = db.prepare(
+    `UPDATE jobs
+     SET status = 'cancelled', claimed_at = NULL, cancel_requested_at = ?, updated_at = ?
+     WHERE id = ?`
+  );
+  const markCancelRequested = db.prepare(
+    "UPDATE jobs SET cancel_requested_at = ?, updated_at = ? WHERE id = ?"
+  );
+  const markCancelHonoured = db.prepare(
+    `UPDATE jobs
+     SET status = 'cancelled', claimed_at = NULL, updated_at = ?
+     WHERE id = ?`
+  );
+  const markRequeued = db.prepare(
+    `UPDATE jobs
+     SET status = 'queued', claimed_at = NULL, started_at = NULL, attempts = 0,
+         last_failure_kind = NULL, last_failure_reason = NULL, cancel_requested_at = NULL,
+         not_before = NULL, updated_at = ?
+     WHERE id = ?`
+  );
+  const selectCheckpointIdsForJob = db.prepare(
+    "SELECT DISTINCT checkpoint_id FROM job_checkpoints WHERE job_id = ?"
+  );
+  const deleteCheckpointsForJob = db.prepare("DELETE FROM job_checkpoints WHERE job_id = ?");
+  const selectFence = db.prepare("SELECT epoch FROM job_store_fence WHERE id = 1");
+  const upsertFence = db.prepare(
+    `INSERT INTO job_store_fence (id, epoch) VALUES (1, ?)
+     ON CONFLICT (id) DO UPDATE SET epoch = excluded.epoch`
+  );
+  const upsertCheckpoint = db.prepare(
+    `INSERT INTO job_checkpoints
+       (job_id, checkpoint_id, attempt, payload_json, payload_digest, epoch)
+     VALUES (?, ?, ?, ?, ?, ?)
+     ON CONFLICT (job_id, attempt, checkpoint_id) DO UPDATE SET
+       payload_json = excluded.payload_json,
+       payload_digest = excluded.payload_digest,
+       epoch = excluded.epoch`
+  );
+  const selectLatestCheckpoint = db.prepare(
+    `SELECT payload_json, payload_digest, attempt, epoch
+     FROM job_checkpoints
+     WHERE job_id = ? AND checkpoint_id = ?
+     ORDER BY attempt DESC
+     LIMIT 1`
+  );
+  const insertNotification = db.prepare(
+    `INSERT INTO notifications (run_id, payload, created_at) VALUES (?, ?, ?)
+     ON CONFLICT (run_id) DO NOTHING`
+  );
+  const selectJobStatus = db.prepare("SELECT status FROM jobs WHERE id = ?");
+  const selectNotifications = db.prepare(
+    "SELECT run_id, payload, created_at FROM notifications ORDER BY run_id ASC"
+  );
+  const deleteNotificationForRun = db.prepare("DELETE FROM notifications WHERE run_id = ?");
+  function inTransaction(body) {
+    db.exec("BEGIN IMMEDIATE");
+    try {
+      const result = body();
+      db.exec("COMMIT");
+      return result;
+    } catch (error) {
+      if (db.isTransaction) db.exec("ROLLBACK");
+      throw error;
+    }
+  }
+  function currentEpoch() {
+    const row = selectFence.get();
+    return row === void 0 ? 0 : toNumber(row.epoch);
+  }
+  function requireFence(fence) {
+    const observed = currentEpoch();
+    if (observed !== fence.epoch) {
+      throw new StaleJobStoreEpochError2(fence.epoch, observed);
+    }
+  }
+  function rowToJob(row) {
+    if (row === void 0) {
+      throw new UnknownJobRowError("<missing>");
+    }
+    return jobSchema.parse({
+      id: String(row.id),
+      kind: String(row.kind),
+      status: String(row.status),
+      summary: String(row.summary),
+      attempts: toNumber(row.attempts),
+      createdAt: String(row.created_at),
+      updatedAt: String(row.updated_at)
+    });
+  }
+  function requireRow(jobId) {
+    const row = selectById.get(jobId);
+    if (row === void 0) {
+      throw new UnknownJobRowError(jobId);
+    }
+    return row;
+  }
+  function insertOrGet(request, now) {
+    if (request.idempotencyKey.trim() === "") {
+      throw new MissingIdempotencyKeyError(request.kind);
+    }
+    const changes = insertJob.run(
+      String(request.id),
+      request.kind,
+      request.idempotencyKey,
+      request.summary,
+      JSON.stringify(request.payload ?? null),
+      now,
+      now
+    ).changes;
+    return {
+      job: rowToJob(selectByKey.get(request.kind, request.idempotencyKey)),
+      deduped: toNumber(changes) === 0
+    };
+  }
+  function recordChainTerminal(chainTerminal, now) {
+    let headExists = false;
+    for (const candidate of chainTerminal.candidateJobIds) {
+      const row = selectJobStatus.get(String(candidate));
+      if (row === void 0) continue;
+      headExists ||= String(candidate) === String(chainTerminal.candidateJobIds[0]);
+      if (!TERMINAL_JOB_STATUSES.includes(String(row.status))) return;
+    }
+    if (!headExists) return;
+    insertNotification.run(chainTerminal.dedupeKey, chainTerminal.payloadJson, now);
+  }
+  function dumpRow(row) {
+    const conclusionKind = quarantineConclusionOf(row);
+    return {
+      id: String(row.id),
+      kind: String(row.kind),
+      idempotencyKey: String(row.idempotency_key),
+      status: String(row.status),
+      summary: String(row.summary),
+      payload: JSON.parse(String(row.payload)),
+      attempts: toNumber(row.attempts),
+      claimed: row.claimed_at !== null,
+      cancelRequested: row.cancel_requested_at !== null,
+      // 422 D-16: OMITTED rather than `undefined` when there is nothing to say, so a reader that
+      // serializes this row does not publish an empty conclusion key for every ordinary job.
+      ...conclusionKind === void 0 ? {} : { conclusionKind },
+      createdAt: String(row.created_at),
+      updatedAt: String(row.updated_at)
+    };
+  }
+  return {
+    close() {
+      db.close();
+    },
+    async adoptEpoch(epoch) {
+      return inTransaction(() => {
+        const observed = currentEpoch();
+        if (epoch < observed) {
+          throw new StaleJobStoreEpochError2(epoch, observed);
+        }
+        upsertFence.run(epoch);
+        return { epoch };
+      });
+    },
+    async enqueue(request) {
+      const now = clock.now();
+      return inTransaction(() => insertOrGet(request, now));
+    },
+    async claimNext(fence, options2) {
+      const now = clock.now();
+      const excludeKinds = options2?.excludeKinds ?? [];
+      return inTransaction(() => {
+        requireFence(fence);
+        for (let scanned = 0; scanned <= QUARANTINE_SCAN_BOUND; scanned += 1) {
+          const row = excludeKinds.length === 0 ? selectClaimable.get(now) : claimableStatementFor(excludeKinds.length).get(now, ...excludeKinds);
+          if (row === void 0) {
+            return { claimed: false };
+          }
+          markClaimed.run(now, now, now, String(row.id));
+          const claimed = requireRow(String(row.id));
+          if (isUnreadableKindRow(claimed)) {
+            markQuarantined.run(QUARANTINED_UNREADABLE_KIND_REASON, now, String(row.id));
+            continue;
+          }
+          return {
+            claimed: true,
+            job: rowToJob(claimed),
+            payload: JSON.parse(String(claimed.payload))
+          };
+        }
+        throw new Error(
+          `agent job claim scanned ${QUARANTINE_SCAN_BOUND} rows without reaching a claimable or exhausted queue; the claimable set is not shrinking, so no row was claimed and the transaction is rolled back rather than reporting an empty queue`
+        );
+      });
+    },
+    async completeAndChain(jobId, next, fence, chainTerminal) {
+      const now = clock.now();
+      return inTransaction(() => {
+        requireFence(fence);
+        requireRow(String(jobId));
+        markDone.run(now, String(jobId));
+        const chained = next.map((request) => insertOrGet(request, now));
+        if (chainTerminal !== void 0) recordChainTerminal(chainTerminal, now);
+        return { job: rowToJob(requireRow(String(jobId))), chained };
+      });
+    },
+    async failAndChain(jobId, disposition, next, fence, chainTerminal) {
+      const now = clock.now();
+      return inTransaction(() => {
+        requireFence(fence);
+        requireRow(String(jobId));
+        markFailed.run(disposition.reason, now, String(jobId));
+        const chained = next.map((request) => insertOrGet(request, now));
+        if (chainTerminal !== void 0) recordChainTerminal(chainTerminal, now);
+        return { job: rowToJob(requireRow(String(jobId))), chained };
+      });
+    },
+    async recordFailure(jobId, disposition, fence) {
+      const now = clock.now();
+      inTransaction(() => {
+        requireFence(fence);
+        requireRow(String(jobId));
+        if (disposition.kind === "retry") {
+          const notBefore = disposition.retryAfterMs === void 0 ? null : new Date(Date.parse(now) + disposition.retryAfterMs).toISOString();
+          markRetryable.run(disposition.reason, now, notBefore, String(jobId));
+        } else {
+          markFailed.run(disposition.reason, now, String(jobId));
+        }
+      });
+    },
+    async releaseInterrupted(jobId, fence) {
+      const now = clock.now();
+      inTransaction(() => {
+        requireFence(fence);
+        requireRow(String(jobId));
+        markInterrupted.run(now, String(jobId));
+      });
+    },
+    async requestCancel(jobId, fence) {
+      const now = clock.now();
+      return inTransaction(() => {
+        requireFence(fence);
+        const row = requireRow(String(jobId));
+        const status = String(row.status);
+        if (TERMINAL_JOB_STATUSES.includes(status)) {
+          return { outcome: "already-terminal", status };
+        }
+        if (row.claimed_at !== null) {
+          markCancelRequested.run(now, now, String(jobId));
+          return { outcome: "cancel-requested" };
+        }
+        markCancelledNow.run(now, now, String(jobId));
+        return { outcome: "cancelled" };
+      });
+    },
+    async recordCancellation(jobId, fence) {
+      const now = clock.now();
+      inTransaction(() => {
+        requireFence(fence);
+        const row = requireRow(String(jobId));
+        if (row.cancel_requested_at === null) {
+          throw new JobCancellationNotRequestedError(jobId);
+        }
+        markCancelHonoured.run(now, String(jobId));
+      });
+    },
+    // The 413-13 gap closure, and the checkpoint forget is its load-bearing half.
+    //
+    // Phase 413's pump composed with no post-run capabilities, so the kind registry selected
+    // the STAND-IN analyze-run handler: nineteen rows recorded a `verdicts-authored`
+    // checkpoint and reached `done` with nothing authored. Resetting the status alone would
+    // not undo that, it would REPEAT it — `selectLatestCheckpoint` reads
+    // `ORDER BY attempt DESC`, so the real handler's next attempt would resume on the
+    // stand-in's recorded value, author nothing again, and report completion again. So the
+    // rows go with the status, inside the same transaction, and the files follow the rows.
+    async requeueTerminal(jobId, fence) {
+      const now = clock.now();
+      const decided = inTransaction(() => {
+        requireFence(fence);
+        const row = requireRow(String(jobId));
+        const status = String(row.status);
+        if (isUnreadableKindRow(row)) {
+          throw new QuarantinedJobRequeueError2(String(jobId), String(row.kind));
+        }
+        if (!TERMINAL_JOB_STATUSES.includes(status)) {
+          return { outcome: "not-terminal", status };
+        }
+        const discard = selectCheckpointIdsForJob.all(String(jobId)).map((checkpoint) => String(checkpoint.checkpoint_id));
+        deleteCheckpointsForJob.run(String(jobId));
+        const requeuedRun = runIdOfPayloadColumn(row.payload);
+        if (requeuedRun !== void 0) deleteNotificationForRun.run(requeuedRun);
+        markRequeued.run(now, String(jobId));
+        return { outcome: "requeued", discard };
+      });
+      if (decided.outcome === "requeued") {
+        for (const checkpointId of decided.discard ?? []) {
+          checkpoints.discard(String(jobId), checkpointId);
+        }
+        return { outcome: "requeued" };
+      }
+      return decided;
+    },
+    async publishCheckpoint(jobId, checkpointId, payload, fence) {
+      const now = clock.now();
+      const payloadJson = canonicalJson4(payload);
+      const payloadDigest = sha256hex2(payloadJson);
+      inTransaction(() => {
+        requireFence(fence);
+        requireRow(String(jobId));
+        touchJob.run(now, String(jobId));
+        upsertCheckpoint.run(
+          String(jobId),
+          checkpointId,
+          payload.attempt,
+          payloadJson,
+          payloadDigest,
+          fence.epoch
+        );
+      });
+      if (hooks?.beforeCheckpointFilePublish !== void 0) {
+        await hooks.beforeCheckpointFilePublish();
+      }
+      checkpoints.publish(String(jobId), checkpointId, payload);
+    },
+    async readCheckpoint(jobId, checkpointId) {
+      const row = selectLatestCheckpoint.get(String(jobId), checkpointId);
+      if (row === void 0) return { found: false };
+      const authoritative = {
+        found: true,
+        payload: JSON.parse(String(row.payload_json))
+      };
+      try {
+        const projection = checkpoints.read(String(jobId), checkpointId);
+        if (!projection.found) return authoritative;
+        const projectionDigest = sha256hex2(canonicalJson4(projection.payload));
+        return projectionDigest === String(row.payload_digest) ? projection : authoritative;
+      } catch {
+        return authoritative;
+      }
+    },
+    async dumpState() {
+      return {
+        schemaVersion: AGENT_JOB_STORE_USER_VERSION,
+        epoch: currentEpoch(),
+        // The same ordered read the logical dump uses, so the typed projection and the
+        // equality instrument cannot disagree about which rows exist or in what order.
+        jobs: selectOrderedRows(db, "jobs").rows.map(dumpRow)
+      };
+    },
+    async listNotifications() {
+      return selectNotifications.all().map((row) => ({
+        runId: String(row.run_id),
+        payload: guardRunNotification(JSON.parse(String(row.payload))),
+        createdAt: String(row.created_at)
+      }));
+    },
+    async logicalDump() {
+      return createLogicalDump({
+        db,
+        schemaVersion: AGENT_JOB_STORE_USER_VERSION,
+        checkpointsRoot: checkpoints.checkpointsRoot
+      });
+    },
+    async dumpLogicalState() {
+      return canonicalLogicalDump(
+        createLogicalDump({
+          db,
+          schemaVersion: AGENT_JOB_STORE_USER_VERSION,
+          checkpointsRoot: checkpoints.checkpointsRoot
+        })
+      );
+    }
+  };
+}
+
+// src/store/post-processing-reader.ts
+var CurationSnapshotReadError = class extends Error {
+  name = "CurationSnapshotReadError";
+  constructor() {
+    super("The recorded curation checkpoint is invalid; its snapshot cannot be read.");
+  }
+};
+function recordOf(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    throw new CurationSnapshotReadError();
+  }
+  return value;
+}
+function readCurationSnapshot(db, root, ids, runId) {
+  const checkpointId = "bundle-committed";
+  const row = db.prepare(`SELECT payload_json, payload_digest, attempt FROM job_checkpoints
+    WHERE job_id = ? AND checkpoint_id = ? ORDER BY attempt DESC LIMIT 1`).get(String(ids.curateMemory), checkpointId);
+  if (row === void 0) return void 0;
+  try {
+    const authoritative = JSON.parse(String(row.payload_json));
+    if (sha256hex3(canonicalJson5(authoritative)) !== row.payload_digest) {
+      throw new CurationSnapshotReadError();
+    }
+    let payload = authoritative;
+    try {
+      const cached = readJobCheckpointEnvelope({ root }, String(ids.curateMemory), checkpointId);
+      if (cached.found && sha256hex3(canonicalJson5(cached.envelope.payload)) === row.payload_digest) {
+        payload = cached.envelope.payload;
+      }
+    } catch {
+    }
+    const checkpoint = recordOf(payload);
+    if (checkpoint.jobId !== ids.curateMemory || checkpoint.checkpointId !== checkpointId || checkpoint.attempt !== Number(row.attempt) || !Number.isInteger(checkpoint.attempt) || Number(checkpoint.attempt) < 1 || typeof checkpoint.recordedAt !== "string" || checkpoint.recordedAt.length === 0) throw new CurationSnapshotReadError();
+    const value = recordOf(checkpoint.value);
+    if (value.curationSnapshot === void 0) return void 0;
+    const job = db.prepare("SELECT kind, idempotency_key, payload, attempts FROM jobs WHERE id = ?").get(String(ids.curateMemory));
+    if (job === void 0 || job.kind !== "curate-memory" || job.idempotency_key !== `${ids.analyzeRun}->curate-memory` || Number(job.attempts) < Number(checkpoint.attempt) || recordOf(JSON.parse(String(job.payload))).runId !== runId || value.runId !== runId) throw new CurationSnapshotReadError();
+    return CurationSnapshotSchema.parse(value.curationSnapshot);
+  } catch {
+    throw new CurationSnapshotReadError();
+  }
+}
+function toNumber2(value) {
+  return typeof value === "bigint" ? Number(value) : Number(value);
+}
+function toRow(row) {
+  if (row === void 0) return void 0;
+  const conclusionKind = !isJobKind2(String(row.kind)) && row.status === "failed" && row.last_failure_kind === "permanent" && row.last_failure_reason === QUARANTINED_UNREADABLE_KIND_REASON ? "unreadable_kind" : void 0;
+  return {
+    status: String(row.status),
+    claimed: row.claimed_at !== null,
+    attempts: toNumber2(row.attempts),
+    createdAt: String(row.created_at),
+    updatedAt: String(row.updated_at),
+    ...row.claimed_at === null ? {} : { claimedAt: String(row.claimed_at) },
+    ...row.started_at === null ? {} : { startedAt: String(row.started_at) },
+    ...conclusionKind === void 0 ? {} : { conclusionKind },
+    ...row.last_failure_kind === null ? {} : { lastFailureKind: String(row.last_failure_kind) },
+    ...row.last_failure_reason === null ? {} : { lastFailureReason: String(row.last_failure_reason) }
+  };
+}
+function createPostProcessingReader(options) {
+  const path = join6(options.agentQaRoot, AGENT_JOB_STORE_DB_FILE);
+  return {
+    idSource: options.idSource,
+    async readChain(ids, runId) {
+      if (!existsSync3(path)) return void 0;
+      const db = new DatabaseSync3(path, {
+        readOnly: true,
+        timeout: AGENT_JOB_STORE_BUSY_TIMEOUT_MS
+      });
+      try {
+        const stamped = toNumber2(db.prepare("PRAGMA user_version").get()?.user_version);
+        if (stamped !== 0 && stamped !== AGENT_JOB_STORE_USER_VERSION) {
+          throw new JobStoreSchemaVersionError(path, AGENT_JOB_STORE_USER_VERSION, stamped);
+        }
+        const selectJob = db.prepare(`
+          SELECT kind, status, attempts, created_at, claimed_at, started_at, updated_at,
+                 last_failure_kind, last_failure_reason
+          FROM jobs WHERE id = ?
+        `);
+        const notificationRow = db.prepare("SELECT payload FROM notifications WHERE run_id = ?").get(runId);
+        const analyzeRun = toRow(
+          selectJob.get(String(ids.analyzeRun))
+        );
+        const curateMemory = toRow(
+          selectJob.get(String(ids.curateMemory))
+        );
+        const proposeImprovements = toRow(
+          selectJob.get(String(ids.proposeImprovements))
+        );
+        const notification = notificationRow === void 0 ? void 0 : guardRunNotification2(JSON.parse(String(notificationRow.payload)));
+        const curationSnapshot = readCurationSnapshot(db, options.agentQaRoot, ids, runId);
+        return {
+          ...analyzeRun === void 0 ? {} : { analyzeRun },
+          ...curateMemory === void 0 ? {} : { curateMemory },
+          ...proposeImprovements === void 0 ? {} : { proposeImprovements },
+          ...notification === void 0 ? {} : { notification },
+          ...curationSnapshot === void 0 ? {} : { curationSnapshot }
+        };
+      } finally {
+        db.close();
+      }
+    }
+  };
+}
+
+// src/composition/compose-local-agent.ts
+var resolveHostRetrievalRung = resolveRetrievalRung;
+var LOCAL_KNOWLEDGE_PROBES = Object.freeze({
+  classifyIndexFace,
+  foldRetrievalRung,
+  indexDbPath,
+  readEmbedderWorkerRegistration,
+  readWriterLease,
+  resolveEmbedderCapability
+});
+function resolveEmbedderWorkerEntryPath() {
+  const requireBase = typeof __filename === "string" ? __filename : import.meta.url;
+  const knowledgeEntry = createRequire(requireBase).resolve("@vostride/agent-qa-knowledge-local");
+  return join7(dirname6(knowledgeEntry), "embedder-worker", "worker-entry.js");
+}
+var LOCAL_DAEMON_CAPABILITIES = Object.freeze({
+  acquireWriterLease,
+  heartbeatLease,
+  releaseLease,
+  readWriterLease,
+  deriveWriterLeaseFreshness,
+  isLeaseStale,
+  countPendingCurationJobs,
+  countRemainingCurationWork,
+  inspectDrainableCurationWork,
+  listQueuedCandidates,
+  acquireEmbedder,
+  drainQueue,
+  runMaintenanceTail,
+  resolveEmbedderWorkerEntryPath,
+  readEmbedderWorkerRegistration,
+  embedderWorkerProcessIsAlive,
+  embedderWorkerSocketPath,
+  probeEmbedderWorkerSocket,
+  verifyEmbedderWorkerIncarnation,
+  resolveProcessIncarnation,
+  removeEmbedderWorkerRegistration,
+  resetEmbedderCapability: () => resetEmbedderCapability(DEFAULT_EMBEDDING_PROFILE),
+  pinLocalHeadlessExecutionContext: () => {
+    setActiveExecutionContextResolver(() => "local-headless");
+  }
+});
+function receiptWriter(input) {
+  return createLocalKnowledgeStore({
+    knowledgeRoot: input.knowledgeRoot,
+    executionContext: input.executionContext,
+    writerLeaseId: input.lease.leaseId,
+    epoch: input.lease.epoch,
+    ...input.resolveTrustPriors === void 0 ? {} : { resolveTrustPriors: input.resolveTrustPriors },
+    ...input.resolvePromotionPosture === void 0 ? {} : { resolvePromotionPosture: input.resolvePromotionPosture },
+    ...input.sourceBuildOrdinal === void 0 ? {} : { sourceBuildOrdinal: input.sourceBuildOrdinal },
+    ...input.sourceRunId === void 0 ? {} : { sourceRunId: input.sourceRunId }
+  });
+}
+function recordGateReceipt(input) {
+  return receiptWriter(input).recordGateReceipt(input.receipt);
+}
+function promoteWithReceipts(input) {
+  return receiptWriter(input).promote(input.candidateId, input.receipts);
+}
+function readFeedbackRecord(input) {
+  const matches = enumerateBundleDirs(input.knowledgeRoot).flatMap((entry) => {
+    const result = loadBundle(entry.dir);
+    return result.kind === "loaded" && result.bundle.manifest.id === input.recordId && verifyBundleIntegrity(entry.dir).ok ? [result.bundle] : [];
+  });
+  if (matches.length !== 1) return void 0;
+  const bundle = matches[0];
+  const artifact = input.evidenceRef ?? bundle.artifactsIndex.artifacts[0];
+  if (artifact === void 0) return void 0;
+  return {
+    recordId: input.recordId,
+    kind: bundle.frontmatter.kind,
+    ...bundle.frontmatter.subtype === void 0 ? {} : { subtype: bundle.frontmatter.subtype },
+    anchors: bundle.frontmatter.anchors.map((anchor) => anchor.raw),
+    scope: bundle.frontmatter.scope,
+    summary: bundle.summary,
+    distilledEvidenceRef: { id: artifact.id, sha: artifact.sha },
+    // This is the only admitted draft construction stage; user origin belongs on the delta.
+    originStage: "run-curation"
+  };
+}
+var LOCAL_CURATION_CAPABILITIES = Object.freeze({
+  readFeedbackRecord,
+  appendMarkEvidence,
+  planMarkEvidence,
+  projectMarkEvidenceOutcome,
+  triageMark,
+  servedIdsOn,
+  procedureReadOn,
+  applyFeedback,
+  recordGateReceipt,
+  promoteWithReceipts,
+  openKnowledgeReader: openKnowledgeReader2,
+  drainQueue,
+  foldRunOutcomes,
+  reconcileRunOutcomesProjection,
+  enqueueCurationCandidateProjection,
+  readCanonicalBundleAnchors,
+  readCanonicalBundleStateDigests,
+  readCanaryPostureFacts: canaryPostureFactsFor,
+  readStandingGateReceipts: standingReceiptDigestsFor,
+  readLowerTrustShares: lowerTrustSharesFor,
+  runOutcomesProjectionVersion: RUN_OUTCOMES_PROJECTION_VERSION,
+  canaryOutcomeObservationId,
+  maintenance: Object.freeze({
+    acquireWriterLease,
+    refreshWriterLeaseAuthority,
+    releaseLease,
+    rebuildIndex,
+    purgeRecord,
+    resolvePurgeAffectedSet,
+    purgeAffectedSetFingerprint,
+    rollbackCampaign,
+    rollbackCurationJob,
+    resolveRollbackAffectedSet,
+    rollbackAffectedSetFingerprint
+  })
+});
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isTargetName(value) {
+  return typeof value === "string" && value.trim().length > 0;
+}
+function recordedTargetsOf(artifact) {
+  const source = isRecord(artifact) ? artifact.source : void 0;
+  if (!isRecord(source)) return { status: "unknown" };
+  if (source.kind === "test") {
+    const target = isRecord(source.resolvedDefinition) ? source.resolvedDefinition.target : void 0;
+    return isTargetName(target) ? { status: "recorded", names: [target] } : { status: "unknown" };
+  }
+  if (source.kind !== "suite" || !Array.isArray(source.members)) return { status: "unknown" };
+  const names = /* @__PURE__ */ new Set();
+  for (const member of source.members) {
+    if (!isRecord(member)) return { status: "unknown" };
+    if (member.target === void 0 || member.target === null) continue;
+    if (!isTargetName(member.target)) return { status: "unknown" };
+    names.add(member.target);
+  }
+  return names.size === 0 ? { status: "unknown" } : { status: "recorded", names: [...names].sort() };
+}
+function createRunsReader(agentQaRoot) {
+  function enumerate() {
+    const runsDir = join7(agentQaRoot, RUNS_SUBDIR3);
+    if (!existsSync4(runsDir)) return [];
+    const documents = [];
+    for (const entry of readdirSync3(runsDir, { withFileTypes: true })) {
+      if (!entry.isDirectory()) continue;
+      const handoffPath = join7(runsDir, entry.name, HANDOFF_FILE);
+      if (!existsSync4(handoffPath)) continue;
+      try {
+        documents.push(loadCompletedRunHandoff(handoffPath));
+      } catch {
+        continue;
+      }
+    }
+    return documents;
+  }
+  return {
+    list() {
+      return Promise.resolve(enumerate());
+    },
+    /**
+     * Resolution runs over the ENUMERATED run documents and matches on the recorded `runId`,
+     * never by joining the caller's string onto a path (T-384-08): a `runId` of `../../etc` can
+     * therefore address nothing outside the runs directory, because it is never used to build a
+     * path at all.
+     */
+    get(runId) {
+      return Promise.resolve(enumerate().find((document) => document.runId === runId));
+    },
+    /**
+     * Deep replay of one run's `events.jsonl` through the SAME concrete store the v49 bus appends
+     * with, so a replayed stream is byte-for-byte what the run emitted.
+     *
+     * Two cases are deliberately distinct. An absent or empty log is an ordinary empty replay —
+     * nothing was recorded, so nothing was lost. A log whose earliest surviving seq is ABOVE the
+     * requested resume point means events the caller asked for existed and are gone; that is
+     * reported with the bus's own `ReplayIncompleteError` carrying the floor, never papered over
+     * by returning the surviving suffix (D-07/D-08).
+     */
+    readEvents(runId, fromSeq) {
+      const recorded = [...new FsEventLog2({ root: agentQaRoot, runId }).read(0)].sort((left, right) => left.seq - right.seq);
+      if (recorded.length === 0) return Promise.resolve([]);
+      const earliestAvailableSeq = recorded[0].seq;
+      if (fromSeq < earliestAvailableSeq) {
+        return Promise.reject(new ReplayIncompleteError(fromSeq, earliestAvailableSeq));
+      }
+      return Promise.resolve(recorded.filter((event) => event.seq >= fromSeq));
+    },
+    /**
+     * One step's persisted evidence, read back out of the run's own handoff document
+     * (387 KREV-02 / D-15).
+     *
+     * Through `loadCompletedRunHandoff` — the version guard — and NOT through a raw JSON read,
+     * which is the load-bearing half. 387-02 gave the guard a present-implies-valid clause for
+     * the retrieval trace, so a document whose trace is present but malformed is refused here
+     * rather than reaching the why-verb looking well-formed.
+     *
+     * The ambiguity check is the never-guess law at this seam. `stepIndex` numbers steps per
+     * MEMBER TEST, so a run with two tests has two step 0s; when the address does not name a
+     * test and more than one candidate answers to it, this reports the candidates rather than
+     * picking whichever test the document happened to list first. Picking would have produced a
+     * confident, wrong answer to a question that was never asked — and a why-verb that does
+     * that is worse than one that refuses, because its answer looks exactly like a right one.
+     */
+    readStepEvidence(runId, address) {
+      const document = enumerate().find((candidate) => candidate.runId === runId);
+      if (document === void 0) return Promise.resolve({ kind: "run-not-recorded" });
+      const candidates = document.tests.filter((test) => (address.testId === void 0 || test.testId === address.testId) && test.steps.some((step) => step.stepIndex === address.stepIndex));
+      if (candidates.length === 0) return Promise.resolve({ kind: "step-not-found" });
+      if (candidates.length > 1) {
+        return Promise.resolve({
+          kind: "ambiguous-step-address",
+          // Sorted, so the refusal a surface prints is the same list twice running.
+          testIds: candidates.map((test) => test.testId).sort()
+        });
+      }
+      const evidence = candidates[0].steps.find((step) => step.stepIndex === address.stepIndex);
+      return Promise.resolve(
+        evidence === void 0 ? { kind: "step-not-found" } : { kind: "found", evidence }
+      );
+    },
+    /**
+     * Resolved over the ENUMERATED run directories (T-384-08, T-431-01): the caller's id is only
+     * ever compared, never joined onto a path, and the directory must hold a completed handoff
+     * recording that same id, so one run's snapshot can never answer for another. A snapshot that
+     * is absent, unreadable or gone since `list()` answered is `unknown`, never an error.
+     */
+    getRecordedTargets(runId) {
+      const runsDir = join7(agentQaRoot, RUNS_SUBDIR3);
+      if (!existsSync4(runsDir)) return Promise.resolve({ status: "unknown" });
+      const entry = readdirSync3(runsDir, { withFileTypes: true }).find((candidate) => candidate.isDirectory() && candidate.name === runId);
+      if (entry === void 0) return Promise.resolve({ status: "unknown" });
+      try {
+        const runDir = join7(runsDir, entry.name);
+        if (loadCompletedRunHandoff(join7(runDir, HANDOFF_FILE)).runId !== runId) {
+          return Promise.resolve({ status: "unknown" });
+        }
+        return Promise.resolve(
+          recordedTargetsOf(JSON.parse(readFileSync4(join7(runDir, ARTIFACT_FILE), "utf8")))
+        );
+      } catch {
+        return Promise.resolve({ status: "unknown" });
+      }
+    }
+  };
+}
+function createKnowledgeReader(resolveKnowledgeRoot, sightMemoryEntities, resolvePromotionPosture, resolveTrustPriors) {
+  return createKnowledgeReaderPort({
+    resolveKnowledgeRoot,
+    ...resolveTrustPriors === void 0 ? {} : { resolveTrustPriors },
+    ...resolvePromotionPosture === void 0 ? {} : { resolvePromotionPosture },
+    ...sightMemoryEntities === void 0 ? {} : { sightMemoryEntities }
+  });
+}
+function knowledgeChangeOutput(verb, operationId, result) {
+  switch (result.outcome) {
+    case "applied":
+      return {
+        outcome: "applied",
+        verb,
+        operationId,
+        recordIds: [...result.recordIds],
+        ...result.forgetReceipt === void 0 ? {} : { forgetReceipt: result.forgetReceipt },
+        ...result.commitReceipt === void 0 ? {} : { commitReceipt: result.commitReceipt }
+      };
+    case "target-not-found":
+      return { outcome: "target-not-found", verb, operationId, target: result.target };
+    case "policy-materialize-refused":
+      return { outcome: "refused", verb, operationId, reason: "policy-materialize-refused" };
+    default:
+      return result;
+  }
+}
+function createKnowledgeReview(input) {
+  async function roots() {
+    return { knowledgeRoot: await input.resolveKnowledgeRoot() };
+  }
+  let changeChain = Promise.resolve();
+  function serialized(work) {
+    const next = changeChain.then(work, work);
+    changeChain = next.then(() => void 0, () => void 0);
+    return next;
+  }
+  return {
+    // 432-12 (D-04/D-05/D-09): one explicit change, applied in the call through the direct writer
+    // (432-06). Nothing is filed: the change is committed under the lease, handed to a live
+    // holder, or refused by type. A missing identity is minted here, once per call, and returned on
+    // the receipt so the caller can retry the same change.
+    change: (request) => serialized(async () => {
+      const { knowledgeRoot } = await roots();
+      const operationId = request.operationId ?? randomUUID3();
+      const authority = input.resolveWriterAuthority?.();
+      const result = await applyKnowledgeChange({
+        agentQaRoot: input.agentQaRoot,
+        knowledgeRoot,
+        request: { verb: request.verb, input: request.input },
+        operationId,
+        // The op that made the change, stamped on Gate-3 receipts: `knowledge.accept`,
+        // `knowledge.reject` or `knowledge.forget`, which is the verb's own op id.
+        opId: `knowledge.${request.verb}`,
+        executionContext: (input.resolveExecutionContext ?? getActiveExecutionContext)(),
+        ...input.resolveTrustPriors === void 0 ? {} : { resolveTrustPriors: input.resolveTrustPriors },
+        ...input.resolvePromotionPosture === void 0 ? {} : { resolvePromotionPosture: input.resolvePromotionPosture },
+        ...input.knowledgeChangeDelegate === void 0 ? {} : { delegate: input.knowledgeChangeDelegate },
+        ...authority === void 0 ? {} : { writerAuthority: authority }
+      });
+      return knowledgeChangeOutput(request.verb, operationId, result);
+    })
+    // 2026-10-01 (432-17, D-05/D-22): `propose` and `apply` are deleted with the proposal inbox.
+  };
+}
+async function applyKnowledgeChange(input) {
+  const posture = await input.resolvePromotionPosture?.();
+  const ledger = openAddressingLedgerForReview({
+    path: join7(input.agentQaRoot, ADDRESSING_LEDGER_DB_FILE)
+  });
+  try {
+    return await applyExplicitReview({
+      agentQaRoot: input.agentQaRoot,
+      knowledgeRoot: input.knowledgeRoot,
+      request: input.request,
+      operationId: input.operationId,
+      opId: input.opId,
+      executionContext: input.executionContext,
+      resolveBundleShortId: (shortId) => ledger.lookupByShortId(shortId)?.machineId,
+      ...input.resolveTrustPriors === void 0 ? {} : { resolveTrustPriors: input.resolveTrustPriors },
+      ...posture === void 0 ? {} : { resolvePromotionPosture: posture },
+      ...input.delegate === void 0 ? {} : { delegate: input.delegate },
+      ...input.writerAuthority === void 0 ? {} : { writerAuthority: input.writerAuthority }
+    });
+  } finally {
+    ledger.close();
+  }
+}
+function createEntityDirectory(input) {
+  return {
+    resolve(ref) {
+      return withEntityResolutionDeps(input, (deps) => resolveEntityRef(ref, deps));
+    },
+    get(ref) {
+      return withEntityResolutionDeps(input, (deps) => getEntityDescriptor(ref, deps));
+    }
+  };
+}
+function createMemorySightingHook(input) {
+  return (bundleIds) => withEntityResolutionDeps(input, (deps) => {
+    for (const bundleId of bundleIds) sightEntity(bundleId, deps);
+  });
+}
+async function withEntityResolutionDeps(input, body) {
+  const knowledgeRoot = await input.resolveKnowledgeRoot();
+  const ledger = openAddressingLedger({
+    path: join7(input.agentQaRoot, ADDRESSING_LEDGER_DB_FILE)
+  });
+  const entityIndex = openEntityIndex({ path: entityIndexDbPath(knowledgeRoot), knowledgeRoot });
+  try {
+    return await body({
+      ledger,
+      entityIndex,
+      // One kind is wired by the tracer. 387-03 registers the remaining sources here and
+      // neither the resolver nor the ops change — which is the property the tracer exists
+      // to establish before anything expands.
+      sources: [createMemorySightingSource(() => knowledgeRoot)]
+    });
+  } finally {
+    entityIndex.close();
+    ledger.close();
+  }
+}
+async function sweepEntityIndexProjection(input) {
+  const knowledgeRoot = await input.resolveKnowledgeRoot();
+  const ledger = openAddressingLedger({
+    path: join7(input.agentQaRoot, ADDRESSING_LEDGER_DB_FILE)
+  });
+  const entityIndex = openEntityIndex({ path: entityIndexDbPath(knowledgeRoot), knowledgeRoot });
+  try {
+    const report = sweepEntityIndex(entityIndex, describeAllEntities({
+      ledger,
+      sources: [createMemorySightingSource(() => knowledgeRoot)]
+    }));
+    let embedded = 0;
+    const acquire = input.acquireEmbedderCapability ?? acquireEmbedder;
+    const capability = await acquire({
+      preferredProfile: DEFAULT_EMBEDDING_PROFILE,
+      allowDownload: false,
+      agentQaRoot: input.agentQaRoot
+    });
+    if (capability.kind === "ready") {
+      embedded = await embedPendingEntities(
+        entityIndex,
+        capability.embedder,
+        capability.profile
+      );
+    }
+    return { ...report, embedded };
+  } finally {
+    entityIndex.close();
+    ledger.close();
+  }
+}
+var RunProducedNoEventsError = class extends Error {
+  constructor(runId) {
+    super(
+      `The host reported run ${runId}, but no run events were recorded for it. A run that started at all writes runStarted before anything else, so an empty event log means no run took place under that id.`
+    );
+    this.runId = runId;
+    this.name = "RunProducedNoEventsError";
+  }
+};
+function createLocalRunInvocation(input) {
+  return {
+    async start(request) {
+      const started = await input.execution.execute(request);
+      const { eventLog } = buildRunPorts({
+        configDir: dirname6(input.agentQaRoot),
+        runId: String(started.runId)
+      });
+      if (eventLog.read(0).length === 0) {
+        throw new RunProducedNoEventsError(String(started.runId));
+      }
+      return started;
+    }
+  };
+}
+var EMPTY_FINGERPRINT_SNAPSHOT = {
+  union: /* @__PURE__ */ new Set(),
+  covered: [],
+  elements: /* @__PURE__ */ new Map()
+};
+function draftIdentityKey(identity) {
+  return `${identity.filePath}\0${identity.testName}`;
+}
+function readSuiteFingerprints(knowledgeRoot, product, draft) {
+  const path = indexDbPath(knowledgeRoot);
+  if (!existsSync4(path)) return EMPTY_FINGERPRINT_SNAPSHOT;
+  const db = new DatabaseSync4(path, { readOnly: true });
+  try {
+    const index = createSuiteFingerprintIndex(db, { product });
+    const draftKey = draftIdentityKey(draft);
+    const covered = index.coveredTests().filter((identity) => draftIdentityKey(identity) !== draftKey);
+    const elements = /* @__PURE__ */ new Map();
+    const union = /* @__PURE__ */ new Set();
+    for (const identity of covered) {
+      const own = index.elementsForTest(identity.filePath, identity.testName);
+      elements.set(draftIdentityKey(identity), own);
+      for (const element of own) union.add(element);
+    }
+    return { union, covered, elements };
+  } catch (error) {
+    if (error instanceof Error && error.message.includes("no such table")) {
+      return EMPTY_FINGERPRINT_SNAPSHOT;
+    }
+    throw error;
+  } finally {
+    db.close();
+  }
+}
+function createDraftEvaluation(input) {
+  return {
+    resolveDraft(draftPath) {
+      return input.authoring.parseDraft(draftPath);
+    },
+    async openEvaluation(draft) {
+      const knowledgeRoot = await input.knowledgeRoot();
+      const draftIdentity = {
+        filePath: draft.filePath,
+        testName: draft.testName
+      };
+      const draftKey = draftIdentityKey(draftIdentity);
+      const textCorpus = (await input.authoring.suiteTextCorpus()).filter(
+        (entry) => draftIdentityKey(entry) !== draftKey
+      );
+      let observedProduct;
+      let snapshot;
+      const fingerprints = () => {
+        if (snapshot !== void 0) return snapshot;
+        snapshot = observedProduct === void 0 ? EMPTY_FINGERPRINT_SNAPSHOT : readSuiteFingerprints(knowledgeRoot, observedProduct, draftIdentity);
+        return snapshot;
+      };
+      return {
+        runs: {
+          async start(request) {
+            const acknowledgement = await input.startGateRun(request);
+            observedProduct ??= slugBranch4(acknowledgement.scope.key);
+            return acknowledgement;
+          },
+          get: (runId) => input.readRun(runId)
+        },
+        fingerprints: {
+          elementUnion: () => fingerprints().union,
+          coveredTests: () => fingerprints().covered,
+          elementsForTest: (filePath, testName) => fingerprints().elements.get(draftIdentityKey({ filePath, testName })) ?? []
+        },
+        textCorpus,
+        // D-19: the gitignored per-draft receipt store, bound over `agentQaRoot` beside the
+        // proposals inbox and for its reason — a receipt is machine-local working state under the
+        // runtime root, not a committed artifact a pull request has any business showing.
+        receipts: createDraftReceiptsStore({ resolveAgentQaRoot: () => input.agentQaRoot }),
+        // D-14's live arm (394-17, step c). `product` is the SAME `observedProduct` gate 3's index
+        // is opened against — read off the first gate-run acknowledgment, never derived from
+        // configuration — so the stability read and the suite index can never be asking about two
+        // different applications. Before any run is acknowledged it is `undefined` and the
+        // consultation is skipped; D-04 forbids short-circuiting, so a flip cannot be observed
+        // until at least one run has been.
+        suiteStability: {
+          port: input.authoringFunnel,
+          product: () => observedProduct
+        }
+      };
+    }
+  };
+}
+var AUTHORING_GATE_RUN_CALLER = Object.freeze({
+  surface: "authoring",
+  origin: "agent"
+});
+var AUTHORING_LOOP_VERIFY_CALLER = Object.freeze({
+  surface: "authoring",
+  origin: "agent"
+});
+var SYSTEM_CLOCK = Object.freeze({
+  now: () => (/* @__PURE__ */ new Date()).toISOString()
+});
+var digestJobIdSource = {
+  jobIdFor: (kind, idempotencyKey) => asJobId2(`job_${sha256hex16(`${kind} ${idempotencyKey}`)}`)
+};
+var DIGEST_JOB_ID_SOURCE = Object.freeze(digestJobIdSource);
+var LocalAgentClosedError = class extends Error {
+  constructor(agentQaRoot) {
+    super(
+      `The local agent composition for ${agentQaRoot} is closed. A closed composition cannot reopen its job store; create a new composition with fresh lifecycle ownership instead.`
+    );
+    this.agentQaRoot = agentQaRoot;
+  }
+  name = "LocalAgentClosedError";
+};
+var UNCLAIMABLE_BY_PROSE_POSTURE = Object.freeze({
+  // Frozen to the same depth it is read at (WR-11). The shallow freeze every sibling table
+  // here uses is not enough for this one: the VALUES are the arrays the queue claims
+  // against, so an unfrozen inner array is a writable disclosure guard reachable from any
+  // module that can import the table.
+  "masker-active": Object.freeze([]),
+  "no-masker": Object.freeze(["curate-memory"])
+});
+function readProjectedTestHistory(knowledgeRoot, query) {
+  const path = indexDbPath(knowledgeRoot);
+  if (!existsSync4(path)) return void 0;
+  const db = new DatabaseSync4(path, { readOnly: true });
+  try {
+    return readTestOutcomeHistory(db, {
+      product: query.product,
+      filePath: query.filePath,
+      testName: query.testName
+    });
+  } catch (error) {
+    if (error instanceof Error && error.message.includes("no such table")) return void 0;
+    throw error;
+  } finally {
+    db.close();
+  }
+}
+function readProjectedRecurrence(knowledgeRoot, query) {
+  const path = indexDbPath(knowledgeRoot);
+  if (!existsSync4(path)) return void 0;
+  const db = new DatabaseSync4(path, { readOnly: true });
+  try {
+    const history = readTestOutcomeHistory(db, {
+      product: query.product,
+      filePath: query.filePath,
+      testName: query.testName
+    });
+    if (history === void 0) return void 0;
+    const currentBuildOrdinal = history.lastBuildOrdinal ?? history.lastOutcomes.reduce((max, entry) => Math.max(max, entry.buildOrdinal), 0);
+    if (query.fingerprint === void 0) return failureRecurrence(history, currentBuildOrdinal);
+    const windowed = fingerprintRecurrence(
+      db,
+      { product: query.product, fingerprint: query.fingerprint },
+      currentBuildOrdinal
+    );
+    return { kth: windowed.occurrenceOrdinals, windowBuilds: windowed.windowOrdinals };
+  } catch (error) {
+    if (error instanceof Error && error.message.includes("no such table")) return void 0;
+    throw error;
+  } finally {
+    db.close();
+  }
+}
+var LADDER_STATE_FOR_ENTRY = {
+  quarantined: "quarantined",
+  expired: "expired",
+  released: void 0
+};
+function readQuarantineLadder(knowledgeRoot, identity, now, recurrence) {
+  const entries = foldQuarantineLedgerState2(readQuarantineLedger2(knowledgeRoot).events, now);
+  const entry = entries.find((candidate) => candidate.product === identity.product && candidate.filePath === identity.filePath && candidate.testName === identity.testName);
+  const state = entry === void 0 ? void 0 : LADDER_STATE_FOR_ENTRY[entry.state];
+  if (entry !== void 0 && state !== void 0) return { state, expiresAt: entry.expiresAt };
+  if (recurrence.kth >= QUARANTINE_FLAG_FLOOR) return { state: "flagged" };
+  return void 0;
+}
+function createProjectionRecurrenceProvider(resolveKnowledgeRoot, now) {
+  let root;
+  let resolving;
+  function beginResolve() {
+    if (resolving !== void 0) return resolving;
+    let answer;
+    try {
+      answer = resolveKnowledgeRoot();
+    } catch {
+      return void 0;
+    }
+    if (typeof answer === "string") {
+      root = answer;
+      return void 0;
+    }
+    resolving = answer.then(
+      (value) => {
+        root = value;
+      },
+      () => {
+        resolving = void 0;
+      }
+    );
+    return resolving;
+  }
+  function rootNow() {
+    if (root !== void 0) return root;
+    beginResolve();
+    return root;
+  }
+  return {
+    prime() {
+      if (root !== void 0) return Promise.resolve();
+      return beginResolve() ?? Promise.resolve();
+    },
+    provider: {
+      failureRecurrence(query) {
+        const knowledgeRoot = rootNow();
+        if (knowledgeRoot === void 0) return void 0;
+        const recurrence = readProjectedRecurrence(knowledgeRoot, query);
+        if (recurrence === void 0) return void 0;
+        const ladder = readQuarantineLadder(knowledgeRoot, query, now(), recurrence);
+        return ladder === void 0 ? recurrence : { ...recurrence, ladder };
+      }
+    }
+  };
+}
+function createAnalysisArtifactReader(agentQaRoot) {
+  return {
+    getArtifact(runId) {
+      const path = join7(agentQaRoot, RUNS_SUBDIR3, slugBranch4(runId), ANALYSIS_FILE);
+      let bytes;
+      try {
+        bytes = readFileSync4(path, "utf8");
+      } catch (error) {
+        if (error.code === "ENOENT") return void 0;
+        throw error;
+      }
+      const admission = admitAnalysisArtifactForRun(
+        guardRunAnalysisArtifact(JSON.parse(bytes)),
+        runId
+      );
+      return admission.kind === "admitted" ? admission.artifact : void 0;
+    }
+  };
+}
+function postRunCapabilities(input, knowledgeRoot, analysisTokenBudget, jobStore, proposeGate1MaxPerJob) {
+  const postRun = input.postRun;
+  if (postRun === void 0) return void 0;
+  return {
+    // 422 D-14: ONE narrow read — this job's own durable Gate-1 charge, addressed by its own id,
+    // through the authoritative `readCheckpoint` the store already publishes. The handler is
+    // handed no store, no checkpoint reader and no path; the shape check is `agent`'s, beside
+    // the shape it checks, so two hosts cannot disagree about what a readable charge is.
+    ...jobStore === void 0 ? {} : {
+      readProposeGate1Allowance: async (jobId) => parseProposeGate1Allowance(
+        await jobStore.readCheckpoint(asJobId2(jobId), PROPOSE_GATE1_ALLOWANCE_CHECKPOINT)
+      )
+    },
+    loadCompletedRunHandoff: (runId) => loadCompletedRunHandoff(
+      join7(input.agentQaRoot, RUNS_SUBDIR3, slugBranch4(runId), HANDOFF_FILE)
+    ),
+    curateRun: postRun.curateRun,
+    // 422 D-13: spread on the conditional idiom this file uses throughout, so an unbound port
+    // is an ABSENT member rather than a present `undefined` — the handler decides on presence,
+    // in one place, and a host that declined to bind cannot be mistaken for one that bound a
+    // hole.
+    ...postRun.stageAdversarialProposal === void 0 ? {} : { stageAdversarialProposal: postRun.stageAdversarialProposal },
+    // 422-09 (D-14): the Gate-1 leg's four ports and its bound, forwarded on the same
+    // presence-spread idiom one line up. The handler's own `screenGate1` requires ALL FOUR before
+    // it screens anything, so a host that binds three of them is a host that screens nothing —
+    // which is why they are forwarded one by one rather than as a bundle a caller could
+    // half-populate without noticing.
+    ...postRun.runReplayGate === void 0 ? {} : { runReplayGate: postRun.runReplayGate },
+    ...postRun.listBundles === void 0 ? {} : { listBundles: postRun.listBundles },
+    ...postRun.gateReceiptsFor === void 0 ? {} : { gateReceiptsFor: postRun.gateReceiptsFor },
+    ...postRun.readProposeCorpusPosture === void 0 ? {} : { readProposeCorpusPosture: postRun.readProposeCorpusPosture },
+    ...postRun.readMisdirectionRootPosture === void 0 ? {} : { readMisdirectionRootPosture: postRun.readMisdirectionRootPosture },
+    ...proposeGate1MaxPerJob === void 0 ? {} : { proposeGate1MaxPerJob },
+    // 389 D-09: the artifact's path is DERIVED from the artifact's own runId through the
+    // same `runs/<slug>/` law as the handoff read above — `slugBranch` is the traversal
+    // guard (T-389-01), and a job payload never carries a path.
+    persistAnalysis: (artifact) => writeAnalysisArtifact(
+      join7(input.agentQaRoot, RUNS_SUBDIR3, slugBranch4(artifact.runId), ANALYSIS_FILE),
+      artifact
+    ),
+    // Plan 02's read side over the derived projection, keyed the projection's way —
+    // (product, filePath, testName), the stable identity, NEVER a per-run explicit id.
+    // The query arrives already keyed by the author callback; this binding only reads.
+    readTestHistory: (query) => readProjectedTestHistory(knowledgeRoot, query),
+    // D-02's sha-addressed screenshot bytes: the SAME CASS-02 store the runner writes.
+    // `FsEvidenceArtifactStore.getBlob` validates the lowercase 64-hex shape BEFORE any
+    // path use (T-389-14) and answers ENOENT as honest absence; the runId becomes a path
+    // segment only through `slugBranch` inside the store's own constructor.
+    //
+    // 405-05: THROUGH THE SHARED RULE, not a lambda of its own. `runs.artifact` binds a port over
+    // the same `lookupEvidenceBlob` below, and two lambdas over one store would be two answers to
+    // where a run's blobs live — agreeing on the day the second is written and diverging the first
+    // time either side changes a root. This job wants only the found bytes, so the three-arm
+    // lookup collapses here; the SPLIT is what the op needs and what this caller does not.
+    readEvidenceBlob: (runId, sha) => readEvidenceBlobBytes({ agentQaRoot: input.agentQaRoot }, runId, sha),
+    // Host-resolved and passed through untouched (386 D-15): the budget derives from the
+    // same profile resolution as the job model, and this composition adds no knob of its own.
+    ...analysisTokenBudget === void 0 ? {} : { analysisTokenBudget }
+  };
+}
+var CHAT_RESOLVER_CALLER = Object.freeze({
+  surface: "chat",
+  origin: "human"
+});
+var CHAT_PLANNER_CALLER = Object.freeze({
+  surface: "chat",
+  origin: "agent"
+});
+function chatToolsetIds(registry) {
+  if (registry === void 0) return [];
+  return registry.list(CHAT_RESOLVER_CALLER).map((declaration) => declaration.id).sort();
+}
+function chatToolsetHash(registry) {
+  if (registry === void 0) return "unbound";
+  return sha256hex16(chatToolsetIds(registry).join("\n"));
+}
+function projectChatMembers(value, rules, mask) {
+  return Object.fromEntries(Object.entries(value).map(([key, member]) => {
+    const rule = Object.hasOwn(rules, key) ? rules[key] : "tree";
+    if (rule === "as-written") return [key, member];
+    if (typeof rule === "function") return [key, rule(member, mask)];
+    if (rule === "text" && typeof member === "string") return [key, mask(member)];
+    return [key, maskPayloadTree(member, mask)];
+  }));
+}
+var eachChatRecord = (rules) => (value, mask) => {
+  const project = (entry) => isRecord(entry) ? projectChatMembers(entry, rules, mask) : maskPayloadTree(entry, mask);
+  return Array.isArray(value) ? value.map(project) : project(value);
+};
+var CHAT_EVENT_BASE = {
+  kind: "as-written",
+  turnId: "as-written",
+  at: "as-written"
+};
+var CHAT_CLAUSE_RECEIPT_RULES = {
+  clause: "text",
+  functionId: "as-written",
+  origin: "as-written",
+  status: "as-written",
+  outcome: "text"
+};
+var CHAT_EVENT_RULES = {
+  user_message: { ...CHAT_EVENT_BASE, text: "text" },
+  stage_outcome: { ...CHAT_EVENT_BASE, stage: "as-written", outcome: "as-written" },
+  clause_receipt: { ...CHAT_EVENT_BASE, ...CHAT_CLAUSE_RECEIPT_RULES },
+  clause_result: { ...CHAT_EVENT_BASE, functionId: "as-written", payload: "tree" },
+  approval_decision: {
+    ...CHAT_EVENT_BASE,
+    actionClass: "as-written",
+    decision: "as-written",
+    source: "as-written"
+  },
+  mark_unhandled: { ...CHAT_EVENT_BASE, clause: "text", reason: "text" },
+  model_change: { ...CHAT_EVENT_BASE, from: "text", to: "text", source: "as-written" },
+  active_tools_change: {
+    ...CHAT_EVENT_BASE,
+    addedIds: "as-written",
+    removedIds: "as-written",
+    toolsetHash: "as-written"
+  },
+  compaction: {
+    ...CHAT_EVENT_BASE,
+    beforeTokens: "as-written",
+    afterTokens: "as-written",
+    outcome: "as-written"
+  },
+  aborted: { ...CHAT_EVENT_BASE, source: "as-written" },
+  turn_complete: { ...CHAT_EVENT_BASE, status: "as-written" }
+};
+var CHAT_INVOKE_ANSWER_RULES = {
+  payload: "tree",
+  verdict: eachChatRecord({ status: "as-written", outcome: "text" }),
+  foldLines: "tree"
+};
+var CHAT_TURN_RESULT_RULES = {
+  sessionId: "as-written",
+  turnId: "as-written",
+  status: "as-written",
+  answer: "text",
+  receipts: eachChatRecord(CHAT_CLAUSE_RECEIPT_RULES),
+  results: eachChatRecord({ functionId: "as-written", payload: "tree" }),
+  unhandled: eachChatRecord({ clause: "text", reason: "text" }),
+  refusedLineCount: "as-written"
+};
+function projectChatSessionEvent(event, mask) {
+  const rules = Object.hasOwn(CHAT_EVENT_RULES, event.kind) ? CHAT_EVENT_RULES[event.kind] : CHAT_EVENT_BASE;
+  return projectChatMembers(event, rules, mask);
+}
+function composeLocalAgent(input) {
+  const clock = input.clock ?? SYSTEM_CLOCK;
+  const entityResolutionInput = {
+    agentQaRoot: input.agentQaRoot,
+    resolveKnowledgeRoot: input.knowledgeRoot
+  };
+  const recurrence = createProjectionRecurrenceProvider(input.knowledgeRoot, () => clock.now());
+  const runsReader = createRunsReader(input.agentQaRoot);
+  let composedRegistry;
+  const composedChatModelName = input.chatModel === void 0 ? "unbound" : input.chatModel.modelId;
+  const chatScopes = /* @__PURE__ */ new Map();
+  const chatScopeFor = (sessionId) => {
+    const existing = chatScopes.get(sessionId);
+    if (existing !== void 0) return existing;
+    if (composedRegistry === void 0) {
+      throw new TypeError("a chat session opened before its registry finished composing");
+    }
+    const scope = {
+      // An UNBORN session has run no `/model`, so it opens under the model this host composed —
+      // which is also what its header will say. A container seeded from another session's override
+      // would make one conversation's verb the next conversation's opening posture.
+      state: createChatState({ activeModel: composedChatModelName })
+      // 432-13 (D-14): no pin holder. `/pin` left chat resolution with the op gate it tightened.
+    };
+    chatScopes.set(sessionId, scope);
+    return scope;
+  };
+  const chatModelNameFor = (sessionId) => chatScopeFor(sessionId).state.read().activeModel;
+  const chatModelsByName = /* @__PURE__ */ new Map();
+  if (input.chatModel !== void 0) chatModelsByName.set(composedChatModelName, input.chatModel);
+  const chatSessionLog = createJsonlSessionLog({
+    root: input.agentQaRoot,
+    now: () => clock.now(),
+    // THE COMPOSED MODEL, not a session's override, and the difference is a leak this keying closes.
+    // This thunk is read when a header is WRITTEN, which happens exactly once per session and only
+    // for a session that has not existed until now — so no `/model` can have run in it. Answering
+    // with a live override would stamp one conversation's switch onto the opening header of every
+    // conversation opened after it. 441 GAP3-D4: written and listed through the declared mask.
+    model: () => input.mask(composedChatModelName),
+    toolsetHash: () => chatToolsetHash(composedRegistry)
+  });
+  const liveChatSessions = /* @__PURE__ */ new Map();
+  const trackedChatSessionLog = {
+    async open(sessionId) {
+      const opened2 = await chatSessionLog.open(sessionId);
+      const id = opened2.header.sessionId;
+      const turnIds = /* @__PURE__ */ new Set();
+      const tracked = {
+        header: opened2.header,
+        events: opened2.events,
+        refusedLines: opened2.refusedLines,
+        append: async (event) => {
+          const projected = projectChatSessionEvent(event, input.mask);
+          turnIds.add(projected.turnId);
+          await opened2.append(projected);
+          try {
+            input.observeSessionEvent?.(id, projected);
+          } catch {
+          }
+        },
+        turnBoundary: () => opened2.turnBoundary(),
+        close: async () => {
+          liveChatSessions.delete(id);
+          await opened2.close();
+        }
+      };
+      liveChatSessions.set(id, { handle: tracked, turnIds });
+      return tracked;
+    }
+  };
+  const chatSessionHoldingTurn = (turnId) => {
+    for (const entry of liveChatSessions.values()) {
+      if (entry.turnIds.has(turnId)) return entry.handle;
+    }
+    return void 0;
+  };
+  const plannerStages = /* @__PURE__ */ new Map();
+  const chatPlanner = input.chatModel === void 0 ? void 0 : {
+    plan: (request) => {
+      if (composedRegistry === void 0) {
+        throw new TypeError("a chat turn ran before its registry finished composing");
+      }
+      const activeName = chatModelNameFor(request.sessionId);
+      let stage = plannerStages.get(activeName);
+      if (stage === void 0) {
+        stage = createPlannerStage({
+          model: chatModelsByName.get(activeName) ?? input.chatModel,
+          tools: projectPlannerTools(composedRegistry, CHAT_PLANNER_CALLER),
+          // Read PER REQUEST — not per turn and not per stage (392 plan 13, CR-02). A stage
+          // is shared by every session planning under the same model name, so a context
+          // thunk taking no argument had exactly one conversation to answer with, and on
+          // two interleaved turns it answered with whichever one published last. Taking the
+          // requesting session's id makes "the conversation this request replays" a fact
+          // about the call. The read is still LIVE, so a `/model` override still moves what
+          // the prompt states without the stage being rebuilt, and the conversation block
+          // still carries what compaction left rather than a second replay of the log.
+          context: (contextRequest) => {
+            const scope = chatScopeFor(contextRequest.sessionId).state.read();
+            return { activeModel: scope.activeModel, conversation: scope.conversation };
+          }
+        });
+        plannerStages.set(activeName, stage);
+      }
+      return stage.plan(request);
+    }
+  };
+  const chatCompaction = input.chatAccounting === void 0 ? void 0 : createChatCompactionHook({
+    accounting: input.chatAccounting,
+    now: () => clock.now(),
+    // 392-06's flagged consumer, wired: what compaction leaves IS the conversation the
+    // prompt renders, and it lands in the live state on EVERY turn rather than only on a
+    // triggered pass — a sink that fired only when a pass ran would leave the prompt holding
+    // a stale conversation on every quiet turn. Into the SESSION'S OWN container (plan 13):
+    // the id is the compacted turn's, so a pruned history cannot land in another
+    // conversation however many turns are in flight.
+    onConversation: (messages, sessionId) => {
+      chatScopeFor(sessionId).state.setConversation(messages);
+    }
+  });
+  const chatTurn = createTurnEngine({
+    table: CHAT_RESOLVER_TABLE,
+    // 392 plan 02, D-09: the real conjunction grammar, quote-aware. The tracer's
+    // whole-utterance placeholder is gone; this is the seam filled, not widened.
+    split: splitClauses,
+    reconcile: input.chatReconcile ?? deterministicOverrideStrategy,
+    sessionLog: trackedChatSessionLog,
+    // RESEARCH Pitfall 1: per-STAGE minting, because origin is a per-call fact. A deterministic
+    // table hit is a person typing and mints `human`; a planner-planned call mints `agent`, and the
+    // turn's receipts record which.
+    // 2026-10-01 (432-21, D-12): NOT STAMPED WITH THE SESSION ANY MORE. The session id rode the
+    // caller for the gate's deny overlay (plan 13, W-03) and the overlay is deleted (432-13/18/19);
+    // nothing reads `FunctionCaller.sessionId`. The session still reaches the ops that record it
+    // through the turn's own session facts, not through the caller.
+    mint: {
+      forStage: (stage) => stage === "resolver" ? CHAT_RESOLVER_CALLER : CHAT_PLANNER_CALLER
+    },
+    // 399.1 D-01/D-03/D-05: the classified envelope, built HERE because this closure is the one
+    // place in the system holding both the registry and the invoke call. The chat subtree cannot
+    // reach a spec by construction (384 FUNC-03), so the verdict and the render fold have to arrive
+    // as data on this return — which is what `ChatInvokeAnswer` is. `foldFunctionResult` owns the
+    // fail-closed rule so both composition roots get the same one rather than a copy each.
+    //
+    // invokeFunction validates canonical output; it does not promise masking. Classify those
+    // original bytes before projecting the answer into results[] and the durable clause_result.
+    invoke: async (functionId, invokeInput, caller) => {
+      if (composedRegistry === void 0) {
+        throw new TypeError("a chat turn ran before its registry finished composing");
+      }
+      const payload = await invokeFunction(composedRegistry, functionId, invokeInput, caller);
+      const fold = foldFunctionResult(composedRegistry, functionId, payload);
+      return projectChatMembers({ payload, ...fold }, CHAT_INVOKE_ANSWER_RULES, input.mask);
+    },
+    ...chatPlanner === void 0 ? {} : { planner: chatPlanner },
+    ...chatCompaction === void 0 ? {} : { compaction: chatCompaction },
+    // 392 plan 08: the directive handlers, which is what turns the engine's
+    // `directive recognised but no handler` refusal from the shipped behaviour into an
+    // unreachable arm on this host. `/help` and `/quit` are REPL chrome and answer in prose;
+    // `/model` changes what the session is and returns the EFFECT it had. (432-13: `/pin` is gone.)
+    //
+    // RESOLVED PER SESSION (plan 13, CR-02 / W-03). Each one acts on a conversation rather than the
+    // project, so the handler set is built over the scope of the session running the turn:
+    // `/model` moves that conversation's model and `/quit` asks that loop to end.
+    directives: (sessionId) => ({
+      // THE BATCH PRE-FLIGHT (392-14, E3/E3b). The engine asks this of EVERY directive of a turn
+      // before it applies the first one, so a refused later directive leaves an earlier one
+      // unapplied.
+      //
+      // IT APPLIES NOTHING. `/model` RESOLVES the model and caches it under its name — a cache is
+      // not the session's state, and the session's own `activeModel` is left exactly where it was.
+      // The resolution is also the only part of `/model` that can fail, so caching it here is what
+      // makes the later apply unable to throw after an earlier directive has already been carried
+      // out.
+      validate: async (directive, argument) => {
+        if (directive === "model" && argument !== void 0 && input.chatModelFor !== void 0) {
+          chatModelsByName.set(argument, await input.chatModelFor(argument));
+        }
+      },
+      model: async (name) => {
+        const scope = chatScopeFor(sessionId);
+        const from = scope.state.read().activeModel;
+        if (input.chatModelFor !== void 0 && !chatModelsByName.has(name)) {
+          chatModelsByName.set(name, await input.chatModelFor(name));
+        }
+        scope.state.setActiveModel(name);
+        return { from, to: name, line: `model: ${from} \u2192 ${name}` };
+      },
+      help: () => CHAT_HELP_TEXT,
+      quit: () => {
+        chatScopeFor(sessionId).state.requestClose();
+        return "closing this session";
+      }
+    }),
+    state: (sessionId) => chatScopeFor(sessionId).state,
+    // D-04: the configuration RE-READ, per turn and PER SESSION. A thunk rather than a captured
+    // value, because the drift worth detecting is precisely the one that happens underneath a
+    // running session — a model resolved differently by the host, or a build whose registry
+    // reaches further than the one this session opened against. The engine folds the log for what
+    // was last recorded and emits `model_change` / `active_tools_change` on the difference.
+    //
+    // THE MODEL IT REPORTS IS THE ASKING SESSION'S (plan 13). A composition-wide read would answer
+    // one conversation's `/model` override for every conversation, and the per-turn diff would
+    // then write a `model_change` into sessions nobody had switched.
+    //
+    // 441 GAP3-D4: masked, because the log it is compared with is masked on append.
+    config: (sessionId) => {
+      const ids = chatToolsetIds(composedRegistry);
+      return {
+        model: input.mask(chatModelNameFor(sessionId)),
+        toolset: { hash: chatToolsetHash(composedRegistry), ids }
+      };
+    },
+    // 395-08 D-14/D-15 · CFGM-05: the target vocabulary the PRE-DISPATCH write_test route reads.
+    // Bound off the SAME host verb `authoringRead.configuredTargetNames` uses, so the seam that
+    // decides whether to offer a scaffold and the loop that later checks what a model emitted are
+    // reading one answer rather than two. A host that cannot name its targets binds nothing and the
+    // route never runs, which leaves the shipped dispatch and the loop's own backstop exactly as
+    // they were.
+    // BOUND ONLY WHERE THE LOOP IS. A host that cannot author has nothing for this route to route,
+    // and binding it anyway would answer an empty vocabulary — which the route reads as the
+    // from-zero case and refuses, reporting the wrong cause for a host whose real problem is that
+    // `authoring.draft.write` is unbound. Absent leaves the shipped dispatch untouched.
+    ...input.draftAuthoring !== void 0 && input.runExecution !== void 0 ? { configuredTargets: () => input.draftAuthoring.configuredTargetNames() } : {},
+    // 395-13 D-14: where the scaffold proposal is rendered before the in-turn apply is invoked.
+    // Conditionally spread on the exact idiom above, so a host that binds no surface leaves the
+    // field ABSENT and the engine's own "renders nothing" posture is what answers — in one place.
+    ...input.chatPresent === void 0 ? {} : { present: input.chatPresent },
+    now: () => clock.now(),
+    mintTurnId: () => `turn-${randomUUID3()}`
+  });
+  const authoringLoopHost = input.draftAuthoring !== void 0 && input.runExecution !== void 0 ? input.draftAuthoring : void 0;
+  const authoringFunnel = {
+    receipts: createDraftReceiptsStore({ resolveAgentQaRoot: () => input.agentQaRoot }),
+    quarantine: {
+      list: async () => await createQuarantineOperations({
+        resolveKnowledgeRoot: input.knowledgeRoot,
+        now: () => clock.now(),
+        mintIdentityPath: input.mintQuarantineIdentityPath,
+        ...input.resolveWriterAuthority === void 0 ? {} : { resolveWriterAuthority: input.resolveWriterAuthority }
+      }).list()
+    },
+    // D-14's history half, over the run-outcome projection's own read side (394-17, step b).
+    //
+    // ONE CONNECTION PER VERB, opened read-only and closed in `finally`, on the shape
+    // `readProjectedTestHistory` above already takes. An absent database, a store predating the
+    // projection tables and an identity nothing has counted all answer EMPTY — which
+    // `assessSuiteStability` turns into the honest `no-history` posture rather than into a clean
+    // bill of health. Any other read failure propagates: a corrupt store is not "no history".
+    //
+    // THE OUTCOME WORDS. The durable window keeps one boolean per build (`last_outcomes_json`),
+    // which is what the fold reduced each member's outcome to, so this spells it back with the two
+    // words it was reduced FROM. Nothing downstream compares those strings against a member list —
+    // `assessSuiteStability` counts DISTINCT values — so a flip in the window is a flip here, and
+    // no vocabulary is invented beyond what the projection actually kept.
+    outcomes: {
+      testsIn: async (product, filePath) => {
+        const knowledgeRoot = await input.knowledgeRoot();
+        const path = indexDbPath(knowledgeRoot);
+        if (!existsSync4(path)) return [];
+        const db = new DatabaseSync4(path, { readOnly: true });
+        try {
+          return listTestsInFile(db, { product, filePath }).map((testName) => ({ filePath, testName }));
+        } catch (error) {
+          if (error instanceof Error && error.message.includes("no such table")) return [];
+          throw error;
+        } finally {
+          db.close();
+        }
+      },
+      outcomesFor: async (product, filePath, testName) => {
+        const knowledgeRoot = await input.knowledgeRoot();
+        const history = readProjectedTestHistory(knowledgeRoot, { product, filePath, testName });
+        if (history === void 0) return [];
+        return history.lastOutcomes.map((entry) => entry.passed ? "passed" : "failed");
+      }
+    }
+  };
+  const registry = createFunctionRegistry({
+    deps: {
+      secretMask: input.mask,
+      runs: {
+        ...runsReader,
+        get: async (runId) => {
+          await recurrence.prime();
+          return runsReader.get(runId);
+        }
+      },
+      // 387 D-01: this host's list verbs are live sighting sites. Every entity a listing,
+      // an inspect, a diff or a show surfaces gets its permanent address the first time it
+      // is surfaced — which is what "pre-existing entities get IDs the day they are first
+      // referenced" means in practice, and it costs the creation paths nothing.
+      knowledge: createKnowledgeReader(
+        input.knowledgeRoot,
+        createMemorySightingHook(entityResolutionInput),
+        input.resolvePromotionPosture,
+        input.resolveTrustPriors
+      ),
+      config: input.config,
+      entities: createEntityDirectory(entityResolutionInput),
+      // 387-08 KREV-01: the WRITE half, and it is present in every local composition because a
+      // local host owns the knowledge root it serves from. It stays an OPTIONAL dep so a host
+      // that is genuinely read-only — a listing, a remote surface — reports the four mutating
+      // verbs as `unbound` BY NAME rather than as a hole in the catalogue.
+      knowledgeReview: createKnowledgeReview({
+        ...input.resolveTrustPriors === void 0 ? {} : { resolveTrustPriors: input.resolveTrustPriors },
+        ...input.resolvePromotionPosture === void 0 ? {} : { resolvePromotionPosture: input.resolvePromotionPosture },
+        agentQaRoot: input.agentQaRoot,
+        resolveKnowledgeRoot: input.knowledgeRoot,
+        ...input.knowledgeChangeDelegate === void 0 ? {} : { knowledgeChangeDelegate: input.knowledgeChangeDelegate },
+        ...input.resolveWriterAuthority === void 0 ? {} : { resolveWriterAuthority: input.resolveWriterAuthority },
+        // 432-12: the host's own context, so a direct change is recorded under the context it was
+        // actually made in. (432-39: the registry no longer receives it; this is its one reader.)
+        ...input.resolveExecutionContext === void 0 ? {} : { resolveExecutionContext: input.resolveExecutionContext }
+      }),
+      // 388 D-14: chip truth, on EVERY local host and not gated on `postRun`. The two are
+      // different questions and conflating them would be the bug: `postRun` says whether this
+      // host can DO the chain's work, while this says whether it can SEE what the chain did —
+      // and a host that never drains anything (a status query, a listing, the CLI after a
+      // handed-off tail) is exactly the caller that most needs to read durable state.
+      //
+      // Given the SAME id source the queue below is built with, so the rows projected are the
+      // rows enqueued. It opens nothing here: the reader constructs no handle until it is asked
+      // a question, and never one that could create the database (Pitfall 4).
+      postProcessing: createPostProcessingReader({
+        agentQaRoot: input.agentQaRoot,
+        idSource: input.idSource ?? DIGEST_JOB_ID_SOURCE
+      }),
+      // 405 D-03: the run-detail projection read, conditionally spread on the house rule — an
+      // absent port must be an ABSENT field and not a present `undefined` one, because the
+      // registry reads exactly this record to decide what the capability LISTS as. Unlike
+      // `postProcessing` above it is NOT present on every local host: chip truth is readable from
+      // `agentQaRoot` alone, but a run's projected step tree lives in a dashboard database that
+      // only the dashboard process holds.
+      // 423 D-04: runs.evidence shares this reader with runs.detail and the blob reader
+      // below. The registry requires both for evidence without narrowing detail availability.
+      ...input.runDetail === void 0 ? {} : { runDetail: input.runDetail },
+      // 405-05 D-12/D-13: the run-scoped evidence-blob read, on EVERY local host and NOT
+      // conditionally spread — unlike `runDetail` one line up, which needs a dashboard database
+      // this host may not hold, every local composition has a runtime root and therefore has the
+      // run directories these blobs live in. It is the SAME reader the analysis job's
+      // `readEvidenceBlob` is built over, so "resolve this ref" and "diet this evidence" cannot
+      // disagree about where a blob is.
+      evidenceBlobs: createEvidenceBlobReader({ agentQaRoot: input.agentQaRoot }),
+      // Present iff this host can execute a run. The registry reads the SAME record to
+      // decide what `runs.start` lists as, so the declaration and the dispatch cannot
+      // disagree about whether this composition can run it (D-16).
+      ...input.runExecution === void 0 ? {} : {
+        runInvocation: createLocalRunInvocation({
+          agentQaRoot: input.agentQaRoot,
+          execution: input.runExecution
+        })
+      },
+      // 389 D-10/D-11: the artifact read `analysis.get` binds through, and the D-08
+      // recurrence join the one renderer consults. Both are bindable from `agentQaRoot`
+      // and the knowledge root alone, so every local composition carries them — a host
+      // with no artifact on disk serves the floor, and a host with no recorded history
+      // renders the explicit no-history clause; neither is a refusal (plan 05's law).
+      analysis: createAnalysisArtifactReader(input.agentQaRoot),
+      recurrence: recurrence.provider,
+      // 398 D-09 (dated 2026-08-17): the catalog port `agent.explain` binds through, handed
+      // straight through from the host. Conditionally spread rather than assigned, on the
+      // `runInvocation` precedent: an absent port must be an ABSENT field and not a present
+      // `undefined` one, because the registry reads exactly this record to decide what the
+      // capability LISTS as — so the declaration and the dispatch cannot disagree about whether
+      // this composition can explain itself (D-16).
+      ...input.capabilityCatalog === void 0 ? {} : { capabilityCatalog: input.capabilityCatalog },
+      // 403 D-03: the live-view mint seam, conditionally spread on the same rule — an absent port
+      // must be an ABSENT field, so `runs.liveurl` declares `unbound` where no origin is served.
+      ...input.liveView === void 0 ? {} : { liveView: input.liveView },
+      // 390 D-12/D-13: the three quarantine verbs, bound HERE and therefore on BOTH hosts —
+      // the CLI tail and 386's daemon compose the same root, which is the whole point of
+      // 385 D-15 (a second binding site is a second answer to "what is quarantined").
+      //
+      // Present in every local composition for the same reason the knowledge WRITE half is: a
+      // local host owns the committed knowledge root the ledger lives at. It stays an OPTIONAL
+      // dep so a genuinely read-only or remote composition reports all three `unbound` BY NAME
+      // rather than answering an empty list about a ledger it has never been able to open.
+      //
+      // The port takes the root as a FACTORY (the CLI resolves it asynchronously) and the clock
+      // as an argument, so this composition supplies both and the implementation reads neither
+      // of its own accord. Nothing opens here: the first byte is read when a verb is invoked.
+      //
+      // 390-09 / CR-03: the SAME `resolveWriterAuthority` the apply path consumes three bindings
+      // above, and it is what lands each host on the correct lease arm with zero daemon changes.
+      // The daemon supplies it (`cli/src/daemon/host.ts:1839`) because it acquired the lease at
+      // startup and holds it for its lifetime, so the verbs ride that authority instead of asking
+      // for a lease the process cannot be granted twice; the CLI in-process host supplies nothing,
+      // so the verbs acquire and release per call. Conditionally spread like its neighbour rather
+      // than assigned through: an absent authority must be an ABSENT field, not a present
+      // `undefined` one, so the implementation's `?.()` arm distinguishes the two hosts.
+      //
+      // 390-12 / D-01: the identity mint is handed straight through, REQUIRED and unspread. The
+      // verbs key the committed ledger on `filePath` and every reader compares those bytes with
+      // `===`, so a host that supplied nothing would be back to storing whatever a human typed —
+      // the round-2 regression. Unlike the authority above there is no host without a checkout
+      // root, so the absent case is a compile error rather than a second posture.
+      // 394-07 D-12 / WTST-05: the honesty funnel's reads, bound HERE and therefore on BOTH hosts,
+      // which is the whole point of 385 D-15 — a second binding site would be a second answer to
+      // "how many drafts did this session keep", and that number is the one WTST-05 exists to keep
+      // honest.
+      //
+      // UNCONDITIONAL, unlike the loop's two halves above it, and the asymmetry is the point: the
+      // funnel is a READ over records this host owns by owning `agentQaRoot`, so every local
+      // composition can answer it whether or not it can author anything. An empty receipts
+      // directory and an absent one are the same answer, and nothing opens here — the first byte
+      // is read when the verb is invoked.
+      //
+      // THE RECEIPTS PORT IS THE READ HALF ONLY. The evaluator one binding below is handed the
+      // same store's `put`; this bundle names `list` and nothing else, so the projection is
+      // structurally unable to write the records it reports on. Two narrow mirrors over one store
+      // rather than one wide port.
+      //
+      // 2026-10-01 (432-17, D-06): the bundle no longer reads the proposals inbox. 2026-10-02
+      // (quick 261002-ctr): the terminal stage is `writeEligible`, read off the receipts this
+      // bundle lists (see `projectAuthoringFunnel`).
+      //
+      // `outcomes` IS BOUND (394-17, step b): the port's two verbs now LEAD with `product`, so the
+      // binding reads the run-outcome projection on its own primary key instead of guessing a
+      // partition or serving every product's history under one file path.
+      //
+      // ASSEMBLED ABOVE rather than inline, because the gate-2 flip path is handed the SAME
+      // bundle: one composition-level answer to "what does this project know about this suite",
+      // reached by the funnel read op and by the evaluator's consultation alike.
+      authoringFunnel,
+      // 2026-10-01 (432-17, D-05/D-22): the proposals inbox (391 PROP-03) is not bound — it is deleted
+      // with its ops. Old files under `<agentQaRoot>/proposals/` are never opened again.
+      ...input.feedback === void 0 ? {} : { feedback: input.feedback },
+      ...input.feedbackReads === void 0 ? {} : { feedbackReads: input.feedbackReads },
+      quarantine: createQuarantineOperations({
+        resolveKnowledgeRoot: input.knowledgeRoot,
+        now: () => clock.now(),
+        mintIdentityPath: input.mintQuarantineIdentityPath,
+        ...input.resolveWriterAuthority === void 0 ? {} : { resolveWriterAuthority: input.resolveWriterAuthority }
+      }),
+      // 392 D-24: the turn engine assembled above. Bound HERE and therefore on BOTH hosts, so
+      // `agent.ask` is a real capability wherever the composition root runs — and unbound nowhere,
+      // which is what lets 397's parity suite read it off the registry with no chat-specific case.
+      chatTurn: {
+        // The engine also echoes authored clause text on receipts and refusal answers. Mask
+        // the complete outward projection after execution, never the message it dispatches.
+        runTurn: async (turnInput) => projectChatMembers(await chatTurn.runTurn(turnInput), CHAT_TURN_RESULT_RULES, input.mask)
+      },
+      // 393 D-01 / D-15: the keep-gate evaluator's two host halves, bound HERE and therefore on
+      // BOTH hosts — the CLI and 386's daemon compose this same root, which is the whole point of
+      // 385 D-15 (a second binding site would be a second answer to "is this draft worth keeping",
+      // and the two would disagree about a decision that gets written into a durable receipt).
+      //
+      // Conditionally spread on BOTH halves, because a capability that can parse but cannot run is
+      // not a degraded evaluator — it is a host that must say `unbound` by name. `runs.start` is
+      // dispatched through the registry this very call is about to produce, which is the same
+      // deferred reference the chat engine takes and is safe for the same reason: no op can run
+      // before the registry it is registered in has been built.
+      ...input.draftAuthoring === void 0 || input.runExecution === void 0 ? {} : {
+        draftEvaluation: createDraftEvaluation({
+          authoring: input.draftAuthoring,
+          agentQaRoot: input.agentQaRoot,
+          knowledgeRoot: input.knowledgeRoot,
+          authoringFunnel,
+          readRun: (runId) => runsReader.get(runId),
+          startGateRun: async (request) => {
+            if (composedRegistry === void 0) {
+              throw new TypeError("a gate-run started before its registry finished composing");
+            }
+            return await invokeFunction(
+              composedRegistry,
+              RUNS_START_FUNCTION_ID,
+              request,
+              AUTHORING_GATE_RUN_CALLER
+            );
+          }
+        })
+      },
+      // 394 D-01 / WTST-01: the authoring LOOP's two halves, bound HERE and therefore on BOTH
+      // hosts, under the SAME condition the evaluator above is bound under — the loop's stage 4
+      // dispatches `authoring.draft.verify`, so a host that cannot verify a draft cannot author
+      // one either, and a third answer to "can this host author" would be a third thing to keep
+      // in step.
+      //
+      // THE READ HALF IS `getAuthoringBrief`'S FIRST PRODUCTION CALLER. The port has been
+      // implemented and unbound since v51 (`knowledge-local/src/serving/authoring-reader.ts`),
+      // which means every field of its contract is crossing a real seam for the first time here;
+      // a mismatch surfaces at this binding rather than in a surface. The reader is built PER
+      // CALL over a freshly resolved knowledge root, on the standing-approval reader's stated
+      // reasoning — the CLI resolves its root asynchronously and per call, and a root captured
+      // once would serve a brief out of a knowledge tree the invocation is not serving from. No
+      // `product` is bound: the composition does not own one, and the SCOPE arrives on the op's
+      // input, which is the honest half of the pair the reader filters on.
+      //
+      // `suiteTextCorpus` is the SAME host walk gate 3's degraded lane already consumes, reached
+      // here for stage 2's pre-authoring screen. One walk, one notion of what a suite test's text
+      // is; a second enumeration would let the screen and the gate disagree about the same pair.
+      //
+      // THE WRITE HALF bundles the model, the shelf and the verify dispatch, because none of the
+      // three is independently bindable: a host with a model and no shelf cannot author, one with
+      // a shelf and no model has nothing to author with, and one that can do both but cannot
+      // verify would produce a test and have nothing to say about whether it is worth keeping.
+      // The model is a FACTORY, resolved at most once and only when a draft is actually compiled,
+      // the same idiom `openJobs` uses — binding this capability must not construct a client for a
+      // host that never authors.
+      //
+      // WHY THE ROUTER (plan 05) WILL READ `DraftRunPortLike.get`'s `CompletedRunHandoff` AND NOT
+      // `runs.get`'s PROJECTION. D-08 routes on run EVIDENCE — step terminations, planning
+      // failure, cycle flags, the per-step sub-action record — and `runs.get` projects a
+      // `RunDetail` in which none of that survives (`stepCount` is its only step-shaped field).
+      // This is `createDraftEvaluation`'s own posture, stated one layer out: the op is reached for
+      // what an op owns, and the reader is read for evidence no projection carries. A router built
+      // on the projection would have to infer a mechanics failure from a member verdict, and
+      // inferring an app defect out of a bare member verdict is precisely the cardinal error D-08
+      // exists to make unreachable.
+      //
+      // A NOTE FOR WHOEVER EDITS THIS PARAGRAPH. The arch dependency scan reads import specifiers
+      // out of this file's RAW BYTES, comments included, so any prose shaped like an import's
+      // trailing clause — the keyword, then a quoted phrase — is reported as an undeclared
+      // external dependency of this package. Two drafts of this comment tripped it, once on a
+      // sentence about verdicts and once on the sentence explaining the first. Keep quoted phrases
+      // away from that keyword here.
+      ...authoringLoopHost === void 0 ? {} : {
+        authoringRead: {
+          async getAuthoringBrief(intent, scope) {
+            const knowledgeRoot = await input.knowledgeRoot();
+            return createAuthoringReader({ knowledgeRoot }).getAuthoringBrief(intent, scope);
+          },
+          suiteTextCorpus: () => authoringLoopHost.suiteTextCorpus(),
+          // 394-33 · WR-07: the `target` vocabulary stage 3's compile prompt serves. Bound off the
+          // SAME port the brief and the corpus come from, so a host that can run the loop's read
+          // stages can name its own targets by construction — see the port's own doc.
+          configuredTargetNames: () => authoringLoopHost.configuredTargetNames()
+        },
+        // 394-26 · WINDOWS 110: the scope an intent-only call is authored at, bound HERE and so on
+        // BOTH hosts, off the same port the read and compile halves come from. Its own deps key
+        // rather than a third verb on `authoringRead`, because deriving a scope needs the resolved
+        // config and the workspace while the brief needs a knowledge index — a host can have one
+        // without the other, and the op refuses on THIS key by name when a scope-less call arrives
+        // at a composition that never bound it.
+        authoringScope: {
+          deriveDefault: () => authoringLoopHost.deriveDefaultScope()
+        },
+        draftShelf: {
+          model: async () => await input.model(),
+          write: (contents) => authoringLoopHost.stageDraft(contents),
+          // 394-06 D-09/D-20: the ONE RFC-6902 applier, reached at the host because it needs the
+          // yaml CST and neither `agent` nor this package may depend on `core`. Same seam,
+          // same reason and same shape as `stageDraft` right above it.
+          applyPatches: (draft, patchSet) => authoringLoopHost.applyPatchesToDraft(draft, patchSet),
+          // 432 D-06/D-07: the direct writer the loop's final write and the edit op reach. Same seam
+          // and same reason as the two verbs above: the boundary check needs `core`.
+          publish: (request) => authoringLoopHost.publishDraft(request),
+          // 394-06: stage 5's evidence reader and the repair arm's probe runner. The reader is
+          // the same `runsReader` the gate evaluator is bound to — a second reader would be a
+          // second answer to what one run recorded — and the starter dispatches the REGISTERED
+          // `runs.start` on the gate-run caller, so a probe is marker-stamped exactly as a gate
+          // run is and is excluded from outcomes for the same reason.
+          runs: {
+            start: async (request) => {
+              if (composedRegistry === void 0) {
+                throw new TypeError("a repair probe started before its registry finished composing");
+              }
+              return await invokeFunction(
+                composedRegistry,
+                RUNS_START_FUNCTION_ID,
+                request,
+                AUTHORING_GATE_RUN_CALLER
+              );
+            },
+            get: (runId) => runsReader.get(runId)
+          },
+          // 2026-10-01 (432-18/432-19, D-15): no dispatch-scoped grant exists. The authoring loop
+          // runs its dispatch directly, and no gate run it starts consults any approval.
+          verifyDraft: async (verifyInput) => {
+            if (composedRegistry === void 0) {
+              throw new TypeError("a draft was verified before its registry finished composing");
+            }
+            return await invokeFunction(
+              composedRegistry,
+              AUTHORING_DRAFT_VERIFY_FUNCTION_ID,
+              verifyInput,
+              AUTHORING_LOOP_VERIFY_CALLER
+            );
+          }
+        }
+        // 2026-10-01 (432-17, D-06): no authoring proposal writer is bound; an authored test is
+        // written in its own call through the shelf's direct writer.
+      },
+      // 432-16 (D-07): no test-draft or config commit port and no undo source is bound — agent-qa
+      // makes no git commits. The final authored test is written through `draftShelf.publish`.
+      //
+      // 395-01 D-01/D-03/D-17 · CFGM-01/03/04: the config editor's host half, each spread on its
+      // OWN condition rather than as one bundle, so a host missing one reports that one `unbound`.
+      ...input.configFiles === void 0 ? {} : { configFiles: input.configFiles },
+      ...input.configValidate === void 0 ? {} : { configValidate: input.configValidate },
+      ...input.scaffoldContent === void 0 ? {} : { scaffoldContent: input.scaffoldContent },
+      ...input.configWrite === void 0 ? {} : { configWrite: input.configWrite }
+      // 2026-10-14 (441-39, D-15): a config change is not scanned for secrets, so no scan is bound.
+      // 2026-10-01 (432-17, D-05): no config proposal filer is bound; the six config ops write in
+      // the call through `configWrite`.
+    }
+    // 2026-10-15 (441-28, D-15): no audit sink; the guardrail audit went with the guardrails.
+    // 432-13 (D-14/D-15): no standing-approval reader, confirm port or session deny overlay reaches
+    // the registry — `invokeFunction` asks nobody. 432-18 deleted the grant reader with the ledger.
+    // 2026-10-02 (432-39, D-12): the host's execution-context answer is no longer forwarded here.
+    // The registry's option was retired and unread since 432-13 and is deleted; the same answer
+    // still reaches the knowledge review above, which records a direct change under it.
+  });
+  composedRegistry = registry;
+  let opened;
+  let opening;
+  let closing;
+  let lifecycleGeneration = 0;
+  let closed = false;
+  async function openJobs(openGeneration) {
+    const model = await input.model();
+    const knowledgeRoot = await input.knowledgeRoot();
+    const analysisTokenBudget = input.analysisTokenBudget === void 0 ? void 0 : await input.analysisTokenBudget();
+    const proposeGate1MaxPerJob = input.postRun?.proposeGate1MaxPerJob === void 0 ? void 0 : await input.postRun.proposeGate1MaxPerJob();
+    const store = createSqliteJobStore({
+      path: join7(input.agentQaRoot, AGENT_JOB_STORE_DB_FILE),
+      clock,
+      checkpoints: createJobCheckpointStore({ root: input.agentQaRoot })
+    });
+    let jobs;
+    try {
+      const kinds = input.jobKinds ?? createRealJobKindRegistry(
+        postRunCapabilities(input, knowledgeRoot, analysisTokenBudget, store, proposeGate1MaxPerJob)
+      );
+      const idSource = input.idSource ?? DIGEST_JOB_ID_SOURCE;
+      const unclaimableKinds = UNCLAIMABLE_BY_PROSE_POSTURE[input.postRun?.candidateProse ?? "no-masker"];
+      jobs = {
+        queue: createAgentJobQueue({
+          store,
+          registry: kinds,
+          clock,
+          idSource,
+          model,
+          ...unclaimableKinds.length === 0 ? {} : { unclaimableKinds }
+        }),
+        store,
+        kinds,
+        model,
+        idSource,
+        unclaimableKinds
+      };
+    } catch (error) {
+      store.close();
+      throw error;
+    }
+    if (closed || openGeneration !== lifecycleGeneration) {
+      store.close();
+      throw new LocalAgentClosedError(input.agentQaRoot);
+    }
+    opened = jobs;
+    return jobs;
+  }
+  return {
+    registry,
+    chat: {
+      stateFor: (sessionId) => chatScopes.get(sessionId)?.state.read(),
+      async abortActiveTurn() {
+        for (const [sessionId, entry] of liveChatSessions) {
+          const turnId = chatScopes.get(sessionId)?.state.read().activeTurnId;
+          if (turnId === void 0) continue;
+          if (!entry.turnIds.has(turnId)) continue;
+          await entry.handle.append({
+            kind: "aborted",
+            turnId,
+            at: clock.now(),
+            source: "explicit"
+          });
+          await entry.handle.turnBoundary();
+        }
+      }
+    },
+    curation: LOCAL_CURATION_CAPABILITIES,
+    clock,
+    jobs() {
+      if (closed) return Promise.reject(new LocalAgentClosedError(input.agentQaRoot));
+      opening ??= openJobs(lifecycleGeneration);
+      return opening;
+    },
+    close() {
+      if (closing !== void 0) return closing;
+      closed = true;
+      lifecycleGeneration += 1;
+      const pending = opening;
+      const current = opened;
+      opened = void 0;
+      current?.store.close();
+      closing = (async () => {
+        if (pending !== void 0) {
+          try {
+            const late = await pending;
+            if (late !== current) late.store.close();
+          } catch {
+          }
+        }
+        opening = void 0;
+      })();
+      return closing;
+    }
+  };
+}
+
+// src/composition/build-ordinals.ts
+import {
+  BuildOrdinalReservationError,
+  reserveBuildOrdinalForProducts,
+  latestBuildOrdinal
+} from "@vostride/agent-qa-runner-local";
+import { resolveBuildTag } from "@vostride/agent-qa-runner-local";
+
+// src/composition/compose-job-recovery.ts
+import { join as join8 } from "node:path";
+import { createAgentJobQueue as createAgentJobQueue2, createRealJobKindRegistry as createRealJobKindRegistry2 } from "@vostride/agent-qa-agent";
+var JOB_RECOVERY_MAX_RESUMED_JOBS = 64;
+function composeJobRecovery(input) {
+  const store = createSqliteJobStore({
+    path: join8(input.agentQaRoot, AGENT_JOB_STORE_DB_FILE),
+    clock: input.clock,
+    checkpoints: createJobCheckpointStore({ root: input.agentQaRoot })
+  });
+  const kinds = input.jobKinds ?? createRealJobKindRegistry2();
+  const queue = createAgentJobQueue2({
+    store,
+    registry: kinds,
+    clock: input.clock,
+    idSource: input.idSource,
+    model: input.model
+  });
+  return {
+    store,
+    kinds,
+    queue,
+    recoverAbandonedClaims(fence) {
+      return queue.recoverAbandonedClaims({ fence });
+    },
+    async resumePending(fence, maxJobs = JOB_RECOVERY_MAX_RESUMED_JOBS) {
+      const outcomes = [];
+      for (; ; ) {
+        if (outcomes.length >= maxJobs) {
+          throw new Error(
+            `agent job recovery ran ${maxJobs} jobs without emptying the agent job queue; the bound exists so a chain that keeps enqueuing successors cannot turn recovery into an unbounded drain, and stopping early without saying so would report success over work left behind`
+          );
+        }
+        const outcome = await queue.runNextJob({ fence });
+        if (!outcome.ran) return outcomes;
+        outcomes.push(outcome);
+      }
+    },
+    close() {
+      store.close();
+    }
+  };
+}
+
+// src/session/memory-session-log.ts
+import { repairSession as repairSession2 } from "@vostride/agent-qa-agent";
+import { CURRENT_CHAT_SESSION_SCHEMA_VERSION as CURRENT_CHAT_SESSION_SCHEMA_VERSION2 } from "@vostride/agent-qa-schema";
+function createMemorySessionLog(options) {
+  const sessions = /* @__PURE__ */ new Map();
+  const random = options.random ?? Math.random;
+  const liveSessions = /* @__PURE__ */ new Set();
+  function handleFor(id, opened) {
+    let live = true;
+    const requireLive = (verb) => {
+      if (!live) {
+        throw new TypeError(
+          `a chat session ${verb} cannot go through a closed handle for ${id}. Open the session again to write to it.`
+        );
+      }
+    };
+    liveSessions.add(id);
+    return {
+      header: opened.header,
+      events: opened.events,
+      refusedLines: opened.refusedLines,
+      append(event) {
+        requireLive("event");
+        sessions.get(id).events.push(event);
+        return Promise.resolve();
+      },
+      turnBoundary() {
+        requireLive("turn boundary");
+        return Promise.resolve();
+      },
+      close() {
+        if (live) {
+          live = false;
+          liveSessions.delete(id);
+        }
+        return Promise.resolve();
+      }
+    };
+  }
+  return {
+    open(sessionId) {
+      if (sessionId !== void 0) {
+        const existing = sessions.get(sessionId);
+        if (existing === void 0) throw new UnknownChatSessionError(sessionId);
+        if (liveSessions.has(sessionId)) throw new ChatSessionBusyError(sessionId);
+        const repair = repairSession2(
+          existing.events.map((event, index) => ({
+            lineNumber: index + 2,
+            text: JSON.stringify(event)
+          })),
+          { declaredVersion: existing.header.schemaVersion, now: options.now }
+        );
+        existing.events.push(...repair.synthesized);
+        return Promise.resolve(
+          handleFor(sessionId, {
+            header: existing.header,
+            events: [...existing.events],
+            // Always empty here, and that is the honest answer rather than a placeholder: this
+            // twin stores typed records, so no line of it can be damaged in the way a file's can.
+            refusedLines: repair.refusedLines
+          })
+        );
+      }
+      const createdAt = options.now();
+      const id = mintChatSessionId(createdAt, random);
+      const header = {
+        schemaVersion: CURRENT_CHAT_SESSION_SCHEMA_VERSION2,
+        sessionId: id,
+        createdAt,
+        model: options.model(),
+        toolsetHash: options.toolsetHash()
+      };
+      sessions.set(id, { header, events: [] });
+      return Promise.resolve(handleFor(id, { header, events: [], refusedLines: [] }));
+    },
+    snapshot(sessionId) {
+      const found = sessions.get(sessionId);
+      return found === void 0 ? void 0 : { header: found.header, events: [...found.events], refusedLines: [] };
+    }
+  };
+}
+export {
+  ALLOW_PRODUCTION_OPT_IN,
+  BRIEF_CEILING,
+  BRIEF_FRACTION,
+  BuildOrdinalReservationError,
+  CAUTION_FRACTION,
+  CHAT_PLANNER_CALLER,
+  CHAT_RESOLVER_CALLER,
+  CHAT_SESSIONS_SUBDIR,
+  ChatSessionBusyError,
+  ChatSessionHeaderError,
+  DIGEST_JOB_ID_SOURCE,
+  DRAIN_BUDGET_MS,
+  EMBEDDER_WORKER_REGISTRATION_FILE,
+  EMBEDDER_WORKER_START_TIMEOUT_MS,
+  EMBEDDER_WORKER_TERM_GRACE_MS,
+  ENTITY_INDEX_SWEEP_INTERVAL_MS,
+  EmbedderWorkerTimeoutError,
+  GLOBAL_RECORD_CAP,
+  InvalidChatSessionIdError,
+  JOB_RECOVERY_MAX_RESUMED_JOBS,
+  LOCAL_CURATION_CAPABILITIES,
+  LOCAL_DAEMON_CAPABILITIES,
+  LOCAL_KNOWLEDGE_PROBES,
+  LocalAgentClosedError,
+  MIN_BRIEF,
+  MIN_CAUTION,
+  MIN_MEMORY_TOOL_CONTEXT_WINDOW,
+  QUARANTINE_CLASS_DISPOSITIONS,
+  QUARANTINE_FLOOR_ELIGIBILITY,
+  READ_BODY_FRACTION,
+  REFUSED_RUN_REQUEST_FIELDS,
+  RunDeniedError,
+  RunIdAlreadyInUseError,
+  RunIdNotMintedError,
+  RunProducedNoEventsError,
+  RunRequestFieldRefusedError,
+  SUITE_LIFECYCLE_LANE,
+  SYSTEM_CLOCK,
+  SuiteBoundaryWhileLiveError,
+  UNCLAIMABLE_BY_PROSE_POSTURE,
+  UnknownChatSessionError,
+  WEAK_MODEL_CAP_SCALE,
+  applyKnowledgeChange,
+  buildMemberRunConfig,
+  buildProductionRefusal,
+  buildRunPorts,
+  buildScreenshotCompressor,
+  buildSuiteMemberExecutor,
+  composeJobRecovery,
+  composeLocalAgent,
+  computeKnowledgeBudgets,
+  computeRunConfigDigests,
+  constructKnowledgeReader,
+  createEvidenceBlobReader,
+  createFrozenKnowledgeReader,
+  createJsonlSessionLog,
+  createKnowledgeReader,
+  createKnowledgeReview,
+  createLocalRunInvocation,
+  createMemorySessionLog,
+  createRunInvocationCore,
+  createRunsReader,
+  createSuiteLifecycle,
+  latestBuildOrdinal,
+  listSessions,
+  lookupEvidenceBlob,
+  mapVerdictToExitCode,
+  memoryToolGate,
+  mintChatSessionId,
+  openRunKnowledgeComposition,
+  readEvidenceBlobBytes,
+  refuseProductionWithoutOptIn,
+  refuseUnavailableRunId,
+  registerAdapterLiveStream,
+  reserveBuildOrdinalForProducts,
+  resolveBuildTag,
+  resolveBuildTagSetting,
+  resolveHostRetrievalRung,
+  resolveRunBuildOrdinal,
+  resolveRunExecutionContext,
+  resolveRunQuarantineSnapshot,
+  runSafetyScope,
+  scaledRecordCap,
+  statEvidenceBlob,
+  sweepEntityIndexProjection,
+  toMemberTest
+};
+//# sourceMappingURL=index.js.map