@sema-agent/server 7.110.0 → 7.112.0

package/dist/plugins/user-input-ledger-sql.js

@@ -1,3 +1,4 @@
+import { recordFailOpen } from "../observability/fail-open.js";
 import { isDupKeyError } from "./sql-errors.js";
 import { mysqlDriver, pgDriver } from "./sql-driver.js";
 import { assertPageLimit, CRASHED_CAUSE, SETTLE_HOW_WORDS, USER_INPUT_KIND_WORDS, USER_INPUT_OPEN_SCAN_MAX, USER_INPUT_SESSION_READ_MAX, } from "../user-input-ledger.js";
@@ -12,35 +13,57 @@ function rowState(r) {
         case "settled": {
             const how = String(r["settle_how"]);
             if (!Object.hasOwn(SETTLE_HOW_WORDS, how) || !Number.isFinite(at))
-                break;
+                return undefined;
             return { kind: "settled", how: how, atMs: at };
         }
         case "converged":
             if (!Number.isFinite(at))
-                break;
+                return undefined;
             return { kind: "converged", cause: CRASHED_CAUSE, atMs: at };
         default:
-            break;
+            return undefined;
     }
-    throw new Error(`${USER_INPUT_ACCEPTANCE_TABLE} row ${String(r["accept_id"])}: unreadable state (${String(r["state"])} / ${String(r["settle_how"])} / ${String(r["state_at_ms"])})`);
 }
