@sema-agent/server 7.68.0 → 7.69.0

package/dist/orchestration/workflow-agent-session-index.d.ts

@@ -0,0 +1,96 @@
+/** 一条索引行:**子会话 id 是主键**(会话 id 全局唯一 ⇒ 读口天然是单行精确查,无分页假阴性)。 */
+export interface WorkflowAgentSessionRow {
+    /** parked 的那只 workflow 子代自己的会话 id(= `WorkflowAgentRun.sessionId` = checkpoint 的 `sourceTaskId`)。 */
+    sessionId: string;
+    /** 它所属的 workflow run(`w*`)。 */
+    runId: string;
+    /** 该 agent 调用的稳定顺位身份(`WorkflowAgentRun.callKey`)—— 行自描述用,取 run 后仍以行内实体为准。 */
+    agentKey: string;
+    /** run 的租户键(`WorkflowRun.scope`)。 */
+    scope: string;
+}
+/**
+ * 索引面的两个动词。**写者只有一个**(见文件头),读者是判别器/收敛器/读面。
+ *
+ * `syncRun` 语义 = 「这条 run 当前的 parked 行集**就是** rows」:多出来的旧行删,rows 里的行 upsert。
+ * 幂等、可重放、与 run 的一次成功写同拍。
+ */
+export interface WorkflowAgentSessionIndex {
+    syncRun(runId: string, rows: readonly WorkflowAgentSessionRow[]): Promise<void>;
+    findByAgentSession(sessionId: string): Promise<WorkflowAgentSessionRow | null>;
+}
+/** 派生的**唯一属主**:一只 `WorkflowRun` 当前的 parked 索引行。
+ *
+ *  三个键缺任何一个都不入索引 —— 缺 `sessionId` 的 park 行 join 不到(checkpoint 那侧的键就是它),
+ *  缺 `parkedCheckpointToken` 的行不是一条可赎回的 park(core 契约:在场 ⟺ `status:"parked"`)。
+ *  ⚠️ token **不进索引行**:它是赎回能力,家在 run 的 blob 里(与 bg 行同判),索引只回答「去哪条 run 找」。 */
+export declare function buildParkedAgentSessionRows(runId: string, run: {
+    scope: string;
+    agents?: ReadonlyArray<{
+        status?: string;
+        sessionId?: string;
+        callKey?: string;
+        parkedCheckpointToken?: string;
+    }>;
+}): WorkflowAgentSessionRow[];
+/** 两处(装饰器的变更检测、local 后端的重放)共用的行集等值判据 —— 顺序无关的集合比较,单一属主。 */
+export declare function sameAgentSessionRows(a: readonly WorkflowAgentSessionRow[], b: readonly WorkflowAgentSessionRow[]): boolean;
+/** 账本一行的**内域形**:一次 `syncRun` 的整份行集快照(`{runId, rows}`)。 */
+export interface WorkflowAgentSessionLedgerLine {
+    runId: string;
+    rows: WorkflowAgentSessionRow[];
+}
+/**
+ * 盘上账本行 → 内域形的**唯一读者**(宪法 [ref] §2:进程外字节禁裸 `as` 铸形)。
+ *
+ * 姿态与 SQL 孪生逐字同源:那边 `findByAgentSession` 逐字段收窄(`String(r.session_id)` …),这边逐字段
+ * 判形 —— 一张索引面、两个后端、**一种**入域姿态。
+ *
+ * **整行成败制**(与既有的撕裂行臂同一条规则):一行 = 一次 syncRun 的**整份**快照,任一位读不出来就说明
+ * 这份快照重建不出来 ⇒ 整行不 apply(那条 run 保留上一份已知良好的快照)。不做「丢掉坏成员、留下好成员」
+ * ——那会静默铸出一份**比真相少几条 park** 的行集,而这条索引的消费面正是 park 的赎回路由。
+ * 读不出来 ⇒ 调用方**响亮**记一笔([ref]:安全轴不许静默),不吞整档。
+ */
+export declare function readAgentSessionLedgerLine(v: unknown): WorkflowAgentSessionLedgerLine | undefined;
+/**
+ * 单机车道的索引(`FileWorkflowRunStore` / `InMemoryWorkflowRunStore` 的同室孪生)。
+ *
+ * `root` 在场 ⇒ 追加式 JSONL 账本(与姊妹 {@link import("./workflow-notify-journal.js").FileWorkflowNotifyJournalStore}
+ * 逐字同形:0o700 目录 + 0o600 账本、按行重放、末行撕裂即丢),重启后 park 仍可 join;缺席 ⇒ 纯内存
+ * (`WORKFLOW_RUN_STORE=memory` 的显式易失车道,与它的 run 店同寿命)。
+ *
+ * 账本的一行 = **一次 `syncRun` 的整份行集**(按 runId 后写覆盖),所以重放即收敛,不需要压缩腿。
+ */
+export declare class LocalWorkflowAgentSessionIndex implements WorkflowAgentSessionIndex {
+    private readonly fsyncEnabled;
+    /** 坏账本行的**响亮**出口(可选;缺席 ⇒ 那一行照样不入索引,只是没人听见)。形与 workflow 店族的
+     *  `onWarn` 逐字同源(`workflow-completion-inbox.ts` 的那一只),不另立第二种披露通道。 */
+    private readonly onWarn?;
+    private readonly ledgerPath;
+    private readonly byRun;
+    private readonly bySession;
+    private fd;
+    constructor(root?: string, fsyncEnabled?: boolean, 
+    /** 坏账本行的**响亮**出口(可选;缺席 ⇒ 那一行照样不入索引,只是没人听见)。形与 workflow 店族的
+     *  `onWarn` 逐字同源(`workflow-completion-inbox.ts` 的那一只),不另立第二种披露通道。 */
+    onWarn?: ((msg: string, meta: Record<string, unknown>) => void) | undefined);
+    /**
+     * 打开账本时把**撕裂尾**(崩在 append 中途、末尾没有换行的那截字节)截回最后一个完整行边界。
+     *
+     * 🔴 为什么必须在**任何 append 之前**做(codex 修复验证轮 [medium],故障注入复现):残尾留在盘上时,
+     * 下一次 `syncRun` 会紧贴着它落字节 ⇒ `<残尾><新记录>` 在 replay 里是**一行**,JSON 解析失败被整行丢掉。
+     * 丢的**不是**那截未提交的残尾(丢它是对的),而是紧随其后那次**成功重试**写下的行 —— 于是「写失败了
+     * 下一次写会重试救回来」这条本模块与 `syncAgentSessionIndex` 都在依赖的性质当场失效,park 索引静默消失。
+     * 截尾之后 append 永远从一个干净的行边界开始,重试才真的救得回来。
+     *
+     * 截掉的只可能是**未提交**的字节(一条记录的耐久性以它那个换行为界,与 notify journal 同一条崩溃序),
+     * 所以这里不是丢数据;但它是一次真实的崩溃留痕,**响亮**一次([ref]:安全轴不许静默)。
+     */
+    private truncateTornTail;
+    private replay;
+    /** 内存两张表的收敛(重放与写路径共用一份逻辑)。 */
+    private apply;
+    syncRun(runId: string, rows: readonly WorkflowAgentSessionRow[]): Promise<void>;
+    findByAgentSession(sessionId: string): Promise<WorkflowAgentSessionRow | null>;
+}
+//# sourceMappingURL=workflow-agent-session-index.d.ts.map

