@akagilnc/pi-workflow-roles 0.1.3572 → 0.1.3621

package/dist/gatekeeper-role.js

@@ -1,11 +1,8 @@
-import { Type } from "typebox";
-import { auditorRunDirectory, createAuditorDossierTool, persistGateSubmissionCandidate, } from "./auditor-dossier-tool.js";
-import { executeAuditorChild } from "./evidence-child-executor.js";
-import { openToolObject } from "./open-tool-schema.js";
-import { loadGatekeeperSessionMaterials } from "./session-opening-materials.js";
+import { auditorRunDirectory, persistGateSubmissionCandidate, } from "./auditor-dossier-tool.js";
 import { GatekeeperDecisionError } from "./submission-errors.js";
 import { INSPECTOR_OUTPUT_TOOL_NAME } from "./inspector-contracts.js";
 import { GATEKEEPER_OUTPUT_TOOL_NAME, gatekeeperDecisionSchema, gatekeeperOutputSchema, } from "./package-contracts/gatekeeper-output.js";
+import { retainedShapeUnreadable } from "./shape-unreadable-failure.js";
 export const INSPECTOR_OUTPUT_TOOL = INSPECTOR_OUTPUT_TOOL_NAME;
 export const NOTARY_OUTPUT_TOOL = "ak_notary_output";
 function gateSeatLabel(stage) {
@@ -20,13 +17,6 @@ export class GatekeeperEscalationError extends Error {
         this.gatekeeper = gatekeeper;
     }
 }
-// Unknown fields so wrong types/spellings still reach projection (ADR 0055/0057; 仓第 0 条).
-// Opening goes through the sole openToolObject owner — no parallel transport helper.
-const officerDecisionSchema = openToolObject(Type.Object({
-    status: Type.Unknown({ description: "pass | bounce | escalate — 形状指引，非 schema 闸" }),
-    reason: Type.Optional(Type.Unknown({ description: "status 为 escalate 时的理由" })),
-    findings: Type.Unknown({ description: "string[] findings，随 pass、bounce 或 escalate 留存" }),
-}));
 /**
  * Direct-seat decision tool spec (#639). Lifecycle assembly stays on the
  * registration envelope — src/role-runtime.ts (ADR 0018). Schema authority is
@@ -42,27 +32,17 @@ export const GATEKEEPER_TOOL_SPEC = {
 function result(content, details) {
     return { content: [{ type: "text", text: content }], details };
 }
-/** Shared officer decision tool — open transport; projection owns legality. */
-export function createOfficerDecisionTool(name) {
-    return {
-        name,
-        description: "提交一份 typed pass/bounce/escalate 决议。",
-        parameters: officerDecisionSchema,
-        async execute(_id, args) { return result(`已收 ${String(args?.status)}`, args); },
-    };
-}
 /** Gatekeeper province decision tool — open transport; package-contract projection owns legality. */
 export function createGatekeeperOutputTool() {
     return {
         name: GATEKEEPER_OUTPUT_TOOL_NAME,
         description: "提交门下省派官决定。",
         parameters: gatekeeperDecisionSchema,
-        async execute(_id, args) { return result(`已收 ${String(args?.status)}`, args); },
+        async execute(_id, args) {
+            return result(`已收 ${String(args?.status)}`, args);
+        },
     };
 }
