@vostride/agent-qa-agent-local 0.2.2 → 0.2.4

package/dist/index.cjs

@@ -30,7 +30,6 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
-  ALLOW_PRODUCTION_OPT_IN: () => import_agent_qa_schema.ALLOW_PRODUCTION_OPT_IN,
   BRIEF_CEILING: () => BRIEF_CEILING,
   BRIEF_FRACTION: () => BRIEF_FRACTION,
   BuildOrdinalReservationError: () => import_agent_qa_runner_local4.BuildOrdinalReservationError,
@@ -47,25 +46,32 @@ __export(index_exports, {
   EMBEDDER_WORKER_TERM_GRACE_MS: () => import_agent_qa_knowledge_local.EMBEDDER_WORKER_TERM_GRACE_MS,
   ENTITY_INDEX_SWEEP_INTERVAL_MS: () => import_agent_qa_knowledge_local.ENTITY_INDEX_SWEEP_INTERVAL_MS,
   EmbedderWorkerTimeoutError: () => import_agent_qa_knowledge_local.EmbedderWorkerTimeoutError,
+  FsMarkLedger: () => FsMarkLedger,
   GLOBAL_RECORD_CAP: () => GLOBAL_RECORD_CAP,
+  HANDOFF_FILE: () => import_agent_qa_runner_local6.HANDOFF_FILE,
   InvalidChatSessionIdError: () => InvalidChatSessionIdError,
   JOB_RECOVERY_MAX_RESUMED_JOBS: () => JOB_RECOVERY_MAX_RESUMED_JOBS,
   LOCAL_CURATION_CAPABILITIES: () => LOCAL_CURATION_CAPABILITIES,
   LOCAL_DAEMON_CAPABILITIES: () => LOCAL_DAEMON_CAPABILITIES,
   LOCAL_KNOWLEDGE_PROBES: () => LOCAL_KNOWLEDGE_PROBES,
   LocalAgentClosedError: () => LocalAgentClosedError,
+  MARKS_LEDGER_FILE: () => MARKS_LEDGER_FILE,
+  MARKS_LEDGER_LOCK_FILE: () => MARKS_LEDGER_LOCK_FILE,
+  MARK_INTENT_FILE: () => MARK_INTENT_FILE,
   MIN_BRIEF: () => MIN_BRIEF,
   MIN_CAUTION: () => MIN_CAUTION,
   MIN_MEMORY_TOOL_CONTEXT_WINDOW: () => MIN_MEMORY_TOOL_CONTEXT_WINDOW,
+  MarkIntentUnusableError: () => MarkIntentUnusableError,
+  MarkLedgerBusyError: () => MarkLedgerBusyError,
+  MarkLedgerCorruptError: () => MarkLedgerCorruptError,
+  MarkLedgerNoRunError: () => MarkLedgerNoRunError,
   QUARANTINE_CLASS_DISPOSITIONS: () => import_reader3.QUARANTINE_CLASS_DISPOSITIONS,
   QUARANTINE_FLOOR_ELIGIBILITY: () => import_reader3.QUARANTINE_FLOOR_ELIGIBILITY,
   READ_BODY_FRACTION: () => READ_BODY_FRACTION,
-  REFUSED_RUN_REQUEST_FIELDS: () => REFUSED_RUN_REQUEST_FIELDS,
-  RunDeniedError: () => RunDeniedError,
+  RUNS_SUBDIR: () => import_agent_qa_runner_local6.RUNS_SUBDIR,
   RunIdAlreadyInUseError: () => RunIdAlreadyInUseError,
   RunIdNotMintedError: () => RunIdNotMintedError,
   RunProducedNoEventsError: () => RunProducedNoEventsError,
-  RunRequestFieldRefusedError: () => RunRequestFieldRefusedError,
   SUITE_LIFECYCLE_LANE: () => SUITE_LIFECYCLE_LANE,
   SYSTEM_CLOCK: () => SYSTEM_CLOCK,
   SuiteBoundaryWhileLiveError: () => SuiteBoundaryWhileLiveError,
@@ -74,7 +80,6 @@ __export(index_exports, {
   WEAK_MODEL_CAP_SCALE: () => WEAK_MODEL_CAP_SCALE,
   applyKnowledgeChange: () => applyKnowledgeChange,
   buildMemberRunConfig: () => buildMemberRunConfig,
-  buildProductionRefusal: () => import_agent_qa_schema.buildProductionRefusal,
   buildRunPorts: () => buildRunPorts,
   buildScreenshotCompressor: () => buildScreenshotCompressor,
   buildSuiteMemberExecutor: () => buildSuiteMemberExecutor,
@@ -94,15 +99,17 @@ __export(index_exports, {
   createRunsReader: () => createRunsReader,
   createSuiteLifecycle: () => createSuiteLifecycle,
   latestBuildOrdinal: () => import_agent_qa_runner_local4.latestBuildOrdinal,
+  latestMarkReceiptFor: () => latestMarkReceiptFor,
+  latestMarkReceiptsPerAddress: () => latestMarkReceiptsPerAddress,
   listSessions: () => listSessions,
+  loadCompletedRunHandoff: () => import_agent_qa_runner_local6.loadCompletedRunHandoff,
   lookupEvidenceBlob: () => lookupEvidenceBlob,
   mapVerdictToExitCode: () => import_agent_qa_runner3.mapVerdictToExitCode,
   memoryToolGate: () => memoryToolGate,
   mintChatSessionId: () => mintChatSessionId,
   openRunKnowledgeComposition: () => openRunKnowledgeComposition,
+  purgeActionCache: () => import_agent_qa_runner_local7.purgeActionCache,
   readEvidenceBlobBytes: () => readEvidenceBlobBytes,
-  refuseProductionWithoutOptIn: () => refuseProductionWithoutOptIn,
-  refuseUnavailableRunId: () => refuseUnavailableRunId,
   registerAdapterLiveStream: () => registerAdapterLiveStream,
   reserveBuildOrdinalForProducts: () => import_agent_qa_runner_local4.reserveBuildOrdinalForProducts,
   resolveBuildTag: () => import_agent_qa_runner_local5.resolveBuildTag,
@@ -189,7 +196,6 @@ function createFrozenKnowledgeReader(reader) {
 }
 function constructKnowledgeReader(input) {
   return createFrozenKnowledgeReader((0, import_reader.openKnowledgeReader)({
-    ...input.resolveTrustPriors === void 0 ? {} : { priors: input.resolveTrustPriors() },
     knowledgeRoot: input.knowledgeRoot,
     ...input.product === void 0 ? {} : { product: input.product },
     scopeDefaults: {
@@ -220,7 +226,6 @@ function openRunKnowledgeComposition(input) {
     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 },
@@ -471,8 +476,7 @@ function buildMemberRunConfig(input) {
     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.
+    // The model's canonical compaction applies to every tool-output value.
     guardBlob: import_agent_qa_model.guardToolOutput,
     compressor: input.compressor,
     knowledgeReader: input.knowledgeReader,
@@ -527,24 +531,6 @@ function buildMemberRunConfig(input) {
 var import_node_fs = require("node:fs");
 var import_node_path2 = require("node:path");
 var import_agent_qa_runner2 = require("@vostride/agent-qa-runner");
-
-// src/composition/run-risk.ts
-var import_agent_qa_schema = require("@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(
@@ -563,22 +549,6 @@ var RunIdAlreadyInUseError = class extends Error {
     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 = (0, import_agent_qa_schema.buildProductionRefusal)(declaration.productionTargetNames);
-  throw new RunDeniedError(runId, reason);
-}
 function refuseUnavailableRunId(input) {
   if (!input.isMintedRunId(input.runId)) throw new RunIdNotMintedError(input.runId);
   if ((0, import_node_fs.existsSync)(runDirFor({ configDir: input.configDir, runId: input.runId }))) {
@@ -589,8 +559,6 @@ function createRunInvocationCore(options) {
   const configDir = (0, import_node_path2.dirname)(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,
@@ -599,9 +567,6 @@ function createRunInvocationCore(options) {
         });
       }
       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 });
@@ -614,8 +579,7 @@ function createRunInvocationCore(options) {
           ...postVerdict === void 0 ? {} : { postVerdict }
         },
         configDir,
-        configPath: request.configPath ?? options.configPath,
-        targetClass
+        configPath: request.configPath ?? options.configPath
       });
       const session = (0, import_agent_qa_runner2.startRun)({
         ...assembled,
@@ -679,12 +643,12 @@ function readEvidenceBlobBytes(input, runId, sha) {
 }
 
 // src/composition/quarantine-snapshot.ts
-var import_agent_qa_schema2 = require("@vostride/agent-qa-schema");
+var import_agent_qa_schema = require("@vostride/agent-qa-schema");
 var import_reader2 = require("@vostride/agent-qa-knowledge-local/reader");
 function resolveRunQuarantineSnapshot(input) {
   const warn = input.warn ?? (() => {
   });
-  const product = (0, import_agent_qa_schema2.slugBranch)(input.product);
+  const product = (0, import_agent_qa_schema.slugBranch)(input.product);
   let read;
   try {
     read = (0, import_reader2.readQuarantineLedger)(input.knowledgeRoot);
@@ -722,7 +686,7 @@ var import_agent_qa_knowledge_local = require("@vostride/agent-qa-knowledge-loca
 var import_agent_qa_runner4 = require("@vostride/agent-qa-runner");
 var import_agent_qa_safety = require("@vostride/agent-qa-safety");
 var import_agent_qa_runner_local3 = require("@vostride/agent-qa-runner-local");
-var import_agent_qa_schema10 = require("@vostride/agent-qa-schema");
+var import_agent_qa_schema9 = require("@vostride/agent-qa-schema");
 
 // src/composition/knowledge-review-reader.ts
 var import_reader4 = require("@vostride/agent-qa-knowledge-local/reader");
@@ -735,31 +699,20 @@ function createKnowledgeReaderPort(input) {
     }
   }
   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 (0, import_reader4.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.
+    // The caller supplied the identity; forward the reader's answer verbatim.
     async gateReceipts({ candidateId }) {
       return (0, import_reader4.gateReceiptsFor)({
         knowledgeRoot: await input.resolveKnowledgeRoot(),
-        candidateId,
-        resolvePromotionPosture: await input.resolvePromotionPosture?.()
+        candidateId
       });
     },
     async listBundles() {
-      const rows = (0, import_reader4.listBundles)(await input.resolveKnowledgeRoot(), input.resolveTrustPriors?.());
+      const rows = (0, import_reader4.listBundles)(await input.resolveKnowledgeRoot());
       await sight(rows.map((row) => row.bundleId));
       return rows;
     },
     async inspectRecords({ filter }) {
       const records = (0, import_reader4.inspectRecords)({
-        ...input.resolveTrustPriors === void 0 ? {} : { priors: input.resolveTrustPriors() },
         knowledgeRoot: await input.resolveKnowledgeRoot(),
         filter
       });
@@ -776,7 +729,6 @@ function createKnowledgeReaderPort(input) {
     },
     async showRecord({ recordId }) {
       const result = (0, import_reader4.showRecord)({
-        ...input.resolveTrustPriors === void 0 ? {} : { priors: input.resolveTrustPriors() },
         knowledgeRoot: await input.resolveKnowledgeRoot(),
         recordId
       });
@@ -788,19 +740,7 @@ function createKnowledgeReaderPort(input) {
     async showRecords({ recordIds }) {
       return (0, import_reader4.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.
-     */
+    // Not sighted; `skippedBundles` is forwarded verbatim so a half-read store never looks clean.
     async canaryAttributions({ runId, tuples }) {
       return (0, import_reader4.canaryAttributionsFor)({
         knowledgeRoot: await input.resolveKnowledgeRoot(),
@@ -815,7 +755,7 @@ function createKnowledgeReaderPort(input) {
 var import_node_fs3 = require("node:fs");
 var import_node_crypto2 = require("node:crypto");
 var import_node_path4 = require("node:path");
-var import_agent_qa_schema3 = require("@vostride/agent-qa-schema");
+var import_agent_qa_schema2 = require("@vostride/agent-qa-schema");
 var ANALYSIS_STAGE_PREFIX = "analysis.json";
 function fsyncFile(file) {
   const fd = (0, import_node_fs3.openSync)(file, "r");
@@ -829,7 +769,7 @@ function writeAnalysisArtifact(path, artifact) {
   const dir = (0, import_node_path4.dirname)(path);
   const staged = (0, import_node_path4.join)(dir, `.${ANALYSIS_STAGE_PREFIX}.${(0, import_node_crypto2.randomUUID)()}.tmp`);
   try {
-    (0, import_node_fs3.writeFileSync)(staged, `${(0, import_agent_qa_schema3.canonicalJson)(artifact)}
+    (0, import_node_fs3.writeFileSync)(staged, `${(0, import_agent_qa_schema2.canonicalJson)(artifact)}
 `, { encoding: "utf8", mode: 384 });
     fsyncFile(staged);
     (0, import_node_fs3.renameSync)(staged, path);
@@ -843,16 +783,16 @@ function writeAnalysisArtifact(path, artifact) {
 var import_node_fs5 = require("node:fs");
 var import_node_path6 = require("node:path");
 var import_agent_qa_agent2 = require("@vostride/agent-qa-agent");
-var import_agent_qa_schema6 = require("@vostride/agent-qa-schema");
+var import_agent_qa_schema5 = require("@vostride/agent-qa-schema");
 
 // src/store/job-checkpoint-store.ts
 var import_node_crypto3 = require("node:crypto");
 var import_node_fs4 = require("node:fs");
 var import_node_path5 = require("node:path");
-var import_agent_qa_schema5 = require("@vostride/agent-qa-schema");
+var import_agent_qa_schema4 = require("@vostride/agent-qa-schema");
 
 // src/store/store-errors.ts
-var import_agent_qa_schema4 = require("@vostride/agent-qa-schema");
+var import_agent_qa_schema3 = require("@vostride/agent-qa-schema");
 var import_agent_qa_agent = require("@vostride/agent-qa-agent");
 var JobStoreSchemaVersionError = class extends Error {
   constructor(path, expectedVersion, observedVersion) {
@@ -885,7 +825,7 @@ var InvalidJobCheckpointIdError = class extends Error {
 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 ${import_agent_qa_schema4.JOB_CHECKPOINT_SCHEMA_VERSION}. There is no migration machinery by design \u2014 clear agent job queue state and re-enqueue.`
+      `Agent job checkpoint ${path} was written at schema version ${String(observedVersion)}, but this build reads version ${import_agent_qa_schema3.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;
@@ -938,10 +878,10 @@ function readEnvelopeOn(fs, root, jobId, checkpointId) {
     throw error;
   }
   const raw = JSON.parse(text);
-  if (raw?.schemaVersion !== import_agent_qa_schema5.JOB_CHECKPOINT_SCHEMA_VERSION) {
+  if (raw?.schemaVersion !== import_agent_qa_schema4.JOB_CHECKPOINT_SCHEMA_VERSION) {
     throw new JobCheckpointSchemaVersionError(file, raw?.schemaVersion);
   }
-  const envelope = import_agent_qa_schema5.jobCheckpointEnvelopeSchema.parse(raw);
+  const envelope = import_agent_qa_schema4.jobCheckpointEnvelopeSchema.parse(raw);
   if (envelope.jobId !== jobId || envelope.checkpointId !== checkpointId) {
     throw new TypeError("Agent job checkpoint envelope does not match its address");
   }
@@ -984,8 +924,8 @@ function createJobCheckpointStoreOn(fs, options) {
     publish(jobId, checkpointId, payload) {
       const file = pathFor(jobId, checkpointId);
       const envelope = {
-        schemaVersion: import_agent_qa_schema5.JOB_CHECKPOINT_SCHEMA_VERSION,
-        jobId: (0, import_agent_qa_schema5.asJobId)(jobId),
+        schemaVersion: import_agent_qa_schema4.JOB_CHECKPOINT_SCHEMA_VERSION,
+        jobId: (0, import_agent_qa_schema4.asJobId)(jobId),
         checkpointId,
         payload
       };
@@ -994,7 +934,7 @@ function createJobCheckpointStoreOn(fs, options) {
       let fd;
       try {
         fd = fs.openSync(temporary, "wx");
-        fs.writeFileSync(fd, `${(0, import_agent_qa_schema5.canonicalJson)(envelope)}
+        fs.writeFileSync(fd, `${(0, import_agent_qa_schema4.canonicalJson)(envelope)}
 `, "utf8");
         fs.fsyncSync(fd);
         fs.closeSync(fd);
@@ -1088,10 +1028,10 @@ function guardHeader(sessionId, line) {
     throw new ChatSessionHeaderError(sessionId, "its header line is not an object");
   }
   const header = parsed;
-  if (header.schemaVersion !== import_agent_qa_schema6.CURRENT_CHAT_SESSION_SCHEMA_VERSION) {
+  if (header.schemaVersion !== import_agent_qa_schema5.CURRENT_CHAT_SESSION_SCHEMA_VERSION) {
     throw new ChatSessionHeaderError(
       sessionId,
-      `it declares schemaVersion ${String(header.schemaVersion)} and this build reads ` + String(import_agent_qa_schema6.CURRENT_CHAT_SESSION_SCHEMA_VERSION)
+      `it declares schemaVersion ${String(header.schemaVersion)} and this build reads ` + String(import_agent_qa_schema5.CURRENT_CHAT_SESSION_SCHEMA_VERSION)
     );
   }
   if (header.sessionId !== sessionId) {
@@ -1290,16 +1230,12 @@ function createJsonlSessionLogOn(fs, options) {
       const createdAt = options.now();
       const id = mintChatSessionId(createdAt, random);
       const header = {
-        schemaVersion: import_agent_qa_schema6.CURRENT_CHAT_SESSION_SCHEMA_VERSION,
+        schemaVersion: import_agent_qa_schema5.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.
+        // Spread conditionally, so absent means the option is not given.
         ...options.surface === void 0 ? {} : { surface: options.surface }
       };
       const created = fs.openSync(pathFor(id), "wx");
@@ -1321,20 +1257,20 @@ function createJsonlSessionLogOn(fs, options) {
 var import_node_fs8 = require("node:fs");
 var import_node_path9 = require("node:path");
 var import_node_sqlite3 = require("node:sqlite");
-var import_agent_qa_schema9 = require("@vostride/agent-qa-schema");
+var import_agent_qa_schema8 = require("@vostride/agent-qa-schema");
 
 // src/store/sqlite-job-store.ts
 var import_node_fs7 = require("node:fs");
 var import_node_path8 = require("node:path");
 var import_node_sqlite2 = require("node:sqlite");
 var import_agent_qa_agent3 = require("@vostride/agent-qa-agent");
-var import_agent_qa_schema8 = require("@vostride/agent-qa-schema");
+var import_agent_qa_schema7 = require("@vostride/agent-qa-schema");
 
 // src/store/logical-dump.ts
 var import_node_fs6 = require("node:fs");
 var import_node_path7 = require("node:path");
 var import_node_sqlite = require("node:sqlite");
-var import_agent_qa_schema7 = require("@vostride/agent-qa-schema");
+var import_agent_qa_schema6 = require("@vostride/agent-qa-schema");
 var SAFE_IDENTIFIER = /^[A-Za-z_][A-Za-z0-9_]*$/;
 function requireIdentifier(value) {
   if (!SAFE_IDENTIFIER.test(value)) {
@@ -1391,7 +1327,7 @@ function checkpointDigests(checkpointsRoot) {
       }
       found.push({
         path: (0, import_node_path7.relative)(checkpointsRoot, path).split(import_node_path7.sep).join("/"),
-        digest: (0, import_agent_qa_schema7.sha256hex)((0, import_node_fs6.readFileSync)(path, "utf8"))
+        digest: (0, import_agent_qa_schema6.sha256hex)((0, import_node_fs6.readFileSync)(path, "utf8"))
       });
     }
   }
@@ -1406,7 +1342,7 @@ function createLogicalDump(input) {
   };
 }
 function canonicalLogicalDump(dump) {
-  return (0, import_agent_qa_schema7.canonicalJson)(dump);
+  return (0, import_agent_qa_schema6.canonicalJson)(dump);
 }
 
 // src/store/sqlite-job-store.ts
@@ -1429,22 +1365,14 @@ var SCHEMA_STATEMENTS = [
      -- 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.
+     -- A stop request, not a lifecycle stage. New columns go last, or positional reads would move.
      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.
+     -- When the row was first claimed; survives lease release, cleared only by operator requeue.
      started_at TEXT,
-     -- 444.1 D-23: a retrying row is not claimable before this instant. Appended last, as above.
+     -- A retrying row is not claimable before this instant.
      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.
+  // The dedupe is this unique index, so no caller in any process can enqueue the same work twice.
   `CREATE UNIQUE INDEX IF NOT EXISTS jobs_kind_idempotency_key
      ON jobs (kind, idempotency_key)`,
   `CREATE TABLE IF NOT EXISTS job_store_fence (
@@ -1464,18 +1392,13 @@ var SCHEMA_STATEMENTS = [
      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.
+  // `created_at` comes from the injected clock; a SQL default would leak host time into the dump.
   `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.
+  // One notification per run, ever: a crash-replayed terminal hits this unique index.
   `CREATE UNIQUE INDEX IF NOT EXISTS notifications_run_id
      ON notifications (run_id)`
 ];
@@ -1484,7 +1407,7 @@ 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 !(0, import_agent_qa_schema8.isJobKind)(String(row.kind));
+  return !(0, import_agent_qa_schema7.isJobKind)(String(row.kind));
 }
 function quarantineConclusionOf(row) {
   if (!isUnreadableKindRow(row)) return void 0;
@@ -1666,7 +1589,7 @@ function createSqliteJobStore(options) {
     if (row === void 0) {
       throw new UnknownJobRowError("<missing>");
     }
-    return import_agent_qa_schema8.jobSchema.parse({
+    return import_agent_qa_schema7.jobSchema.parse({
       id: String(row.id),
       kind: String(row.kind),
       status: String(row.status),
@@ -1724,8 +1647,7 @@ function createSqliteJobStore(options) {
       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.
+      // Omitted rather than `undefined`, so a serialized row publishes no empty conclusion key.
       ...conclusionKind === void 0 ? {} : { conclusionKind },
       createdAt: String(row.created_at),
       updatedAt: String(row.updated_at)
@@ -1847,15 +1769,7 @@ function createSqliteJobStore(options) {
         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.
+    // Checkpoint rows go with the status, or the real handler resumes on the stand-in's value.
     async requeueTerminal(jobId, fence) {
       const now = clock.now();
       const decided = inTransaction(() => {
@@ -1885,8 +1799,8 @@ function createSqliteJobStore(options) {
     },
     async publishCheckpoint(jobId, checkpointId, payload, fence) {
       const now = clock.now();
-      const payloadJson = (0, import_agent_qa_schema8.canonicalJson)(payload);
-      const payloadDigest = (0, import_agent_qa_schema8.sha256hex)(payloadJson);
+      const payloadJson = (0, import_agent_qa_schema7.canonicalJson)(payload);
+      const payloadDigest = (0, import_agent_qa_schema7.sha256hex)(payloadJson);
       inTransaction(() => {
         requireFence(fence);
         requireRow(String(jobId));
@@ -1915,7 +1829,7 @@ function createSqliteJobStore(options) {
       try {
         const projection = checkpoints.read(String(jobId), checkpointId);
         if (!projection.found) return authoritative;
-        const projectionDigest = (0, import_agent_qa_schema8.sha256hex)((0, import_agent_qa_schema8.canonicalJson)(projection.payload));
+        const projectionDigest = (0, import_agent_qa_schema7.sha256hex)((0, import_agent_qa_schema7.canonicalJson)(projection.payload));
         return projectionDigest === String(row.payload_digest) ? projection : authoritative;
       } catch {
         return authoritative;
@@ -1933,7 +1847,7 @@ function createSqliteJobStore(options) {
     async listNotifications() {
       return selectNotifications.all().map((row) => ({
         runId: String(row.run_id),
-        payload: (0, import_agent_qa_schema8.guardRunNotification)(JSON.parse(String(row.payload))),
+        payload: (0, import_agent_qa_schema7.guardRunNotification)(JSON.parse(String(row.payload))),
         createdAt: String(row.created_at)
       }));
     },
@@ -1976,13 +1890,13 @@ function readCurationSnapshot(db, root, ids, runId) {
   if (row === void 0) return void 0;
   try {
     const authoritative = JSON.parse(String(row.payload_json));
-    if ((0, import_agent_qa_schema9.sha256hex)((0, import_agent_qa_schema9.canonicalJson)(authoritative)) !== row.payload_digest) {
+    if ((0, import_agent_qa_schema8.sha256hex)((0, import_agent_qa_schema8.canonicalJson)(authoritative)) !== row.payload_digest) {
       throw new CurationSnapshotReadError();
     }
     let payload = authoritative;
     try {
       const cached = readJobCheckpointEnvelope({ root }, String(ids.curateMemory), checkpointId);
-      if (cached.found && (0, import_agent_qa_schema9.sha256hex)((0, import_agent_qa_schema9.canonicalJson)(cached.envelope.payload)) === row.payload_digest) {
+      if (cached.found && (0, import_agent_qa_schema8.sha256hex)((0, import_agent_qa_schema8.canonicalJson)(cached.envelope.payload)) === row.payload_digest) {
         payload = cached.envelope.payload;
       }
     } catch {
@@ -1993,7 +1907,7 @@ function readCurationSnapshot(db, root, ids, runId) {
     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 import_agent_qa_schema9.CurationSnapshotSchema.parse(value.curationSnapshot);
+    return import_agent_qa_schema8.CurationSnapshotSchema.parse(value.curationSnapshot);
   } catch {
     throw new CurationSnapshotReadError();
   }
@@ -2003,7 +1917,7 @@ function toNumber2(value) {
 }
 function toRow(row) {
   if (row === void 0) return void 0;
-  const conclusionKind = !(0, import_agent_qa_schema9.isJobKind)(String(row.kind)) && row.status === "failed" && row.last_failure_kind === "permanent" && row.last_failure_reason === QUARANTINED_UNREADABLE_KIND_REASON ? "unreadable_kind" : void 0;
+  const conclusionKind = !(0, import_agent_qa_schema8.isJobKind)(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,
@@ -2044,15 +1958,11 @@ function createPostProcessingReader(options) {
         const curateMemory = toRow(
           selectJob.get(String(ids.curateMemory))
         );
-        const proposeImprovements = toRow(
-          selectJob.get(String(ids.proposeImprovements))
-        );
-        const notification = notificationRow === void 0 ? void 0 : (0, import_agent_qa_schema9.guardRunNotification)(JSON.parse(String(notificationRow.payload)));
+        const notification = notificationRow === void 0 ? void 0 : (0, import_agent_qa_schema8.guardRunNotification)(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 }
         };
@@ -2101,7 +2011,7 @@ var LOCAL_DAEMON_CAPABILITIES = Object.freeze({
   verifyEmbedderWorkerIncarnation: import_agent_qa_knowledge_local.verifyEmbedderWorkerIncarnation,
   resolveProcessIncarnation: import_agent_qa_knowledge_local.resolveProcessIncarnation,
   removeEmbedderWorkerRegistration: import_agent_qa_knowledge_local.removeEmbedderWorkerRegistration,
-  resetEmbedderCapability: () => (0, import_agent_qa_knowledge_local.resetEmbedderCapability)(import_agent_qa_schema10.DEFAULT_EMBEDDING_PROFILE),
+  resetEmbedderCapability: () => (0, import_agent_qa_knowledge_local.resetEmbedderCapability)(import_agent_qa_schema9.DEFAULT_EMBEDDING_PROFILE),
   pinLocalHeadlessExecutionContext: () => {
     (0, import_agent_qa_safety.setActiveExecutionContextResolver)(() => "local-headless");
   }
@@ -2112,8 +2022,6 @@ function receiptWriter(input) {
     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 }
   });
@@ -2162,10 +2070,6 @@ var LOCAL_CURATION_CAPABILITIES = Object.freeze({
   reconcileRunOutcomesProjection: import_agent_qa_knowledge_local.reconcileRunOutcomesProjection,
   enqueueCurationCandidateProjection: import_agent_qa_knowledge_local.enqueueCurationCandidateProjection,
   readCanonicalBundleAnchors: import_agent_qa_knowledge_local.readCanonicalBundleAnchors,
-  readCanonicalBundleStateDigests: import_agent_qa_knowledge_local.readCanonicalBundleStateDigests,
-  readCanaryPostureFacts: import_agent_qa_knowledge_local.canaryPostureFactsFor,
-  readStandingGateReceipts: import_agent_qa_knowledge_local.standingReceiptDigestsFor,
-  readLowerTrustShares: import_agent_qa_knowledge_local.lowerTrustSharesFor,
   runOutcomesProjectionVersion: import_agent_qa_knowledge_local.RUN_OUTCOMES_PROJECTION_VERSION,
   canaryOutcomeObservationId: import_reader5.canaryOutcomeObservationId,
   maintenance: Object.freeze({
@@ -2189,21 +2093,11 @@ 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() };
+  const targets = isRecord(artifact) ? artifact.targets : void 0;
+  if (!Array.isArray(targets) || targets.length === 0 || !targets.every(isTargetName)) {
+    return { status: "unknown" };
+  }
+  return { status: "recorded", names: [...new Set(targets)].sort() };
 }
 function createRunsReader(agentQaRoot) {
   function enumerate() {
@@ -2226,25 +2120,11 @@ function createRunsReader(agentQaRoot) {
     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.
-     */
+    // Matches the recorded `runId` over enumerated documents, so `../../etc` addresses nothing.
     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).
-     */
+    // A resume point below the earliest surviving seq throws `ReplayIncompleteError`.
     readEvents(runId, fromSeq) {
       const recorded = [...new import_agent_qa_runner_local3.FsEventLog({ root: agentQaRoot, runId }).read(0)].sort((left, right) => left.seq - right.seq);
       if (recorded.length === 0) return Promise.resolve([]);
@@ -2254,22 +2134,7 @@ function createRunsReader(agentQaRoot) {
       }
       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.
-     */
+    // Read through the version guard; an ambiguous step reports its candidates instead of guessing.
     readStepEvidence(runId, address) {
       const document = enumerate().find((candidate) => candidate.runId === runId);
       if (document === void 0) return Promise.resolve({ kind: "run-not-recorded" });
@@ -2287,12 +2152,7 @@ function createRunsReader(agentQaRoot) {
         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.
-     */
+    // The caller's id is compared, never joined onto a path; an absent snapshot is `unknown`.
     getRecordedTargets(runId) {
       const runsDir = (0, import_node_path10.join)(agentQaRoot, import_agent_qa_runner_local3.RUNS_SUBDIR);
       if (!(0, import_node_fs9.existsSync)(runsDir)) return Promise.resolve({ status: "unknown" });
@@ -2312,11 +2172,9 @@ function createRunsReader(agentQaRoot) {
     }
   };
 }
-function createKnowledgeReader(resolveKnowledgeRoot, sightMemoryEntities, resolvePromotionPosture, resolveTrustPriors) {
+function createKnowledgeReader(resolveKnowledgeRoot, sightMemoryEntities) {
   return createKnowledgeReaderPort({
     resolveKnowledgeRoot,
-    ...resolveTrustPriors === void 0 ? {} : { resolveTrustPriors },
-    ...resolvePromotionPosture === void 0 ? {} : { resolvePromotionPosture },
     ...sightMemoryEntities === void 0 ? {} : { sightMemoryEntities }
   });
 }
@@ -2350,10 +2208,7 @@ function createKnowledgeReview(input) {
     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.
+    // A missing identity is minted once per call and returned, so a retry is the same change.
     change: (request) => serialized(async () => {
       const { knowledgeRoot } = await roots();
       const operationId = request.operationId ?? (0, import_node_crypto4.randomUUID)();
@@ -2367,18 +2222,14 @@ function createKnowledgeReview(input) {
         // `knowledge.reject` or `knowledge.forget`, which is the verb's own op id.
         opId: `knowledge.${request.verb}`,
         executionContext: (input.resolveExecutionContext ?? import_agent_qa_safety.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 = (0, import_agent_qa_knowledge_local.openAddressingLedger)({
     path: (0, import_node_path10.join)(input.agentQaRoot, import_agent_qa_knowledge_local.ADDRESSING_LEDGER_DB_FILE)
   });
@@ -2391,8 +2242,6 @@ async function applyKnowledgeChange(input) {
       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 }
     });
@@ -2425,9 +2274,6 @@ async function withEntityResolutionDeps(input, body) {
     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: [(0, import_agent_qa_knowledge_local.createMemorySightingSource)(() => knowledgeRoot)]
     });
   } finally {
@@ -2449,7 +2295,7 @@ async function sweepEntityIndexProjection(input) {
     let embedded = 0;
     const acquire = input.acquireEmbedderCapability ?? import_agent_qa_knowledge_local.acquireEmbedder;
     const capability = await acquire({
-      preferredProfile: import_agent_qa_schema10.DEFAULT_EMBEDDING_PROFILE,
+      preferredProfile: import_agent_qa_schema9.DEFAULT_EMBEDDING_PROFILE,
       allowDownload: false,
       agentQaRoot: input.agentQaRoot
     });
@@ -2560,16 +2406,9 @@ function createDraftEvaluation(input) {
           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 are machine-local working state under the runtime root, not committed artifacts.
         receipts: (0, import_agent_qa_knowledge_local.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.
+        // `product` is gate 3's observed product: stability and the index ask about one app.
         suiteStability: {
           port: input.authoringFunnel,
           product: () => observedProduct
@@ -2590,7 +2429,7 @@ var SYSTEM_CLOCK = Object.freeze({
   now: () => (/* @__PURE__ */ new Date()).toISOString()
 });
 var digestJobIdSource = {
-  jobIdFor: (kind, idempotencyKey) => (0, import_agent_qa_schema10.asJobId)(`job_${(0, import_agent_qa_schema10.sha256hex16)(`${kind} ${idempotencyKey}`)}`)
+  jobIdFor: (kind, idempotencyKey) => (0, import_agent_qa_schema9.asJobId)(`job_${(0, import_agent_qa_schema9.sha256hex16)(`${kind} ${idempotencyKey}`)}`)
 };
 var DIGEST_JOB_ID_SOURCE = Object.freeze(digestJobIdSource);
 var LocalAgentClosedError = class extends Error {
@@ -2603,10 +2442,7 @@ var LocalAgentClosedError = class extends Error {
   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.
+  // Frozen deep, because the inner arrays are what the queue claims against.
   "masker-active": Object.freeze([]),
   "no-masker": Object.freeze(["curate-memory"])
 });
@@ -2716,7 +2552,7 @@ function createProjectionRecurrenceProvider(resolveKnowledgeRoot, now) {
 function createAnalysisArtifactReader(agentQaRoot) {
   return {
     getArtifact(runId) {
-      const path = (0, import_node_path10.join)(agentQaRoot, import_agent_qa_runner_local3.RUNS_SUBDIR, (0, import_agent_qa_runner_local3.slugBranch)(runId), import_agent_qa_schema10.ANALYSIS_FILE);
+      const path = (0, import_node_path10.join)(agentQaRoot, import_agent_qa_runner_local3.RUNS_SUBDIR, (0, import_agent_qa_runner_local3.slugBranch)(runId), import_agent_qa_schema9.ANALYSIS_FILE);
       let bytes;
       try {
         bytes = (0, import_node_fs9.readFileSync)(path, "utf8");
@@ -2724,71 +2560,32 @@ function createAnalysisArtifactReader(agentQaRoot) {
         if (error.code === "ENOENT") return void 0;
         throw error;
       }
-      const admission = (0, import_agent_qa_schema10.admitAnalysisArtifactForRun)(
-        (0, import_agent_qa_schema10.guardRunAnalysisArtifact)(JSON.parse(bytes)),
+      const admission = (0, import_agent_qa_schema9.admitAnalysisArtifactForRun)(
+        (0, import_agent_qa_schema9.guardRunAnalysisArtifact)(JSON.parse(bytes)),
         runId
       );
       return admission.kind === "admitted" ? admission.artifact : void 0;
     }
   };
 }
-function postRunCapabilities(input, knowledgeRoot, analysisTokenBudget, jobStore, proposeGate1MaxPerJob) {
+function postRunCapabilities(input, knowledgeRoot, analysisTokenBudget) {
   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) => (0, import_agent_qa_agent4.parseProposeGate1Allowance)(
-        await jobStore.readCheckpoint((0, import_agent_qa_schema10.asJobId)(jobId), import_agent_qa_agent4.PROPOSE_GATE1_ALLOWANCE_CHECKPOINT)
-      )
-    },
     loadCompletedRunHandoff: (runId) => (0, import_agent_qa_runner_local3.loadCompletedRunHandoff)(
       (0, import_node_path10.join)(input.agentQaRoot, import_agent_qa_runner_local3.RUNS_SUBDIR, (0, import_agent_qa_runner_local3.slugBranch)(runId), import_agent_qa_runner_local3.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.
+    // Derived from the artifact's own `runId` through `slugBranch`; a payload carries no path.
     persistAnalysis: (artifact) => writeAnalysisArtifact(
-      (0, import_node_path10.join)(input.agentQaRoot, import_agent_qa_runner_local3.RUNS_SUBDIR, (0, import_agent_qa_runner_local3.slugBranch)(artifact.runId), import_agent_qa_schema10.ANALYSIS_FILE),
+      (0, import_node_path10.join)(input.agentQaRoot, import_agent_qa_runner_local3.RUNS_SUBDIR, (0, import_agent_qa_runner_local3.slugBranch)(artifact.runId), import_agent_qa_schema9.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.
+    // Keyed by the stable identity (product, filePath, testName), never a per-run id; read-only.
     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.
+    // Through the shared `lookupEvidenceBlob`, so `runs.artifact` and this job agree on blobs.
     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.
+    // Host-resolved from the job model's profile; this composition adds no knob.
     ...analysisTokenBudget === void 0 ? {} : { analysisTokenBudget }
   };
 }
@@ -2806,7 +2603,7 @@ function chatToolsetIds(registry) {
 }
 function chatToolsetHash(registry) {
   if (registry === void 0) return "unbound";
-  return (0, import_agent_qa_schema10.sha256hex16)(chatToolsetIds(registry).join("\n"));
+  return (0, import_agent_qa_schema9.sha256hex16)(chatToolsetIds(registry).join("\n"));
 }
 function projectChatMembers(value, rules, mask) {
   return Object.fromEntries(Object.entries(value).map(([key, member]) => {
@@ -2814,11 +2611,11 @@ function projectChatMembers(value, rules, mask) {
     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, (0, import_agent_qa_schema10.maskPayloadTree)(member, mask)];
+    return [key, (0, import_agent_qa_schema9.maskPayloadTree)(member, mask)];
   }));
 }
 var eachChatRecord = (rules) => (value, mask) => {
-  const project = (entry) => isRecord(entry) ? projectChatMembers(entry, rules, mask) : (0, import_agent_qa_schema10.maskPayloadTree)(entry, mask);
+  const project = (entry) => isRecord(entry) ? projectChatMembers(entry, rules, mask) : (0, import_agent_qa_schema9.maskPayloadTree)(entry, mask);
   return Array.isArray(value) ? value.map(project) : project(value);
 };
 var CHAT_EVENT_BASE = {
@@ -2902,7 +2699,6 @@ function composeLocalAgent(input) {
       // 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: (0, import_agent_qa_agent4.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;
@@ -2913,11 +2709,7 @@ function composeLocalAgent(input) {
   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.
+    // The composed model, masked: a live override would stamp one session's switch on later ones.
     model: () => input.mask(composedChatModelName),
     toolsetHash: () => chatToolsetHash(composedRegistry)
   });
@@ -2968,14 +2760,7 @@ function composeLocalAgent(input) {
         stage = (0, import_agent_qa_agent4.createPlannerStage)({
           model: chatModelsByName.get(activeName) ?? input.chatModel,
           tools: (0, import_agent_qa_agent4.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.
+          // Read per request: a stage is shared by every session planning under one model.
           context: (contextRequest) => {
             const scope = chatScopeFor(contextRequest.sessionId).state.read();
             return { activeModel: scope.activeModel, conversation: scope.conversation };
@@ -2989,41 +2774,22 @@ function composeLocalAgent(input) {
   const chatCompaction = input.chatAccounting === void 0 ? void 0 : (0, import_agent_qa_agent4.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.
+    // What compaction leaves is the conversation the prompt renders, kept per session.
     onConversation: (messages, sessionId) => {
       chatScopeFor(sessionId).state.setConversation(messages);
     }
   });
   const chatTurn = (0, import_agent_qa_agent4.createTurnEngine)({
     table: import_agent_qa_agent4.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.
+    // The real conjunction grammar, quote-aware.
     split: import_agent_qa_agent4.splitClauses,
     reconcile: input.chatReconcile ?? import_agent_qa_agent4.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.
+    // Minted per stage: a table hit is a person typing (`human`); a planned call is `agent`.
     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.
+    // Classify the original bytes before projecting: `invokeFunction` does not mask.
     invoke: async (functionId, invokeInput, caller) => {
       if (composedRegistry === void 0) {
         throw new TypeError("a chat turn ran before its registry finished composing");
@@ -3034,24 +2800,9 @@ function composeLocalAgent(input) {
     },
     ...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.
+    // Resolved per session: `/model` and `/quit` act on the conversation running the turn.
     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.
+      // Applies nothing: `/model` resolves and caches by name, so the apply cannot throw midway.
       validate: async (directive, argument) => {
         if (directive === "model" && argument !== void 0 && input.chatModelFor !== void 0) {
           chatModelsByName.set(argument, await input.chatModelFor(argument));
@@ -3073,17 +2824,7 @@ function composeLocalAgent(input) {
       }
     }),
     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.
+    // Re-read per turn and per session, and masked like the log it is compared with.
     config: (sessionId) => {
       const ids = chatToolsetIds(composedRegistry);
       return {
@@ -3091,20 +2832,9 @@ function composeLocalAgent(input) {
         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.
+    // Bound only where the loop is; elsewhere an empty vocabulary refuses with the wrong cause.
     ...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.
+    // Spread conditionally, so a host binding no surface leaves `present` absent.
     ...input.chatPresent === void 0 ? {} : { present: input.chatPresent },
     now: () => clock.now(),
     mintTurnId: () => `turn-${(0, import_node_crypto4.randomUUID)()}`
@@ -3120,19 +2850,7 @@ function composeLocalAgent(input) {
         ...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.
+    // One read-only connection per verb; absent data answers empty, other failures propagate.
     outcomes: {
       testsIn: async (product, filePath) => {
         const knowledgeRoot = await input.knowledgeRoot();
@@ -3166,145 +2884,47 @@ function composeLocalAgent(input) {
           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.
+      // List verbs are live sighting sites: an entity gets its address when first surfaced.
       knowledge: createKnowledgeReader(
         input.knowledgeRoot,
-        createMemorySightingHook(entityResolutionInput),
-        input.resolvePromotionPosture,
-        input.resolveTrustPriors
+        createMemorySightingHook(entityResolutionInput)
       ),
       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.
+      // Optional, so a read-only host reports the mutating verbs as `unbound` by name.
       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.)
+        // The host's own context, so a direct change records the context it is made in.
         ...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).
+      // On every host, unlike `postRun`: a host that never drains still reads what the chain did.
       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.
+      // An absent port must be an absent field: the registry lists capabilities off this record.
       ...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.
+      // On every host, and the same reader the analysis job uses, so both agree 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).
+      // Present only if this host can run; the registry lists `runs.start` from the same record.
       ...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).
+      // Bindable from the roots alone, so every host serves the floor or the no-history clause.
       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).
+      // Spread conditionally so `agent.explain` lists `unbound` where no catalog is handed in.
       ...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.
+      // Spread conditionally, 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.
+      // The funnel reads records this host owns, so it is unconditional; its receipts port lists.
       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: (0, import_agent_qa_knowledge_local.createQuarantineOperations)({
@@ -3313,24 +2933,13 @@ function composeLocalAgent(input) {
         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.
+      // Bound here, so `agent.ask` is a real capability on every host.
       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.
+      // Both halves spread conditionally: a host that can parse but not run says `unbound`.
       ...input.draftAuthoring === void 0 || input.runExecution === void 0 ? {} : {
         draftEvaluation: createDraftEvaluation({
           authoring: input.draftAuthoring,
@@ -3351,50 +2960,7 @@ function composeLocalAgent(input) {
           }
         })
       },
-      // 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.
+      // The arch import scan reads comments too: never put a quote after the word `from`.
       ...authoringLoopHost === void 0 ? {} : {
         authoringRead: {
           async getAuthoringBrief(intent, scope) {
@@ -3402,35 +2968,21 @@ function composeLocalAgent(input) {
             return (0, import_agent_qa_knowledge_local.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.
+          // Off the same port as the brief and corpus, so a loop host names its own targets.
           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.
+        // Its own key: a scope needs config and workspace, the brief needs an index.
         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.
+          // The one RFC 6902 applier, at the host because it needs `core`'s yaml CST.
           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`.
+          // Same seam as the 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.
+          // The evaluator's reader; probes use the gate-run caller, so outcomes exclude them.
           runs: {
             start: async (request) => {
               if (composedRegistry === void 0) {
@@ -3445,8 +2997,6 @@ function composeLocalAgent(input) {
             },
             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");
@@ -3459,28 +3009,13 @@ function composeLocalAgent(input) {
             );
           }
         }
-        // 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`.
+      // Each config-editor half spreads on its own condition, so a missing one reads `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;
@@ -3492,7 +3027,6 @@ function composeLocalAgent(input) {
     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: (0, import_node_path10.join)(input.agentQaRoot, AGENT_JOB_STORE_DB_FILE),
       clock,
@@ -3501,7 +3035,7 @@ function composeLocalAgent(input) {
     let jobs;
     try {
       const kinds = input.jobKinds ?? (0, import_agent_qa_agent4.createRealJobKindRegistry)(
-        postRunCapabilities(input, knowledgeRoot, analysisTokenBudget, store, proposeGate1MaxPerJob)
+        postRunCapabilities(input, knowledgeRoot, analysisTokenBudget)
       );
       const idSource = input.idSource ?? DIGEST_JOB_ID_SOURCE;
       const unclaimableKinds = UNCLAIMABLE_BY_PROSE_POSTURE[input.postRun?.candidateProse ?? "no-masker"];
@@ -3584,13 +3118,324 @@ function composeLocalAgent(input) {
 var import_agent_qa_runner_local4 = require("@vostride/agent-qa-runner-local");
 var import_agent_qa_runner_local5 = require("@vostride/agent-qa-runner-local");
 
-// src/composition/compose-job-recovery.ts
+// src/store/mark-ledger.ts
+var import_node_fs11 = require("node:fs");
+var import_node_path12 = require("node:path");
+var import_agent_qa_schema10 = require("@vostride/agent-qa-schema");
+var import_zod2 = require("zod");
+
+// src/composition/run-layout.ts
+var import_agent_qa_runner_local6 = require("@vostride/agent-qa-runner-local");
+
+// src/store/mark-lock.ts
+var import_node_crypto5 = require("node:crypto");
+var import_node_fs10 = require("node:fs");
 var import_node_path11 = require("node:path");
+var import_zod = require("zod");
+var ownerSchema = import_zod.z.object({
+  schemaVersion: import_zod.z.literal(2),
+  kind: import_zod.z.literal("mark-ledger-lock"),
+  pid: import_zod.z.number().int().positive(),
+  token: import_zod.z.uuid(),
+  runId: import_zod.z.string().min(1)
+}).strict();
+function syncDirectory(path) {
+  const fd = (0, import_node_fs10.openSync)(path, "r");
+  try {
+    (0, import_node_fs10.fsyncSync)(fd);
+  } finally {
+    (0, import_node_fs10.closeSync)(fd);
+  }
+}
+function readOwner(path, runId) {
+  try {
+    const directory = (0, import_node_fs10.lstatSync)(path);
+    if (!directory.isDirectory() || directory.isSymbolicLink()) return void 0;
+    const ownerFile = (0, import_node_path11.join)(path, "owner.json");
+    const file = (0, import_node_fs10.lstatSync)(ownerFile);
+    if (!file.isFile() || file.isSymbolicLink()) return void 0;
+    const parsed = ownerSchema.safeParse(JSON.parse((0, import_node_fs10.readFileSync)(ownerFile, "utf8")));
+    return parsed.success && parsed.data.runId === runId ? parsed.data : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function positivelyDead(pid) {
+  try {
+    process.kill(pid, 0);
+    return false;
+  } catch (error) {
+    return error.code === "ESRCH";
+  }
+}
+async function acquireMarkLock(lock, runId, busy) {
+  const owner = { schemaVersion: 2, kind: "mark-ledger-lock", pid: process.pid, token: (0, import_node_crypto5.randomUUID)(), runId };
+  const candidate = `${lock}.candidate-${owner.token}`;
+  (0, import_node_fs10.mkdirSync)(candidate);
+  const fd = (0, import_node_fs10.openSync)((0, import_node_path11.join)(candidate, "owner.json"), "wx", 384);
+  try {
+    (0, import_node_fs10.writeFileSync)(fd, JSON.stringify(owner));
+    (0, import_node_fs10.fsyncSync)(fd);
+  } finally {
+    (0, import_node_fs10.closeSync)(fd);
+  }
+  syncDirectory(candidate);
+  const started = Date.now();
+  let acquired = false;
+  try {
+    while (!acquired) {
+      try {
+        (0, import_node_fs10.mkdirSync)(lock);
+        (0, import_node_fs10.renameSync)((0, import_node_path11.join)(candidate, "owner.json"), (0, import_node_path11.join)(lock, "owner.json"));
+        syncDirectory(lock);
+        syncDirectory((0, import_node_path11.dirname)(lock));
+        (0, import_node_fs10.rmSync)(candidate, { recursive: true });
+        acquired = true;
+      } catch (error) {
+        if (!["EEXIST", "ENOTEMPTY", "ENOTDIR", "EISDIR", "EPERM", "EACCES"].includes(error.code ?? "")) throw error;
+        const current = readOwner(lock, runId);
+        if (current !== void 0 && positivelyDead(current.pid)) {
+          try {
+            (0, import_node_fs10.renameSync)(lock, `${lock}.dead-${current.token}`);
+            syncDirectory((0, import_node_path11.dirname)(lock));
+            continue;
+          } catch (recoveryError) {
+            if (recoveryError.code === "ENOENT") continue;
+            if (!["EEXIST", "ENOTEMPTY", "ENOTDIR", "EISDIR", "EPERM", "EACCES"].includes(recoveryError.code ?? "")) throw recoveryError;
+          }
+        }
+        const remaining = 1e4 - (Date.now() - started);
+        if (remaining <= 0) throw busy();
+        await new Promise((resolve2) => setTimeout(resolve2, Math.min(50, remaining)));
+      }
+    }
+  } finally {
+    if (!acquired) (0, import_node_fs10.rmSync)(candidate, { recursive: true, force: true });
+  }
+  return () => {
+    if (readOwner(lock, runId)?.token !== owner.token) return;
+    const released = `${lock}.released-${owner.token}`;
+    (0, import_node_fs10.renameSync)(lock, released);
+    syncDirectory((0, import_node_path11.dirname)(lock));
+    (0, import_node_fs10.rmSync)(released, { recursive: true });
+    syncDirectory((0, import_node_path11.dirname)(lock));
+  };
+}
+
+// src/store/mark-ledger.ts
+var MARKS_LEDGER_FILE = "marks.jsonl";
+var MARKS_LEDGER_LOCK_FILE = "marks.jsonl.lock";
+var MARK_INTENT_FILE = "mark-intent.json";
+var MARK_INTENT_STAGES = ["prepared", "evidence", "applied"];
+var intentSchema = import_zod2.z.object({
+  schemaVersion: import_zod2.z.literal(2),
+  mark: import_agent_qa_schema10.MarkReceiptSchema,
+  stage: import_zod2.z.enum(MARK_INTENT_STAGES),
+  operationId: import_zod2.z.uuid(),
+  plan: import_agent_qa_schema10.ImprovementPlanSchema.optional()
+}).strict().superRefine((intent, ctx) => {
+  if (intent.stage === "applied" && intent.mark.disposition.kind === "drafted") {
+    ctx.addIssue({ code: "custom", path: ["mark", "disposition"], message: "a mark applies its fix; it never files a draft" });
+  }
+});
+function atomicPublish(path, text) {
+  const staged = `${path}.pending`;
+  const fd = (0, import_node_fs11.openSync)(staged, "w", 384);
+  try {
+    (0, import_node_fs11.writeFileSync)(fd, text);
+    (0, import_node_fs11.fsyncSync)(fd);
+  } finally {
+    (0, import_node_fs11.closeSync)(fd);
+  }
+  (0, import_node_fs11.renameSync)(staged, path);
+}
+var MarkLedgerBusyError = class extends Error {
+  constructor() {
+    super("Mark ledger is busy; retry the mark after the current transaction finishes");
+    this.name = "MarkLedgerBusyError";
+  }
+};
+var MarkLedgerCorruptError = class extends Error {
+  constructor(line) {
+    super(`Mark ledger is corrupt at line ${line}`);
+    this.line = line;
+    this.name = "MarkLedgerCorruptError";
+  }
+};
+var MarkIntentUnusableError = class extends Error {
+  constructor(intentPath, reason) {
+    const what = reason === "earlier-version" ? "was written by an earlier agent-qa version, which this version does not read" : reason === "unreadable" ? "is unreadable" : "does not match this run's mark ledger";
+    super(`The unfinished-mark record ${intentPath} ${what}; nothing was marked. Remove that file, then mark again.`);
+    this.intentPath = intentPath;
+    this.reason = reason;
+    this.name = "MarkIntentUnusableError";
+  }
+};
+function isEarlierVersionIntent(value) {
+  if (value === null || typeof value !== "object") return false;
+  const intent = value;
+  return "proposalUuid" in intent || "testDraft" in intent || intent["stage"] === "drafted";
+}
+function latestMarkReceiptsPerAddress(receipts) {
+  const latest = /* @__PURE__ */ new Map();
+  for (const receipt of receipts) {
+    const key = (0, import_agent_qa_schema10.markAddressKey)(receipt);
+    if ((latest.get(key)?.ordinal ?? 0) < receipt.ordinal) latest.set(key, receipt);
+  }
+  return [...latest.values()].sort(
+    (a, b) => a.testIndex - b.testIndex || (a.stepIndex ?? -1) - (b.stepIndex ?? -1)
+  );
+}
+function latestMarkReceiptFor(receipts, runId, address) {
+  if (address.runId !== runId) return void 0;
+  return latestMarkReceiptsPerAddress(receipts).find((receipt) => (0, import_agent_qa_schema10.markAddressKey)(receipt) === (0, import_agent_qa_schema10.markAddressKey)(address) && (address.testId === void 0 || receipt.testId === address.testId));
+}
+var MarkLedgerNoRunError = class extends Error {
+  constructor() {
+    super("run-not-found: mark ledger requires a completed run handoff");
+    this.name = "MarkLedgerNoRunError";
+  }
+};
+var FsMarkLedger = class {
+  dir;
+  file;
+  lock;
+  runId;
+  runSlug;
+  inTransaction = false;
+  intentValue;
+  constructor(config) {
+    this.runId = config.runId;
+    this.runSlug = (0, import_agent_qa_schema10.slugBranch)(config.runId);
+    this.dir = (0, import_node_path12.join)(config.root, import_agent_qa_runner_local6.RUNS_SUBDIR, this.runSlug);
+    this.file = (0, import_node_path12.join)(this.dir, MARKS_LEDGER_FILE);
+    this.lock = (0, import_node_path12.join)(this.dir, MARKS_LEDGER_LOCK_FILE);
+  }
+  read() {
+    let text;
+    try {
+      text = (0, import_node_fs11.readFileSync)(this.file, "utf8");
+    } catch (error) {
+      if (error.code === "ENOENT") return [];
+      throw error;
+    }
+    if (text === "") return [];
+    const lines = text.split("\n");
+    if (lines.pop() !== "") throw new MarkLedgerCorruptError(lines.length + 1);
+    return lines.map((line, index) => {
+      try {
+        const receipt = import_agent_qa_schema10.MarkReceiptSchema.parse(JSON.parse(line));
+        if (receipt.ordinal !== index + 1 || receipt.runId !== this.runId || receipt.runSlug !== this.runSlug) {
+          throw new Error("ledger identity or ordinal mismatch");
+        }
+        return receipt;
+      } catch {
+        throw new MarkLedgerCorruptError(index + 1);
+      }
+    });
+  }
+  latestPerAddress() {
+    return latestMarkReceiptsPerAddress(this.read());
+  }
+  latestFor(address) {
+    if (address.runId !== this.runId) return void 0;
+    return latestMarkReceiptFor(this.read(), this.runId, address);
+  }
+  /** Private resumable state is admitted only while this run's existing lock is held. */
+  prepareIntent(mark, operationId) {
+    if (!this.inTransaction) throw new Error("mark intent requires the run transaction");
+    const prior = this.intentValue;
+    if (prior !== void 0) {
+      const request = (value) => ({
+        runId: value.runId,
+        testIndex: value.testIndex,
+        testId: value.testId,
+        stepIndex: value.stepIndex,
+        kind: value.kind,
+        note: value.note
+      });
+      if ((0, import_agent_qa_schema10.canonicalJson)(request(prior.mark)) !== (0, import_agent_qa_schema10.canonicalJson)(request(mark))) {
+        throw new Error("An unfinished mark must be retried with its original address, kind and note");
+      }
+      return prior;
+    }
+    return this.checkpointIntent({ schemaVersion: 2, mark, operationId, stage: "prepared" });
+  }
+  checkpointIntent(value) {
+    if (!this.inTransaction) throw new Error("mark intent requires the run transaction");
+    const intent = intentSchema.parse(value);
+    if (intent.mark.runId !== this.runId || intent.mark.runSlug !== this.runSlug || intent.mark.ordinal !== this.read().length + 1) throw new MarkLedgerCorruptError(intent.mark.ordinal);
+    atomicPublish((0, import_node_path12.join)(this.dir, MARK_INTENT_FILE), `${(0, import_agent_qa_schema10.canonicalJson)(intent)}
+`);
+    this.intentValue = intent;
+    return intent;
+  }
+  async transact(fn) {
+    if (!(0, import_node_fs11.existsSync)((0, import_node_path12.join)(this.dir, import_agent_qa_runner_local6.HANDOFF_FILE))) throw new MarkLedgerNoRunError();
+    const release = await acquireMarkLock(this.lock, this.runId, () => new MarkLedgerBusyError());
+    try {
+      const receipts = this.read();
+      const nextOrdinal = receipts.length + 1;
+      const intentPath = (0, import_node_path12.join)(this.dir, MARK_INTENT_FILE);
+      this.intentValue = void 0;
+      if ((0, import_node_fs11.existsSync)(intentPath)) {
+        let raw;
+        try {
+          raw = JSON.parse((0, import_node_fs11.readFileSync)(intentPath, "utf8"));
+        } catch {
+          throw new MarkIntentUnusableError(intentPath, "unreadable");
+        }
+        const parsed = intentSchema.safeParse(raw);
+        if (!parsed.success) {
+          throw new MarkIntentUnusableError(
+            intentPath,
+            isEarlierVersionIntent(raw) ? "earlier-version" : "unreadable"
+          );
+        }
+        const intent = parsed.data;
+        if (intent.mark.runId !== this.runId || intent.mark.runSlug !== this.runSlug) {
+          throw new MarkIntentUnusableError(intentPath, "mismatched");
+        }
+        if (intent.mark.ordinal === nextOrdinal) this.intentValue = intent;
+        else if ((0, import_agent_qa_schema10.canonicalJson)(receipts[intent.mark.ordinal - 1]) === (0, import_agent_qa_schema10.canonicalJson)(intent.mark)) (0, import_node_fs11.unlinkSync)(intentPath);
+        else throw new MarkIntentUnusableError(intentPath, "mismatched");
+      }
+      this.inTransaction = true;
+      const record = await fn(nextOrdinal);
+      if (record === void 0) return void 0;
+      const receipt = import_agent_qa_schema10.MarkReceiptSchema.parse({ ...record, ordinal: nextOrdinal });
+      if (receipt.runId !== this.runId || receipt.runSlug !== this.runSlug) {
+        throw new Error("mark receipt does not belong to this run ledger");
+      }
+      if (this.intentValue !== void 0 && (this.intentValue.stage !== "applied" || (0, import_agent_qa_schema10.canonicalJson)(this.intentValue.mark) !== (0, import_agent_qa_schema10.canonicalJson)(receipt))) {
+        throw new MarkLedgerCorruptError(nextOrdinal);
+      }
+      const before = (0, import_node_fs11.existsSync)(this.file) ? (0, import_node_fs11.readFileSync)(this.file, "utf8") : "";
+      atomicPublish(this.file, `${before}${(0, import_agent_qa_schema10.canonicalJson)(receipt)}
+`);
+      if (this.intentValue !== void 0) (0, import_node_fs11.unlinkSync)(intentPath);
+      return receipt;
+    } finally {
+      this.inTransaction = false;
+      this.intentValue = void 0;
+      release();
+    }
+  }
+  append(record) {
+    return this.transact(async () => record);
+  }
+};
+
+// src/composition/action-cache.ts
+var import_agent_qa_runner_local7 = require("@vostride/agent-qa-runner-local");
+
+// src/composition/compose-job-recovery.ts
+var import_node_path13 = require("node:path");
 var import_agent_qa_agent5 = require("@vostride/agent-qa-agent");
 var JOB_RECOVERY_MAX_RESUMED_JOBS = 64;
 function composeJobRecovery(input) {
   const store = createSqliteJobStore({
-    path: (0, import_node_path11.join)(input.agentQaRoot, AGENT_JOB_STORE_DB_FILE),
+    path: (0, import_node_path13.join)(input.agentQaRoot, AGENT_JOB_STORE_DB_FILE),
     clock: input.clock,
     checkpoints: createJobCheckpointStore({ root: input.agentQaRoot })
   });
@@ -3711,7 +3556,6 @@ function createMemorySessionLog(options) {
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  ALLOW_PRODUCTION_OPT_IN,
   BRIEF_CEILING,
   BRIEF_FRACTION,
   BuildOrdinalReservationError,
@@ -3728,25 +3572,32 @@ function createMemorySessionLog(options) {
   EMBEDDER_WORKER_TERM_GRACE_MS,
   ENTITY_INDEX_SWEEP_INTERVAL_MS,
   EmbedderWorkerTimeoutError,
+  FsMarkLedger,
   GLOBAL_RECORD_CAP,
+  HANDOFF_FILE,
   InvalidChatSessionIdError,
   JOB_RECOVERY_MAX_RESUMED_JOBS,
   LOCAL_CURATION_CAPABILITIES,
   LOCAL_DAEMON_CAPABILITIES,
   LOCAL_KNOWLEDGE_PROBES,
   LocalAgentClosedError,
+  MARKS_LEDGER_FILE,
+  MARKS_LEDGER_LOCK_FILE,
+  MARK_INTENT_FILE,
   MIN_BRIEF,
   MIN_CAUTION,
   MIN_MEMORY_TOOL_CONTEXT_WINDOW,
+  MarkIntentUnusableError,
+  MarkLedgerBusyError,
+  MarkLedgerCorruptError,
+  MarkLedgerNoRunError,
   QUARANTINE_CLASS_DISPOSITIONS,
   QUARANTINE_FLOOR_ELIGIBILITY,
   READ_BODY_FRACTION,
-  REFUSED_RUN_REQUEST_FIELDS,
-  RunDeniedError,
+  RUNS_SUBDIR,
   RunIdAlreadyInUseError,
   RunIdNotMintedError,
   RunProducedNoEventsError,
-  RunRequestFieldRefusedError,
   SUITE_LIFECYCLE_LANE,
   SYSTEM_CLOCK,
   SuiteBoundaryWhileLiveError,
@@ -3755,7 +3606,6 @@ function createMemorySessionLog(options) {
   WEAK_MODEL_CAP_SCALE,
   applyKnowledgeChange,
   buildMemberRunConfig,
-  buildProductionRefusal,
   buildRunPorts,
   buildScreenshotCompressor,
   buildSuiteMemberExecutor,
@@ -3775,15 +3625,17 @@ function createMemorySessionLog(options) {
   createRunsReader,
   createSuiteLifecycle,
   latestBuildOrdinal,
+  latestMarkReceiptFor,
+  latestMarkReceiptsPerAddress,
   listSessions,
+  loadCompletedRunHandoff,
   lookupEvidenceBlob,
   mapVerdictToExitCode,
   memoryToolGate,
   mintChatSessionId,
   openRunKnowledgeComposition,
+  purgeActionCache,
   readEvidenceBlobBytes,
-  refuseProductionWithoutOptIn,
-  refuseUnavailableRunId,
   registerAdapterLiveStream,
   reserveBuildOrdinalForProducts,
   resolveBuildTag,