sortie-dogs 0.5.16 → 0.6.0

package/README.md

@@ -20,7 +20,7 @@ Requirements: Node.js 22.6 or newer, npm, and OpenCode.
 
 Guides: [日本語](docs/guide-ja.md) · [简体中文](docs/guide-zh-CN.md) · [CLI testing](docs/cli-testing.md)
 
-Release: [v0.5.16](https://github.com/zufall-upon/Sortie-dogs/releases/tag/v0.5.16)
+Release: [v0.6.0](https://github.com/zufall-upon/Sortie-dogs/releases/tag/v0.6.0)
 
 ## Quick start
 

package/dist/asset-version.d.ts

@@ -2,5 +2,5 @@
  * Version of the installable runtime assets. Kept in its own module so the plugin can compare an
  * installed project marker without importing every asset body.
  */
-export declare const RUNTIME_ASSET_VERSION = "0.3.48-recovery-compaction-v1";
+export declare const RUNTIME_ASSET_VERSION = "0.3.49-run-metrics-v1";
 export type RuntimeAssetVersion = typeof RUNTIME_ASSET_VERSION;

package/dist/asset-version.js

@@ -2,4 +2,4 @@
  * Version of the installable runtime assets. Kept in its own module so the plugin can compare an
  * installed project marker without importing every asset body.
  */
-export const RUNTIME_ASSET_VERSION = "0.3.48-recovery-compaction-v1";
+export const RUNTIME_ASSET_VERSION = "0.3.49-run-metrics-v1";

package/dist/core/worktree-commit-artifact.js

@@ -13,6 +13,7 @@ const MAX_OUTPUT = 1024 * 1024;
 const MAX_TIMEOUT = 10 * 60_000;
 const GIT_TIMEOUT = 30_000;
 const EXIT_GRACE = 500;
+let systemdUnitSequence = 0;
 const KILL_WAIT = 2_000;
 const WINDOWS_WRAPPER_GRACE = 15_000;
 const LINUX_WRAPPER_GRACE = 10_000;
@@ -483,9 +484,163 @@ async function terminateTree(child, closed) {
             return false;
         };
         if (!(await groupGone())) {
-            throw new WorktreeCommitArtifactError("validation-failed", "Process-tree termination could not be confirmed.");
+            try {
+                process.kill(-child.pid, "SIGKILL");
+            }
+            catch { /* Already closed. */ }
+            if (!(await groupGone())) {
+                throw new WorktreeCommitArtifactError("validation-failed", "Process-tree termination could not be confirmed.");
+            }
+        }
+    }
+}
+async function linuxSystemdRun() {
+    for (const candidate of ["/usr/bin/systemd-run", "/bin/systemd-run"]) {
+        const canonical = await realpath(candidate).catch(() => undefined);
+        if (canonical === undefined || !canonical.startsWith("/usr/bin/") && !canonical.startsWith("/bin/"))
+            continue;
+        const info = await lstat(canonical).catch(() => undefined);
+        if (info !== undefined && info.isFile() && !info.isSymbolicLink() && info.uid === 0 && (info.mode & 0o111) !== 0)
+            return canonical;
+    }
+    throw new WorktreeCommitArtifactError("validation-failed", "Validation containment setup failed.");
+}
+async function linuxSystemctl() {
+    for (const candidate of ["/usr/bin/systemctl", "/bin/systemctl"]) {
+        const canonical = await realpath(candidate).catch(() => undefined);
+        if (canonical === undefined || !canonical.startsWith("/usr/bin/") && !canonical.startsWith("/bin/"))
+            continue;
+        const info = await lstat(canonical).catch(() => undefined);
+        if (info !== undefined && info.isFile() && !info.isSymbolicLink() && info.uid === 0 && (info.mode & 0o111) !== 0)
+            return canonical;
+    }
+    throw new WorktreeCommitArtifactError("validation-failed", "Validation containment setup failed.");
+}
+async function linuxEnvironmentExecutable() {
+    for (const candidate of ["/usr/bin/env", "/bin/env"]) {
+        const canonical = await realpath(candidate).catch(() => undefined);
+        if (canonical === undefined || !canonical.startsWith("/usr/bin/") && !canonical.startsWith("/bin/"))
+            continue;
+        const info = await lstat(canonical).catch(() => undefined);
+        if (info !== undefined && info.isFile() && !info.isSymbolicLink() && info.uid === 0 && (info.mode & 0o111) !== 0)
+            return canonical;
+    }
+    throw new WorktreeCommitArtifactError("validation-failed", "Validation containment setup failed.");
+}
+async function linuxShell() {
+    for (const candidate of ["/bin/sh", "/usr/bin/sh"]) {
+        const canonical = await realpath(candidate).catch(() => undefined);
+        if (canonical === undefined || !canonical.startsWith("/usr/bin/") && !canonical.startsWith("/bin/"))
+            continue;
+        const info = await lstat(canonical).catch(() => undefined);
+        if (info !== undefined && info.isFile() && !info.isSymbolicLink() && info.uid === 0 && (info.mode & 0o111) !== 0)
+            return canonical;
+    }
+    throw new WorktreeCommitArtifactError("validation-failed", "Validation containment setup failed.");
+}
+async function stopSystemdUnit(unit, environment) {
+    const systemctl = await linuxSystemctl();
+    const invoke = async (args) => {
+        const child = spawn(systemctl, args, { env: environment, shell: false, windowsHide: true, stdio: "ignore" });
+        const closed = new Promise((done, reject) => {
+            child.once("error", reject);
+            child.once("close", (code) => done({ code }));
+        });
+        if (!(await waitForClose(closed, KILL_WAIT + 1_500))) {
+            child.kill("SIGKILL");
+            if (!(await waitForClose(closed, KILL_WAIT))) {
+                throw new WorktreeCommitArtifactError("validation-failed", "Validation containment shutdown failed.");
+            }
         }
+        return (await closed).code;
+    };
+    await invoke(["--user", "stop", unit]).catch(() => undefined);
+    const activeState = async () => {
+        const code = await invoke(["--user", "is-active", "--quiet", unit]);
+        if (code === 0)
+            return true;
+        if (code === 3 || code === 4)
+            return false;
+        throw new WorktreeCommitArtifactError("validation-failed", "Validation containment shutdown failed.");
+    };
+    const deadline = Date.now() + KILL_WAIT;
+    while (Date.now() < deadline) {
+        if (await activeState()) {
+            await invoke(["--user", "stop", unit]).catch(() => undefined);
+        }
+        await new Promise((done) => setTimeout(done, 25));
+    }
+    if (await activeState()) {
+        throw new WorktreeCommitArtifactError("validation-failed", "Validation containment shutdown failed.");
+    }
+}
+async function runLinuxSystemd(executable, args, cwd, timeout) {
+    const systemdRun = await linuxSystemdRun();
+    const [environmentExecutable, shell] = await Promise.all([linuxEnvironmentExecutable(), linuxShell()]);
+    const uid = process.getuid?.();
+    if (uid === undefined)
+        throw new WorktreeCommitArtifactError("validation-failed", "Validation containment setup failed.");
+    const runtimeDirectory = `/run/user/${uid}`;
+    const environment = {
+        ...cleanEnvironment(),
+        XDG_RUNTIME_DIR: runtimeDirectory,
+        DBUS_SESSION_BUS_ADDRESS: `unix:path=${runtimeDirectory}/bus`,
+    };
+    systemdUnitSequence = (systemdUnitSequence + 1) % Number.MAX_SAFE_INTEGER;
+    const unit = `sortie-dogs-${process.pid}-${Date.now()}-${systemdUnitSequence}`;
+    const validationEnvironment = Object.entries(cleanEnvironment()).map(([key, value]) => `${key}=${value}`);
+    const child = spawn(systemdRun, [
+        "--user", "--wait", "--collect", "--quiet", `--unit=${unit}`,
+        "--property=KillMode=control-group", `--property=RuntimeMaxSec=${timeout}ms`,
+        "--property=TimeoutStopSec=1s", "--working-directory", cwd, "--",
+        environmentExecutable, "-i", ...validationEnvironment, shell, "-c",
+        '"$@"; code=$?; if [ "$code" -eq 0 ]; then exit 0; else exit 239; fi',
+        "sortie-validation", executable, ...args,
+    ], {
+        cwd, env: environment, shell: false, windowsHide: true, detached: true, stdio: ["ignore", "pipe", "pipe"],
+    });
+    const chunks = [];
+    let outputBytes = 0;
+    let overflow = false;
+    const collect = (chunk) => {
+        outputBytes += chunk.byteLength;
+        if (outputBytes <= MAX_OUTPUT)
+            chunks.push(chunk);
+        else
+            overflow = true;
+    };
+    child.stdout.on("data", collect);
+    child.stderr.on("data", (chunk) => {
+        outputBytes += chunk.byteLength;
+        if (outputBytes > MAX_OUTPUT)
+            overflow = true;
+    });
+    const closed = new Promise((done, reject) => {
+        child.once("error", reject);
+        child.once("close", (code) => done({ code }));
+    });
+    let timer;
+    const bounded = await Promise.race([
+        closed.then((result) => ({ kind: "closed", result })),
+        new Promise((done) => {
+            timer = setTimeout(() => done({ kind: "timeout" }), timeout + LINUX_WRAPPER_GRACE);
+        }),
+    ]).catch(async () => {
+        await terminateTree(child, closed).catch(() => undefined);
+        await stopSystemdUnit(unit, environment);
+        throw new WorktreeCommitArtifactError("validation-failed", "Validation executable failed.");
+    });
+    if (timer !== undefined)
+        clearTimeout(timer);
+    if (bounded.kind === "timeout" || overflow) {
+        if (child.exitCode === null && child.signalCode === null)
+            await terminateTree(child, closed);
+        await stopSystemdUnit(unit, environment);
+        throw new WorktreeCommitArtifactError("validation-failed", "Validation exceeded its resource bound.");
     }
+    await stopSystemdUnit(unit, environment);
+    const code = bounded.result.code === 0 ? 0 : bounded.result.code === 1 ? 238 : 239;
+    return { code, stdout: Buffer.concat(chunks) };
 }
 async function runBounded(executable, args, cwd, timeout, kind) {
     const windowsWrapper = kind === "validation" && process.platform === "win32";
@@ -557,6 +712,8 @@ async function runBounded(executable, args, cwd, timeout, kind) {
         }
         const code = linuxWrapper && result.code !== 0 && ![238, 239, 240, 241].includes(result.code ?? -1)
             ? 240 : result.code ?? -1;
+        if (linuxWrapper && code === 240)
+            return await runLinuxSystemd(executable, args, cwd, timeout);
         return { code, stdout: Buffer.concat(chunks) };
     }
     catch (error) {

package/dist/plugin/index.d.ts

@@ -3,12 +3,13 @@ import { type ContinuationClient } from "./continuation.js";
 import { type ToolExecuteBeforeInput, type ToolExecuteBeforeOutput } from "./gate.js";
 import { type OpenCodeChatMessageHook, type OpenCodeModelAvailabilityClient } from "./model-routing-hook.js";
 import { type SessionMessageReader } from "./task-result-repair.js";
+import type { RunMetricsClient } from "./run-metrics.js";
 export declare const PARALLEL_COMMIT_ARTIFACT_CAPABILITY = "sortie_create_parallel_commit_artifact";
 export interface OpenCodePluginInput {
     directory: string;
     worktree?: string;
     /** The host SDK client. Absent in hosts that construct the plugin without one. */
-    client?: SessionMessageReader & ContinuationClient & OpenCodeModelAvailabilityClient & {
+    client?: SessionMessageReader & RunMetricsClient & ContinuationClient & OpenCodeModelAvailabilityClient & {
         tui?: {
             showToast?: (request: {
                 body: {

package/dist/plugin/index.js

@@ -18,6 +18,7 @@ import { BACKLOG_DRAIN_CAPABILITY, FastLaneController } from "./fast-lane.js";
 import { createModelRoutingHook, } from "./model-routing-hook.js";
 import { createTaskResultRepairHook, lastAssistantText, markConsultationFallbackRetry, taskChildSessionID, } from "./task-result-repair.js";
 import { configRoot, nearestPackageVersion, reflectionEnabled, ReflectionError, ReflectionStore } from "../reflection/index.js";
+import { collectRunMetrics, insertRunMetrics, isDoneTerminalText } from "./run-metrics.js";
 const INPUT_LIMITS = { config: 64 * 1024, manifest: 512 * 1024, handoff: 2 * 1024 * 1024, parallel: 512 * 1024 };
 const INSPECTION_CACHE = { maximum: 256, ttlMilliseconds: 30 * 60 * 1000 };
 const ACTIVE_SESSION_CACHE = { maximum: 256, ttlMilliseconds: 30 * 60 * 1000 };
@@ -919,6 +920,7 @@ export const SortieDogsPlugin = async (input, options) => {
         return loaded?.gate === undefined && manifestAbsent;
     }
     const inspected = new Map();
+    const inspectionOperations = new Map();
     const sessionAuthorizations = new Map();
     const bindingPins = new Map();
     const bindingOperations = new Set();
@@ -1383,8 +1385,8 @@ export const SortieDogsPlugin = async (input, options) => {
                 if (JSON.stringify(running.artifact.validation.command) !== JSON.stringify(requestedCommand)) {
                     return deny("artifact-replay");
                 }
-                await (await getParallelCoordinator()).acceptArtifact(binding.ownerRoot, binding.completionCallID, sessionID, binding.descriptor, running.artifact);
                 await removeParallelControlFiles(binding.descriptor);
+                await (await getParallelCoordinator()).acceptArtifact(binding.ownerRoot, binding.completionCallID, sessionID, binding.descriptor, running.artifact);
                 parallelArtifacts.set(sessionID, { requestFingerprint: request.fingerprint, artifact: running.artifact });
                 pruneParallelChildMap(parallelArtifacts);
                 return JSON.stringify({ status: "created", replay: true, artifact: boundedParallelArtifact(running.artifact) });
@@ -1397,8 +1399,8 @@ export const SortieDogsPlugin = async (input, options) => {
             };
             const recovered = await recoverWorktreeCommitArtifact(produceRequest);
             const artifact = recovered ?? await produceWorktreeCommitArtifact(produceRequest);
-            await (await getParallelCoordinator()).acceptArtifact(binding.ownerRoot, binding.completionCallID, sessionID, binding.descriptor, artifact);
             await removeParallelControlFiles(binding.descriptor);
+            await (await getParallelCoordinator()).acceptArtifact(binding.ownerRoot, binding.completionCallID, sessionID, binding.descriptor, artifact);
             parallelArtifacts.set(sessionID, { requestFingerprint: request.fingerprint, artifact });
             pruneParallelChildMap(parallelArtifacts);
             return JSON.stringify({ status: "created", ...(recovered === undefined ? {} : { replay: true }),
@@ -1953,6 +1955,11 @@ export const SortieDogsPlugin = async (input, options) => {
                     return deny("binding-replay");
             }
             const existingAuthorization = sessionAuthorizations.get(sessionID);
+            const pendingInspections = [...inspectionOperations.entries()]
+                .filter(([key]) => key.startsWith(`${sessionID}\u0000`))
+                .map(([, operation]) => operation);
+            if (pendingInspections.length > 0)
+                await Promise.allSettled(pendingInspections);
             pruneInspections(now);
             const inspectedEntry = [...inspected.entries()].find(([key, entry]) => key.startsWith(`${sessionID}\u0000`) &&
                 entry.ownerSessionID === sessionID &&
@@ -2401,7 +2408,17 @@ export const SortieDogsPlugin = async (input, options) => {
         const path = input.args.filePath;
         if (typeof path !== "string" || path.length === 0)
             return;
-        await inspect(path, input.sessionID);
+        const absolutePath = resolve(path);
+        const key = `${input.sessionID}\u0000${absolutePath}`;
+        const operation = inspect(path, input.sessionID).then(() => undefined);
+        inspectionOperations.set(key, operation);
+        try {
+            await operation;
+        }
+        finally {
+            if (inspectionOperations.get(key) === operation)
+                inspectionOperations.delete(key);
+        }
     }
     async function invalidateEditedHandoff(path) {
         await ensureLoaded();
@@ -2482,7 +2499,7 @@ export const SortieDogsPlugin = async (input, options) => {
             return undefined;
         }
     }
-    async function hostSessionUserTurn(sessionID) {
+    async function hostSessionRecoveryHistory(sessionID) {
         const messages = input.client?.session?.messages;
         if (messages === undefined)
             return undefined;
@@ -2494,55 +2511,40 @@ export const SortieDogsPlugin = async (input, options) => {
             const payload = isRecord(response) && "data" in response ? response.data : response;
             if (!Array.isArray(payload))
                 return undefined;
+            let persistedTurn;
+            let hasForeignUserTurn = false;
             for (let index = payload.length - 1; index >= 0; index -= 1) {
                 const message = payload[index];
-                if ((message.info?.role ?? message.role) !== "user")
-                    continue;
-                const agent = message.info?.agent ?? message.agent;
-                if (typeof agent !== "string")
+                if (!isRecord(message))
                     return undefined;
-                return {
-                    agent,
-                    synthetic: (message.parts ?? []).some((part) => part.synthetic === true),
-                };
-            }
-            return undefined;
-        }
-        catch {
-            return undefined;
-        }
-    }
-    async function hostSessionForeignUserAgent(sessionID) {
-        const messages = input.client?.session?.messages;
-        if (messages === undefined)
-            return undefined;
-        try {
-            const response = await messages.call(input.client.session, {
-                path: { id: sessionID },
-                query: { directory: input.directory },
-            });
-            const payload = isRecord(response) && "data" in response ? response.data : response;
-            if (!Array.isArray(payload))
-                return undefined;
-            for (const message of payload) {
-                if ((message.info?.role ?? message.role) !== "user")
+                if (message.info !== undefined && !isRecord(message.info))
+                    return undefined;
+                const info = isRecord(message.info) ? message.info : undefined;
+                const role = info?.role ?? message.role;
+                if (role !== "user" && role !== "assistant")
+                    return undefined;
+                if (role !== "user")
                     continue;
-                const agent = message.info?.agent ?? message.agent;
+                const agent = info?.agent ?? message.agent;
                 if (typeof agent !== "string")
                     return undefined;
                 if (agent !== COORDINATOR_AGENT)
-                    return agent;
+                    hasForeignUserTurn = true;
+                if (persistedTurn === undefined) {
+                    if (message.parts !== undefined && !Array.isArray(message.parts))
+                        return undefined;
+                    persistedTurn = {
+                        agent,
+                        synthetic: Array.isArray(message.parts) && message.parts.some((part) => isRecord(part) && part.synthetic === true),
+                    };
+                }
             }
-            return false;
+            return { hasForeignUserTurn, persistedTurn };
         }
         catch {
             return undefined;
         }
     }
-    async function hostSessionHasForeignUserTurn(sessionID) {
-        const agent = await hostSessionForeignUserAgent(sessionID);
-        return typeof agent === "string" ? true : agent;
-    }
     async function assistantMessageText(sessionID, messageID, expectedAgent, partID) {
         const messages = input.client?.session?.messages;
         if (messages === undefined)
@@ -2600,10 +2602,13 @@ export const SortieDogsPlugin = async (input, options) => {
             return false;
         if (identity.agent !== undefined && identity.agent !== COORDINATOR_AGENT)
             return false;
-        if (await hostSessionHasForeignUserTurn(sessionID) !== false)
+        const history = await hostSessionRecoveryHistory(sessionID);
+        if (history === undefined || history.hasForeignUserTurn)
             return false;
-        const persistedTurn = await hostSessionUserTurn(sessionID);
-        if (persistedTurn?.agent !== COORDINATOR_AGENT)
+        const persistedTurn = history.persistedTurn;
+        if (persistedTurn === undefined && identity.agent !== COORDINATOR_AGENT)
+            return false;
+        if (persistedTurn !== undefined && persistedTurn.agent !== COORDINATOR_AGENT)
             return false;
         await rememberCoordinatorRoot(sessionID);
         releaseSessionEnforcement(sessionID);
@@ -2899,6 +2904,12 @@ export const SortieDogsPlugin = async (input, options) => {
                     .replaceAll(CONTINUATION_MARKER, "")
                     .trimEnd();
             }
+            if ((isCoordinatorSession(textInput.sessionID) || await recoverCoordinatorRoot(textInput.sessionID)) &&
+                isDoneTerminalText(textOutput.text)) {
+                const metrics = await collectRunMetrics(input.client, textInput.sessionID, input.directory).catch(() => undefined);
+                if (metrics !== undefined)
+                    textOutput.text = insertRunMetrics(textOutput.text, metrics);
+            }
             await completeContinuationText(textInput.sessionID, textOutput.text, false);
         },
         "experimental.session.compacting": async (compactInput, compactOutput) => {
@@ -3102,6 +3113,7 @@ export const SortieDogsPlugin = async (input, options) => {
          */
         "tool.execute.after": async (toolInput, output) => {
             const completedChildSessionID = toolInput.tool === "task" ? taskChildSessionID(output) : undefined;
+            const handoffInspection = inspectSuccessfulRead(toolInput);
             try {
                 if (bootstrapRequired && toolInput.tool === "sortie_check_contract" && toolInput.sessionID !== undefined &&
                     isCoordinatorSession(toolInput.sessionID) && successfulBootstrapContractCheck(output)) {
@@ -3121,7 +3133,7 @@ export const SortieDogsPlugin = async (input, options) => {
                         }
                     }
                 }
-                await inspectSuccessfulRead(toolInput);
+                await handoffInspection;
                 let parallel = parallelCalls.get(toolInput.callID ?? "");
                 if (parallel === undefined && toolInput.tool === "task" && toolInput.sessionID !== undefined &&
                     toolInput.callID !== undefined &&

package/dist/plugin/run-metrics.d.ts

@@ -0,0 +1,40 @@
+export interface RunMetricsClient {
+    readonly session?: {
+        readonly get?: (request: {
+            path: {
+                id: string;
+            };
+            query?: {
+                directory?: string;
+            };
+        }) => Promise<unknown>;
+        readonly children?: (request: {
+            path: {
+                id: string;
+            };
+            query?: {
+                directory?: string;
+            };
+        }) => Promise<unknown>;
+        readonly messages?: (request: {
+            path: {
+                id: string;
+            };
+            query?: {
+                directory?: string;
+            };
+        }) => Promise<unknown>;
+    };
+}
+export interface RunMetrics {
+    readonly durationMilliseconds: number | undefined;
+    readonly tokens: number | undefined;
+    readonly cost: number | undefined;
+    readonly steps: number | undefined;
+    readonly sessions: number | undefined;
+    readonly cacheRatio: number | undefined;
+}
+export declare function collectRunMetrics(client: RunMetricsClient | undefined, rootSessionID: string, directory?: string, now?: number): Promise<RunMetrics | undefined>;
+export declare function formatRunMetrics(metrics: RunMetrics): string;
+export declare function isDoneTerminalText(text: string): boolean;
+export declare function insertRunMetrics(text: string, metrics: RunMetrics): string;

package/dist/plugin/run-metrics.js

@@ -0,0 +1,169 @@
+const MAX_SESSIONS = 128;
+function record(value) {
+    return value !== null && typeof value === "object" ? value : undefined;
+}
+function unwrap(value) {
+    const object = record(value);
+    return object !== undefined && "data" in object ? object.data : value;
+}
+function number(value) {
+    return typeof value === "number" && Number.isFinite(value) && value >= 0 ? value : undefined;
+}
+function messageTokens(message) {
+    const info = record(message.info) ?? message;
+    const tokens = record(info.tokens) ?? record(message.tokens);
+    if (tokens === undefined)
+        return undefined;
+    const input = number(tokens.input);
+    const output = number(tokens.output);
+    const reasoning = number(tokens.reasoning);
+    const cache = record(tokens.cache);
+    const cacheRead = number(cache?.read) ?? number(tokens.cacheRead) ?? number(tokens.cache_read);
+    const cacheWrite = number(cache?.write) ?? number(tokens.cacheWrite) ?? number(tokens.cache_write);
+    if (input === undefined || output === undefined || reasoning === undefined || cacheRead === undefined || cacheWrite === undefined)
+        return undefined;
+    return [input + output + reasoning + cacheRead + cacheWrite, cacheRead];
+}
+function assistantMessages(value) {
+    const payload = unwrap(value);
+    if (!Array.isArray(payload))
+        return undefined;
+    return payload.filter((entry) => {
+        const item = record(entry);
+        const info = item === undefined ? undefined : record(item.info);
+        return item !== undefined && (info?.role ?? item.role) === "assistant";
+    });
+}
+export async function collectRunMetrics(client, rootSessionID, directory, now = Date.now()) {
+    const session = client?.session;
+    if (session?.messages === undefined)
+        return undefined;
+    const ids = [rootSessionID];
+    const visited = new Set(ids);
+    let hierarchyComplete = session.children !== undefined;
+    for (let index = 0; index < ids.length && ids.length < MAX_SESSIONS; index += 1) {
+        if (session.children === undefined)
+            break;
+        try {
+            const children = unwrap(await session.children.call(session, { path: { id: ids[index] }, query: { directory } }));
+            if (!Array.isArray(children)) {
+                hierarchyComplete = false;
+                break;
+            }
+            for (const child of children) {
+                const item = record(child);
+                const id = typeof item?.id === "string" ? item.id : typeof item?.sessionID === "string" ? item.sessionID : undefined;
+                if (id === undefined) {
+                    hierarchyComplete = false;
+                    continue;
+                }
+                if (!visited.has(id) && ids.length < MAX_SESSIONS) {
+                    visited.add(id);
+                    ids.push(id);
+                }
+                else if (!visited.has(id))
+                    hierarchyComplete = false;
+            }
+        }
+        catch {
+            hierarchyComplete = false;
+            break;
+        }
+    }
+    if (ids.length >= MAX_SESSIONS)
+        hierarchyComplete = false;
+    const uniqueMessages = new Set();
+    let totalTokens = 0;
+    let cacheRead = 0;
+    let tokensAvailable = true;
+    let messagesComplete = true;
+    let steps = 0;
+    let cost = 0;
+    let costAvailable = true;
+    for (const id of ids) {
+        try {
+            const messages = assistantMessages(await session.messages.call(session, { path: { id }, query: { directory } }));
+            if (messages === undefined)
+                return undefined;
+            for (const message of messages) {
+                const info = record(message.info) ?? message;
+                const time = record(info.time) ?? record(message.time);
+                if (time !== undefined && number(time.completed) === undefined)
+                    continue;
+                const messageID = typeof info.id === "string" ? info.id : typeof message.id === "string" ? message.id : undefined;
+                if (messageID === undefined) {
+                    messagesComplete = false;
+                    continue;
+                }
+                if (uniqueMessages.has(messageID))
+                    continue;
+                uniqueMessages.add(messageID);
+                steps += 1;
+                const tokens = messageTokens(message);
+                if (tokens !== undefined) {
+                    totalTokens += tokens[0];
+                    cacheRead += tokens[1];
+                }
+                else
+                    tokensAvailable = false;
+                const reportedCost = number(info.cost) ?? number(message.cost);
+                if (reportedCost === undefined)
+                    costAvailable = false;
+                else
+                    cost += reportedCost;
+            }
+        }
+        catch {
+            return undefined;
+        }
+    }
+    let created;
+    if (session.get !== undefined) {
+        try {
+            const root = record(unwrap(await session.get.call(session, { path: { id: rootSessionID }, query: { directory } })));
+            const time = record(root?.time);
+            created = number(time?.created);
+        }
+        catch { /* fallback below */ }
+    }
+    return {
+        durationMilliseconds: created === undefined ? undefined : Math.max(0, now - created),
+        tokens: hierarchyComplete && messagesComplete && tokensAvailable ? totalTokens : undefined,
+        cost: hierarchyComplete && messagesComplete && costAvailable ? cost : undefined,
+        steps: hierarchyComplete && messagesComplete ? steps : undefined,
+        sessions: hierarchyComplete ? ids.length : undefined,
+        cacheRatio: hierarchyComplete && messagesComplete && tokensAvailable && totalTokens > 0 ? cacheRead / totalTokens : undefined,
+    };
+}
+function duration(milliseconds) {
+    const seconds = Math.floor(milliseconds / 1000);
+    if (seconds < 60)
+        return `${seconds}s`;
+    const minutes = Math.floor(seconds / 60);
+    return `${minutes}m ${String(seconds % 60).padStart(2, "0")}s`;
+}
+export function formatRunMetrics(metrics) {
+    const elapsed = metrics.durationMilliseconds === undefined ? "duration unavailable" : `${duration(metrics.durationMilliseconds)} wall-clock`;
+    const cost = metrics.cost === undefined ? "cost unavailable" : `$${metrics.cost.toFixed(4)}`;
+    const tokens = metrics.tokens === undefined ? "tokens unavailable" : `${metrics.tokens.toLocaleString("en-US")} tokens`;
+    const steps = metrics.steps === undefined ? "steps unavailable" : `${metrics.steps} completed assistant model step${metrics.steps === 1 ? "" : "s"}`;
+    const sessions = metrics.sessions === undefined ? "sessions unavailable" : `${metrics.sessions} session${metrics.sessions === 1 ? "" : "s"}`;
+    const cache = metrics.cacheRatio === undefined ? "cache ratio unavailable" : `${(metrics.cacheRatio * 100).toFixed(1)}% cache ratio`;
+    return `**Run:** pre-terminal host snapshot · ${elapsed} · ${tokens} · ${cost} · ${steps} · ${sessions} · ${cache}`;
+}
+export function isDoneTerminalText(text) {
+    const first = text.split(/\r?\n/u).find((line) => line.trim().length > 0) ?? "";
+    return /^✅\s+\*\*DONE\*\*(?:\s|$)/u.test(first) || /^status:\s*DONE(?:\s|$)/u.test(first);
+}
+export function insertRunMetrics(text, metrics) {
+    if (/\*\*Run:\*\*/u.test(text) || !isDoneTerminalText(text))
+        return text;
+    const newline = text.includes("\r\n") ? "\r\n" : "\n";
+    const statusStart = text.search(/^(?:✅\s+\*\*DONE\*\*|status:\s*DONE).*$/mu);
+    if (statusStart < 0)
+        return text;
+    const statusEnd = text.indexOf(newline, statusStart);
+    if (statusEnd < 0)
+        return `${text}${newline}${newline}${formatRunMetrics(metrics)}`;
+    return `${text.slice(0, statusEnd + newline.length)}${newline}${formatRunMetrics(metrics)}${newline}${text.slice(statusEnd + newline.length)}`;
+}