-function rowToAcceptance(r) {
+function readRow(r) {
     const input = String(r["input_kind"]);
     if (!Object.hasOwn(USER_INPUT_KIND_WORDS, input))
-        throw new Error(`${USER_INPUT_ACCEPTANCE_TABLE} row ${String(r["accept_id"])}: input_kind ${input} is not a ledger word`);
+        return { ok: false, reason: `input_kind ${input} is not a ledger word` };
+    const state = rowState(r);
+    if (state === undefined)
+        return { ok: false, reason: `unreadable state (${String(r["state"])} / ${String(r["settle_how"])} / ${String(r["state_at_ms"])})` };
     const announcedAt = r["announced_at_ms"] == null ? undefined : Number(r["announced_at_ms"]);
     return {
-        acceptId: String(r["accept_id"]),
-        input: input,
-        messageId: String(r["message_id"]),
-        sessionId: String(r["session_id"]),
-        taskId: String(r["task_id"]),
-        writer: String(r["writer"]),
-        acceptedAtMs: Number(r["accepted_at_ms"]),
-        state: rowState(r),
-        ...(announcedAt !== undefined ? { announced: { atMs: announcedAt, taskId: String(r["announced_task_id"]) } } : {}),
+        ok: true,
+        acceptance: {
+            acceptId: String(r["accept_id"]),
+            input: input,
+            messageId: String(r["message_id"]),
+            sessionId: String(r["session_id"]),
+            taskId: String(r["task_id"]),
+            writer: String(r["writer"]),
+            acceptedAtMs: Number(r["accepted_at_ms"]),
+            state,
+            ...(announcedAt !== undefined ? { announced: { atMs: announcedAt, taskId: String(r["announced_task_id"]) } } : {}),
+        },
     };
 }
+function readRows(rows, op) {
+    const out = [];
+    for (const r of rows) {
+        const read = readRow(r);
+        if (read.ok)
+            out.push(read.acceptance);
+        else
+            recordFailOpen("server.user-input-ledger.corrupt-record-skipped", `table=${USER_INPUT_ACCEPTANCE_TABLE} op=${op} accept_id=${String(r["accept_id"])} ${read.reason}`);
+    }
+    return out;
+}
+function rawCursor(r) {
+    const acceptedAtMs = Number(r["accepted_at_ms"]);
+    if (!Number.isFinite(acceptedAtMs))
+        throw new Error(`${USER_INPUT_ACCEPTANCE_TABLE} row ${String(r["accept_id"])}: accepted_at_ms ${String(r["accepted_at_ms"])} is not a number — cannot page past it`);
+    return { acceptedAtMs, acceptId: String(r["accept_id"]) };
+}
 export class SqlUserInputLedgerStore {
     db;
     constructor(db) {
@@ -76,16 +99,21 @@ export class SqlUserInputLedgerStore {
         const { rows } = after === undefined
             ? await this.db.query(this.q(`SELECT ${COLUMNS} FROM ${USER_INPUT_ACCEPTANCE_TABLE} WHERE state = 'open' ORDER BY accepted_at_ms, accept_id LIMIT ${limit}`, `SELECT ${COLUMNS} FROM ${USER_INPUT_ACCEPTANCE_TABLE} WHERE state = 'open' ORDER BY accepted_at_ms, accept_id LIMIT ${limit}`), [])
             : await this.db.query(this.q(`SELECT ${COLUMNS} FROM ${USER_INPUT_ACCEPTANCE_TABLE} WHERE state = 'open' AND (accepted_at_ms > ? OR (accepted_at_ms = ? AND accept_id > ?)) ORDER BY accepted_at_ms, accept_id LIMIT ${limit}`, `SELECT ${COLUMNS} FROM ${USER_INPUT_ACCEPTANCE_TABLE} WHERE state = 'open' AND (accepted_at_ms > $1 OR (accepted_at_ms = $2 AND accept_id > $3)) ORDER BY accepted_at_ms, accept_id LIMIT ${limit}`), [after.acceptedAtMs, after.acceptedAtMs, after.acceptId]);
-        return rows.map(rowToAcceptance);
+        const open = readRows(rows, "listOpen");
+        return rows.length === limit ? { open, next: rawCursor(rows[rows.length - 1]) } : { open };
     }
     async listCrashed(sessionId) {
         const { rows } = await this.db.query(this.q(`SELECT ${COLUMNS} FROM ${USER_INPUT_ACCEPTANCE_TABLE} WHERE session_id = ? AND state = 'converged' ORDER BY accepted_at_ms DESC, accept_id DESC LIMIT ${USER_INPUT_SESSION_READ_MAX}`, `SELECT ${COLUMNS} FROM ${USER_INPUT_ACCEPTANCE_TABLE} WHERE session_id = $1 AND state = 'converged' ORDER BY accepted_at_ms DESC, accept_id DESC LIMIT ${USER_INPUT_SESSION_READ_MAX}`), [sessionId]);
-        return rows.map(rowToAcceptance).reverse();
+        return readRows(rows, "listCrashed").reverse();
     }
     async listUnannounced(sessionId, limit) {
         const n = assertPageLimit("listUnannounced", limit);
         const { rows } = await this.db.query(this.q(`SELECT ${COLUMNS} FROM ${USER_INPUT_ACCEPTANCE_TABLE} WHERE session_id = ? AND state = 'converged' AND announced_at_ms IS NULL ORDER BY accepted_at_ms, accept_id LIMIT ${n}`, `SELECT ${COLUMNS} FROM ${USER_INPUT_ACCEPTANCE_TABLE} WHERE session_id = $1 AND state = 'converged' AND announced_at_ms IS NULL ORDER BY accepted_at_ms, accept_id LIMIT ${n}`), [sessionId]);
-        return rows.map(rowToAcceptance);
+        return readRows(rows, "listUnannounced");
+    }
+    async deleteBySession(sessionId) {
+        const res = await this.db.query(this.q(`DELETE FROM ${USER_INPUT_ACCEPTANCE_TABLE} WHERE session_id = ?`, `DELETE FROM ${USER_INPUT_ACCEPTANCE_TABLE} WHERE session_id = $1`), [sessionId]);
+        return res.affected;
     }
 }
 export class TiDBUserInputLedgerStore extends SqlUserInputLedgerStore {

package/dist/project-memory.d.ts

@@ -25,7 +25,8 @@ interface ProjectMemoryCtx {
  *  every CLAUDE file it finds, per directory level up the ancestor chain, whereas this loader reads one root and
  *  takes the single first hit. */
 declare const INSTRUCTION_FILE_CHAIN: readonly ["CLAUDE.md", ".claude/CLAUDE.md", "AGENTS.md", ".claude/AGENTS.md"];
-type ChainMember = (typeof INSTRUCTION_FILE_CHAIN)[number];
+/** 一个链成员(相对项目根的拼写)。导出给 S-961 的 wire 段与它的值闭集登记(`trace/self-minted-wire.ts`)—— 链长一员,两处 tsc 跟着红。 */
+export type InstructionChainMember = (typeof INSTRUCTION_FILE_CHAIN)[number];
 /** Recover (root, rel) for a path the LOADER declared — every declared path is `root + one chain member`.
  *  The probe needs this to re-run the loader's parent-directory symlink gate each round (self-review: the probe
  *  checked only the final component, so swapping `.claude` for a symlink out of the repo MID-RUN made the probe
@@ -33,7 +34,7 @@ type ChainMember = (typeof INSTRUCTION_FILE_CHAIN)[number];
  *  calls it with the host `node:path`. */
 export declare function instructionChainCoordinates(absPath: string, p?: PlatformPath): {
     root: string;
-    rel: ChainMember;
+    rel: InstructionChainMember;
 } | null;
 /**
  * Build a `loadProjectMemory` for the host lane. Returns null (skip) unless hands are enabled AND cwd is a local
@@ -54,6 +55,13 @@ export declare function instructionChainCoordinates(absPath: string, p?: Platfor
  * an absolute local directory) is "not applicable", not "none" — it never reaches the mint (O6, see `LoadOutcome`). The member is the one the snapshot carries — a cache hit answers the cached pick, so
  * the notice follows what the model actually reads, not the disk (a same-process edit changes nothing until the
  * snapshot is re-read: restart, post-compact, or a new session).
+ *
+ * S-961 — the same statement (same predicate, same member) also settles the calling LEG's `wiring_manifest.instructions`
+ * segment through {@link settleLegInstructionStatement} (`instruction-selection.ts`): the leg scope is the run identity
+ * the ctx does not carry, and the first call inside a leg's scope whose `ctx.sessionId` equals the leg's session is that
+ * leg's own prepare (a session-less adhoc leg falls back to plain first-call; [ref] X1). The segment projects
+ * `instructionFile`, not `instructionSources`: an empty selected file with no git narrative returns no answer and so no
+ * `instructionSources`, yet it IS the pick (it shadows every member below it) — and the notice reads the same value.
  */
 export declare function makeLoadProjectMemory(opts: {
     logger?: {

package/dist/project-memory.js

@@ -3,6 +3,7 @@ import { execFile } from "node:child_process";
 import { createHmac, randomBytes } from "node:crypto";
 import hostPath, { isAbsolute, join } from "node:path";
 import { announceInstructionSource } from "./instruction-source-notice.js";
+import { settleLegInstructionStatement } from "./instruction-selection.js";
 import { gitSubprocessEnv } from "./server-secret-env.js";
 import { redactSecrets } from "./trace/redact.js";
 const INSTRUCTION_FILE_CHAIN = ["CLAUDE.md", ".claude/CLAUDE.md", "AGENTS.md", ".claude/AGENTS.md"];
@@ -92,8 +93,10 @@ export function makeLoadProjectMemory(opts) {
     const seat = opts.instructionSource;
     return async (ctx) => {
         const outcome = await loadOutcome(ctx);
-        if (seat && ctx.sessionId && !ctx.isSubagent && outcome.walked)
-            await announceInstructionSource(seat, ctx.sessionId, outcome.instructionFile);
+        const statement = outcome.walked && !ctx.isSubagent ? { stated: true, file: outcome.instructionFile } : { stated: false };
+        settleLegInstructionStatement(statement, ctx.sessionId);
+        if (seat && ctx.sessionId && statement.stated)
+            await announceInstructionSource(seat, ctx.sessionId, statement.file);
         return outcome.answer;
     };
     async function loadOutcome(ctx) {

package/dist/run-cancel-context.d.ts

@@ -1,4 +1,4 @@
-import type { PersistedTaskResult, RunCancelContext } from "./plugins/store-contracts.js";
+import type { AbortCause, PersistedTaskResult, RunCancelContext } from "./plugins/store-contracts.js";
 /**
  * @param taskId  这条 run 的账本 id(turn 活性登记的键)。
  * @param startedAtMs 这条 run 起跑的墙钟时刻(epoch ms):取消腿手上有行就用行的 `createdAt`,
@@ -43,11 +43,23 @@ export declare const CANCELLED_CODE = "cancelled";
  *  · `cancelContext`:已经有快照就不重铸(重铸会把「上一条引擎事件多久以前」重新计时)。
  *
  * ## 为什么不判「这条 failed 是不是 abort 形」
- * 判据在**调用点**:调用点问的是「本腿这次是不是被取消动词打中了」(`cancelCtrl.signal.aborted` /
- * `cancelledViaVerb`),那是 server 自己的事实。让本函数去嗅 `terminal.message` 的字面就是再造事实
+ * 判据在**调用点**:调用点问的是「本腿这次是不是被 server 中止了」—— 本腿 {@link RunAbort} 句柄上登记的成因
+ * (`cause()` 在场),那是 server 自己的事实。让本函数去嗅 `terminal.message` 的字面就是再造事实
  * —— [ref] 二那次事故的同一个形。
+ *
+ * ## S-947:成因(`abortCause`)与码、快照**同进同退**
+ * `cause` 是**必填**:本函数是 server 铸取消终局的唯一出口,而每一次取消都有一个发起者 ⇒ 「本仓铸的取消终局上恒有
+ * `abortCause`」由签名保证,不靠调用方记得。它走与补码、补快照**同一条**空座闸 —— 引擎给的终局不是无码的 failed
+ * (与中止赛跑跑完了 / 引擎自带码)⇒ 整只原样返回,成因也不挂(那条终局不是这次中止的结果,挂上就是「完成了却带着取消便签」)。
  */
-export declare function mintCancelledResult(args: {
+export declare function mintCancelledResult<R extends PersistedTaskResult>(args: CancelMintArgs & {
+    engineResult: R;
+}): R;
+export declare function mintCancelledResult(args: CancelMintArgs & {
+    engineResult?: undefined;
+}): PersistedTaskResult;
+/** {@link mintCancelledResult} 的公共实参(`engineResult` 另列:在场与否决定返回型)。 */
+interface CancelMintArgs {
     /** 这条 run 的账本 id(活性登记的键;账本不在场时给空串,快照按「证不出」处理)。 */
     taskId: string;
     /** 会话 id(合成形要写进结果;引擎给了结果时不用)。 */
@@ -56,7 +68,47 @@ export declare function mintCancelledResult(args: {
     startedAtMs: number;
     /** 合成形的失败文案(引擎给了终局时不用)。 */
     message: string;
-    /** 引擎给出的终局(在场 ⇒ 在它之上补标)。 */
-    engineResult?: PersistedTaskResult;
-}): PersistedTaskResult;
+    /** S-947:这次取消的发起者(本腿 {@link RunAbort} 句柄上登记的那一个;park 中直接终局化的取消动词给 `"cancel_verb"`)。 */
+    cause: AbortCause;
+}
+/**
+ * S-947 —— 没有 `done` 可落的取消形在账本上的那一行(`failed`):**从铸好的取消终局投影**,不手抄。
+ *
+ * 账本 `failed` 行是平面形(`errorMessage` / `errorCode` 顶层),所以成因也在顶层、与 `errorCode` 并列;有 `done` 可落的
+ * 那几形,成因随 `done.result` 走(结果本身带它)。两形同一个来源 = 同一只取消终局,不是两处各写一份。
+ * 返回纯数据 ⇒ `build*`。
+ */
+export declare function buildCancelledLedgerRow(c: PersistedTaskResult): {
+    errorMessage?: string;
+    errorCode?: string;
+    abortCause?: AbortCause;
+};
+/**
+ * S-947 —— 一条 run 腿的**中止句柄**:server 中止这条腿的唯一入口,也是「为什么中止」的唯一登记处。
+ *
+ * ## 为什么是句柄、不是一张按 taskId 键控的表
+ * 修前这件事由 `cancelledViaVerb: Set<taskId>`(「这次是取消动词」一个词)+ 各腿手写的生命周期(登记 / finally 里按身份守卫删 /
+ * 同步腿「删之前先取」)承担:一个键控在 **taskId** 上的旁表,要防的病都来自键与腿不同寿 —— 快速续跑在旧腿 finally 之前
+ * 用同一 taskId 登记新腿、旧腿收尾删掉新腿的条目;同步腿必须在删之前取值。成因挂在**腿自己的中止控制器**上之后,
+ * 这些规则一条都不需要:句柄与腿同寿,换腿就是换句柄,没有可删、可串、可漏的旁表。
+ *
+ * ## 先到先得(first-writer-wins)
+ * 第一次 `abort(cause)` 生效并登记成因;之后的调用全是 no-op(信号早已中止,成因不改写)—— 断连之后又到了取消动词、
+ * 取消之后又断连,终局说的都是**真正让这条腿停下来**的那一个。`AbortController.abort()` 自身就是幂等的,本句柄只是在
+ * 「第一次」那一刻把词记下。
+ *
+ * ## 引擎看到的东西不变
+ * 中止走 `AbortController.abort()` 的默认原因(引擎、provider 的 fetch、子进程看到的仍是标准 `AbortError`)—— 成因**不**塞进
+ * `signal.reason`:那会改掉引擎与 provider 层收到的拒绝值,是在下游改上游接缝的输入(立宪禁区)。
+ */
+export interface RunAbort {
+    /** 交给引擎的那只信号(`spec.signal` / 审批 / 提问 ALS 的 `abortSignal` / 子代 stoppedBy 归因都用它)。 */
+    readonly signal: AbortSignal;
+    /** 以 `cause` 中止本腿。已中止 ⇒ no-op(成因不改写)。 */
+    abort(cause: AbortCause): void;
+    /** 让本腿停下来的那次中止的成因;未中止 ⇒ `undefined`。 */
+    cause(): AbortCause | undefined;
+}
+export declare function createRunAbort(): RunAbort;
+export {};
 //# sourceMappingURL=run-cancel-context.d.ts.map

package/dist/run-cancel-context.js

@@ -23,6 +23,7 @@ export function mintCancelledResult(args) {
             ...engine,
             terminal: { ...engine.terminal, code: CANCELLED_CODE },
             ...(engine.cancelContext === undefined && ctx !== undefined ? { cancelContext: ctx } : {}),
+            abortCause: args.cause,
         };
     }
     return {
@@ -32,6 +33,31 @@ export function mintCancelledResult(args) {
         result: "",
         stats: { turns: 0, tokens: 0, usageMissing: true },
         ...(ctx ? { cancelContext: ctx } : {}),
+        abortCause: args.cause,
+    };
+}
+export function buildCancelledLedgerRow(c) {
+    const t = c.terminal;
+    return {
+        ...(t.kind === "failed" && t.message !== undefined ? { errorMessage: t.message } : {}),
+        ...(t.kind === "failed" && t.code !== undefined ? { errorCode: t.code } : {}),
+        ...(c.abortCause !== undefined ? { abortCause: c.abortCause } : {}),
+    };
+}
+export function createRunAbort() {
+    const ctrl = new AbortController();
+    let landed;
+    return {
+        signal: ctrl.signal,
+        abort(cause) {
+            if (ctrl.signal.aborted)
+                return;
+            landed = cause;
+            ctrl.abort();
+        },
+        cause() {
+            return landed;
+        },
     };
 }
 //# sourceMappingURL=run-cancel-context.js.map

package/dist/runs.d.ts

@@ -2,6 +2,7 @@ import { defaultTaskRegistry, type CascadeConfig, type CheckpointToken, type Run
 import type { SendUserFileEmitter } from "./capabilities/send-user-file-tool.js";
 import type { RunStore } from "./plugins/store-backend.js";
 import type { Metrics } from "./observability/metrics.js";
+import { type RunAbort } from "./run-cancel-context.js";
 import type { ModelUsageTracker, PromptManifestTracker } from "./budget.js";
 import type { ElicitationCoordinator } from "./elicitation.js";
 import type { QuestionCoordinator } from "./question.js";
@@ -259,10 +260,11 @@ export declare function evictIfConflict(runner: Runner, sessionId: string | unde
  * text); tool/lifecycle events are recorded individually. Per-token live streaming stays on the
  * synchronous `/v1/tasks/stream` endpoint. Never throws — failures are recorded on the run.
  *
- * Cancellation (POST /v1/runs/:id/cancel): the run registers an AbortController in `inflight` (same-replica
- * fast path — the cancel handler aborts it directly) and its heartbeat tick polls the durable
- * `cancel_requested` flag (cross-replica, ≤HEARTBEAT_MS lag). Either way the run settles to
- * status "failed" + errorCode "cancelled" (metric label "cancelled"); the entry is removed in `finally`.
+ * Cancellation (POST /v1/runs/:id/cancel): the run registers its abort handle (S-947 `RunAbort`) in `inflight`
+ * (same-replica fast path — the cancel handler aborts it directly) and its heartbeat tick polls the durable
+ * `cancel_requested` flag (cross-replica, ≤HEARTBEAT_MS lag); both abort with `cancel_verb`. Either way the run settles
+ * to status "failed" + errorCode "cancelled" + `result.abortCause` (metric label "cancelled"); the entry is removed in
+ * `finally`.
  *
  * Preemption (POST /v1/assistant/tasks/:id/preempt, [ref] seam #2): a SECOND, INDEPENDENT controller
  * (`preemptCtrl`, registered in `preemptable`) carries the scheduler's graceful "yield this task" — when raised,
@@ -281,7 +283,7 @@ export declare function evictIfConflict(runner: Runner, sessionId: string | unde
 export declare function runInBackground(runner: Runner, spec: TaskSpec, runStore: RunStore, taskId: string, metrics?: Metrics, principal?: string, verify?: VerifyRoundsSpec, // 快审 F1:number 参升整对象——cost 顶随传
 cascade?: CascadeConfig, instrumentDegenerate?: (result: TaskResult) => void, planCacheProbe?: {
     record: (scope: string | undefined, objective: string, completed: boolean) => void;
-}, persistThinking?: boolean, inflight?: Map<string, AbortController>, preemptable?: Map<string, AbortController>, steerable?: Map<string, TaskStream>, modelUsage?: ModelUsageTracker, elicitation?: ElicitationCoordinator, 
+}, persistThinking?: boolean, inflight?: Map<string, RunAbort>, preemptable?: Map<string, AbortController>, steerable?: Map<string, TaskStream>, modelUsage?: ModelUsageTracker, elicitation?: ElicitationCoordinator, 
 /** E23: the VERIFIED principal (gatedPrincipal) that may answer this run's elicitations — matches the respond
  *  owner-gate's identity source (NOT the cost-attribution `principal`, which on a direct door is the self-asserted
  *  header → can be null while a JWT principal exists). Falls back to the run owner when not supplied. */

package/dist/runs.js

@@ -6,12 +6,13 @@ import { isSessionErrorCode, sessionErrorHttp } from "./session-error-wire.js";
 import { redactErrorMessage } from "./observability/run-terminal.js";
 import { withPrincipal } from "./observability/principal-context.js";
 import { withModelReachScope } from "./model-reach-scope.js";
+import { createInstructionSelectionLeg } from "./instruction-selection.js";
 import { redactSecrets } from "./trace/redact.js";
 import { taskNotificationEventData, appendModelUsageDelta, appendPromptManifest, attachModelUsage } from "./trace/project.js";
 import { createLedgerSink } from "./trace/ledger-sink.js";
 import { registerEngineNoticeLeg } from "./trace/engine-notice-wire.js";
 import { recordTurnActivity } from "./turn-activity.js";
-import { CANCELLED_CODE, mintCancelledResult } from "./run-cancel-context.js";
+import { buildCancelledLedgerRow, CANCELLED_CODE, createRunAbort, mintCancelledResult } from "./run-cancel-context.js";
 import { createApprovalCardEmitter, resolveApprovalLeg } from "./tool-approval.js";
 import { fleetRunResiduals, isFleetAgentTerminalNotification } from "./fleet/fleet-bus.js";
 import { defaultSubagentTailBus } from "./fleet/subagent-tail-bus.js";
@@ -177,14 +178,16 @@ export async function runInBackground(runner, spec, runStore, taskId, metrics, p
     const startedAt = Date.now();
     metrics?.addGauge("runs_active", 1);
     fleetPublisher?.onStart();
-    const cancelCtrl = new AbortController();
+    const cancelCtrl = createRunAbort();
     inflight?.set(taskId, cancelCtrl);
     markChildrenStoppedByUserOnAbort(cancelCtrl.signal, taskId, principal);
     const preemptEligible = verify === undefined && cascade === undefined;
     const preemptCtrl = new AbortController();
     if (preemptEligible)
         preemptable?.set(taskId, preemptCtrl);
-    const cancelledResult = (engineResult) => mintCancelledResult({ taskId, sessionId: spec.sessionId ?? "", startedAtMs: startedAt, message: "cancelled by user", ...(engineResult !== undefined ? { engineResult } : {}) });
+    const cancelledResult = (cause, engineResult) => engineResult !== undefined
+        ? mintCancelledResult({ taskId, sessionId: spec.sessionId ?? "", startedAtMs: startedAt, message: "cancelled by user", cause, engineResult })
+        : mintCancelledResult({ taskId, sessionId: spec.sessionId ?? "", startedAtMs: startedAt, message: "cancelled by user", cause });
     const recordDone = (result, status) => {
         metrics?.addGauge("runs_active", -1);
         metrics?.inc("tasks_total", { status });
@@ -221,7 +224,7 @@ export async function runInBackground(runner, spec, runStore, taskId, metrics, p
         void runStore.heartbeat(taskId, owner).catch(() => { metrics?.inc("run_signal_poll_errors_total", { kind: "heartbeat" }); });
         if (!cancelCtrl.signal.aborted) {
             void runStore.isCancelRequested(taskId, owner).then((c) => { if (c)
-                cancelCtrl.abort(); }).catch(() => { metrics?.inc("run_signal_poll_errors_total", { kind: "cancel" }); });
+                cancelCtrl.abort("cancel_verb"); }).catch(() => { metrics?.inc("run_signal_poll_errors_total", { kind: "cancel" }); });
         }
         if (preemptEligible && !preemptCtrl.signal.aborted) {
             void runStore.isPreemptRequested(taskId, owner).then((p) => { if (p)
@@ -232,7 +235,7 @@ export async function runInBackground(runner, spec, runStore, taskId, metrics, p
     const anchor = new TurnAnchorCapture(captureTurnAnchor, () => metrics?.inc("resume_anchor_capture_failed"), captureUserMessageAnchor);
     let reached;
     let observedDone;
-    let cancelledAtDone = false;
+    let causeAtDone;
     let settledAsCancel = false;
     let steerableStreamRef;
     let legLive = true;
@@ -247,7 +250,8 @@ export async function runInBackground(runner, spec, runStore, taskId, metrics, p
         metrics?.addGauge("runs_active", -1);
         metrics?.inc("tasks_total", { status: "needs_review" });
     };
-    const sink = createLedgerSink({ appendEvent: (seq, type, data) => runStore.appendEvent(taskId, seq, type, data), persistThinking, notifiedKeys, onActivity: (kind, statusData) => recordTurnActivity(taskId, kind, statusData) });
+    const instructionLeg = createInstructionSelectionLeg();
+    const sink = createLedgerSink({ appendEvent: (seq, type, data) => runStore.appendEvent(taskId, seq, type, data), persistThinking, notifiedKeys, onActivity: (kind, statusData) => recordTurnActivity(taskId, kind, statusData), instructionsSegment: instructionLeg.segment });
     const append = (type, data) => sink.append(type, data);
     const flush = () => sink.flush();
     const flushModelUsage = () => appendModelUsageDelta(append, modelUsage, taskId);
@@ -362,7 +366,7 @@ export async function runInBackground(runner, spec, runStore, taskId, metrics, p
             for await (const ev of stream) {
                 if (ev.type === "done") {
                     observedDone = ev.result;
-                    cancelledAtDone = cancelCtrl.signal.aborted;
+                    causeAtDone = cancelCtrl.cause();
                 }
                 fleetPublisher?.onEvent(ev);
                 await flushPromptManifest();
@@ -400,7 +404,7 @@ export async function runInBackground(runner, spec, runStore, taskId, metrics, p
                     }
                     evictIfConflict(runner, spec.sessionId, ev.result);
                     {
-                        const settled = cancelledAtDone ? cancelledResult(ev.result) : ev.result;
+                        const settled = causeAtDone !== undefined ? cancelledResult(causeAtDone, ev.result) : ev.result;
                         settledAsCancel = failureCodeOf(settled.terminal) === CANCELLED_CODE;
                         const safe = await withModelUsage(sealResultForExit(settled));
                         await sink.appendDone(safe);
@@ -422,7 +426,7 @@ export async function runInBackground(runner, spec, runStore, taskId, metrics, p
                 await append("suggestions", { suggestions: suggestions.map((s) => redactSecrets(s)) });
             }
         };
-        await withModelReachScope(spec.sessionId, () => withPrincipal(principal, () => {
+        await instructionLeg.run(spec.sessionId, () => withModelReachScope(spec.sessionId, () => withPrincipal(principal, () => {
             const withElicit = elicitation
                 ? () => elicitation.runWithContext({ taskId, owner: elicitOwner ?? owner, emit: elicitEmit, abortSignal: cancelCtrl.signal }, runBody)
                 : runBody;
@@ -445,18 +449,19 @@ export async function runInBackground(runner, spec, runStore, taskId, metrics, p
             return sendUserFile
                 ? sendUserFile.runWithContext({ taskId, emit: (frame) => { const { type, ...rest } = frame; return append(type, rest); } }, withApproval)
                 : withApproval();
-        }));
-        if (!reached && cancelCtrl.signal.aborted) {
+        })));
+        const cleanCancelCause = cancelCtrl.cause();
+        if (!reached && cleanCancelCause !== undefined) {
             try {
                 await flush();
             }
             catch (e) {
                 recordFailOpen("server.runs.terminal-ledger-write-failed", `arm=flush-clean-cancel ${errText(e)}`);
             }
-            const c = cancelledResult();
+            const c = cancelledResult(cleanCancelCause);
             settledAsCancel = failureCodeOf(c.terminal) === CANCELLED_CODE;
             try {
-                await append("failed", { errorMessage: "cancelled by user", errorCode: CANCELLED_CODE });
+                await append("failed", buildCancelledLedgerRow(c));
             }
             catch (e) {
                 recordFailOpen("server.runs.terminal-ledger-write-failed", `arm=append-clean-cancel ${errText(e)}`);
@@ -467,6 +472,7 @@ export async function runInBackground(runner, spec, runStore, taskId, metrics, p
         }
     }
     catch (err) {
+        const thrownCancelCause = cancelCtrl.cause();
         const message = errText(err);
         try {
             try {
@@ -486,11 +492,11 @@ export async function runInBackground(runner, spec, runStore, taskId, metrics, p
             else if (reached?.kind === "needs_review") {
                 await runStore.setNeedsReview(taskId, reached.result);
             }
-            else if (cancelCtrl.signal.aborted && observedDone === undefined) {
-                const c = cancelledResult();
+            else if (thrownCancelCause !== undefined && observedDone === undefined) {
+                const c = cancelledResult(thrownCancelCause);
                 settledAsCancel = failureCodeOf(c.terminal) === CANCELLED_CODE;
                 try {
-                    await append("failed", { errorMessage: "cancelled by user", errorCode: CANCELLED_CODE });
+                    await append("failed", buildCancelledLedgerRow(c));
                 }
                 catch (e) {
                     recordFailOpen("server.runs.terminal-ledger-write-failed", `arm=append-thrown-cancel ${errText(e)}`);

package/dist/trace/ledger-sink.d.ts

@@ -2,6 +2,7 @@ import { type TerminalCause } from "@sema-agent/core";
 import { brainStatusEventData } from "./project.js";
 import { NotifiedKeys } from "../orchestration/workflow-completion-inbox.js";
 import { type LedgerEventType, type ParkLedgerEventType } from "./ledger-events.js";
+import type { InstructionsSegment } from "../instruction-selection.js";
 /**
  * LedgerSink — the SINGLE "stream event → durable runs-ledger" projection, shared by the background leg
  * (runs.ts `runInBackground`) and the sync `/v1/tasks/stream` detach lane (server.ts, `x-detach-on-disconnect`).
@@ -115,5 +116,8 @@ export declare function createLedgerSink(opts: {
      *  各传自己看得见的那个词(位①=流事件 `ev.type`,位②=账本行 `type`);拿不到类型的打点方
      *  (core 的 onActivity 第五席、resume 腿手动打点)省参,`kind` 诚实缺席(见 turn-activity.ts)。 */
     onActivity?: (kind?: string, statusData?: Record<string, unknown>) => void;
+    /** S-961:这条腿的 `wiring_manifest.instructions` 段(腿的 `InstructionSelectionLeg.segment`)。**必填**:账本行与 live 帧是
+     *  同一条腿的两个载体,段必须来自同一只腿;在投帧那一刻读(core 推帧之前已 await 过 loader)。返回 `undefined` ⇒ 段缺席。 */
+    instructionsSegment: () => InstructionsSegment | undefined;
 }): LedgerSink;
 //# sourceMappingURL=ledger-sink.d.ts.map

package/dist/trace/ledger-sink.js

@@ -97,7 +97,7 @@ export function createLedgerSink(opts) {
                 await append("workspace_changed", workspaceChangedEventData(ev));
                 break;
             case "wiring_manifest":
-                await append("wiring_manifest", wiringManifestEventData(ev));
+                await append("wiring_manifest", wiringManifestEventData(ev, opts.instructionsSegment()));
                 break;
             case "tool_roster_delta": {
                 const rosterDelta = toolRosterDeltaEventData(ev);

package/dist/trace/project.d.ts

@@ -28,6 +28,7 @@ import type { RunEvent, RunRecord } from "../plugins/store-contracts.js";
 import type { ModelUsageDelta, ModelUsageTracker, PromptManifestRecord } from "../budget.js";
 import { type SemaProvenanceInput } from "./sema-provenance.js";
 import type { LedgerEventType } from "./ledger-events.js";
+import type { InstructionsSegment } from "../instruction-selection.js";
 /** 账本写口的统一签名 —— `type` 是**闭集**(`ledger-events.ts`):新型必须先登记,否则调用点编译红
  *  (codex 交叉复审 F2:别名门 `ap("x")` 与动态首参让纯词法门结构性抓不全)。 */
 type AppendFn = (type: LedgerEventType, data: unknown) => Promise<void>;
@@ -719,11 +720,18 @@ export declare function toolRosterDeltaEventData(ev: {
     eventId?: unknown;
     parentToolCallId?: unknown;
 }): Record<string, unknown> | undefined;
+/**
+ * 🔴 S-961(7.111.0)**第二参 `instructions` 必传**(值可以是 `undefined`):`wiring_manifest` 上唯一一段**本仓自铸**的段
+ * —— 这条腿的 project-memory loader 选中的指令文件链成员,`{ selected: string[] }`。它不在 core 的 manifest 里(core 不持有
+ * 选择规则),所以不从 `ev` 读:每条投帧的腿把**自己那只** `InstructionSelectionLeg.segment()` 递进来。必传而不是可选 ——
+ * 漏递的腿当场 tsc 红,而不是静默投出一个「缺席」(缺席在 wire 上是一句话:「这条腿没有关于指令文件的陈述」)。
+ * `undefined` ⇒ 段缺席;`{ selected: [] }` ⇒ 显式空(走了链、没选中)。登记:`wire-projection-faces.ts` 租户行 `minted`。
+ */
 export declare function wiringManifestEventData(ev: {
     manifest?: unknown;
     eventId?: unknown;
     parentToolCallId?: unknown;
-}): Record<string, unknown>;
+}, instructions: InstructionsSegment | undefined): Record<string, unknown>;
 /**
  * `wiring_manifest` 的 **operator 投影**([ref] 件一)—— {@link wiringManifestEventData} 的租户形加上
  * `governance` 段与 core 的真 `configFingerprint`。
@@ -759,7 +767,7 @@ export declare function wiringManifestOperatorEventData(ev: {
     manifest?: unknown;
     eventId?: unknown;
     parentToolCallId?: unknown;
-}): Record<string, unknown>;
+}, instructions: InstructionsSegment | undefined): Record<string, unknown>;
 /**
  * `wiring_manifest` 的**唯一分叉点**(S-528)—— 两条知道调用方身份的 live 消费腿共用它:
  * `/v1/tasks/stream` 的 SSE 帧,与 `POST /v1/tasks`(非流式)200 体里的 `wiringManifest` 起手回执。
@@ -780,7 +788,7 @@ export declare function wiringManifestFaceEventData(ev: {
     manifest?: unknown;
     eventId?: unknown;
     parentToolCallId?: unknown;
-}, operatorFace: boolean): Record<string, unknown>;
+}, operatorFace: boolean, instructions: InstructionsSegment | undefined): Record<string, unknown>;
 /**
  * `human_input`(core 5.14.0 [ref] 新 `TaskEvent` 臂)—— 「谁把什么喂进了这条 run」的生命周期账本
  * 帧(objective / 实时 steer / nextTurn / parked-steer 续跑 / wake 五个载体共用一个投影点)。

package/dist/trace/project.js

@@ -464,7 +464,7 @@ export function toolRosterDeltaEventData(ev) {
     }
     return { delta: ev.delta, ...identityFields(ev) };
 }
-export function wiringManifestEventData(ev) {
+export function wiringManifestEventData(ev, instructions) {
     const str = (v) => (typeof v === "string" && v.length > 0 ? v : undefined);
     const bool = (v) => (typeof v === "boolean" ? v : undefined);
     const num = (v) => (typeof v === "number" && Number.isFinite(v) ? v : undefined);
@@ -630,11 +630,12 @@ export function wiringManifestEventData(ev) {
         ...(lsp !== undefined ? { lsp } : {}),
         ...(hands !== undefined ? { hands } : {}),
         ...(writeProtection !== undefined ? { writeProtection } : {}),
+        ...(instructions !== undefined ? { instructions: { selected: [...instructions.selected] } } : {}),
         ...identityFields(ev),
     };
 }
-export function wiringManifestOperatorEventData(ev) {
-    const tenant = wiringManifestEventData(ev);
+export function wiringManifestOperatorEventData(ev, instructions) {
+    const tenant = wiringManifestEventData(ev, instructions);
     const str = (v) => (typeof v === "string" && v.length > 0 ? v : undefined);
     const bool = (v) => (typeof v === "boolean" ? v : undefined);
     const sec = (v) => (typeof v === "object" && v !== null && !Array.isArray(v) ? { ...v } : undefined);
@@ -678,8 +679,8 @@ export function wiringManifestOperatorEventData(ev) {
         ...(str(m.configFingerprint) !== undefined ? { configFingerprint: m.configFingerprint } : {}),
     };
 }
-export function wiringManifestFaceEventData(ev, operatorFace) {
-    return operatorFace ? wiringManifestOperatorEventData(ev) : wiringManifestEventData(ev);
+export function wiringManifestFaceEventData(ev, operatorFace, instructions) {
+    return operatorFace ? wiringManifestOperatorEventData(ev, instructions) : wiringManifestEventData(ev, instructions);
 }
 export function humanInputEventData(ev) {
     const str = (v) => (typeof v === "string" && v.length > 0 ? v : undefined);

package/dist/trace/self-minted-wire.d.ts

@@ -32,6 +32,54 @@ export declare const SELF_MINTED_WIRE: {
             };
         };
     };
+    /**
+     * S-961(7.111.0):`wiring_manifest.instructions.selected[]` 的成员值 = 指令文件链的成员(相对 cwd 的拼写)。属主是 `project-memory.ts`
+     * 的 `INSTRUCTION_FILE_CHAIN`([ref] 序:CLAUDE 族先、AGENTS 族后,首中即选)—— 链加 / 删一员 ⇒ 本行 `satisfies` 编译红,登记跟着动。
+     * 段本身(键)登记在 `wire-projection-faces.ts` 的 `wiring_manifest_tenant.minted`。
+     */
+    readonly wiringInstructionsSelected: {
+        readonly at: "wiring_manifest instructions.selected[](本腿 loader 选中的链成员;段缺席 = 本腿无陈述)";
+        readonly members: {
+            "CLAUDE.md": {
+                attr: string;
+                since: string;
+            };
+            ".claude/CLAUDE.md": {
+                attr: string;
+                since: string;
+            };
+            "AGENTS.md": {
+                attr: string;
+                since: string;
+            };
+            ".claude/AGENTS.md": {
+                attr: string;
+                since: string;
+            };
+        };
+    };
+    /**
+     * S-947(7.112.0):server 发起的中止在取消终局上留下的机读成因 —— `PersistedTaskResult.abortCause`,与 `cancelContext` 同住、同铸点、
+     * 同在场闸(在场 ⇔ 这条终局就是 server 那次中止铸出来的取消终局)。逐词站点见契约 §5.0d。键本身是 run 结果上的 server 侧记键
+     * (`store-contracts.ts` 的 `PersistedResultSideKeys`),不是事件投影面的键 ⇒ 不在 `wire-projection-faces.ts`。
+     */
+    readonly abortCause: {
+        readonly at: "run 结果 result.abortCause(GET /v1/runs/:id → result · done.result · POST /v1/tasks 200 体顶层 · 账本 done 行 result / 无 done 的取消形账本 failed 行顶层)";
+        readonly members: {
+            client_disconnected: {
+                attr: string;
+                since: string;
+            };
+            ask_park_grace_exhausted: {
+                attr: string;
+                since: string;
+            };
+            cancel_verb: {
+                attr: string;
+                since: string;
+            };
+        };
+    };
     /**
      * 会话所有者自助抹除面的**已分类拒** → HTTP 状态(S-930 起与 operator 面 `POST /v1/memory/erase` 同一只映射;`since` 记的是**本面**
      * 自哪一版起这样答 —— 7.107.0 及以前本面只认前两只,其余落 500 `internal.error`)。