@kontourai/flow-agents 3.8.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,29 @@
 # 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)
+
+
+### Features
+
+* **workflow:** add bounded continuation driver ([#560](https://github.com/kontourai/flow-agents/issues/560)) ([e6365ab](https://github.com/kontourai/flow-agents/commit/e6365aba324c76ee164681c987d20916c315444e))
+
 ## [3.8.0](https://github.com/kontourai/flow-agents/compare/v3.7.0...v3.8.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/builder-flow-runtime.js

@@ -760,7 +760,9 @@ function projectFlowRun(context, run, sidecar) {
     const complete = run.state.status === "completed";
     const paused = run.state.status === "paused";
     const canceled = run.state.status === "canceled";
-    const action = complete || paused || canceled ? { skills: [], operations: [] } : stepAction(run.definitionId, run.state.current_step);
+    const needsDecision = run.state.status === "needs_decision";
+    const failed = run.state.status === "failed";
+    const action = complete || paused || canceled || needsDecision || failed ? { skills: [], operations: [] } : stepAction(run.definitionId, run.state.current_step);
     if (!action) {
         throw new BuilderBuildRunInputError("kit.flow_step_actions", `does not declare Builder step ${run.state.current_step}`);
     }
@@ -785,18 +787,22 @@ function projectFlowRun(context, run, sidecar) {
             ? { status: "done", summary: "Canonical Flow run was canceled by an authorized external request. Artifacts are retained until separately archived." }
             : paused
                 ? { status: "blocked", summary: "Canonical Flow run is paused. The current assignment actor may resume it with a reason." }
-                : {
-                    status: "continue",
-                    summary: `Flow step \`${run.state.current_step}\`: ${skillText}${operationText} ${gateText}${routeText} Then synchronize the recorded evidence.`,
-                    skills,
-                    operations,
-                    command: syncCommand,
-                };
+                : needsDecision
+                    ? { status: "blocked", summary: "Canonical Flow requires an external decision before continuation." }
+                    : failed
+                        ? { status: "failed", summary: "Canonical Flow run failed; no continuation turn is allowed." }
+                        : {
+                            status: "continue",
+                            summary: `Flow step \`${run.state.current_step}\`: ${skillText}${operationText} ${gateText}${routeText} Then synchronize the recorded evidence.`,
+                            skills,
+                            operations,
+                            command: syncCommand,
+                        };
     const phase = phaseForStep(definition.phase_map, run.state.current_step) ?? sidecar.phase;
     return {
         ...sidecar,
-        status: complete ? "delivered" : canceled ? "canceled" : paused ? "blocked" : (run.state.transitions.length > 0 ? "in_progress" : sidecar.status),
-        phase: complete || canceled ? "done" : phase,
+        status: complete ? "delivered" : canceled ? "canceled" : failed ? "failed" : (paused || needsDecision) ? "blocked" : (run.state.transitions.length > 0 ? "in_progress" : sidecar.status),
+        phase: complete || canceled || failed ? "done" : phase,
         updated_at: run.state.updated_at,
         flow_run: {
             run_id: run.runId,

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

@@ -0,0 +1,26 @@
+import type { ContinuationBarrier, ContinuationTurnRequest, ContinuationTurnResult } from "../continuation-driver.js";
+export type ContinuationAdapterCommand = {
+    argv: string[];
+    identity: string;
+    integrity: Array<{
+        file: string;
+        sha256: string;
+    }>;
+};
+export declare function loadContinuationAdapterCommand(commandFileInput: string): ContinuationAdapterCommand;
+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

@@ -0,0 +1,243 @@
+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")));
+    if (!path.isAbsolute(command.argv[0]))
+        throw new Error("continuation adapter executable must be an absolute path");
+    const integrity = [...new Set(command.argv.filter((entry) => path.isAbsolute(entry) && regularFileExists(entry)))]
+        .map((file) => ({ file, sha256: sha256File(file, "continuation adapter integrity file") }));
+    if (!integrity.some((entry) => entry.file === command.argv[0]))
+        throw new Error("continuation adapter executable must be a regular file");
+    const identity = createHash("sha256").update(JSON.stringify({ ...command, integrity })).digest("hex");
+    return { ...command, identity, integrity };
+}
+export async function executeContinuationAdapter(commandFileInput, request, options) {
+    const command = loadContinuationAdapterCommand(commandFileInput);
+    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}`);
+        }
+    }
+}
+export async function waitForContinuationBarrier(barrier, options) {
+    assertPositiveInteger(options.maxWaitMs, "continuation barrier maxWaitMs", 0, 86_400_000);
+    assertPositiveInteger(options.pollMs, "continuation barrier pollMs", 1, 60_000);
+    const now = options.now ?? Date.now;
+    const sleep = options.sleep ?? ((ms) => new Promise((resolve) => setTimeout(resolve, ms)));
+    const stopAt = now() + options.maxWaitMs;
+    if (barrier.kind === "deadline") {
+        const deadline = Date.parse(barrier.at);
+        if (deadline <= now())
+            return "ready";
+        const waitMs = Math.min(deadline - now(), Math.max(0, stopAt - now()));
+        if (waitMs > 0)
+            await sleep(waitMs);
+        return Date.parse(barrier.at) <= now() ? "ready" : "pending";
+    }
+    while (pidAlive(barrier.pid)) {
+        const remaining = stopAt - now();
+        if (remaining <= 0)
+            return "pending";
+        await sleep(Math.min(options.pollMs, remaining));
+    }
+    return "ready";
+}
+function spawnAdapter(command, request, options) {
+    return new Promise((resolve, reject) => {
+        const child = spawn(command.argv[0], command.argv.slice(1), {
+            cwd: options.cwd,
+            env: adapterEnvironment(options),
+            detached: process.platform !== "win32",
+            shell: false,
+            stdio: ["pipe", "pipe", "pipe"],
+        });
+        const stdout = [];
+        const stderr = [];
+        let stdoutBytes = 0;
+        let stderrBytes = 0;
+        let settled = false;
+        let forcedKill;
+        let terminationError;
+        const maxBytes = 4 * 1024 * 1024;
+        const timeout = setTimeout(() => {
+            if (settled)
+                return;
+            terminationError = new ContinuationAdapterTimeoutError(options.timeoutMs);
+            terminateProcessGroup(child.pid, "SIGTERM");
+            forcedKill = setTimeout(() => terminateProcessGroup(child.pid, "SIGKILL"), 250);
+        }, options.timeoutMs);
+        child.stdout.on("data", (chunk) => {
+            stdoutBytes += chunk.length;
+            if (stdoutBytes > maxBytes) {
+                if (!terminationError) {
+                    terminationError = new Error("continuation adapter stdout exceeded 4 MiB");
+                    clearTimeout(timeout);
+                    terminateProcessGroup(child.pid, "SIGTERM");
+                    forcedKill = setTimeout(() => terminateProcessGroup(child.pid, "SIGKILL"), 250);
+                }
+                return;
+            }
+            stdout.push(chunk);
+        });
+        child.stderr.on("data", (chunk) => {
+            stderrBytes += chunk.length;
+            if (stderrBytes <= maxBytes)
+                stderr.push(chunk);
+        });
+        child.on("error", (error) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timeout);
+            if (forcedKill)
+                clearTimeout(forcedKill);
+            reject(error);
+        });
+        child.on("close", (code, signal) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timeout);
+            if (forcedKill)
+                clearTimeout(forcedKill);
+            if (terminationError) {
+                reject(terminationError);
+                return;
+            }
+            const stderrText = Buffer.concat(stderr).toString("utf8").trim();
+            if (code !== 0) {
+                scheduleProcessGroupTermination(child.pid);
+                reject(new Error(`continuation adapter exited ${code ?? signal ?? "unknown"}${stderrText ? `: ${stderrText}` : ""}`));
+                return;
+            }
+            const output = Buffer.concat(stdout).toString("utf8").trim();
+            try {
+                const result = JSON.parse(output);
+                if (!isValidWaitResult(result))
+                    scheduleProcessGroupTermination(child.pid);
+                resolve(result);
+            }
+            catch {
+                scheduleProcessGroupTermination(child.pid);
+                reject(new Error("continuation adapter must emit exactly one JSON result on stdout"));
+            }
+        });
+        child.stdin.on("error", (error) => {
+            if (error.code !== "EPIPE" && !settled) {
+                settled = true;
+                clearTimeout(timeout);
+                if (forcedKill)
+                    clearTimeout(forcedKill);
+                scheduleProcessGroupTermination(child.pid);
+                reject(error);
+            }
+        });
+        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");
+    const argv = value.argv;
+    if (!Array.isArray(argv) || argv.length === 0 || argv.length > 128 || argv.some((entry) => typeof entry !== "string" || entry.length === 0 || entry.includes("\0"))) {
+        throw new Error("continuation adapter command argv must contain 1 through 128 non-empty strings");
+    }
+    return { argv: [...argv] };
+}
+function assertRegularFile(file, label) {
+    const stat = fs.lstatSync(file);
+    if (stat.isSymbolicLink() || !stat.isFile())
+        throw new Error(`${label} must be a regular file`);
+}
+function readRegularFileNoFollow(file, label) {
+    return readRegularFileBufferNoFollow(file, label).toString("utf8");
+}
+function readRegularFileBufferNoFollow(file, label) {
+    assertRegularFile(file, label);
+    const noFollow = typeof fs.constants.O_NOFOLLOW === "number" ? fs.constants.O_NOFOLLOW : 0;
+    const fd = fs.openSync(file, fs.constants.O_RDONLY | noFollow);
+    try {
+        if (!fs.fstatSync(fd).isFile())
+            throw new Error(`${label} must be a regular file`);
+        return fs.readFileSync(fd);
+    }
+    finally {
+        fs.closeSync(fd);
+    }
+}
+function assertPositiveInteger(value, label, min, max) {
+    if (!Number.isSafeInteger(value) || value < min || value > max)
+        throw new Error(`${label} must be an integer from ${min} through ${max}`);
+}
+function pidAlive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (error) {
+        return error.code === "EPERM";
+    }
+}
+function terminateProcessGroup(pid, signal) {
+    if (!pid)
+        return;
+    try {
+        process.kill(process.platform === "win32" ? pid : -pid, signal);
+    }
+    catch (error) {
+        if (error.code !== "ESRCH")
+            throw error;
+    }
+}
+function isValidWaitResult(result) {
+    if (result?.status !== "wait" || !result.barrier || typeof result.barrier !== "object")
+        return false;
+    if (result.barrier.kind === "pid")
+        return Number.isSafeInteger(result.barrier.pid) && result.barrier.pid > 0;
+    return result.barrier.kind === "deadline" && typeof result.barrier.at === "string" && Number.isFinite(Date.parse(result.barrier.at));
+}
+function scheduleProcessGroupTermination(pid) {
+    terminateProcessGroup(pid, "SIGTERM");
+    const forcedKill = setTimeout(() => terminateProcessGroup(pid, "SIGKILL"), 250);
+    forcedKill.unref();
+}
+function regularFileExists(file) {
+    try {
+        const stat = fs.lstatSync(file);
+        return !stat.isSymbolicLink() && stat.isFile();
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return false;
+        throw error;
+    }
+}
+function sha256File(file, label) {
+    return createHash("sha256").update(readRegularFileBufferNoFollow(file, label)).digest("hex");
+}

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));
         }