-async function defaultLoadSoul(role) {
-    return loadGatekeeperSessionMaterials(role);
-}
 function failureReason(error) {
     if (error instanceof AggregateError)
         return error.errors.map(failureReason).join("; ");
@@ -88,14 +68,15 @@ function retainedSubmission(decision) {
         : decision;
 }
 /**
- * No usable explicit release is infrastructure failure, not a judgment status.
- * Original submission is retained for the failure channel (#475).
+ * Shape-unreadable officer decision — retain original candidate + typed reason.
+ * Not a forged bounce, not transport abort (CLAUDE.md §0 / ADR 0055).
+ * Real provider/engine/disk failures stay transport_failure elsewhere.
  */
-function noUsableReleaseFailure(stage, decision) {
+function shapeUnreadable(officer, decision, reason = "decision 无显式 pass/bounce/escalate") {
     return {
-        status: "transport_failure",
-        stage,
-        reason: "decision 无显式 pass/bounce/escalate",
+        status: "unreadable",
+        officer,
+        reason,
         submission: retainedSubmission(decision),
     };
 }
@@ -107,7 +88,7 @@ function readRecord(value) {
 function projectOfficerDecision(officer, decision) {
     const record = readRecord(decision);
     if (record === undefined)
-        return noUsableReleaseFailure(officer, decision);
+        return shapeUnreadable(officer, decision);
     if (record.status === "bounce") {
         return {
             status: "bounce",
@@ -133,63 +114,105 @@ function projectOfficerDecision(officer, decision) {
             submission: retainedSubmission(decision),
         };
     }
-    return noUsableReleaseFailure(officer, decision);
+    return shapeUnreadable(officer, decision);
 }
-/** Submission-gate summons: subject kind determines the officer without a province child. */
-export async function runGatekeeper(options) {
-    const loadSoul = options.loadSoul ?? defaultLoadSoul;
+/** Map a public-role terminal onto the gate officer result surface. */
+function projectOfficerTerminal(officer, summoned) {
+    const terminal = summoned.terminal;
+    const outcome = terminal?.roleOutcome;
+    if (outcome === undefined) {
+        const detail = summoned.stderr?.trim();
+        return {
+            status: "transport_failure",
+            stage: officer,
+            reason: detail && detail.length > 0
+                ? `${gateSeatLabel(officer)} public summon exit ${summoned.exitCode}: ${detail}`
+                : `${gateSeatLabel(officer)} public summon produced no terminal (exit ${summoned.exitCode})`,
+            submission: summoned,
+        };
+    }
+    if (outcome.kind === "no_receipt") {
+        return {
+            status: "no_receipt",
+            stage: officer,
+            reason: `${gateSeatLabel(officer)}未产生已接受回执即散局`,
+            facts: outcome,
+        };
+    }
+    if (outcome.kind === "failure") {
+        // Single settlement marker only (ADR 0055 / #675) — no cause=output re-derivation.
+        const shape = retainedShapeUnreadable(outcome.decisiveFacts);
+        if (shape !== undefined) {
+            return shapeUnreadable(officer, shape.candidate, outcome.diagnostic);
+        }
+        return {
+            status: "transport_failure",
+            stage: officer,
+            reason: outcome.diagnostic,
+            submission: outcome.decisiveFacts,
+        };
+    }
+    if (outcome.kind === "accepted") {
+        return projectOfficerDecision(officer, {
+            status: outcome.status,
+            ...outcome.decisiveFacts,
+        });
+    }
+    return {
+        status: "transport_failure",
+        stage: officer,
+        reason: `${gateSeatLabel(officer)} public summon returned unusable terminal kind`,
+        submission: outcome,
+    };
+}
+/**
+ * Summon + project only. Lifecycle book and host abort face live on the shared
+ * submit envelope (`gatekeeper-pass-envelope.ts`, ADR 0018 / #675).
+ */
+export async function projectGatekeeperRun(options) {
     const officer = options.subject.kind === "worker_completion" ? "inspector" : "notary";
-    // Resolve once so dossier tool and child session share the same run binding (#632).
     const runDirectory = options.runDirectory ?? auditorRunDirectory(options.context);
+    if (runDirectory === undefined) {
+        return {
+            officer,
+            result: {
+                status: "transport_failure",
+                stage: officer,
+                reason: `${gateSeatLabel(officer)} requires a parent run directory pointer`,
+            },
+        };
+    }
     // Pointer-only summons need a resolvable leaf: Grok session.jsonl is header-only
     // (#617 DK-4); write the in-memory tool-call candidate as a run artifact first (#632).
-    const submissionCandidate = runDirectory === undefined
-        ? undefined
-        : persistGateSubmissionCandidate(runDirectory, options.context);
+    persistGateSubmissionCandidate(runDirectory, options.context);
+    let summoned;
     try {
-        const officerRun = await executeAuditorChild({
-            context: options.context,
-            roleLabel: officer === "inspector" ? "Inspector" : "Notary",
-            gateSeat: officer,
-            systemPrompt: await loadSoul(officer),
-            prompt: "卷宗已受理。",
-            tool: createOfficerDecisionTool(officer === "inspector" ? INSPECTOR_OUTPUT_TOOL : NOTARY_OUTPUT_TOOL),
-            // Same locator as 审刑院 — run directory + path identifiers only; no receipt body (#632).
-            dossierTool: createAuditorDossierTool(runDirectory, submissionCandidate === undefined ? undefined : { submissionCandidate }),
-            ...(options.signal === undefined ? {} : { signal: options.signal }),
-            ...(runDirectory === undefined ? {} : { runDirectory }),
-        });
-        if (officerRun.noReceiptLifecycle !== undefined) {
-            return { status: "no_receipt", stage: officer, reason: `${gateSeatLabel(officer)}未产生已接受回执即散局`, facts: officerRun.noReceiptLifecycle };
-        }
-        return projectOfficerDecision(officer, officerRun.decision);
+        const summon = options.summonOfficer
+            ?? (async (nextOfficer, sourceRunDirectory, officerSignal) => {
+                const { summonGateOfficer } = await import("./public-role-summons.js");
+                return summonGateOfficer({
+                    officer: nextOfficer,
+                    sourceRunDirectory,
+                    cwd: options.context.cwd ?? process.cwd(),
+                    ...(officerSignal === undefined ? {} : { signal: officerSignal }),
+                });
+            });
+        summoned = await summon(officer, runDirectory, options.signal);
     }
     catch (error) {
-        return { status: "transport_failure", stage: officer, reason: failureReason(error) };
+        return {
+            officer,
+            result: { status: "transport_failure", stage: officer, reason: failureReason(error) },
+        };
     }
+    return {
+        officer,
+        result: projectOfficerTerminal(officer, summoned),
+        summoned,
+    };
 }
-/** Project GatekeeperResult onto a submit path: transport→failInfrastructure; bounce/no_receipt→typed throw; pass silent. */
-export async function requireGatekeeperPass(options) {
-    const gatekeeper = await runGatekeeper({
-        context: options.context,
-        subject: options.subject,
-        ...(options.signal === undefined ? {} : { signal: options.signal }),
-    });
-    if (gatekeeper.status === "pass")
-        return;
-    if (gatekeeper.status === "transport_failure") {
-        // Typed stage/reason/submission ride failInfrastructure → durable tool_result (#475).
-        const error = new Error(`交卷闸 transport_failure（${gatekeeper.stage}）：${gatekeeper.reason}`);
-        error.stage = gatekeeper.stage;
-        error.reason = gatekeeper.reason;
-        if (gatekeeper.submission !== undefined)
-            error.submission = gatekeeper.submission;
-        options.hostActions.failInfrastructure(error, options.context, options.toolCallId);
-    }
-    if (gatekeeper.status === "escalate") {
-        throw new GatekeeperEscalationError(gatekeeper);
-    }
-    // Envelope owns the execute→tool_result bridge; this module only projects + throws.
-    options.hostActions.bindSubmissionNonPass(options.toolCallId, gatekeeper);
-    throw new GatekeeperDecisionError(gatekeeper);
+/** Submission-gate summons: subject kind → officer; activation is public role path (#675). Projection only. */
+export async function runGatekeeper(options) {
+    const { result } = await projectGatekeeperRun(options);
+    return result;
 }

package/dist/host-transition-prior-native.js

@@ -0,0 +1,78 @@
+/**
+ * Single authority for #617 DK-4 cross-host prior-native projection.
+ * Classifies the prior volume into the two record families that exist
+ * (Pi native session file / sitian run records), never by host name.
+ */
+import { access, readdir } from "node:fs/promises";
+import { dirname, join } from "node:path";
+function isEnoent(error) {
+    return typeof error === "object" && error !== null && error.code === "ENOENT";
+}
+/** Present Pi native session path, or empty when ENOENT. */
+async function listPiNativeRecordPaths(sessionFile) {
+    try {
+        await access(sessionFile);
+        return [sessionFile];
+    }
+    catch (error) {
+        if (isEnoent(error))
+            return [];
+        throw error;
+    }
+}
+/**
+ * Present sitian records.jsonl paths under sessionParent topology (#717).
+ * resolveSitianRecordPathInLedger writes dirname(sessionParent)/<category>/records.jsonl
+ * when sessionParent is inside ledger home — never session.jsonl itself.
+ */
+async function listSitianRecordPaths(sessionParent) {
+    const sessionRoot = dirname(sessionParent);
+    let entries;
+    try {
+        entries = await readdir(sessionRoot, { withFileTypes: true });
+    }
+    catch (error) {
+        if (isEnoent(error))
+            return [];
+        throw error;
+    }
+    const recordPaths = [];
+    for (const entry of entries) {
+        if (!entry.isDirectory())
+            continue;
+        const recordFile = join(sessionRoot, entry.name, "records.jsonl");
+        try {
+            await access(recordFile);
+            recordPaths.push(recordFile);
+        }
+        catch (error) {
+            if (!isEnoent(error))
+                throw error;
+        }
+    }
+    recordPaths.sort();
+    return recordPaths;
+}
+/**
+ * Project one hostTransition only for a real host switch. Empty native volume
+ * still yields a typed switch (empty path list).
+ *
+ * Pi wrote its own session.jsonl; every other host's run volume is the sitian
+ * record set on the live run (ADR 0077 `record-scope-phase-two`, #717) — the CLI's
+ * own journals stay in the operator home and are never copied here.
+ */
+export async function projectHostTransitionPriorNative(input) {
+    if (input.previousHost === input.liveHost)
+        return undefined;
+    if (input.previousHost === "pi") {
+        return {
+            priorNativeKind: "pi-native",
+            priorNativePaths: await listPiNativeRecordPaths(input.piSessionFile),
+        };
+    }
+    // Sitian path handoff only — do not read bytes.
+    return {
+        priorNativeKind: "sitian",
+        priorNativePaths: await listSitianRecordPaths(input.piSessionFile),
+    };
+}

package/dist/institutional-resolution.js

@@ -1,24 +1,4 @@
-import { readFile, writeFile } from "node:fs/promises";
-import { join } from "node:path";
 import { seatModelOnly } from "./public-cli/registry.js";
-const INSTITUTIONAL_RESOLUTION_FILE = "institutional-resolution.json";
-class InstitutionalResolutionError extends Error {
-  reason;
-  constructor(message, reason, options) {
-    super(message, options);
-    this.name = "InstitutionalResolutionError";
-    this.reason = reason;
-  }
-}
-function cleanSelection(model) {
-  if (model === void 0) return void 0;
-  if (typeof model.provider !== "string" || typeof model.model !== "string") return void 0;
-  return {
-    provider: model.provider,
-    model: model.model,
-    ...model.thinking === void 0 ? {} : { thinking: model.thinking }
-  };
-}
 function resolveConfiguredProvinceOfficer(config, officer) {
   const ownModel = seatModelOnly(config.seats[officer]);
   if (ownModel !== void 0) {
@@ -33,80 +13,6 @@ function resolveConfiguredProvinceOfficer(config, officer) {
   }
   return { source: "unconfigured" };
 }
-function resolveInstitutionalSeatSelections(config, parentEffectiveModel) {
-  const parentSelection = cleanSelection(parentEffectiveModel);
-  const gatekeeper = resolveConfiguredProvinceOfficer(config, "gatekeeper").selection ?? parentSelection;
-  const inspector = resolveConfiguredProvinceOfficer(config, "inspector").selection ?? parentSelection;
-  const notary = resolveConfiguredProvinceOfficer(config, "notary").selection ?? parentSelection;
-  const auditor = parentSelection;
-  const evidenceChild = parentSelection;
-  const navigator = cleanSelection(seatModelOnly(config.seats?.navigator));
-  return {
-    version: 1,
-    seats: {
-      ...gatekeeper === void 0 ? {} : { gatekeeper },
-      ...inspector === void 0 ? {} : { inspector },
-      ...notary === void 0 ? {} : { notary },
-      ...auditor === void 0 ? {} : { auditor },
-      ...evidenceChild === void 0 ? {} : { evidenceChild },
-      ...navigator === void 0 ? {} : { navigator }
-    }
-  };
-}
-async function writeInstitutionalResolutionPage(runDirectory, page) {
-  const filePath = join(runDirectory, INSTITUTIONAL_RESOLUTION_FILE);
-  await writeFile(filePath, `${JSON.stringify(page, null, 2)}
-`, "utf8");
-}
-async function readInstitutionalSeatSelection(runDirectory, seat) {
-  const filePath = join(runDirectory, INSTITUTIONAL_RESOLUTION_FILE);
-  let raw;
-  try {
-    raw = await readFile(filePath, "utf8");
-  } catch (error) {
-    throw new InstitutionalResolutionError(
-      `institutional resolution page is missing at ${filePath}`,
-      "missing-page",
-      { cause: error }
-    );
-  }
-  let page;
-  try {
-    page = JSON.parse(raw);
-  } catch (error) {
-    throw new InstitutionalResolutionError(
-      `institutional resolution page is corrupted at ${filePath}`,
-      "corrupted",
-      { cause: error }
-    );
-  }
-  if (typeof page !== "object" || page === null || page.version !== 1) {
-    throw new InstitutionalResolutionError(
-      `institutional resolution page format is invalid at ${filePath}`,
-      "invalid-format"
-    );
-  }
-  const seats = page.seats;
-  if (typeof seats !== "object" || seats === null) {
-    throw new InstitutionalResolutionError(
-      `institutional resolution page missing seats object at ${filePath}`,
-      "invalid-format"
-    );
-  }
-  const selection = cleanSelection(seats[seat]);
-  if (selection === void 0) {
-    throw new InstitutionalResolutionError(
-      `institutional resolution page has no resolution for seat "${seat}" at ${filePath}`,
-      "missing-seat"
-    );
-  }
-  return selection;
-}
 export {
-  INSTITUTIONAL_RESOLUTION_FILE,
-  InstitutionalResolutionError,
-  readInstitutionalSeatSelection,
-  resolveConfiguredProvinceOfficer,
-  resolveInstitutionalSeatSelections,
-  writeInstitutionalResolutionPage
+  resolveConfiguredProvinceOfficer
 };

package/dist/judge-auditor.js

@@ -0,0 +1,26 @@
+import { runComplianceAudit, } from "./compliance-transport.js";
+import { auditorRunDirectory } from "./auditor-dossier-tool.js";
+import { readJudgeAuditSubjects, requireAuditMaterials, resolveAuditDossier, } from "./dossier-resolution.js";
+export const JUDGE_AUDIT_TOOL_NAME = "ak_soul_audit_decision";
+export const SOUL_AUDIT_TOOL_NAME = JUDGE_AUDIT_TOOL_NAME;
+/**
+ * Judge compliance via public auditor activation (#675 / ADR 0062 / owner r11).
+ * 审刑院 is an independent role; subject=judge selects souls/judge-auditor.md.
+ */
+export function createPiJudgeAuditor() {
+    return async (options) => {
+        const dossier = resolveAuditDossier();
+        requireAuditMaterials(dossier);
+        const subjects = readJudgeAuditSubjects(options.context);
+        requireAuditMaterials(subjects);
+        return runComplianceAudit({
+            subject: "judge",
+            context: options.context,
+            ...(auditorRunDirectory(options.context) === undefined
+                ? {}
+                : { runDirectory: auditorRunDirectory(options.context) }),
+            ...(options.signal === undefined ? {} : { signal: options.signal }),
+            ...(options.summonAuditor === undefined ? {} : { summonAuditor: options.summonAuditor }),
+        });
+    };
+}

package/dist/ledger-session-read.js

@@ -0,0 +1,227 @@
+/**
+ * Canonical ledger session JSONL read primitives (shared owner).
+ * Consumers (ticket-trajectory, analyst, …) must import here — no second parse kernel.
+ */
+import { readFile } from "node:fs/promises";
+/**
+ * Loud JSONL failure that still retains rows parsed before the bad line.
+ * Callers that only need the throw keep catching Error; owners that must
+ * surface partial typed facts (e.g. first-frame timestamp) read prefixRows.
+ */
+export class LedgerSessionJsonlError extends Error {
+    path;
+    line;
+    prefixRows;
+    constructor(message, init) {
+        super(message);
+        this.name = "LedgerSessionJsonlError";
+        this.path = init.path;
+        this.line = init.line;
+        this.prefixRows = init.prefixRows;
+    }
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+/**
+ * Read session JSONL with honest live-tail semantics:
+ * a malformed line is tolerated only when it is an unfinished final
+ * fragment at EOF (no record terminator after it). Any malformed line
+ * completed by a line terminator must fail loudly with file and 1-based
+ * line context — even when no non-empty record follows — never silently
+ * under-count.
+ *
+ * Loud failures throw LedgerSessionJsonlError carrying prefixRows so the
+ * single parse kernel can still expose facts obtained before the bad line.
+ */
+export async function readLedgerSessionJsonl(path) {
+    const text = await readFile(path, "utf8");
+    // split keeps a trailing empty segment iff text ends with "\n", so
+    // index < lines.length - 1 means this segment was terminated.
+    const lines = text.split("\n");
+    const rows = [];
+    for (let index = 0; index < lines.length; index += 1) {
+        const line = lines[index];
+        if (!line.trim())
+            continue;
+        let row;
+        try {
+            row = JSON.parse(line);
+        }
+        catch (error) {
+            if (!(error instanceof SyntaxError))
+                throw error;
+            const completedByTerminator = index < lines.length - 1;
+            if (completedByTerminator) {
+                throw new LedgerSessionJsonlError(`malformed JSONL record in ${path} at line ${index + 1}: ${error.message}`, { path, line: index + 1, prefixRows: rows });
+            }
+            // unfinished fragment at EOF — keep prior complete rows
+            break;
+        }
+        // Syntactically complete line: must be a session object. Silent omission
+        // would under-count ledger evidence (failure honesty).
+        if (!isRecord(row)) {
+            const kind = row === null ? "null" : Array.isArray(row) ? "array" : typeof row;
+            throw new LedgerSessionJsonlError(`complete non-object JSONL record in ${path} at line ${index + 1}: expected object, got ${kind}`, { path, line: index + 1, prefixRows: rows });
+        }
+        rows.push(row);
+    }
+    return rows;
+}
+/** First and last record timestamps in encounter order. */
+export function extractSessionTimestampSpan(rows) {
+    let startedAt;
+    let endedAt;
+    for (const row of rows) {
+        if (typeof row.timestamp !== "string" || !row.timestamp)
+            continue;
+        if (startedAt === undefined)
+            startedAt = row.timestamp;
+        endedAt = row.timestamp;
+    }
+    return {
+        ...(startedAt !== undefined ? { startedAt } : {}),
+        ...(endedAt !== undefined ? { endedAt } : {}),
+    };
+}
+/**
+ * Ordered-unique model ids from session frames (first-seen order).
+ * Sources (same faces ticket-trajectory already reads — single parse kernel):
+ * - `model_change.modelId`
+ * - assistant `message.model`
+ * Blank / non-string values are skipped. Does not invent a default model.
+ */
+export function extractSessionModelSequence(rows) {
+    const seen = new Set();
+    const ordered = [];
+    const push = (raw) => {
+        const model = raw.trim();
+        if (model === "" || seen.has(model))
+            return;
+        seen.add(model);
+        ordered.push(model);
+    };
+    for (const row of rows) {
+        if (row.type === "model_change" && typeof row.modelId === "string") {
+            push(row.modelId);
+        }
+        const message = isRecord(row.message) ? row.message : undefined;
+        if (message?.role === "assistant" && typeof message.model === "string") {
+            push(message.model);
+        }
+    }
+    return ordered;
+}
+/** First line of a bash `command` argument (sole owner of this summary). */
+export function bashCommandFirstLine(command) {
+    const match = /^[^\r\n]*/.exec(command);
+    return match?.[0] ?? "";
+}
+/**
+ * Pair toolCall frames → toolResult frames by toolCallId.
+ * Throws when a tool-bearing frame is structurally unreadable for association
+ * (toolCall missing string id, toolResult missing string toolCallId).
+ * Unpaired open calls remain without endedAt — that is incomplete, not unreadable.
+ */
+export function extractSessionToolIntervals(rows) {
+    const order = [];
+    const openById = new Map();
+    for (const row of rows) {
+        const rowTimestamp = typeof row.timestamp === "string" ? row.timestamp : undefined;
+        const message = isRecord(row.message) ? row.message : undefined;
+        if (message?.role === "assistant" && Array.isArray(message.content)) {
+            const callTimestamp = typeof message.timestamp === "string" && message.timestamp
+                ? message.timestamp
+                : rowTimestamp;
+            for (const part of message.content) {
+                if (!isRecord(part) || part.type !== "toolCall")
+                    continue;
+                if (typeof part.id !== "string" || part.id.length === 0) {
+                    throw new Error("toolCall frame missing string id");
+                }
+                if (typeof part.name !== "string" || part.name.length === 0) {
+                    throw new Error(`toolCall ${part.id} missing string name`);
+                }
+                if (callTimestamp === undefined || callTimestamp.length === 0) {
+                    throw new Error(`toolCall ${part.id} missing timestamp`);
+                }
+                if (openById.has(part.id)) {
+                    throw new Error(`duplicate toolCall id ${part.id}`);
+                }
+                const args = isRecord(part.arguments) ? part.arguments : undefined;
+                // Ticket surface: only bash first-line summary is authorized here.
+                const command = part.name === "bash" &&
+                    args !== undefined &&
+                    typeof args.command === "string"
+                    ? bashCommandFirstLine(args.command)
+                    : undefined;
+                const interval = {
+                    toolCallId: part.id,
+                    toolName: part.name,
+                    startedAt: callTimestamp,
+                    ...(command !== undefined ? { command } : {}),
+                };
+                order.push(interval);
+                openById.set(part.id, interval);
+            }
+        }
+        if (message?.role === "toolResult") {
+            if (typeof message.toolCallId !== "string" || message.toolCallId.length === 0) {
+                throw new Error("toolResult frame missing string toolCallId");
+            }
+            const resultTimestamp = typeof message.timestamp === "string" && message.timestamp
+                ? message.timestamp
+                : rowTimestamp;
+            if (resultTimestamp === undefined || resultTimestamp.length === 0) {
+                throw new Error(`toolResult ${message.toolCallId} missing timestamp`);
+            }
+            const open = openById.get(message.toolCallId);
+            if (open === undefined) {
+                // Result without a prior call is still associable as a closed interval
+                // once a name is known; keep structural readability without inventing a call.
+                const toolName = typeof message.toolName === "string" && message.toolName.length > 0
+                    ? message.toolName
+                    : "unknown";
+                order.push({
+                    toolCallId: message.toolCallId,
+                    toolName,
+                    startedAt: resultTimestamp,
+                    endedAt: resultTimestamp,
+                });
+                continue;
+            }
+            if (open.endedAt !== undefined) {
+                throw new Error(`duplicate toolResult for toolCallId ${message.toolCallId}`);
+            }
+            open.endedAt = resultTimestamp;
+        }
+    }
+    return order.map((interval) => {
+        const base = {
+            toolCallId: interval.toolCallId,
+            toolName: interval.toolName,
+            startedAt: interval.startedAt,
+            ...(interval.command !== undefined ? { command: interval.command } : {}),
+        };
+        return interval.endedAt === undefined
+            ? base
+            : { ...base, endedAt: interval.endedAt };
+    });
+}
+export function intervalRowsAroundAnchor(rows, anchorIndex, isBindingRow) {
+    let start = 0;
+    for (let i = anchorIndex; i >= 0; i -= 1) {
+        if (isBindingRow(rows[i])) {
+            start = i;
+            break;
+        }
+    }
+    let end = rows.length;
+    for (let i = Math.max(anchorIndex, start) + 1; i < rows.length; i += 1) {
+        if (isBindingRow(rows[i])) {
+            end = i;
+            break;
+        }
+    }
+    return { rows: rows.slice(start, end), closed: end < rows.length };
+}