package/dist/orchestration/workflow-agent-session-index.js

@@ -0,0 +1,146 @@
+import { existsSync, fsyncSync, mkdirSync, openSync, readFileSync, truncateSync, writeSync } from "node:fs";
+import { join } from "node:path";
+export function buildParkedAgentSessionRows(runId, run) {
+    const rows = [];
+    for (const a of run.agents ?? []) {
+        if (a.status !== "parked")
+            continue;
+        if (typeof a.sessionId !== "string" || a.sessionId === "")
+            continue;
+        if (typeof a.parkedCheckpointToken !== "string" || a.parkedCheckpointToken === "")
+            continue;
+        rows.push({ sessionId: a.sessionId, runId, agentKey: typeof a.callKey === "string" ? a.callKey : "", scope: run.scope });
+    }
+    return rows;
+}
+export function sameAgentSessionRows(a, b) {
+    if (a.length !== b.length)
+        return false;
+    const key = (r) => `${r.sessionId}\u0000${r.runId}\u0000${r.agentKey}\u0000${r.scope}`;
+    const left = new Set(a.map(key));
+    for (const r of b)
+        if (!left.has(key(r)))
+            return false;
+    return true;
+}
+export function readAgentSessionLedgerLine(v) {
+    if (typeof v !== "object" || v === null)
+        return undefined;
+    if (!("runId" in v) || !("rows" in v))
+        return undefined;
+    const { runId, rows } = v;
+    if (typeof runId !== "string" || runId === "")
+        return undefined;
+    if (!Array.isArray(rows))
+        return undefined;
+    const out = [];
+    for (const raw of rows) {
+        const row = readAgentSessionRow(raw);
+        if (row === undefined)
+            return undefined;
+        out.push(row);
+    }
+    return { runId, rows: out };
+}
+function readAgentSessionRow(v) {
+    if (typeof v !== "object" || v === null)
+        return undefined;
+    if (!("sessionId" in v) || !("runId" in v) || !("agentKey" in v) || !("scope" in v))
+        return undefined;
+    const { sessionId, runId, agentKey, scope } = v;
+    if (typeof sessionId !== "string" || sessionId === "")
+        return undefined;
+    if (typeof runId !== "string" || runId === "")
+        return undefined;
+    if (typeof agentKey !== "string")
+        return undefined;
+    if (typeof scope !== "string" || scope === "")
+        return undefined;
+    return { sessionId, runId, agentKey, scope };
+}
+export class LocalWorkflowAgentSessionIndex {
+    fsyncEnabled;
+    onWarn;
+    ledgerPath;
+    byRun = new Map();
+    bySession = new Map();
+    fd;
+    constructor(root, fsyncEnabled = true, onWarn) {
+        this.fsyncEnabled = fsyncEnabled;
+        this.onWarn = onWarn;
+        if (root === undefined) {
+            this.ledgerPath = undefined;
+            return;
+        }
+        const dir = join(root, "workflow-agent-sessions");
+        mkdirSync(dir, { recursive: true, mode: 0o700 });
+        this.ledgerPath = join(dir, "index.jsonl");
+        this.truncateTornTail();
+        this.replay();
+    }
+    truncateTornTail() {
+        const path = this.ledgerPath;
+        if (path === undefined || !existsSync(path))
+            return;
+        const bytes = readFileSync(path);
+        if (bytes.length === 0 || bytes[bytes.length - 1] === 0x0a)
+            return;
+        const keep = bytes.lastIndexOf(0x0a) + 1;
+        truncateSync(path, keep);
+        this.onWarn?.("workflow_agent_session_ledger_torn_tail_truncated", {
+            path,
+            droppedBytes: bytes.length - keep,
+            note: "the last append never finished (no trailing newline) — those uncommitted bytes were cut back to the last complete line so the NEXT append starts on a clean boundary. Without the cut, the retry that follows would be glued onto the broken suffix and dropped as one unparsable line, i.e. the retry — not the torn write — is what would be lost.",
+        });
+    }
+    replay() {
+        if (this.ledgerPath === undefined || !existsSync(this.ledgerPath))
+            return;
+        for (const line of readFileSync(this.ledgerPath, "utf8").split("\n")) {
+            if (!line.trim())
+                continue;
+            let rec;
+            try {
+                rec = JSON.parse(line);
+            }
+            catch {
+                continue;
+            }
+            const entry = readAgentSessionLedgerLine(rec);
+            if (entry === undefined) {
+                this.onWarn?.("workflow_agent_session_ledger_line_rejected", {
+                    path: this.ledgerPath,
+                    note: "a committed ledger line did not read back as {runId, rows[]} — that run keeps its previous snapshot; a /decide for a park it should have indexed falls back to the legacy lane (honest miss, never a mis-route)",
+                });
+                continue;
+            }
+            this.apply(entry.runId, entry.rows);
+        }
+    }
+    apply(runId, rows) {
+        for (const old of this.byRun.get(runId) ?? []) {
+            if (this.bySession.get(old.sessionId)?.runId === runId)
+                this.bySession.delete(old.sessionId);
+        }
+        if (rows.length === 0)
+            this.byRun.delete(runId);
+        else
+            this.byRun.set(runId, [...rows]);
+        for (const r of rows)
+            this.bySession.set(r.sessionId, r);
+    }
+    async syncRun(runId, rows) {
+        if (this.ledgerPath !== undefined) {
+            if (this.fd === undefined)
+                this.fd = openSync(this.ledgerPath, "a", 0o600);
+            writeSync(this.fd, `${JSON.stringify({ runId, rows })}\n`);
+            if (this.fsyncEnabled)
+                fsyncSync(this.fd);
+        }
+        this.apply(runId, rows);
+    }
+    async findByAgentSession(sessionId) {
+        return this.bySession.get(sessionId) ?? null;
+    }
+}
+//# sourceMappingURL=workflow-agent-session-index.js.map

