@kontourai/flow-agents 3.9.0 → 3.10.0

package/.github/workflows/ci.yml

@@ -34,6 +34,10 @@ jobs:
     steps:
       - name: Checkout
         uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0
+        with:
+          # The Codex legacy-instruction ownership audit independently walks
+          # every seed-capable release tag and must not trust the catalog alone.
+          fetch-depth: 0
 
       - name: Set up Node.js
         uses: actions/setup-node@48b55a011bda9f5d6aeb4c2d9c7362e8dae4041e # v6.4.0
@@ -326,6 +330,10 @@ jobs:
         continue-on-error: true
         run: bash evals/ci/run-baseline.sh --check telemetry-usage-pipeline-integration
 
+      - name: Telemetry tool usage integration
+        continue-on-error: true
+        run: bash evals/ci/run-baseline.sh --check telemetry-tool-usage-integration
+
       - name: Economics record integration
         continue-on-error: true
         run: bash evals/ci/run-baseline.sh --check economics-record-integration

package/CHANGELOG.md

@@ -1,5 +1,22 @@
 # Changelog
 
+## [3.10.0](https://github.com/kontourai/flow-agents/compare/v3.9.0...v3.10.0) (2026-07-13)
+
+
+### Features
+
+* **telemetry:** per-turn model/tokens/cost on tool events ([#568](https://github.com/kontourai/flow-agents/issues/568) slice 1) ([80ac0e7](https://github.com/kontourai/flow-agents/commit/80ac0e73a524fb1f84f0bffac94fe78ce4883b74))
+* **telemetry:** per-turn model/tokens/cost on tool events ([#568](https://github.com/kontourai/flow-agents/issues/568) slice 1) ([2b6276d](https://github.com/kontourai/flow-agents/commit/2b6276d42b30123a61b3d9a9181ebd77affc0e70))
+
+
+### Fixes
+
+* **#440:** scope ownership signals to the actor's own per-actor pointer ([#586](https://github.com/kontourai/flow-agents/issues/586)) ([7a8fc82](https://github.com/kontourai/flow-agents/commit/7a8fc82f22201fd916631beff6bb85fe288d461e))
+* **liveness:** identify Codex actors by thread ([#556](https://github.com/kontourai/flow-agents/issues/556)) ([5ac02cb](https://github.com/kontourai/flow-agents/commit/5ac02cbc6f374d0b75bc03c4230f6d255568693a))
+* **packaging:** preserve runtime instruction files ([#575](https://github.com/kontourai/flow-agents/issues/575)) ([f55d288](https://github.com/kontourai/flow-agents/commit/f55d28839bf87f35aaecb5a7aae0ba7fe55f51c7))
+* **packaging:** stop seeding Codex global instructions ([#573](https://github.com/kontourai/flow-agents/issues/573)) ([2d25cb6](https://github.com/kontourai/flow-agents/commit/2d25cb65af2b5403a164a645ae615e2388681640))
+* resolve continuation validator from installed runtime ([#591](https://github.com/kontourai/flow-agents/issues/591)) ([86191c4](https://github.com/kontourai/flow-agents/commit/86191c4e39abcb3123b8823f4604ca7183d0be83))
+
 ## [3.9.0](https://github.com/kontourai/flow-agents/compare/v3.8.0...v3.9.0) (2026-07-12)
 
 

package/README.md

@@ -91,7 +91,7 @@ npx @kontourai/flow-agents init --runtime pi --dest /path/to/workspace --yes
 
 For Codex global installs, omit `--dest` and use `--global`: Flow Agents installs into `CODEX_HOME` when it is set, otherwise `~/.codex`. Pass `--dest` only when you intentionally want an isolated or test-specific Codex home.
 
-Runtime auto-detection is best-effort: it first checks environment markers set by the invoking coding agent (e.g. `CLAUDECODE`, `CODEX_SESSION_ID`, `OPENCODE_SESSION_ID`), then falls back to checking whether exactly one of `~/.claude`, `~/.codex` (or `$CODEX_HOME`), or opencode's global config dir already exists. If neither signal is unambiguous, it defaults to `base`. Pass `--runtime` explicitly to override the detected default at any time.
+Runtime auto-detection is best-effort: it first checks environment markers set by the invoking coding agent (e.g. `CLAUDECODE`, Codex's preferred `CODEX_THREAD_ID`, the backward-compatible `CODEX_SESSION_ID`, or `OPENCODE_SESSION_ID`), then falls back to checking whether exactly one of `~/.claude`, `~/.codex` (or `$CODEX_HOME`), or opencode's global config dir already exists. If neither signal is unambiguous, it defaults to `base`. Pass `--runtime` explicitly to override the detected default at any time. Codex thread identifiers are never written into actor keys verbatim; Flow Agents derives a stable, domain-separated opaque token instead.
 
 Working from a checkout (for contributors): `npm install && npm run build`, then `node build/src/cli.js init --dest /path/to/workspace`.
 

package/build/src/cli/assignment-provider.js

@@ -1,5 +1,4 @@
 import * as fs from "node:fs";
-import * as os from "node:os";
 import * as path from "node:path";
 import { randomBytes } from "node:crypto";
 import { createRequire } from "node:module";
@@ -81,25 +80,12 @@ function loadActorStruct(args) {
 }
 export function resolveCurrentAssignmentActor() {
     const helper = loadActorIdentityHelper();
-    const resolved = helper.resolveActor(process.env);
+    const resolved = helper.resolveActorIdentity(process.env);
     if (helper.isUnresolvedActor(resolved.actor))
         throw new Error("could not resolve an actor identity (no --actor-json and no resolvable environment actor); pass --actor-json explicitly");
-    // #398: reconstruct the SAME struct resolveActor serialized for a CI actor, mirroring
-    // resolveEnsureSessionActor (workflow-sidecar.ts) via the shared detectCiActor. Without this the
-    // else-branch would write `record.actor = {runtime:"unknown", session_id:<the whole triple>}` for a
-    // CI session — actor_key stays correct (so no false-block), but record.actor is malformed and the
-    // audit-trail / `assignment-provider status` output for CI sessions would be corrupt.
-    const ci = resolved.source.startsWith("ci-runtime") ? helper.detectCiActor(process.env) : null;
-    const runtimeSessionId = resolved.source.startsWith("runtime-session-id") ? helper.runtimeSessionId(process.env) : "";
-    const ancestrySeed = resolved.source === "process-ancestry" ? helper.ancestorActorSeed() : "";
-    const actor = resolved.source === "explicit-override"
-        ? { runtime: "explicit-override", session_id: resolved.actor, host: os.hostname(), human: null }
-        : ci && ci.session_id
-            ? { runtime: ci.runtime, session_id: ci.session_id, host: os.hostname(), human: null }
-            : runtimeSessionId
-                ? { runtime: helper.detectRuntime(process.env), session_id: runtimeSessionId, host: os.hostname(), human: null }
-                : { runtime: helper.detectRuntime(process.env), session_id: ancestrySeed ? `anc-${ancestrySeed}` : resolved.actor, host: os.hostname(), human: null };
-    return { actor, actorKey: resolved.actor };
+    if (!resolved.actorStruct)
+        throw new Error("actor identity resolved without a canonical actor struct");
+    return { actor: { ...resolved.actorStruct, human: resolved.actorStruct.human ?? null }, actorKey: resolved.actor };
 }
 export function assignmentFilePath(artifactRoot, subjectId) {
     const sanitized = loadActorIdentityHelper().sanitizeSegment(subjectId);

package/build/src/cli/continuation-adapter.d.ts

@@ -8,17 +8,19 @@ export type ContinuationAdapterCommand = {
     }>;
 };
 export declare function loadContinuationAdapterCommand(commandFileInput: string): ContinuationAdapterCommand;
-export declare function executeContinuationAdapter(commandFileInput: string, request: ContinuationTurnRequest, options: {
-    cwd: string;
-    timeoutMs: number;
-}): Promise<ContinuationTurnResult>;
-export declare function executeLoadedContinuationAdapter(command: ContinuationAdapterCommand, request: ContinuationTurnRequest, options: {
-    cwd: string;
-    timeoutMs: number;
-}): Promise<ContinuationTurnResult>;
+export declare function executeContinuationAdapter(commandFileInput: string, request: ContinuationTurnRequest, options: ContinuationAdapterOptions): Promise<ContinuationTurnResult>;
+export declare function executeLoadedContinuationAdapter(command: ContinuationAdapterCommand, request: ContinuationTurnRequest, options: ContinuationAdapterOptions): Promise<ContinuationTurnResult>;
+export declare function assertLoadedContinuationAdapterIntegrity(command: ContinuationAdapterCommand): void;
 export declare function waitForContinuationBarrier(barrier: ContinuationBarrier, options: {
     maxWaitMs: number;
     pollMs: number;
     now?: () => number;
     sleep?: (ms: number) => Promise<void>;
 }): Promise<"ready" | "pending">;
+type ContinuationAdapterOptions = {
+    cwd: string;
+    timeoutMs: number;
+    continuationTurnSecret?: string;
+    continuationRunId?: string;
+};
+export {};

package/build/src/cli/continuation-adapter.js

@@ -2,6 +2,7 @@ import * as fs from "node:fs";
 import * as path from "node:path";
 import { spawn } from "node:child_process";
 import { createHash } from "node:crypto";
+import { ContinuationAdapterTimeoutError } from "../continuation-driver.js";
 export function loadContinuationAdapterCommand(commandFileInput) {
     const commandFile = path.resolve(commandFileInput);
     const command = validateAdapterCommand(JSON.parse(readRegularFileNoFollow(commandFile, "continuation adapter command file")));
@@ -19,13 +20,16 @@ export async function executeContinuationAdapter(commandFileInput, request, opti
     return executeLoadedContinuationAdapter(command, request, options);
 }
 export async function executeLoadedContinuationAdapter(command, request, options) {
+    assertLoadedContinuationAdapterIntegrity(command);
+    assertPositiveInteger(options.timeoutMs, "continuation adapter timeoutMs", 1, 86_400_000);
+    return await spawnAdapter(command, request, options);
+}
+export function assertLoadedContinuationAdapterIntegrity(command) {
     for (const entry of command.integrity) {
         if (sha256File(entry.file, "continuation adapter integrity file") !== entry.sha256) {
             throw new Error(`continuation adapter integrity changed after mission binding: ${entry.file}`);
         }
     }
-    assertPositiveInteger(options.timeoutMs, "continuation adapter timeoutMs", 1, 86_400_000);
-    return await spawnAdapter(command, request, options);
 }
 export async function waitForContinuationBarrier(barrier, options) {
     assertPositiveInteger(options.maxWaitMs, "continuation barrier maxWaitMs", 0, 86_400_000);
@@ -54,7 +58,7 @@ function spawnAdapter(command, request, options) {
     return new Promise((resolve, reject) => {
         const child = spawn(command.argv[0], command.argv.slice(1), {
             cwd: options.cwd,
-            env: process.env,
+            env: adapterEnvironment(options),
             detached: process.platform !== "win32",
             shell: false,
             stdio: ["pipe", "pipe", "pipe"],
@@ -70,7 +74,7 @@ function spawnAdapter(command, request, options) {
         const timeout = setTimeout(() => {
             if (settled)
                 return;
-            terminationError = new Error(`continuation adapter timed out after ${options.timeoutMs}ms`);
+            terminationError = new ContinuationAdapterTimeoutError(options.timeoutMs);
             terminateProcessGroup(child.pid, "SIGTERM");
             forcedKill = setTimeout(() => terminateProcessGroup(child.pid, "SIGKILL"), 250);
         }, options.timeoutMs);
@@ -143,6 +147,20 @@ function spawnAdapter(command, request, options) {
         child.stdin.end(`${JSON.stringify(request)}\n`);
     });
 }
+function adapterEnvironment(options) {
+    const env = { ...process.env };
+    delete env.FLOW_AGENTS_CONTINUATION_TURN_SECRET;
+    delete env.FLOW_AGENTS_CONTINUATION_RUN_ID;
+    delete env.FLOW_AGENTS_CONTINUATION_TURN_NONCE;
+    delete env.FLOW_AGENTS_CONTINUATION_TURN_PUBLIC_KEY_DIGEST;
+    delete env.FLOW_AGENTS_CONTINUATION_ACTOR_B64;
+    const { continuationTurnSecret: turnSecret, continuationRunId: runId } = options;
+    if (!turnSecret || !runId)
+        return env;
+    env.FLOW_AGENTS_CONTINUATION_TURN_SECRET = turnSecret;
+    env.FLOW_AGENTS_CONTINUATION_RUN_ID = runId;
+    return env;
+}
 function validateAdapterCommand(value) {
     if (!value || typeof value !== "object" || Array.isArray(value))
         throw new Error("continuation adapter command file must contain an object");

package/build/src/cli/validate-workflow-artifacts.js

@@ -19,6 +19,10 @@ const sidecarSchemas = {
     "release.json": "schemas/workflow-release.schema.json",
     "learning.json": "schemas/workflow-learning.schema.json",
 };
+// Runtime coordination records live below a session but are not workflow
+// sidecars. Recursing into them would validate continuation-driver/state.json
+// against the public workflow-state schema and turn an active driver into a
+// false Goal Fit hard block.
 function readText(file) {
     return fs.readFileSync(file, "utf8");
 }
@@ -81,11 +85,27 @@ function hasEvidence(text) {
 function hasExplicitAcceptance(text) {
     return /explicitly accepted|accepted by user|user accepted|accepted gap/i.test(text);
 }
+function isPrivateRuntimeChild(dir) {
+    if (path.basename(dir) !== "continuation-driver")
+        return false;
+    const sessionDir = path.dirname(dir);
+    const sessionState = path.join(sessionDir, "state.json");
+    try {
+        const stat = fs.lstatSync(sessionState);
+        if (stat.isSymbolicLink() || !stat.isFile())
+            return false;
+        const state = JSON.parse(readText(sessionState));
+        return state.task_slug === path.basename(sessionDir);
+    }
+    catch {
+        return false;
+    }
+}
 function walk(dir) {
     const out = [];
     for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
         const p = path.join(dir, entry.name);
-        if (entry.isDirectory())
+        if (entry.isDirectory() && !isPrivateRuntimeChild(p))
             out.push(...walk(p));
         else
             out.push(p);

package/build/src/cli/workflow-sidecar.js

@@ -288,7 +288,9 @@ function resolveEnsureSessionActor(p) {
         die("ensure-session --actor value strips to empty under the allowed actor charset ([A-Za-z0-9_.-]) — pass a value containing at least one letter, digit, underscore, period, or hyphen.");
     }
     const explicitActor = explicitActorRaw ? helper.sanitizeSegment(explicitActorRaw) : "";
-    const resolved = explicitActor ? { actor: explicitActor, source: "explicit-override" } : helper.resolveActor(process.env);
+    const resolved = explicitActor
+        ? { actor: explicitActor, source: "explicit-override", actorStruct: { runtime: "explicit-override", session_id: explicitActor, host: os.hostname() } }
+        : helper.resolveActorIdentity(process.env);
     const unresolved = helper.isUnresolvedActor(resolved.actor);
     const branchActorKey = unresolved ? `unknown-actor-${unknownDisambiguator(resolved.actor)}` : resolved.actor;
     if (unresolved) {
@@ -297,17 +299,9 @@ function resolveEnsureSessionActor(p) {
         // the ownership guard entirely when unresolved, rather than claiming under a synthetic identity.
         return { actorStruct: { runtime: "unresolved", session_id: branchActorKey, host: os.hostname() }, actorKey: resolved.actor, branchActorKey, unresolved: true };
     }
-    // #398: the CI-runtime tier must reconstruct the SAME struct resolveActor serialized, or
-    // `serializeActor(actorStruct)` would diverge from `resolved.actor` (the else-branch would rebuild
-    // an ANCESTRY struct — detectRuntime→unknown, runtimeSessionId→'' — so the claim's stored
-    // actor_key would not match the CI actor at publish → self not recognized → false-block, the exact
-    // bug this issue removes). Uses the SAME helper.detectCiActor as resolveActor, single-sourced.
-    const ciActor = resolved.source.startsWith("ci-runtime") ? helper.detectCiActor(process.env) : null;
-    const actorStruct = resolved.source === "explicit-override"
-        ? { runtime: "explicit-override", session_id: resolved.actor, host: os.hostname() }
-        : ciActor && ciActor.session_id
-            ? { runtime: ciActor.runtime, session_id: ciActor.session_id, host: os.hostname() }
-            : { runtime: helper.detectRuntime(process.env), session_id: helper.runtimeSessionId(process.env) || (() => { const seed = helper.ancestorActorSeed(); return seed ? `anc-${seed}` : ""; })(), host: os.hostname() };
+    if (!resolved.actorStruct)
+        die("ensure-session could not resolve a canonical actor struct");
+    const actorStruct = resolved.actorStruct;
     const actorKey = helper.serializeActor(actorStruct);
     return { actorStruct, actorKey, branchActorKey, unresolved: false };
 }
@@ -1767,14 +1761,15 @@ function updateCurrentAgent(root, dir, agentId, status, timestamp, actorKey) {
     }
     if (actorKey && !loadActorIdentityHelper().isUnresolvedActor(actorKey)) {
         const helper = loadCurrentPointerHelper();
-        const perActorFile = helper.perActorCurrentFile(root, actorKey);
-        let perActor = null;
-        try {
-            perActor = fs.existsSync(perActorFile) ? JSON.parse(fs.readFileSync(perActorFile, "utf8")) : null;
-        }
-        catch {
-            perActor = null;
-        }
+        // #440 fix-wave 3: read through the legacy-aware path (readOwnCurrentPointer tries the new
+        // collision-resistant filename first, then falls back to the pre-fix-wave-2 legacy filename)
+        // instead of a direct fs read of perActorCurrentFile() alone — a direct read of ONLY the new
+        // filename would silently skip this active_agents/updated_at projection for a pointer a
+        // still-running pre-fix-wave-2 sidecar wrote under the old name. The write below always goes
+        // through writePerActorCurrent (new filename only), so the pointer migrates to the new name
+        // on first touch.
+        const pointer = helper.readOwnCurrentPointer(root, actorKey);
+        const perActor = pointer.payload;
         if (perActor && path.resolve(root, perActor.artifact_dir ?? "") === path.resolve(dir)) {
             helper.writePerActorCurrent(root, actorKey, applyAgentUpdate(perActor));
         }

package/build/src/cli/workflow.js

@@ -15,7 +15,7 @@ import { flagBool, flagList, flagString, parseArgs } from "../lib/args.js";
 import { main as builderRun } from "./builder-run.js";
 import { currentWorkflowSessionDir, isMeaningfulTestCommand, mainFromPublicWorkflow, WORKFLOW_WRITER_CONTRACT_VERSION } from "./workflow-sidecar.js";
 import { resolveCurrentAssignmentActor, withSubjectLock } from "./assignment-provider.js";
-import { executeLoadedContinuationAdapter, loadContinuationAdapterCommand, waitForContinuationBarrier } from "./continuation-adapter.js";
+import { assertLoadedContinuationAdapterIntegrity, executeLoadedContinuationAdapter, loadContinuationAdapterCommand, waitForContinuationBarrier } from "./continuation-adapter.js";
 export const WORKFLOW_CONTRACT_VERSION = "1.0";
 const PACKAGE_ROOT = flowAgentsPackageRoot();
 const REQUIRE = createRequire(import.meta.url);
@@ -81,16 +81,39 @@ async function drive(sessionDir, argv, json) {
     const barrierWaitMs = integerFlag(parsed.flags, "barrier-wait-ms", 300_000, 0, 86_400_000);
     const barrierPollMs = integerFlag(parsed.flags, "barrier-poll-ms", 1_000, 1, 60_000);
     const { slug, projectRoot } = readBoundSession(sessionDir);
-    assertMatchingAssignmentActor(sessionDir, slug);
+    assertOrdinaryMatchingAssignmentActor(sessionDir, slug);
     const adapterCommand = loadContinuationAdapterCommand(adapterCommandFile);
-    const result = await withContinuationDriverLock(sessionDir, async () => {
-        assertMatchingAssignmentActor(sessionDir, slug);
+    const result = await withContinuationDriverLock(sessionDir, async (lock) => {
+        assertOrdinaryMatchingAssignmentActor(sessionDir, slug);
         return driveBuilderFlowSession({
             sessionDir,
             maxTurns,
             adapterCommandIdentity: adapterCommand.identity,
-            authorizeTurn: async () => { assertMatchingAssignmentActor(sessionDir, slug); },
-            execute: async (request) => executeLoadedContinuationAdapter(adapterCommand, request, { cwd: projectRoot, timeoutMs: turnTimeoutMs }),
+            authorizeTurn: async () => { assertOrdinaryMatchingAssignmentActor(sessionDir, slug); },
+            issueTurnAuthority: async (request) => {
+                const currentAssignment = assertOrdinaryMatchingAssignmentActor(sessionDir, slug);
+                assertLoadedContinuationAdapterIntegrity(adapterCommand);
+                const authority = loadContinuationTurnAuthority();
+                return authority.issueActiveTurnAuthority({
+                    sessionDir,
+                    runId: request.run_id,
+                    definitionId: request.definition_id,
+                    currentStep: request.current_step,
+                    iteration: request.iteration,
+                    maxTurns: request.max_turns,
+                    adapterCommandIdentity: adapterCommand.identity,
+                    assignmentActor: currentAssignment.actorKey,
+                    assignmentActorStruct: currentAssignment.actor,
+                    lock,
+                    timeoutMs: turnTimeoutMs,
+                });
+            },
+            execute: async (request, context) => executeLoadedContinuationAdapter(adapterCommand, request, {
+                cwd: projectRoot,
+                timeoutMs: turnTimeoutMs,
+                continuationTurnSecret: context?.continuationTurnSecret,
+                continuationRunId: context?.continuationRunId,
+            }),
             waitForBarrier: async (barrier) => waitForContinuationBarrier(barrier, { maxWaitMs: barrierWaitMs, pollMs: barrierPollMs }),
         });
     });
@@ -100,6 +123,9 @@ async function drive(sessionDir, argv, json) {
         console.log(`Continuation driver ${result.outcome} after ${result.turns_started} turn(s); canonical Flow is ${result.snapshot.status} at ${result.snapshot.current_step}.`);
     return 0;
 }
+function loadContinuationTurnAuthority() {
+    return REQUIRE(path.resolve(PACKAGE_ROOT, "scripts", "hooks", "lib", "continuation-turn-authority.js"));
+}
 async function start(argv) {
     const parsed = parseArgs(argv);
     assertOnlyFlags(parsed.flags, new Set(["flow", "work-item", "task-slug", "artifact-root", "source-request", "summary", "title", "criterion", "assignment-provider", "effective-state-json"]), "workflow start");
@@ -553,14 +579,35 @@ function readAssignment(sessionDir, slug) {
     return readJsonFile(file, "workflow assignment");
 }
 function assertMatchingAssignmentActor(sessionDir, slug) {
-    const assignment = readActiveAssignment(sessionDir, slug);
-    const caller = resolveCurrentAssignmentActor();
-    const normalizeActor = (value) => value && typeof value === "object" ? { ...value, human: value.human ?? null } : null;
-    if (assignment.actor_key !== caller.actorKey || !isDeepStrictEqual(normalizeActor(assignment.actor), normalizeActor(caller.actor))) {
-        throw new Error("workflow mutation requires the session's active, matching assignment actor");
+    const { assignment, caller, matches } = assignmentActorContext(sessionDir, slug);
+    if (matches)
+        return caller;
+    const authority = loadContinuationTurnAuthority().validateSignedActiveTurnAssignmentAuthority({
+        sessionDir,
+        runId: process.env.FLOW_AGENTS_CONTINUATION_RUN_ID,
+        turnSecret: process.env.FLOW_AGENTS_CONTINUATION_TURN_SECRET,
+    });
+    if (authority.valid && authority.record
+        && assignment.actor_key === authority.record.assignment_actor
+        && isDeepStrictEqual(normalizeAssignmentActor(assignment.actor), normalizeAssignmentActor(authority.record.assignment_actor_struct))) {
+        return { actorKey: authority.record.assignment_actor, actor: normalizeAssignmentActor(authority.record.assignment_actor_struct) };
     }
+    throw new Error("workflow mutation requires the session's active, matching assignment actor");
+}
+function assertOrdinaryMatchingAssignmentActor(sessionDir, slug) {
+    const { caller, matches } = assignmentActorContext(sessionDir, slug);
+    if (!matches)
+        throw new Error("workflow mutation requires the session's active, matching assignment actor");
     return caller;
 }
+function assignmentActorContext(sessionDir, slug) {
+    const assignment = readActiveAssignment(sessionDir, slug);
+    const caller = resolveCurrentAssignmentActor();
+    return { assignment, caller, matches: assignment.actor_key === caller.actorKey && isDeepStrictEqual(normalizeAssignmentActor(assignment.actor), normalizeAssignmentActor(caller.actor)) };
+}
+function normalizeAssignmentActor(value) {
+    return value && typeof value === "object" ? { ...value, human: value.human ?? null } : null;
+}
 function readActiveAssignment(sessionDir, slug) {
     const assignment = readAssignment(sessionDir, slug);
     if (assignment.status !== "claimed" || assignment.artifact_dir !== slug || typeof assignment.actor_key !== "string" || !assignment.actor_key || !assignment.actor || typeof assignment.actor !== "object" || Array.isArray(assignment.actor)) {

package/build/src/continuation-driver.d.ts

@@ -30,6 +30,10 @@ export type ContinuationTurnResult = {
     barrier: ContinuationBarrier;
     summary?: string;
 };
+export declare class ContinuationAdapterTimeoutError extends Error {
+    readonly code = "CONTINUATION_ADAPTER_TIMEOUT";
+    constructor(timeoutMs: number);
+}
 export type ContinuationDriverState = {
     schema_version: "1.0";
     run_id: string;
@@ -38,12 +42,14 @@ export type ContinuationDriverState = {
     adapter_command_identity: string | null;
     status: "active" | "waiting" | "done" | "failed" | "budget_exhausted";
     turns_started: number;
+    active_turn_step?: string | null;
+    active_turn_public_key_digest?: string | null;
     pending_barrier: ContinuationBarrier | null;
     updated_at: string;
 };
 export type ContinuationDriverEvent = {
     schema_version: "1.0";
-    type: "started" | "turn_started" | "turn_completed" | "turn_failed" | "parked" | "resumed" | "done" | "budget_exhausted";
+    type: "started" | "turn_started" | "turn_completed" | "gate_not_advanced" | "turn_failed" | "authority_cleanup_failed" | "parked" | "resumed" | "done" | "budget_exhausted";
     run_id: string;
     definition_id: string;
     current_step: string;
@@ -51,6 +57,7 @@ export type ContinuationDriverEvent = {
     at: string;
     barrier?: ContinuationBarrier;
     summary?: string;
+    failure_kind?: "adapter_error" | "timeout";
 };
 export interface ContinuationStateStore {
     load(): ContinuationDriverState | null;
@@ -60,8 +67,23 @@ export interface ContinuationStateStore {
 export interface ContinuationRuntimePort {
     inspect(): Promise<ContinuationSnapshot>;
     synchronize(): Promise<ContinuationSnapshot>;
-    execute(request: ContinuationTurnRequest): Promise<ContinuationTurnResult>;
+    execute(request: ContinuationTurnRequest, context?: ContinuationTurnContext): Promise<ContinuationTurnResult>;
 }
+export type ContinuationTurnContext = {
+    continuationTurnSecret?: string;
+    continuationRunId?: string;
+};
+export type ContinuationDriverLockLease = {
+    pid: number;
+    token: string;
+    created_at: string;
+};
+export type ContinuationTurnAuthority = {
+    runId: string;
+    turnSecret: string;
+    publicKeyDigest: string;
+    cleanup(): boolean;
+};
 export type ContinuationDriverOutcome = {
     outcome: "done" | "waiting" | "failed" | "budget_exhausted";
     turns_started: number;
@@ -75,6 +97,7 @@ export interface RunContinuationDriverInput {
     store: ContinuationStateStore;
     waitForBarrier?: (barrier: ContinuationBarrier) => Promise<"ready" | "pending">;
     authorizeTurn?: () => Promise<void>;
+    issueTurnAuthority?: (request: ContinuationTurnRequest) => Promise<ContinuationTurnAuthority>;
     now?: () => Date;
 }
 export interface DriveBuilderFlowSessionInput {
@@ -84,9 +107,10 @@ export interface DriveBuilderFlowSessionInput {
     execute: ContinuationRuntimePort["execute"];
     waitForBarrier?: RunContinuationDriverInput["waitForBarrier"];
     authorizeTurn?: RunContinuationDriverInput["authorizeTurn"];
+    issueTurnAuthority?: RunContinuationDriverInput["issueTurnAuthority"];
     now?: () => Date;
 }
 export declare function runContinuationDriver(input: RunContinuationDriverInput): Promise<ContinuationDriverOutcome>;
 export declare function driveBuilderFlowSession(input: DriveBuilderFlowSessionInput): Promise<ContinuationDriverOutcome>;
-export declare function withContinuationDriverLock<T>(sessionDirInput: string, body: () => Promise<T>): Promise<T>;
+export declare function withContinuationDriverLock<T>(sessionDirInput: string, body: (lease: ContinuationDriverLockLease) => Promise<T>): Promise<T>;
 export declare function createFileContinuationStore(sessionDirInput: string): ContinuationStateStore;