@akagilnc/pi-workflow-roles 0.1.4620 → 0.1.4631

package/dist/headless-host/production-host.js

@@ -417,7 +417,7 @@ function normalizeReviewComment(raw) {
 function createGhApiRunner(options = {}) {
   const spawnImpl = options.spawnImpl ?? spawn;
   return async (args, runOptions = {}) => {
-    return await new Promise((resolve22, reject) => {
+    return await new Promise((resolve21, reject) => {
       const signal = runOptions.signal;
       if (signal?.aborted) {
         reject(signal.reason ?? new Error("aborted"));
@@ -490,11 +490,11 @@ function createGhApiRunner(options = {}) {
               const value = line2.slice(idx + 1).trim();
               headers[name] = value;
             }
-            resolve22({ status, headers, bodyText });
+            resolve21({ status, headers, bodyText });
             return;
           }
           if (code === 0) {
-            resolve22({ status: 200, headers: {}, bodyText: stdout });
+            resolve21({ status: 200, headers: {}, bodyText: stdout });
             return;
           }
           const failure2 = new Error(
@@ -691,7 +691,6 @@ var activation_ledger_topology_exports = {};
 __export(activation_ledger_topology_exports, {
   ActivationLedgerError: () => ActivationLedgerError,
   activationBookDirectory: () => activationBookDirectory,
-  activationWaitingLedgerPath: () => activationWaitingLedgerPath,
   assertLedgerFileInsideHome: () => assertLedgerFileInsideHome,
   ensureRealDirectoryTree: () => ensureRealDirectoryTree,
   errnoCode: () => errnoCode,
@@ -754,9 +753,6 @@ function resolveActivationLedgerHomeForPath(path) {
 function activationBookDirectory(ledgerHome, bookKey) {
   return join(ledgerHome, "books", bookKey);
 }
-function activationWaitingLedgerPath(ledgerHome, bookKey) {
-  return join(activationBookDirectory(ledgerHome, bookKey), "waiting.jsonl");
-}
 function pathContainedIn(root, candidate) {
   const rel = relative(root, candidate);
   return rel !== "" && rel !== ".." && !rel.startsWith(`..${sep}`) && !isAbsolute(rel);
@@ -1964,7 +1960,7 @@ async function spawnEngineDetourOnce(input) {
   }
   const command = input.argv[0];
   const args = input.argv.slice(1);
-  return await new Promise((resolve22, reject) => {
+  return await new Promise((resolve21, reject) => {
     let settled = false;
     const signal = input.signal;
     const child = spawn2(command, args, {
@@ -1994,7 +1990,7 @@ async function spawnEngineDetourOnce(input) {
       if (signal !== void 0) {
         signal.removeEventListener("abort", onAbort);
       }
-      resolve22(result);
+      resolve21(result);
     };
     const onAbort = () => {
       fail4(signal !== void 0 ? abortReasonError(signal) : new Error("aborted"));
@@ -3746,9 +3742,6 @@ ${paths.join("\n")}`
       if (typeof process.env.AK_ROLE_AUDITOR_SUBJECT === "string" && process.env.AK_ROLE_AUDITOR_SUBJECT.trim() !== "") {
         env.AK_ROLE_AUDITOR_SUBJECT = process.env.AK_ROLE_AUDITOR_SUBJECT;
       }
-      if (request.correlationId !== void 0 && request.correlationId.trim() !== "") {
-        env.AK_CORRELATION_ID = request.correlationId;
-      }
       if (config.recordLaunchedRolePackageIdentity !== void 0 && config.observeLaunchedRolePackageIdentity !== void 0) {
         await config.recordLaunchedRolePackageIdentity(
           request.runDirectory,
@@ -12018,12 +12011,12 @@ function createSystemCollectorClock() {
   return {
     wallNow: () => /* @__PURE__ */ new Date(),
     monoNow: () => Number(process.hrtime.bigint() - start) / 1e6,
-    sleep: (ms, signal) => new Promise((resolve22, reject) => {
+    sleep: (ms, signal) => new Promise((resolve21, reject) => {
       if (signal?.aborted) {
         reject(signal.reason ?? new Error("aborted"));
         return;
       }
-      const timer = setTimeout(resolve22, ms);
+      const timer = setTimeout(resolve21, ms);
       const onAbort = () => {
         clearTimeout(timer);
         reject(signal?.reason ?? new Error("aborted"));
@@ -16500,10 +16493,10 @@ function presentFailureTerminal(terminal, io) {
 }
 function defaultNavigatorGraceSleep() {
   let timer;
-  const sleep = ((ms) => new Promise((resolve22) => {
+  const sleep = ((ms) => new Promise((resolve21) => {
     timer = setTimeout(() => {
       timer = void 0;
-      resolve22();
+      resolve21();
     }, ms);
   }));
   sleep.cancel = () => {
@@ -16515,7 +16508,7 @@ function defaultNavigatorGraceSleep() {
   return sleep;
 }
 function raceNavigatorGrace(work, graceMs = NAVIGATOR_POST_ROLE_GRACE_MS, sleep = defaultNavigatorGraceSleep()) {
-  return new Promise((resolve22, reject) => {
+  return new Promise((resolve21, reject) => {
     let settled = false;
     const finish = (action) => {
       if (settled) return;
@@ -16524,11 +16517,11 @@ function raceNavigatorGrace(work, graceMs = NAVIGATOR_POST_ROLE_GRACE_MS, sleep
       action();
     };
     void work.then(
-      (value) => finish(() => resolve22({ status: "done", value })),
+      (value) => finish(() => resolve21({ status: "done", value })),
       (error) => finish(() => reject(error))
     );
     void sleep(graceMs).then(() => {
-      finish(() => resolve22({ status: "timeout" }));
+      finish(() => resolve21({ status: "timeout" }));
     });
   });
 }
@@ -17534,6 +17527,24 @@ var init_public_run_credentials = __esm({
   }
 });
 
+// src/public-cli/process-cancel.ts
+function processCancelSignalName(signal) {
+  if (signal === void 0 || signal.aborted !== true) return void 0;
+  const reason = signal.reason;
+  if (reason === "SIGTERM" || reason === "SIGINT" || reason === "SIGHUP") {
+    return reason;
+  }
+  return void 0;
+}
+function processCancelDiagnostic(signalName) {
+  return `ak-role terminated by ${signalName}`;
+}
+var init_process_cancel = __esm({
+  "src/public-cli/process-cancel.ts"() {
+    "use strict";
+  }
+});
+
 // src/public-cli/auto-resume.ts
 import { constants as fsConstants2 } from "node:fs";
 import { randomUUID as randomUUID5 } from "node:crypto";
@@ -17836,6 +17847,10 @@ async function runWithAutoResumeLoop(options) {
         if (terminal !== void 0) presentTerminal(terminal, options.io);
         return result;
       }
+      if (processCancelSignalName(options.signal) !== void 0) {
+        if (terminal !== void 0) presentTerminal(terminal, options.io);
+        return result;
+      }
     }
     if (result !== void 0) {
       const terminal = result.terminal;
@@ -17869,6 +17884,28 @@ async function runWithAutoResumeLoop(options) {
           terminal
         };
       }
+      const cancelName = processCancelSignalName(options.signal);
+      if (cancelName !== void 0) {
+        const terminal = await attachDispatchExceptionTerminal(
+          options.admitted,
+          dispatchExceptionFailureTerminal({
+            role: options.admitted.role,
+            runId: options.admitted.runId,
+            causeError: lastThrownError,
+            errorFiles: retainedErrorFiles,
+            autoResumeAttempts,
+            endReason: `ak-role terminated by ${cancelName}`,
+            everyAttemptThrew
+          }),
+          options.io
+        );
+        await finalizeExceptionRunBestEffort(options.admitted.runDirectory, options.io);
+        presentTerminal(terminal, options.io);
+        return {
+          exitCode: 1,
+          terminal
+        };
+      }
       if (!await isPrincipalAvailable(options.admitted.principal)) {
         const terminal = await attachDispatchExceptionTerminal(
           options.admitted,
@@ -17905,6 +17942,7 @@ var init_auto_resume = __esm({
     init_role_run_placement();
     init_run_lifecycle();
     init_config();
+    init_process_cancel();
     init_terminal();
     init_settlement();
     dummyIo = { stdout: () => {
@@ -17937,6 +17975,36 @@ function describeCaughtError(error) {
 function isStationChildOfficerDialogue(role, env) {
   return env.stationChild === true && isOfficerReviewSeat(role);
 }
+function withProcessCancelSkipAutoResume(result, signal) {
+  if (processCancelSignalName(signal) === void 0) {
+    return result;
+  }
+  return { ...result, skipAutoResume: true };
+}
+async function settleProcessCancelAfterTurn(input) {
+  const failed = await settleAfterTurnStarted(
+    input.admitted,
+    withEngineDetourInvocationScope(
+      {
+        timedOut: input.result.timedOut,
+        code: input.result.code,
+        stderr: input.result.stderr,
+        knownDiagnostic: processCancelDiagnostic(input.cancelName)
+      },
+      input.invocationScopeId
+    ),
+    input.adapters,
+    input.env.principalAuthority,
+    input.io,
+    input.persistRunState
+  );
+  return {
+    ...failed,
+    turnDispatched: true,
+    skipAutoResume: true,
+    ...input.deferredPersist
+  };
+}
 function withOnceSuccessfulBeforeDispatch(adapters) {
   const hook = adapters.beforeDispatch;
   if (hook === void 0) return adapters;
@@ -18097,6 +18165,31 @@ async function dispatchPostAdmissionTurn(input) {
   const finishAfterTurn = async (result) => {
     if (afterDispatchApplied) return result;
     afterDispatchApplied = true;
+    const cancelBeforeFinish = processCancelSignalName(env.signal);
+    if (cancelBeforeFinish !== void 0 && result.terminal !== void 0 && isLawfulTypedTerminalOutcome(result.terminal.roleOutcome)) {
+      result = {
+        ...await settleAfterTurnStarted(
+          admitted,
+          withEngineDetourInvocationScope(
+            {
+              timedOut: false,
+              code: null,
+              stderr: "",
+              knownDiagnostic: processCancelDiagnostic(cancelBeforeFinish),
+              skipRunStateWrite: true
+            },
+            request.invocationScopeId
+          ),
+          adapters,
+          env.principalAuthority,
+          io,
+          persistRunState
+        ),
+        turnDispatched: true,
+        skipAutoResume: true,
+        ...deferredPersist
+      };
+    }
     try {
       if (admitted.ticketNumber === void 0) {
         const rows = await readRecordedSubmissionRows(
@@ -18243,20 +18336,26 @@ async function dispatchPostAdmissionTurn(input) {
     try {
       result = await env.roleTurnHost.executeTurn(turnRequest);
     } catch (error) {
+      const processCancelName = processCancelSignalName(env.signal);
       const settled2 = await settleAfterTurnStarted(
         admitted,
         withEngineDetourInvocationScope({
           timedOut: false,
           code: null,
           stderr: "",
-          thrown: error
+          thrown: processCancelName === void 0 ? error : new Error(processCancelDiagnostic(processCancelName), { cause: error })
         }, request.invocationScopeId),
         adapters,
         env.principalAuthority,
         io,
         persistRunState
       );
-      return await finishAfterTurn({ ...settled2, turnDispatched: true, ...deferredPersist });
+      return await finishAfterTurn(
+        withProcessCancelSkipAutoResume(
+          { ...settled2, turnDispatched: true, ...deferredPersist },
+          env.signal
+        )
+      );
     }
     let stderrLogWriteFailure;
     try {
@@ -18296,7 +18395,8 @@ async function dispatchPostAdmissionTurn(input) {
         credential: credentialFailure,
         runDirectory: admitted.runDirectory
       });
-      const directHostFailureSignal = result.timedOut || result.knownFailure !== void 0 || runnerKnownFailure !== void 0 || credentialFailure !== void 0;
+      const processCancelName = processCancelSignalName(env.signal);
+      const directHostFailureSignal = result.timedOut || result.knownFailure !== void 0 || runnerKnownFailure !== void 0 || credentialFailure !== void 0 || processCancelName !== void 0;
       hostSignalFailed = directHostFailureSignal || result.code !== null && result.code !== 0 || resolution.knownFailure !== void 0;
       settled = await adapters.trySettle(admitted, env.principalAuthority, courtScope);
       if (settled !== void 0) {
@@ -18304,7 +18404,8 @@ async function dispatchPostAdmissionTurn(input) {
       }
       const settledIsFreshThisAttempt = settled === void 0 || settled.roleOutcome.kind !== "accepted" && settled.roleOutcome.kind !== "audit_escalation" ? true : await attemptProducedFreshSubmission(admitted, courtScope);
       const staleAcceptanceOutranksRealFailure = !settledIsFreshThisAttempt && hostSignalFailed;
-      if (settled !== void 0 && shouldPresent(settled) && !directHostFailureSignal && !staleAcceptanceOutranksRealFailure && stderrLogWriteFailure === void 0) {
+      const cancelAfterSettle = processCancelSignalName(env.signal);
+      if (settled !== void 0 && shouldPresent(settled) && !directHostFailureSignal && !staleAcceptanceOutranksRealFailure && stderrLogWriteFailure === void 0 && cancelAfterSettle === void 0) {
         if (settled.roleOutcome.kind === "accepted" && request.courtAttemptId !== void 0 && request.courtAttemptId.length > 0) {
           try {
             await clearCurrentCourt(admitted.runDirectory, request.courtAttemptId);
@@ -18341,6 +18442,22 @@ async function dispatchPostAdmissionTurn(input) {
       return await finishAfterTurn({ ...settledFailure, turnDispatched: true, ...deferredPersist });
     }
     if (settledOutcome !== void 0) {
+      const lateCancel = processCancelSignalName(env.signal);
+      if (lateCancel !== void 0) {
+        return await finishAfterTurn(
+          await settleProcessCancelAfterTurn({
+            admitted,
+            cancelName: lateCancel,
+            result,
+            adapters,
+            env,
+            io,
+            persistRunState,
+            deferredPersist,
+            invocationScopeId: request.invocationScopeId
+          })
+        );
+      }
       if (persistRunState) {
         try {
           await persistReturnedRunState(admitted, env.principalAuthority, { lawful: true });
@@ -18359,13 +18476,19 @@ async function dispatchPostAdmissionTurn(input) {
             io,
             persistRunState
           );
-          return await finishAfterTurn({ ...failed, turnDispatched: true, ...deferredPersist });
+          return await finishAfterTurn(
+            withProcessCancelSkipAutoResume(
+              { ...failed, turnDispatched: true, ...deferredPersist },
+              env.signal
+            )
+          );
         }
       }
       return await finishAfterTurn({ ...settledOutcome, ...deferredPersist });
     }
     if (hostSignalFailed) {
       const resolutionInput = controlledFailureInputFromResolution(resolution);
+      const processCancelName = processCancelSignalName(env.signal);
       const stderrLogWriteDetails = stderrLogWriteFailure === void 0 ? void 0 : { stderrLogWriteFailure: describeCaughtError(stderrLogWriteFailure) };
       const failed = await settleAfterTurnStarted(
         admitted,
@@ -18374,6 +18497,7 @@ async function dispatchPostAdmissionTurn(input) {
           code: result.code,
           stderr: result.stderr,
           ...resolutionInput,
+          ...processCancelName === void 0 ? {} : { knownDiagnostic: processCancelDiagnostic(processCancelName) },
           // Secondary fact only — never the cause. Rides on whichever channel
           // classification actually reads (knownFailure.details owns it when
           // a knownFailure exists; the top-level knownDetails otherwise).
@@ -18389,7 +18513,12 @@ async function dispatchPostAdmissionTurn(input) {
         io,
         persistRunState
       );
-      return await finishAfterTurn({ ...failed, turnDispatched: true, ...deferredPersist });
+      return await finishAfterTurn(
+        withProcessCancelSkipAutoResume(
+          { ...failed, turnDispatched: true, ...deferredPersist },
+          env.signal
+        )
+      );
     }
     if (stderrLogWriteFailure !== void 0) {
       const failed = await settleAfterTurnStarted(
@@ -18412,6 +18541,22 @@ async function dispatchPostAdmissionTurn(input) {
       await settleHostEndedNoReceipt(admitted, env.principalAuthority, courtScope),
       courtScope
     );
+    const noReceiptCancel = processCancelSignalName(env.signal);
+    if (noReceiptCancel !== void 0) {
+      return await finishAfterTurn(
+        await settleProcessCancelAfterTurn({
+          admitted,
+          cancelName: noReceiptCancel,
+          result,
+          adapters,
+          env,
+          io,
+          persistRunState,
+          deferredPersist,
+          invocationScopeId: request.invocationScopeId
+        })
+      );
+    }
     if (persistRunState) {
       try {
         await persistReturnedRunState(admitted, env.principalAuthority, { lawful: true });
@@ -18430,7 +18575,12 @@ async function dispatchPostAdmissionTurn(input) {
           io,
           persistRunState
         );
-        return await finishAfterTurn({ ...failed, turnDispatched: true, ...deferredPersist });
+        return await finishAfterTurn(
+          withProcessCancelSkipAutoResume(
+            { ...failed, turnDispatched: true, ...deferredPersist },
+            env.signal
+          )
+        );
       }
     }
     return await finishAfterTurn({
@@ -18626,6 +18776,7 @@ async function runPostAdmissionSeatResume(input) {
         io: input.io,
         sessionAppender: env.sessionAppender,
         autoResumeLimit: env.autoResumeLimit,
+        ...env.signal === void 0 ? {} : { signal: env.signal },
         buildInitialPayload: () => ({ resumeTurn: false }),
         buildResumePayload: () => ({ resumeTurn: true }),
         // Same as public manual resume: prior-court sealed acceptance is not a
@@ -18729,6 +18880,7 @@ async function runPostAdmissionResumable(input) {
     io,
     sessionAppender: env.sessionAppender,
     autoResumeLimit: env.autoResumeLimit,
+    ...env.signal === void 0 ? {} : { signal: env.signal },
     buildInitialPayload: buildScopedInitial,
     buildResumePayload: buildScopedResume,
     dispatch: async (request, lease, _isFirst, attemptIo) => {
@@ -18837,6 +18989,7 @@ var init_post_admission = __esm({
     init_host_transition_prior_native();
     init_public_run_credentials();
     init_run_lifecycle();
+    init_process_cancel();
     init_activation_ledger_topology();
     init_settlement();
     init_terminal();
@@ -23082,7 +23235,7 @@ init_sitian_facade();
 init_submission_ledger();
 init_collector_ledger();
 import { randomUUID as randomUUID8 } from "node:crypto";
-import { readFileSync as readFileSync6, writeSync as writeSync4 } from "node:fs";
+import { readFileSync as readFileSync6, writeSync as writeSync3 } from "node:fs";
 import { join as join39 } from "node:path";
 import { Value as Value4 } from "typebox/value";
 
@@ -23124,16 +23277,7 @@ function namedActivationCause(error) {
 init_activation_ledger_topology();
 
 // src/activation-ledger.ts
-init_activation_ledger_topology();
 init_activation_ledger_git();
-import {
-  constants as constants2,
-  closeSync as closeSync2,
-  fstatSync,
-  openSync as openSync2,
-  writeSync
-} from "node:fs";
-import { dirname as dirname21, isAbsolute as isAbsolute10, resolve as resolve19 } from "node:path";
 
 // src/activation-ledger-session.ts
 init_activation_ledger_topology();
@@ -23237,129 +23381,11 @@ function durableSessionPointer(sessionManager) {
 
 // src/activation-ledger.ts
 init_activation_ledger_topology();
-var ACTIVATION_LEDGER_APPEND_OPEN_FLAGS = constants2.O_APPEND | constants2.O_CREAT | constants2.O_WRONLY | constants2.O_NOFOLLOW;
-var ACCEPTED_ACTIVATION_EVENT = "accepted-activation";
-var ACCEPTED_ACTIVATION_FACT_KEYS = Object.freeze([
-  "event",
-  "role",
-  "observedAt",
-  "bookKey",
-  "session",
-  "correlation"
-]);
-function correlationIdentityFromEnv(env = process.env) {
-  const raw = env.AK_CORRELATION_ID;
-  if (typeof raw === "string" && raw.trim().length > 0) {
-    return { kind: "caller", id: raw };
-  }
-  return { kind: "absent" };
-}
-function projectAcceptedActivationFact(input) {
-  const closed = {
-    event: ACCEPTED_ACTIVATION_EVENT,
-    role: input.role,
-    observedAt: input.observedAt,
-    bookKey: input.bookKey,
-    session: { kind: "session-file", path: input.session.path },
-    correlation: input.correlation.kind === "caller" ? { kind: "caller", id: input.correlation.id } : { kind: "absent" }
-  };
-  return Object.fromEntries(
-    ACCEPTED_ACTIVATION_FACT_KEYS.map((key) => [key, closed[key]])
-  );
-}
-function buildAcceptedActivationFact(input) {
-  return projectAcceptedActivationFact(input);
-}
-function serializeAcceptedActivationFact(fact) {
-  return `${JSON.stringify(projectAcceptedActivationFact(fact))}
-`;
-}
-function appendActivationLedgerLine(ledgerPath, line2, options) {
-  if (!isAbsolute10(options.ledgerHome)) {
-    throw new ActivationLedgerError(
-      `activation ledger home must be absolute: ${options.ledgerHome}`
-    );
-  }
-  const resolvedLedger = resolve19(ledgerPath);
-  const resolvedHome = resolve19(options.ledgerHome);
-  const parent = dirname21(resolvedLedger);
-  ensureRealDirectoryTree(resolvedHome, parent);
-  assertLedgerFileInsideHome(resolvedLedger, resolvedHome);
-  if (typeof constants2.O_NOFOLLOW !== "number") {
-    throw new ActivationLedgerError(
-      "activation ledger append requires O_NOFOLLOW open-flag support (anti-symlink TOCTOU protection must not be silently dropped); refusing to append"
-    );
-  }
-  const bytes = Buffer.isBuffer(line2) ? line2 : Buffer.from(line2);
-  let ledgerFd;
-  let primaryFailure;
-  try {
-    try {
-      ledgerFd = openSync2(resolvedLedger, ACTIVATION_LEDGER_APPEND_OPEN_FLAGS, 420);
-    } catch (error) {
-      throw new ActivationLedgerError(
-        `activation ledger failed to open ledger file (${resolvedLedger}): ${errorText(error)}`,
-        { cause: error }
-      );
-    }
-    let opened;
-    try {
-      opened = fstatSync(ledgerFd);
-    } catch (error) {
-      throw new ActivationLedgerError(
-        `activation ledger failed to fstat ledger file (${resolvedLedger}): ${errorText(error)}`,
-        { cause: error }
-      );
-    }
-    if (!opened.isFile()) {
-      throw new ActivationLedgerError(
-        `activation ledger is not a regular file: ${resolvedLedger}`
-      );
-    }
-    const written = writeSync(ledgerFd, bytes, 0, bytes.length, null);
-    if (written !== bytes.length) {
-      throw new ActivationLedgerError(
-        `activation ledger short write: wrote ${written} of ${bytes.length} bytes to ${resolvedLedger}`
-      );
-    }
-  } catch (error) {
-    primaryFailure = error;
-  }
-  if (ledgerFd !== void 0) {
-    try {
-      closeSync2(ledgerFd);
-    } catch (closeFailure) {
-      if (primaryFailure !== void 0) {
-        throw new AggregateError(
-          [primaryFailure, closeFailure],
-          "activation ledger operation and close failed",
-          { cause: primaryFailure }
-        );
-      }
-      throw closeFailure;
-    }
-  }
-  if (primaryFailure !== void 0) throw primaryFailure;
-}
-function appendAcceptedActivationFact(ledgerPath, fact, options) {
-  appendActivationLedgerLine(
-    ledgerPath,
-    Buffer.from(serializeAcceptedActivationFact(fact), "utf8"),
-    { ledgerHome: options.ledgerHome }
-  );
-}
-function appendAcceptedActivationToBook(options) {
-  appendAcceptedActivationFact(
-    activationWaitingLedgerPath(options.ledgerHome, options.fact.bookKey),
-    options.fact,
-    { ledgerHome: options.ledgerHome }
-  );
-}
 
 // src/stderr-jsonl.ts
-import { writeSync as writeSync2 } from "node:fs";
+import { writeSync } from "node:fs";
 var STDERR_JSONL_WRITE_RETRY_LIMIT = 100;
-function writeStderrJsonlRecord(record4, write = writeSync2) {
+function writeStderrJsonlRecord(record4, write = writeSync) {
   const bytes = Buffer.from(`${JSON.stringify(record4)}
 `);
   let offset = 0;
@@ -23379,7 +23405,7 @@ function writeStderrJsonlRecord(record4, write = writeSync2) {
 }
 
 // src/tool-execution-observation.ts
-import { writeSync as writeSync3 } from "node:fs";
+import { writeSync as writeSync2 } from "node:fs";
 import { Type as Type15 } from "typebox";
 import { Value as Value3 } from "typebox/value";
 var TOOL_EXECUTION_UPDATE_THROTTLE_MS = 3e4;
@@ -23410,7 +23436,7 @@ function validateToolExecutionObservationRecord(record4) {
   }
   return record4;
 }
-function writeToolExecutionObservationRecord(record4, write = writeSync3) {
+function writeToolExecutionObservationRecord(record4, write = writeSync2) {
   writeStderrJsonlRecord(validateToolExecutionObservationRecord(record4), write);
 }
 function isProducingToolUpdate(partialResult) {
@@ -23647,9 +23673,9 @@ import { join as join38, sep as sep6 } from "node:path";
 // src/atomic-write.ts
 import { randomUUID as randomUUID7 } from "node:crypto";
 import { rename as rename3, rm as rm5, writeFile as writeFile11 } from "node:fs/promises";
-import { dirname as dirname22, join as join37 } from "node:path";
+import { dirname as dirname21, join as join37 } from "node:path";
 async function writeFileAtomically(destination, contents) {
-  const parent = dirname22(destination);
+  const parent = dirname21(destination);
   const temporary = join37(parent, `.atomic-write-${randomUUID7()}.tmp`);
   try {
     await writeFile11(temporary, contents);
@@ -25155,7 +25181,7 @@ init_submission_errors();
 init_submission_errors();
 import { execFileSync as execFileSync4 } from "node:child_process";
 import { existsSync as existsSync12, lstatSync as lstatSync3, readdirSync as readdirSync3, readFileSync as readFileSync5, rmdirSync, rmSync } from "node:fs";
-import { resolve as resolve20 } from "node:path";
+import { resolve as resolve19 } from "node:path";
 var WORKER_SUBMISSION_GATE_RECORD_KIND = WORKER_SUBMISSION_GATE_KIND;
 var WORKER_COMMIT_BASELINE_ENTRY_TYPE = "commit-baseline";
 var WORKER_COMMIT_REMINDER_BOUNCE_ENTRY_TYPE = "commit-reminder-bounce";
@@ -25204,7 +25230,7 @@ function escapeGitConfigValueRegex(value) {
 function unsetOwnedHooksPath(file) {
   const owned = [];
   for (const value of tryGetAll(file, "core.hooksPath")) {
-    if (!ownedHook(resolve20(value, HOOK_FILE))) continue;
+    if (!ownedHook(resolve19(value, HOOK_FILE))) continue;
     try {
       gitFile(file, [
         "--unset-all",
@@ -25219,15 +25245,15 @@ function unsetOwnedHooksPath(file) {
   return owned;
 }
 function rmOwnedDir(dir) {
-  const hookPath = resolve20(dir, HOOK_FILE);
+  const hookPath = resolve19(dir, HOOK_FILE);
   if (!ownedHook(hookPath)) return;
   rmSync(hookPath, { force: true });
   if (existsSync12(dir) && readdirSync3(dir).length === 0) rmdirSync(dir);
 }
 function linkedGitDirs(commonDir) {
-  const root = resolve20(commonDir, "worktrees");
+  const root = resolve19(commonDir, "worktrees");
   if (!existsSync12(root)) return [];
-  return readdirSync3(root).map((name) => resolve20(root, name)).filter((dir) => lstatSync3(dir).isDirectory());
+  return readdirSync3(root).map((name) => resolve19(root, name)).filter((dir) => lstatSync3(dir).isDirectory());
 }
 function uninstallPackageWorkerHooks(cwd) {
   let inside;
@@ -25241,14 +25267,14 @@ function uninstallPackageWorkerHooks(cwd) {
   const clear = (configFile) => {
     for (const hooks of unsetOwnedHooksPath(configFile)) rmOwnedDir(hooks);
   };
-  clear(resolve20(commonDir, "config"));
-  clear(resolve20(commonDir, "config.worktree"));
-  rmOwnedDir(resolve20(commonDir, HOOKS_DIR));
-  const legacy = resolve20(commonDir, "hooks", HOOK_FILE);
+  clear(resolve19(commonDir, "config"));
+  clear(resolve19(commonDir, "config.worktree"));
+  rmOwnedDir(resolve19(commonDir, HOOKS_DIR));
+  const legacy = resolve19(commonDir, "hooks", HOOK_FILE);
   if (ownedHook(legacy)) rmSync(legacy, { force: true });
   for (const gitDir of linkedGitDirs(commonDir)) {
-    clear(resolve20(gitDir, "config.worktree"));
-    rmOwnedDir(resolve20(gitDir, HOOKS_DIR));
+    clear(resolve19(gitDir, "config.worktree"));
+    rmOwnedDir(resolve19(gitDir, HOOKS_DIR));
   }
 }
 function isRecord13(value) {
@@ -26001,7 +26027,7 @@ async function executeActivationStage(role, stage, infrastructure) {
     throw activationError;
   }
 }
-function writeActivationTraceRecord(record4, write = writeSync4) {
+function writeActivationTraceRecord(record4, write = writeSync3) {
   writeStderrJsonlRecord(record4, write);
 }
 var ActivationBarrierError = class extends Error {
@@ -27233,11 +27259,8 @@ function createRoleRuntimeExtension(dependencies) {
         }
       };
       try {
-        const bookKey = resolveBookKeyFromGit(ctx.cwd);
-        const correlation = correlationIdentityFromEnv();
-        const sessionFile = ctx.sessionManager.getSessionFile?.() || ctx.sessionManager.getSessionDir?.();
-        const ledgerHome = resolveActivationLedgerHomeForPath(sessionFile);
-        const session = durableSessionPointer(ctx.sessionManager);
+        resolveBookKeyFromGit(ctx.cwd);
+        durableSessionPointer(ctx.sessionManager);
         const isStationChild = roleHost.getFlag(STATION_CHILD_FLAG.name) === true;
         if (dependencies.createNavigatorAttendance !== void 0 && entry.role !== "navigator" && !isStationChild) {
           navigatorSessionParent = ctx.sessionManager.getSessionFile();
@@ -27324,16 +27347,6 @@ function createRoleRuntimeExtension(dependencies) {
           if (entry.role === "coder") coder.armSubmissionGate(ctx.cwd, ctx.sessionManager);
           else fixer.armSubmissionGate(ctx.cwd, ctx.sessionManager);
         }
-        appendAcceptedActivationToBook({
-          ledgerHome,
-          fact: buildAcceptedActivationFact({
-            role: entry.role,
-            observedAt: clock(),
-            bookKey,
-            session,
-            correlation
-          })
-        });
         admitted = true;
       } catch (error) {
         failInfrastructure(error, ctx);
@@ -27418,7 +27431,7 @@ init_engine_detour();
 import { randomUUID as randomUUID9 } from "node:crypto";
 import { appendFile as appendFile3, mkdir as mkdir7, writeFile as writeFile12 } from "node:fs/promises";
 import { createServer } from "node:net";
-import { dirname as dirname24, join as join42 } from "node:path";
+import { dirname as dirname23, join as join42 } from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 
 // src/gatekeeper-pass-envelope.ts
@@ -27505,14 +27518,14 @@ async function requireGatekeeperPass(options) {
 
 // src/host-native-method.ts
 import { lstat as lstat7, mkdir as mkdir6, readlink, realpath as realpath8, symlink } from "node:fs/promises";
-import { basename as basename10, dirname as dirname23, join as join41 } from "node:path";
+import { basename as basename10, dirname as dirname22, join as join41 } from "node:path";
 var HOST_METHOD_PLUGIN_NAME = "ak-methods";
 var packagedMethodsDir = (root) => join41(root, "resources", "methods");
 var packagedMethodPluginDir = (root) => join41(root, "dist", "method-host-plugin");
 function hostMethodSkills(methods) {
   return Object.freeze(methods.flatMap((method) => {
     if (method.kind !== "skill") return [];
-    const name = basename10(dirname23(method.path));
+    const name = basename10(dirname22(method.path));
     return name ? [Object.freeze({ name })] : [];
   }));
 }
@@ -27549,7 +27562,7 @@ async function installWorkspaceMethodSkills(cwd, packageRoot) {
   } catch (error) {
     if (error.code !== "ENOENT") throw error;
   }
-  await mkdir6(dirname23(link), { recursive: true });
+  await mkdir6(dirname22(link), { recursive: true });
   try {
     await symlink(target, link);
   } catch (error) {
@@ -27566,11 +27579,11 @@ init_role_activation_flags();
 init_submission_correctable_error();
 init_navigator_invocation_identity();
 async function listen(server, path) {
-  await new Promise((resolve22, reject) => {
+  await new Promise((resolve21, reject) => {
     server.once("error", reject);
     server.listen(path, () => {
       server.off("error", reject);
-      resolve22();
+      resolve21();
     });
   });
 }
@@ -27606,7 +27619,7 @@ async function prepareRoleEnvelope(options) {
   const runId = request.runDirectory.split("/").filter(Boolean).at(-1) ?? randomUUID9();
   await mkdir7(request.runDirectory, { recursive: true });
   let sessionFile = options.sessionFile ?? join42(request.runDirectory, "session", "session.jsonl");
-  await mkdir7(dirname24(sessionFile), { recursive: true });
+  await mkdir7(dirname23(sessionFile), { recursive: true });
   if (request.continuation.kind !== "resume") {
     try {
       await writeFile12(
@@ -27656,7 +27669,7 @@ async function prepareRoleEnvelope(options) {
       getLeafEntry: () => sessionEntries.at(-1),
       getLeafId: () => runId,
       getEntries: () => sessionEntries,
-      getSessionDir: () => dirname24(sessionFile),
+      getSessionDir: () => dirname23(sessionFile),
       getSessionFile: () => sessionFile,
       getHeader: () => ({ type: "session", id: runId }),
       setSessionFile(path) {
@@ -28003,8 +28016,8 @@ async function prepareRoleEnvelope(options) {
     try {
       const closeAll = server.closeAllConnections;
       if (typeof closeAll === "function") closeAll.call(server);
-      await new Promise((resolve22, reject) => {
-        server.close((error) => error ? reject(error) : resolve22());
+      await new Promise((resolve21, reject) => {
+        server.close((error) => error ? reject(error) : resolve21());
       });
     } catch (error) {
       cleanupFailures.push(error);
@@ -28410,7 +28423,7 @@ import { spawn as spawn4, spawnSync } from "node:child_process";
 import { randomUUID as randomUUID10 } from "node:crypto";
 import { existsSync as existsSync13 } from "node:fs";
 import { writeFile as writeFile13 } from "node:fs/promises";
-import { dirname as dirname25, isAbsolute as isAbsolute11, join as join44, resolve as resolve21 } from "node:path";
+import { dirname as dirname24, isAbsolute as isAbsolute10, join as join44, resolve as resolve20 } from "node:path";
 
 // src/external-host-turn-loop.ts
 init_host_contracts();
@@ -28631,7 +28644,7 @@ function cwdIsGitWorkTree(cwd) {
   let dir = cwd;
   for (; ; ) {
     if (existsSync13(join44(dir, ".git"))) return true;
-    const parent = dirname25(dir);
+    const parent = dirname24(dir);
     if (parent === dir) return false;
     dir = parent;
   }
@@ -28659,10 +28672,10 @@ function resolveGitCommonDir(cwd) {
   if (raw === "") {
     throw new Error("git rev-parse --git-common-dir returned empty stdout");
   }
-  return isAbsolute11(raw) ? raw : resolve21(cwd, raw);
+  return isAbsolute10(raw) ? raw : resolve20(cwd, raw);
 }
 function spawnHeadlessTurn(options) {
-  return new Promise((resolve22, reject) => {
+  return new Promise((resolve21, reject) => {
     if (options.signal?.aborted) {
       reject(hostAbortedError("headless host aborted"));
       return;
@@ -28737,7 +28750,7 @@ function spawnHeadlessTurn(options) {
         reject(stdinDeliveryError);
         return;
       }
-      resolve22({ code, stdout: resultStdout, stderr, timedOut });
+      resolve21({ code, stdout: resultStdout, stderr, timedOut });
     };
     const onAbort = () => {
       child.kill("SIGTERM");