package/dist/orchestration/workflow-journal-entry.d.ts

@@ -0,0 +1,78 @@
+/**
+ * S-185(core 7.10.0 [ref] / B-049)—— `WorkflowJournalEntry` **两臂**的单点读写。
+ *
+ * core 7.10.0 把 journal 记录从一个 interface 换成了判别联合:
+ *   `{ callKey, result }`  —— 这一序数的子代跑完了,`result` 是它的 `TaskResult`;
+ *   `{ callKey, parked }`  —— 这一序数**停在耐久审批门上**,`parked` 是子代那份 `terminal.kind:"paused"`
+ *                             的 `TaskResult`(令牌 / 门 / 钉住的 session / 花费都在里面),**没有 `result`**。
+ *
+ * 两臂的载荷同型(都是一只 `TaskResult`),差的只是**这一位是不是 park**。所以本模块把整条规则收敛成
+ * 两只互逆的函数:读一条记录 ⇒ `(payload, parked)` 二元组;拿到 `(payload, parked)` ⇒ 铸回记录。
+ *
+ * 🔴 **为什么必须单点**:本仓有三个消费面要判这一臂 —— SQL 店的写(`append`)、SQL 店的读(`load`)、
+ * HTTP journal 读面(`GET /v1/workflows/:id/journal`)。每处各写一次 `entry.parked !== undefined ? … : …`
+ * 就是同一条判别式的三个写者;core 哪天加第三臂(它已经加过一次),三处里漏改一处就是**静默丢一条
+ * 承重记录**——而 journal 是 LOAD-BEARING(丢一条 = 一次已完成的子代被当成没跑过而重跑,外部副作用重复)。
+ * 收敛到这里之后,第三臂到货 ⇒ 本文件**一处**编译红。
+ *
+ * 🔴 **park 臂的形是 fail-closed 的**:core 的类型要求 `parked.terminal.kind === "paused"`。从盘上读回来的
+ * 字节没有类型,所以 {@link journalEntryOfRow} 在铸 park 臂时**亲验**这一位,不合就**抛**——它是 LOAD-BEARING
+ * 面上的坏行(一条说自己 park 了却拿不出暂停终局的记录,既不能驱动、也不能当成跑完),吞掉它会让 resume
+ * 在一个被钉住的子代 session 旁边重新起一只活跑,正是 core 那条「一次性、响亮」的 schema 台阶要防的形。
+ *
+ * 🔴 **盘上的编码是那道台阶的一部分**,不是实现细节:见 {@link journalRowPayloadOf} 的顶注(park 载荷走
+ * `{"parked": …}` 信封,好让**回滚/混版**的老读者拿到一个没有 `terminal` 的对象、落进 core 的响亮拒绝臂,
+ * 而不是把一个暂停终局当成可重放结果)。
+ */
+import type { TaskResult, WorkflowJournalEntry } from "@sema-agent/core";
+/** park 臂的载荷型(core 的 `WorkflowJournalEntry` park 成员逐字):一只 `terminal` 收敛到 `paused` 的 `TaskResult`。 */
+export type ParkedTaskResult = TaskResult & {
+    terminal: Extract<TaskResult["terminal"], {
+        kind: "paused";
+    }>;
+};
+/**
+ * 读一条记录的两臂 —— **唯一**的判别点。`parked` 为真时 `payload` 是子代那份暂停终局,否则是它的完成结果。
+ *
+ * ⚠️ 判据逐字照 core 自己的 file 店(`entry.parked !== undefined`),不是真值判:一只 `parked` 位上的
+ * 假值在 core 的类型上拼不出来,而按真值判会在将来某个 falsy 载荷上把 park 读成 result。
+ */
+export declare function journalEntryPayload(entry: WorkflowJournalEntry): {
+    payload: TaskResult;
+    parked: boolean;
+};
+/**
+ * 盘上一行的 **payload 文本编码** —— SQL 店 `append` 的唯一写者。
+ *
+ *  · result 臂 ⇒ `JSON.stringify(entry.result)`,与 7.68.0 及以前**逐字节相同**(历史行零迁移);
+ *  · park 臂  ⇒ **信封** `{"parked": <TaskResult>}`。
+ *
+ * 🔴 **信封不是包装,它是 core 那道「一次性、响亮」的 schema 台阶在 SQL 店上的兑现**(codex 对抗复审
+ * r1 [high],验真后采纳)。core 的设计逐字是:park 序数journal 在 `parked` 键下、**没有 `result`**,
+ * 于是「一个本版本之前的 journal 读者找不到终局因由,会**拒绝**整次 resume(`WorkflowJournalIncompatibleError`)
+ * 而不是把一个暂停终局当成跑完了拿去重跑」。
+ *
+ * 本仓最初的实现把 park 载荷直接写进 `result` 列、判别位另开一列 —— 那**破坏了这条屏障**:一台回滚到
+ * 7.68.0(core 7.9.2)的副本、或滚动升级期的混版机队,它的 `load` 是 `SELECT call_key, result` + 逐行
+ * `{callKey, result: JSON.parse(result)}`,于是拿到一条**带 paused 终局的 result 臂**,照 core 的老语义
+ * 当作可重放结果 —— 在那个子代 session 已被一条 pending checkpoint 钉住的同时**再起一只活跑**,
+ * 批准前的外部副作用重复一遍。这正是那道屏障存在的理由。
+ *
+ * 信封形让老读者拿到一个**没有 `terminal`** 的对象 ⇒ 落进 core 那条「找不到终局因由 ⇒ 拒绝 resume」的
+ * 臂,方向与 core 的 file 店逐字一致。附带的好处是 **零 DDL、零重建库**:判别位活在载荷里,不占列。
+ */
+export declare function journalRowPayloadOf(entry: WorkflowJournalEntry): string;
+/**
+ * {@link journalRowPayloadOf} 的逆 —— 盘上一行的 payload 文本 → 记录。**唯一**的回装点(SQL 店的 `load`
+ * 与 HTTP journal 读面共读它)。
+ *
+ * 判别式 = 解出来的对象上有没有**自有** `parked` 键。它与 `TaskResult` 结构上不相交(core 的 `TaskResult`
+ * 没有这个成员),所以历史字节(裸 TaskResult)恒判 result 臂 —— 不需要任何「老字节 = result」的兼容规则,
+ * 判别式自己就说清了。
+ *
+ * park 臂验 `terminal.kind === "paused"`;不合 ⇒ **抛**,由 LOAD-BEARING 的 `load` 把它当店故障传上去。
+ * 一条「说自己 park 了却拿不出暂停终局」的行既驱动不了、也不能当跑完,吞掉它会让 resume 在被钉住的子代
+ * session 旁边重新起一只活跑 —— 与上面那条屏障要防的是同一件事。
+ */
+export declare function journalEntryOfRow(callKey: string, json: string): WorkflowJournalEntry;
+//# sourceMappingURL=workflow-journal-entry.d.ts.map

package/dist/orchestration/workflow-journal-entry.js

@@ -0,0 +1,20 @@
+export function journalEntryPayload(entry) {
+    return entry.parked !== undefined ? { payload: entry.parked, parked: true } : { payload: entry.result, parked: false };
+}
+export function journalRowPayloadOf(entry) {
+    const { payload, parked } = journalEntryPayload(entry);
+    return JSON.stringify(parked ? { parked: payload } : payload);
+}
+export function journalEntryOfRow(callKey, json) {
+    const raw = JSON.parse(json);
+    if (typeof raw === "object" && raw !== null && Object.hasOwn(raw, "parked")) {
+        const payload = raw.parked;
+        const terminal = payload.terminal;
+        if (terminal === undefined || terminal.kind !== "paused") {
+            throw new Error(`workflow journal: entry ${callKey} is recorded as PARKED but its stored terminal is "${terminal === undefined ? "absent" : terminal.kind}" (expected "paused") — refusing to admit it (a park row that cannot be driven must not be replayed as a completed result)`);
+        }
+        return { callKey, parked: { ...payload, terminal } };
+    }
+    return { callKey, result: raw };
+}
+//# sourceMappingURL=workflow-journal-entry.js.map

package/dist/orchestration/workflow-notify-journal.d.ts

@@ -1,5 +1,6 @@
 import type { WorkflowRun, WorkflowRunStore, WorkflowRunStatus, WorkflowRunSummary } from "@sema-agent/core";
 import { type FleetEventBus } from "../fleet/fleet-bus.js";
+import { type WorkflowAgentSessionIndex } from "./workflow-agent-session-index.js";
 /** A workflow completion notification's terminal payload — the bounded, redacted shape core's notifier seam
  *  carries, re-derivable from a durable {@link import("@sema-agent/core").WorkflowRun} on the recovery path. */
 export interface WorkflowCompletionPayload {
@@ -272,6 +273,10 @@ export declare class JournalingWorkflowRunStore implements WorkflowRunStore {
     /** MF-Fleet (data contract): publish the workflow's fleet row on every put/update (the same write-observation
      *  point as the notify journal). Optional — undefined ⇒ no fleet publish. */
     private readonly fleetBus?;
+    /** S-185 车CM:workflow 出身 park 的 join 索引。**本装饰器是它全仓唯一的写者** —— 索引是 `WorkflowRun`
+     *  的派生投影,写点必须与 fleet 行投影/notify journal 同一个(见 index 模块的文件头「单写者」段)。
+     *  可选:缺席 ⇒ 一位不维护(与 fleet 半场同姿势,行为逐字不变)。 */
+    private readonly agentSessionIndex?;
     constructor(inner: WorkflowRunStore, 
     /** [ref] optional since the fleet decoupling: undefined ⇒ no start-time journal (ephemeral memory
      *  backend has nothing to recover), the FLEET half still publishes — the panel is replica-local UI
@@ -280,7 +285,44 @@ export declare class JournalingWorkflowRunStore implements WorkflowRunStore {
     gate?: Pick<WorkflowNotifyGate, "onWorkflowStart"> | undefined, 
     /** MF-Fleet (data contract): publish the workflow's fleet row on every put/update (the same write-observation
      *  point as the notify journal). Optional — undefined ⇒ no fleet publish. */
-    fleetBus?: FleetEventBus | undefined);
+    fleetBus?: FleetEventBus | undefined, 
+    /** S-185 车CM:workflow 出身 park 的 join 索引。**本装饰器是它全仓唯一的写者** —— 索引是 `WorkflowRun`
+     *  的派生投影,写点必须与 fleet 行投影/notify journal 同一个(见 index 模块的文件头「单写者」段)。
+     *  可选:缺席 ⇒ 一位不维护(与 fleet 半场同姿势,行为逐字不变)。 */
+    agentSessionIndex?: WorkflowAgentSessionIndex | undefined);
+    /** 上一次**本进程**为某条 run 写进索引的行集 —— 变更检测,不是缓存。
+     *
+     *  为什么需要:workflow 的进度写是每只 agent 状态变化一次,而 park 是罕见事件 ⇒ 无条件同步会给
+     *  「一条 park 都没有」的绝大多数 run 每次写多打一发删除(SQL)或多追加一行账本(file,无界增长)。
+     *  判据是**行集是否变化**,与后端无关 ⇒ 规则只有一条、两个后端同享。
+     *  跨副本安全性:一条 run 的写者按 core 契约唯一(`store` 的 owner),而同步只发生在一次**成功 CAS 之后**;
+     *  失败切换后新 owner 的表是空的 ⇒ 它的第一次写必落盘,收敛。
+     *
+     *  🔴 **空集也记**(7.69.0 合并重扫 c0):此前成功臂写作「空集 delete、非空集 set」,于是「一条 park
+     *  都没有」的那条 run —— 也就是上面这段头注**点名要短路的绝大多数形** —— memo 恒回 `undefined`、短路
+     *  判据恒假,每一次 put/update 都重跑一遍 `syncRun(id, [])`(file 车道每次多一行账本 + 一次 fsync,而
+     *  这本账本按设计没有压缩腿;SQL 车道每次多一发 `DELETE`)。代码与自己成文的判据相反。
+     *  当时那条 delete 臂承担的是**有界性**:memo 若无条件记,表会随本进程见过的每一条 run 单调增长。
+     *  现在有界性由下面那条**终态驱逐**独立承担(run 终态 ⇒ 它不会再被写 ⇒ 摘表),两件事各归各位:
+     *  记不记 = 变更检测的正确性;摘不摘 = 表的有界性。**不**加「首次空集跳过」这类依赖进程内历史的特判。 */
+    private readonly indexedRows;
+    /**
+     * 写腿的**不变式守卫**(codex r1 [medium],验真后修):`indexedRows` 只保留一次**我们亲眼看着落地**
+     * 的写。持久化抛错时这条 run 的盘上状态未知(而 core 会吞掉这次失败、这条 run 往往再也不被写),
+     * 若把 memo 留着,那一条 `{runId → rows}` 就永久留在表里 —— 终态驱逐等不到它的终态写。
+     *
+     * ⚠️ 如实登记的残余:一条**最后一次写成功、随后被放弃**的 run(进程崩前没跑到终态)仍会在本进程的
+     * memo 里留一条空集。它与 fleet 活行登记簿同一量级(都随本世进程消亡),刻意**不**为它加清扫腿:
+     * 那是给一个不产生错误答案的形加机制。
+     */
+    private forgetIndexMemoIfWriteOutcomeUnknown;
+    /** 索引的一次收敛(put/update 成功后调用)。
+     *
+     *  **自吞错**:索引是观察面的派生物,它的故障绝不能把一次已成功的 run 持久化变成失败 —— 与
+     *  `publishFleet` 的姿态同源。但自吞 ≠ 静默([ref]):留痕走**登记过的** fail-open tag
+     *  `server.workflow-park-index.sync-failed`(P-DEBT;射程、后果与欠账的唯一属主 = 那条词表项的
+     *  `note`,census 里有对应行)。 */
+    private syncAgentSessionIndex;
     /** Derive + publish the MF-Fleet workflow row from a WorkflowRun (doneCount/totalCount from agents, tokens from
      *  stats); a terminal workflow LEAVES the fleet (publish terminal then remove), a running one stays/updates. */
     private publishFleet;

package/dist/orchestration/workflow-notify-journal.js

@@ -2,6 +2,8 @@ import { mkdirSync, readFileSync, existsSync, openSync, writeSync, fsyncSync, cl
 import { join } from "node:path";
 import { buildFleetWorkflowRow } from "../fleet/fleet-bus.js";
 import { isTerminalWorkflowRowStatus, seedTerminalWorkflowRow } from "../fleet/fleet-terminal-window.js";
+import { buildParkedAgentSessionRows, sameAgentSessionRows } from "./workflow-agent-session-index.js";
+import { recordFailOpen } from "../observability/fail-open.js";
 const SUMMARY_MAX = 500;
 export function recoverySummary(status, error) {
     if (status === "completed")
@@ -271,10 +273,43 @@ export class JournalingWorkflowRunStore {
     inner;
     gate;
     fleetBus;
-    constructor(inner, gate, fleetBus) {
+    agentSessionIndex;
+    constructor(inner, gate, fleetBus, agentSessionIndex) {
         this.inner = inner;
         this.gate = gate;
         this.fleetBus = fleetBus;
+        this.agentSessionIndex = agentSessionIndex;
+    }
+    indexedRows = new Map();
+    async forgetIndexMemoIfWriteOutcomeUnknown(id, write) {
+        try {
+            return await write();
+        }
+        catch (e) {
+            this.indexedRows.delete(id);
+            throw e;
+        }
+    }
+    async syncAgentSessionIndex(id, run) {
+        const index = this.agentSessionIndex;
+        if (index === undefined)
+            return;
+        const rows = buildParkedAgentSessionRows(id, run);
+        const prior = this.indexedRows.get(id);
+        if (prior === undefined || !sameAgentSessionRows(prior, rows)) {
+            try {
+                await index.syncRun(id, rows);
+            }
+            catch (err) {
+                this.indexedRows.delete(id);
+                recordFailOpen("server.workflow-park-index.sync-failed", `runId=${id} rows=${rows.length} err=${err instanceof Error ? err.message : String(err)}`);
+                return;
+            }
+        }
+        if (isTerminalWorkflowRowStatus(run.status))
+            this.indexedRows.delete(id);
+        else
+            this.indexedRows.set(id, rows);
     }
     publishFleet(id, run) {
         if (!this.fleetBus)
@@ -298,11 +333,16 @@ export class JournalingWorkflowRunStore {
             runId: id,
             scope: run.scope,
         });
-        await this.inner.put(id, run);
+        await this.forgetIndexMemoIfWriteOutcomeUnknown(id, () => this.inner.put(id, run));
+        await this.syncAgentSessionIndex(id, run);
         this.publishFleet(id, run);
     }
     async update(id, scope, run, expect) {
-        const ok = await this.inner.update(id, scope, run, expect);
+        const ok = await this.forgetIndexMemoIfWriteOutcomeUnknown(id, () => this.inner.update(id, scope, run, expect));
+        if (!ok)
+            this.indexedRows.delete(id);
+        if (ok)
+            await this.syncAgentSessionIndex(id, run);
         if (ok)
             this.publishFleet(id, run);
         return ok;

package/dist/parked-decide.d.ts

@@ -9,11 +9,59 @@
  * 行永 parked、生命周期分叉)。
  */
 import type { HostDecision } from "./host-decision.js";
-import type { BackgroundAgentRecord, BackgroundAgentStore, CheckpointStore, QuestionAnswer, TaskRegistry, ToolSpec } from "@sema-agent/core";
+import type { BackgroundAgentRecord, BackgroundAgentStore, CheckpointStore, QuestionAnswer, ResumeOutcome, TaskRegistry, ToolSpec, WorkflowAgentRun, WorkflowRun, WorkflowRunStore } from "@sema-agent/core";
+import type { WorkflowAgentSessionIndex } from "./orchestration/workflow-agent-session-index.js";
 export interface ParkedAgentMatch {
     handle: string;
     row: BackgroundAgentRecord;
 }
+/**
+ * S-185 车CM —— **park 的出身判别式**(全仓唯一的那一个)。
+ *
+ * 一条 pending checkpoint 落到 `/decide` 时,它可能来自三种出身:①一只 parked 的**后台委派子代**
+ * ([ref] 的第一条腿)、②一只 parked 的 **workflow 子代**(core 7.10.0 [ref] 开的第二条车道)、③一条
+ * 普通的**任务级** suspend(legacy 腿)。三个消费点 —— decide 路由、SLA deny-sweep 的静默跳过臂、
+ * 将来的读面 —— 此前只认得出 ①,于是 ② 一律落到 ③ 上拿一个**响亮但错因**的 409
+ * `conflict.resume_context_unavailable`(getCtx(子会话) 恒 null),而 sweep 那条静默跳过臂对它整个失效。
+ *
+ * 修法**不是**再写一条 if 链,而是把「出身」抽成这一个判别式:它读两个源(bg 行店 / workflow 索引),
+ * 三个消费点都读它。加第三条车道时只改这里一处 —— 这条纪律就是本函数存在的全部理由。
+ *
+ * 两条臂共享同一条硬判据:**赎回键逐字相等**(bg 行的 `parkedCheckpointToken` / wa* 行的同名位 ⟺
+ * `cp.token`)。行 REOPENED 后在**新** token 下 re-park,旧 cp 的 decide 不得匹配到它;判别不出一律
+ * 诚实 miss(落 legacy 腿,它对已消失/不属于它的 pending cp 有自己的 404/409 处置)——「宁可不命中,
+ * 绝不错配」与收敛器那条铁则同源。
+ *
+ * 顺序 = bg 先、workflow 后:bg 臂是既有行为,零回归优先;两臂的键域(bg 行的 sessionId / wa* 行的
+ * sessionId)结构上互斥(一个子会话不会同时是两种子代),所以顺序只是确定性,不是优先级语义。
+ */
+export type ParkOrigin = {
+    kind: "background";
+    handle: string;
+    row: BackgroundAgentRecord;
+}
+/** `agent` 是**权威实体**(从 run 的 blob 里按赎回键复核出来的那一行);身份位一律从它读 —— 索引行
+ *  是可被改盘的派生投影,不做第二个身份写者(7.69.0 合并重扫 c1 同族收口)。 */
+ | {
+    kind: "workflow";
+    runId: string;
+    run: WorkflowRun;
+    agent: WorkflowAgentRun;
+};
+/** 判别式的两个源。各自可缺席(部署没接就是没接)—— 缺席 ⇒ 那条臂不判,不是失败。 */
+export interface ParkOriginSources {
+    agentStore?: BackgroundAgentStore;
+    /** S-185:workflow 出身的**有界** join 索引(契约见 orchestration/workflow-agent-session-index.ts)。 */
+    workflowIndex?: WorkflowAgentSessionIndex;
+    /** 索引只回答「去哪条 run 找」,行本体(含赎回键)仍以 run 的 blob 为准 ⇒ 两件必须成对在场。 */
+    workflowRunStore?: Pick<WorkflowRunStore, "get">;
+    warn?: (event: string, fields: Record<string, unknown>) => void;
+}
+export declare function findParkOrigin(sources: ParkOriginSources, cp: {
+    token: string;
+    scope: string;
+    sessionId: string;
+}): Promise<ParkOrigin | undefined>;
 /**
  * pending checkpoint → parked bg 行匹配。
  *
@@ -101,13 +149,75 @@ export interface ParkedDecideResult {
     status: number;
     body: Record<string, unknown>;
 }
+/**
+ * 两条 park 车道(bg 赎回 / workflow 驱动)共用的 **`ResumeOutcome` 铸点**(S-185 车CM 单点化)。
+ *
+ * 判据一字未改,只是从 bg 腿里提出来:两条腿结算的是**同一种门**(core gateMatch 的 `policy_ask`),
+ * 各铸一份必然漂移,而漂的是「人到底批了什么」这条审计事实。
+ *
+ * · D-1 绑定:操作员在 GET 看到的 `boundCallId`/`boundInputHash` 原样透传,server **绝不重算**;
+ *   缺席时回落到行上 persisted 的那两位(core resume 侧做 fail-closed 等值校验)。
+ * · `reason` 是**存在性**判定不是真值判定 —— 显式空串("运维选择不写理由")与"没传"是两件事
+ *   (姊妹 approval-hmac.ts `env.reason ?? null` 同判据)。
+ * · `hostDecision` = 结算**事实**逐字上 outcome;`gateOutcome` 一格 server **永不**填(core 对宿主
+ *   自铸的结算词是 pre-CAS 响亮拒)。
+ * · `answer` 原样透传([ref]:header 逐字匹配等语义校验全在 core,server 不预判)。
+ */
+export declare function buildParkedResumeOutcome(req: ParkedDecideRequest): ResumeOutcome;
+/**
+ * S-185 车CM —— **第三条车道的计划**(纯函数;驱动本身归 resume 家族的那条腿,见下方「为什么不自建驱动」)。
+ *
+ * ## 这条车道为什么长这样(亲读 core 实现后的结论,不是从类型面推的)
+ * 任务书原案是「server 直接 `startWorkflow({resumeFromRunId, parkedResume})`」。亲读安装的 core
+ * `dist/orchestration/run-workflow-tool.js` 与 `dist/core/runner/prepare-caps-and-workflow.js` 证伪了它:
+ *  · `startWorkflow(runner, fn, opts)` 的 `fn` 是**脚本函数**,由 `scriptRunner.run({scriptSource, primitives,
+ *    scriptArgs})` 现编 —— server 手上只有持久化的 `WorkflowRun` 行,没有脚本源,也没有那一整套按 host
+ *    任务折出来的 governance/model/limits;自己拼一份 = 在 workflow 启动语义上多一个写者(本仓宪法明令禁止)。
+ *  · core 给部署方留的**唯一**通道是 `RunInternals.workflowParkedResume`(d.ts 逐字:「A host that decided a
+ *    workflow child's parked checkpoint **launches the run that re-invokes** `Workflow({resumeFromRunId})`
+ *    with the decision here」),由 `prepare-caps-and-workflow` 折进 Workflow 工具的 `parkedResume` dep,
+ *    再进 `RunWorkflowOptions.parkedResume`。core 自己给模型的 park 回执也是这句:「once the approval is
+ *    decided, the deployment resumes this run (resumeFromRunId: …)」。
+ * ⇒ 第三条车道 = **把决定挂在宿主会话的下一跑上**,而那一跑必须走 resume 家族**既有**的那条腿
+ * (`notify-wake.ts` 的成文纪律:wake 会烧模型,所以复用 `ctx.legs.resumeWake`,「而不是在本域自建第二条
+ * 驱动路径」)。本函数因此只出**计划**:宿主会话 + 要注入的消息 + 要随 internals 走的那一条决定。
+ *
+ * ## 诚实边界(登记,不假装没有)
+ * · **模型中介**:决定送达宿主之后,真正的赎回发生在宿主再调一次 `Workflow({resumeFromRunId})` 时。
+ *   core 的 park 回执逐字告诉模型这件事,但它不是一条确定性的机器腿。宿主没照做 ⇒ 卡仍 pending、
+ *   人可再决(**不会**静默吃掉批准)。
+ * · **`inheritedGate` 不供**:那是「跨进程重供 checkpoint 的父约束」的席位,而 wa* 行不带父约束链;
+ *   同进程时 core 的内存 registry 自动重供,跨进程且该 cp 带 `requiresParentConstraint` 时 core 响亮拒
+ *   (`resume.parent_constraint_missing`)⇒ 该 ordinal 再 park 一次,不会 fail-open。
+ */
+/**
+ * 🔴 拒臂就是**一条 `ParkedDecideResult`**(7.69.0 合并重扫 c2/c7)。此前它把 `status`/`body` 平铺在
+ * 判别对象上(`{ok:false, status, body}`),于是本文件里同时存在两种「HTTP 错误结果」的写法,而
+ * `test/error-code-catalog-live.test.ts` 的目录抽取器只认这一族既有的 `{ status: 4xx, body: {…} }` 形
+ * (它的臂③ 顶注逐字点名 parked-decide)——两条新码因此在 wire 上发得出、附录 A 查不到、机器门还看不见。
+ * 收法是让**返回形回到同一种**(本文件只留一个 HTTP 结果类型),不是给扫描器加第九条臂:
+ * 后者会让「换个包装就隐形」这条病继续存在,只是多一条特判去追它。
+ */
+export type WorkflowParkedDecidePlan = {
+    ok: true;
+    hostSessionId: string;
+    runId: string;
+    message: string;
+    outcome: ResumeOutcome;
+} | {
+    ok: false;
+    deny: ParkedDecideResult;
+};
+export declare function planWorkflowParkedDecide(origin: Extract<ParkOrigin, {
+    kind: "workflow";
+}>, req: ParkedDecideRequest): WorkflowParkedDecidePlan;
 /**
  * `/decide` parked 赎回腿([ref] 件3d server 半场;[ref]/[ref]/[ref] core 裁定形)。
  *
- * 返回 `undefined` = 该 pending checkpoint 不属于任何 parked 后台子代——调用方走既有任务级
- * resumeCheckpoint 腿(零回归);返回结果对象 = 赎回腿已受理/已拒,调用方直接回 HTTP。
+ * 调用方先经 {@link findParkOrigin} 判出 `kind:"background"` 再进来(S-185 车CM:判别只做一次);
+ * 返回的结果对象 = 赎回腿已受理/已拒,调用方直接回 HTTP。
  *
- * 链:判别(findParkedAgentForCheckpoint)→ `claimParkedAgent`(access = 行镜像双轴
+ * 链:`claimParkedAgent`(access = 行镜像双轴
  * `{scope: row.scope, owner: row.owner}`,[ref] Q3)→ outcome 铸造(D-1 echo/persisted 回落)
  * → 裸 `reviveTool.execute(args, ctx.reviveClaim)`。execute 一旦发起 drive,rollback 全在 core 内
  * (driveParkedResume);server 只在「claim 成功但 drive 从未发起」窗口补 `rollbackParkedClaim`
@@ -116,5 +226,5 @@ export interface ParkedDecideResult {
  * 200 是**受理**语义(drive 是 core 内 fire-and-forget):失败经行/notification 面 + REOPENED
  * re-park 诚实可见,操作员可再决。
  */
-export declare function decideParkedAgent(deps: ParkedDecideDeps, req: ParkedDecideRequest): Promise<ParkedDecideResult | undefined>;
+export declare function decideParkedAgent(deps: ParkedDecideDeps, req: ParkedDecideRequest, match: ParkedAgentMatch): Promise<ParkedDecideResult>;
 //# sourceMappingURL=parked-decide.d.ts.map