@sema-agent/server 7.125.1 → 7.127.0

package/dist/plugins/tidb-session-storage.js

@@ -5,6 +5,7 @@ import { isMysqlDupKeyError } from "./sql-errors.js";
 import { PLACEMENT_SELECT_COLUMNS, placementFromRow } from "./session-placement.js";
 import { decodeSessionEventPayload } from "./session-event-payload.js";
 import { jsonColumnText } from "./sql-json-column.js";
+import { incarnationFromCell } from "../session-incarnation.js";
 const SESSION_EVENT_BY_TYPE_HINT = "/*+ USE_INDEX(session_event, idx_session_event_type) */";
 export const SESSION_EVENT_LATEST_BY_TYPE_SQL = {
     floor: `SELECT ${SESSION_EVENT_BY_TYPE_HINT} ${jsonColumnText("tidb", "payload")} FROM session_event WHERE session_id = ? AND type = 'compaction' ORDER BY seq DESC LIMIT 1`,
@@ -39,7 +40,7 @@ export class TiDBSessionStorage extends BaseSessionStorage {
         }
     }
     static async wake(pool, sessionId) {
-        const [metaRows] = await pool.query(`SELECT created_at, leaf_id, leaf_seq, ${PLACEMENT_SELECT_COLUMNS} FROM session_meta WHERE session_id = ?`, [sessionId]);
+        const [metaRows] = await pool.query(`SELECT created_at, leaf_id, leaf_seq, incarnation, ${PLACEMENT_SELECT_COLUMNS} FROM session_meta WHERE session_id = ?`, [sessionId]);
         const meta = metaRows[0];
         if (!meta)
             return null;
@@ -47,7 +48,7 @@ export class TiDBSessionStorage extends BaseSessionStorage {
         const [eventRows] = await pool.query(`SELECT seq, ${jsonColumnText("tidb", "payload")} FROM session_event WHERE session_id = ? AND seq >= ? ORDER BY seq ASC`, [sessionId, floorSeq]);
         const entries = eventRows.map((r) => decodeSessionEventPayload(r.payload, sessionId, r.seq));
         const placement = placementFromRow(meta);
-        const metadata = { id: sessionId, createdAt: toIso(meta.created_at), ...(placement !== undefined ? { placement } : {}) };
+        const metadata = { id: sessionId, createdAt: toIso(meta.created_at), incarnation: incarnationFromCell(sessionId, meta.incarnation), ...(placement !== undefined ? { placement } : {}) };
         return new TiDBSessionStorage(pool, sessionId, metadata, entries, meta.leaf_id ?? null, floorEntryId, floorSeq);
     }
     static async computeFloor(pool, sessionId) {

package/dist/plugins/tidb-session-store.d.ts

@@ -63,6 +63,8 @@ export declare class TiDBSessionStore implements SessionStore {
     /** S-790:属主 + 化身**一次读**(单行单 SELECT —— 两次独立读在删除 / 重登记的缝里能拼出混世代组合)。`undefined` = 无此会话;
      *  行在而化身为空 ⇒ `SessionIncarnationMissingError`(响亮拒,判据唯一属主 `sessionFaceFromRow`)。 */
     sessionFaceOf(sessionId: string): Promise<SessionFace | undefined>;
+    /** core `SessionStore.incarnationOf`(按 id 读住客,给没取会话的那一侧):{@link sessionFaceOf} 的化身那一半 —— 同一次读、同一只解码。 */
+    incarnationOf(sessionId: string): Promise<string | undefined>;
     touch(sessionId: string): Promise<void>;
     /** E18 — the session's current leaf `SessionTreeEntry.id` (`session_meta.leaf_id`, set transactionally on every
      *  persist). A single SELECT, NO acquire/lock/CAS — safe to call mid-run (write-safety is the append-time CAS, not

package/dist/plugins/tidb-session-store.js

@@ -89,6 +89,9 @@ export class TiDBSessionStore {
             return undefined;
         return sessionFaceFromRow(sessionId, rows[0].owner ?? null, rows[0].incarnation);
     }
+    async incarnationOf(sessionId) {
+        return (await this.sessionFaceOf(sessionId))?.incarnation;
+    }
     async touch(sessionId) {
         await this.pool.query("UPDATE session_meta SET updated_at = ? WHERE session_id = ?", [
             new Date(),
@@ -486,13 +489,14 @@ class TiDBStagingHandle {
             const now = new Date();
             await conn.query("INSERT INTO session_meta (session_id, owner, created_at, updated_at, leaf_id, leaf_seq, incarnation) VALUES (?,?,?,?,?,?,?) " +
                 "ON DUPLICATE KEY UPDATE owner = VALUES(owner), updated_at = VALUES(updated_at), leaf_id = VALUES(leaf_id), leaf_seq = VALUES(leaf_seq)", [this.realSessionId, owner, now, now, leafId, srcIds.length, mintSessionIncarnation()]);
-            const [afterMeta] = await conn.query("SELECT placement_kind FROM session_meta WHERE session_id = ?", [this.realSessionId]);
+            const [afterMeta] = await conn.query("SELECT placement_kind, owner, incarnation FROM session_meta WHERE session_id = ?", [this.realSessionId]);
             if (afterMeta[0]?.placement_kind != null) {
                 await conn.rollback();
                 throw new SessionError("placement_refused", `session ${this.realSessionId} belongs to the ${String(afterMeta[0].placement_kind)} placement partition — a session-sync staged commit cannot overwrite a delegation transcript`);
             }
+            const face = sessionFaceFromRow(this.realSessionId, afterMeta[0]?.owner ?? null, afterMeta[0]?.incarnation);
             await conn.commit();
-            return { relation: rel.relation };
+            return { relation: rel.relation, face };
         }
         catch (err) {
             try {

package/dist/request-key-closure.d.ts

@@ -19,6 +19,17 @@ export declare function scanKeyClosure(bag: object, prefix: string, accepted: Re
 }): void;
 /** 一张分类表的文案片段(封顶后只报数)。 */
 export declare function keyClosureClause(names: string[], label: string): string;
+/**
+ * **场景透传键** —— 它们不属于共享提交面,各属一个场景,由 `capabilities/scenarios.ts` 经
+ * `ScenarioRequest` 的索引签名读(亲读那里的 `req.<key>`:除去已在 `TaskRequestBody` 上的 `objective` / `scenario`,
+ * 余下只有 `repo` 一个 —— 只喂 discuss 场景与 code-review council 腿的五键随那两条腿删除)。`TaskRequestBody` **刻意不声明**它们(那个类型的
+ * 头注逐字成文:场景键属于某一个场景,不属于共享提交面),所以它们只能在这里成文 —— 一个漏登记的场景键
+ * 会被本门 400 掉,而那正是「场景收不到它、调用方却拿到 200」的反面:响亮,不静默。
+ * 🔴 新场景要读一个新的体键 ⇒ 同批加进本行(加消费点而不加这行 = 那个场景在 wire 上不可用)。
+ */
+declare const TASK_BODY_SCENARIO_KEYS: readonly ["repo"];
+/** 场景透传键的型(wire 变更清单的自铸登记表 `trace/self-minted-wire.ts` 的 `scenarioBodyKey` 按它 `satisfies`)。 */
+export type ScenarioBodyKey = (typeof TASK_BODY_SCENARIO_KEYS)[number];
 /** 剥掉索引签名,只留**具名**键 —— `TaskRequestBody` 上那条 `[k: string]: unknown` 会让
  *  `keyof` 退化成 `string`,双向门就永远恒真(零判别力)。
  *  🔴 **导出**(S-405):姊妹门 `request-value-closure.ts` 的双向钉要同一个剥法 —— 抄第二份 = 两处哪天
@@ -26,12 +37,26 @@ export declare function keyClosureClause(names: string[], label: string): string
 export type NamedKeysOf<T> = {
     [K in keyof T as string extends K ? never : number extends K ? never : K]: T[K];
 };
-/**
- * FRESH 提交面的**顶层**键闭集裁决:受理集之外的键 ⇒ 返回拒体(调用方 400 `request.body_shape`);
- * 全部受理 ⇒ `null`。
- *
- * 判据边界(与 settings 那只同源,有意窄):只判**键名**;体本身非对象 ⇒ 本门不判(留给既有的
- * 「missing 'objective' string」那道门,免得同一个体被两句话抢答)。
- */
+/** FRESH 提交面(`POST /v1/tasks` · `/v1/tasks/stream` · `/v1/runs`)的顶层键裁决。 */
 export declare function taskBodyKeyIssue(raw: unknown): KeyClosureIssue | null;
+declare const RUN_STEER_BODY_KEYS: readonly ["mode", "priority", "text"];
+declare const CONTENT_STEER_BODY_KEYS: readonly ["content"];
+declare const INTERRUPT_STEER_BODY_KEYS: readonly ["text"];
+/** `POST /v1/runs/:id/steer` 的体形(键 = 受理集,值形由路由逐键判)。 */
+export type RunSteerBody = {
+    readonly [K in (typeof RUN_STEER_BODY_KEYS)[number]]?: unknown;
+};
+/** 子代 steer / resume 与 workflow 子代 steer 的体形。 */
+export type ContentSteerBody = {
+    readonly [K in (typeof CONTENT_STEER_BODY_KEYS)[number]]?: unknown;
+};
+/** `POST /v1/runs/:id/interrupt` 带 text 形的体形。 */
+export type InterruptSteerBody = {
+    readonly [K in (typeof INTERRUPT_STEER_BODY_KEYS)[number]]?: unknown;
+};
+/** 送话口的三种体形(闭集;词外是编译错)。 */
+export type SteerBodyForm = "run" | "content" | "interrupt";
+/** 送话口的顶层键裁决(四扇门同一只;`form` 选受理集)。 */
+export declare function steerBodyKeyIssue(raw: unknown, form: SteerBodyForm): KeyClosureIssue | null;
+export {};
 //# sourceMappingURL=request-key-closure.d.ts.map

package/dist/request-key-closure.js

@@ -18,9 +18,9 @@ export function keyClosureClause(names, label) {
     return `${label}: ${shown.join(", ")}${more > 0 ? ` (+${more} more)` : ""}`;
 }
 const TASK_BODY_DECLARED_KEYS = [
-    "a2aPeers", "acceptPartialRestore", "additionalDirectories", "additionalReadDirectories", "agents",
+    "a2aPeers", "acceptPartialRestore", "additionalDirectories", "additionalReadDirectories", "agents", "allowTools",
     "appendSystemPrompt", "approvalReach", "attachmentIds", "attachments", "capabilitiesNeeded", "cascade", "clientContext",
-    "compaction", "compactionModel", "council", "cwd", "debate", "deferTools", "deviceId", "disableSkills", "enableFork",
+    "compaction", "compactionModel", "cwd", "deferTools", "deviceId", "disableSkills", "enableFork",
     "excludeAllTools", "excludeTools", "fileHistory",
     "finalVerification", "forwardSubagentEvents", "images", "inheritEnv", "interactiveTools", "jobId", "limits", "maxCostUsd",
     "maxTokens", "mcpServers", "memory", "memoryCapture", "memoryWrite", "model", "objective", "oneShot", "outputRetries", "outputStyle",
@@ -30,28 +30,44 @@ const TASK_BODY_DECLARED_KEYS = [
     "sessionId", "settings", "skills", "suggestNextPrompts", "systemPrompt", "taskId", "toolMaterializeStrategy",
     "userInvokedSkills", "verify", "verifyRounds",
 ];
-const TASK_BODY_SCENARIO_KEYS = ["businessContext", "lenses", "repo", "rounds", "team"];
+const TASK_BODY_SCENARIO_KEYS = ["repo"];
 const ACCEPTED_BODY = new Set([...TASK_BODY_DECLARED_KEYS, ...TASK_BODY_SCENARIO_KEYS]);
-const UNSUPPORTED_BODY = new Set(["handsReadOnly", "readDenyPatterns", "readFace", "shellGate", "writeFace"]);
-export function taskBodyKeyIssue(raw) {
+const UNSUPPORTED_BODY_KEYS = ["handsReadOnly", "readDenyPatterns", "readFace", "shellGate", "userAttachments", "writeFace"];
+const UNSUPPORTED_BODY = new Set(UNSUPPORTED_BODY_KEYS);
+const UNSUPPORTED_LABEL = "unsupported (an engine seat this service does not read from the request body — set by the deployment, or not offered in this version)";
+function closedBodyKeyIssue(raw, accepted, door) {
     if (raw === null || raw === undefined || typeof raw !== "object" || Array.isArray(raw))
         return null;
     const buckets = { unknown: [], unsupported: [] };
-    scanKeyClosure(raw, "", ACCEPTED_BODY, UNSUPPORTED_BODY, buckets);
+    scanKeyClosure(raw, "", accepted, UNSUPPORTED_BODY, buckets);
     if (buckets.unknown.length === 0 && buckets.unsupported.length === 0)
         return null;
     buckets.unknown.sort();
     buckets.unsupported.sort();
     const parts = [
-        ...(buckets.unknown.length > 0 ? [keyClosureClause(buckets.unknown, "unknown (not a task-request key — check the spelling)")] : []),
-        ...(buckets.unsupported.length > 0 ? [keyClosureClause(buckets.unsupported, "unsupported (an engine seat this service derives, never reads from the body)")] : []),
+        ...(buckets.unknown.length > 0 ? [keyClosureClause(buckets.unknown, `unknown (not ${door} key — check the spelling)`)] : []),
+        ...(buckets.unsupported.length > 0 ? [keyClosureClause(buckets.unsupported, UNSUPPORTED_LABEL)] : []),
     ];
     return {
         message: `body: unrecognized top-level key(s) — refused rather than dropped, because a dropped key reads as "in effect" to the caller. ` +
             `${parts.join("; ")}. ` +
-            `Accepted: ${[...ACCEPTED_BODY].sort().join(",")}`,
+            `Accepted: ${[...accepted].sort().join(",")}`,
         unknownKeys: buckets.unknown.slice(0, MAX_KEY_ECHO),
         unsupportedKeys: buckets.unsupported.slice(0, MAX_KEY_ECHO),
     };
 }
+export function taskBodyKeyIssue(raw) {
+    return closedBodyKeyIssue(raw, ACCEPTED_BODY, "a task-request");
+}
+const RUN_STEER_BODY_KEYS = ["mode", "priority", "text"];
+const CONTENT_STEER_BODY_KEYS = ["content"];
+const INTERRUPT_STEER_BODY_KEYS = ["text"];
+const STEER_DOORS = {
+    run: { accepted: new Set(RUN_STEER_BODY_KEYS), door: "a steer-request" },
+    content: { accepted: new Set(CONTENT_STEER_BODY_KEYS), door: "a steer-request" },
+    interrupt: { accepted: new Set(INTERRUPT_STEER_BODY_KEYS), door: "an interrupt-request" },
+};
+export function steerBodyKeyIssue(raw, form) {
+    return closedBodyKeyIssue(raw, STEER_DOORS[form].accepted, STEER_DOORS[form].door);
+}
 //# sourceMappingURL=request-key-closure.js.map

package/dist/router/route-orchestration.d.ts

@@ -1,12 +1,9 @@
 import { type Autonomy } from "../runtime-governance.js";
 import type { GovernanceOverrides } from "../governance-overrides.js";
-export type OrchestrationMode = "single" | "supervisor" | "team";
+export type OrchestrationMode = "single" | "supervisor";
 /** The DETERMINISTIC signals the routing decision reads (extracted by {@link deriveRoutingSignals} from the
  *  task's resolved config — no task-content LLM judgement). */
 export interface RoutingSignals {
-    /** The caller explicitly chose an orchestration (a `council`/`debate`/`team` request). Honored verbatim —
-     *  a deliberate choice outranks automatic routing (back-compat + operator intent). */
-    explicitMode?: OrchestrationMode;
     /** (a) The task can cause harm its sandbox does NOT contain ⇒ route to SUP prevention. */
     dangerousCapability: boolean;
     /** (b) The task delegates / fans out / is long-horizon ⇒ supervisor goal-keeping + ask-aggregation. */
@@ -14,19 +11,16 @@ export interface RoutingSignals {
 }
 export interface RoutingDecision {
     mode: OrchestrationMode;
-    /** A short, audit-friendly machine reason (e.g. `explicit:team` / `danger:prevention-gate` / `default:single`).
+    /** A short, audit-friendly machine reason (e.g. `danger:prevention-gate` / `default:single`).
      *  Emitted on the trace so a routing decision is always explainable (never a silent mode flip). */
     reason: string;
 }
 /**
- * The routing decision (pure). Order matters: explicit caller choice first, then (a) danger, then (b) structural,
- * else the single default. `team` is NEVER produced here — it only ever appears via {@link RoutingSignals.explicitMode}.
+ * The routing decision (pure). Order matters: (a) danger first, then (b) structural, else the single default.
  */
 export declare function routeOrchestration(s: RoutingSignals): RoutingDecision;
 /** The task facts {@link deriveRoutingSignals} reads — all DETERMINISTIC, resolved before the task runs. */
 export interface RoutingContext {
-    /** Caller-explicit orchestration (council/debate/team) — undefined ⇒ the router decides. */
-    explicitMode?: OrchestrationMode;
     /** The resolved autonomy for this task — `read-only` hands cannot mutate/egress ⇒ no danger escalation. */
     autonomy?: Autonomy;
     /** The mounted tools can WRITE the project or run a shell (edit_file / write_file / bash). */
@@ -68,8 +62,6 @@ export declare function routeServiceTask(input: {
     hasExecutionEnv: boolean;
     /** The resolved autonomy for the task. */
     autonomy?: Autonomy;
-    /** The caller explicitly requested a fan-out (council/debate/team). */
-    explicitTeam: boolean;
 }): RoutingDecision;
 /**
  * Resolve whether a task's execution env STRONGLY isolates side effects (a VM/kernel boundary the sandbox tears

package/dist/router/route-orchestration.js

@@ -3,8 +3,6 @@ import { autonomyOverrides } from "../runtime-governance.js";
 import { operatorAlwaysHumanAsk } from "../operator-ask.js";
 import { heldRuleName } from "../tool-rule-names.js";
 export function routeOrchestration(s) {
-    if (s.explicitMode)
-        return { mode: s.explicitMode, reason: `explicit:${s.explicitMode}` };
     if (s.dangerousCapability)
         return { mode: "supervisor", reason: "danger:prevention-gate" };
     if (s.needsGoalKeeping)
@@ -15,7 +13,6 @@ export function deriveRoutingSignals(ctx) {
     const readOnly = ctx.autonomy === "read-only";
     const dangerousCapability = !readOnly && (ctx.canEgress || (ctx.canWriteOrExec && !ctx.isolatedExecEnv));
     return {
-        ...(ctx.explicitMode ? { explicitMode: ctx.explicitMode } : {}),
         dangerousCapability,
         needsGoalKeeping: ctx.delegatedOrLongHorizon,
     };
@@ -23,7 +20,6 @@ export function deriveRoutingSignals(ctx) {
 export function routeServiceTask(input) {
     const readOnlyHands = autonomyOverrides(input.autonomy).handsReadOnly === true;
     return routeOrchestration(deriveRoutingSignals({
-        ...(input.explicitTeam ? { explicitMode: "team" } : {}),
         ...(input.autonomy ? { autonomy: input.autonomy } : {}),
         canWriteOrExec: input.hasExecutionEnv && !readOnlyHands,
         canEgress: false,

package/dist/rule-entry-list.js

@@ -27,10 +27,6 @@ export function inertRuleEntryGuidance(i) {
             return "`*` names no tool (on an allow list it voids the whole list) — name the tools instead";
         case "namespace_wildcard":
             return "a server segment does not take a wildcard (`mcp__*`) — name the server: mcp__<server> or mcp__<server>__*";
-        case "path_pattern":
-            return "a write-path or file-pattern entry has no reading on this side — name the tool, or use Read(//<dir>/**) for a directory a Read may cover";
-        case "domain":
-            return "a domain entry has no reading on this side — name the tool";
         case "content_unsupported":
             return "this tool takes no content form here — name the tool itself, or use Bash(<command>) / Bash(<prefix>:*) for a shell command";
         case "grammar":

package/dist/rules-consent.js

@@ -96,6 +96,9 @@ function isSupportedRuleMatch(match) {
         case "name":
         case "name_prefix":
             return false;
+        case "host":
+        case "subdomain":
+            return false;
         default: {
             const unknown = match;
             void unknown;

package/dist/run-acceptance.d.ts

@@ -0,0 +1,51 @@
+/**
+ * **一次提交的「受理」读法** —— 标题器只在引擎**受理**这条 run 之后起(一条律,唯一属主 = 本文件)。
+ *
+ * ## 受理是哪一刻
+ * 引擎把这次提交的 objective 收进会话的那一帧:`human_input{ carrier: "objective", delivery: "applied" }`。它是第一次模型调用
+ * 之前的最后一帧;在它之前引擎能拒的一切 —— prepare 门(`config.tool_face_control` / `config.user_invoked_skill_unknown` /
+ * `config.memory_capture_unsupported` …)、第一回合前的内联图片准入(`config.image_invalid`)、部署的 UserPromptSubmit 拦截、
+ * 开跑前的预算 / 墙钟 —— 都还没让这次输入进会话。`wiring_manifest` 不是受理:它在 prepare 通过时就出了,图片准入与提示拦截
+ * 都在它之后(core `run-identity-wiring.js` 推 wiring_manifest,`run-leg.js` 才做图片准入、推 human_input、调模型)。
+ *
+ * 只回结果、不交流的腿(verify / cascade:core 在自己里面排空每条腿的流,宿主手里没有流)看不到那一帧。它们的受理证据是结果本身:
+ * 结果里跑过 turn(`stats.turns > 0`)⇒ objective 进过会话、模型答过。**token 不是证据**:被 UserPromptSubmit 拦下的 objective 不进会话,
+ * 而同一条 run 的收尾压缩可以在已有历史的会话上花 token(turns 0、tokens > 0)—— 按 token 判会把被拦下的输入送去起名。
+ * 两种证据说的是同一件事,本文件把它们收成一只闩:先到的那一个算数,只算一次。
+ *
+ * ## 受理之后 / 之前
+ *  · 受理 ⇒ 标题器起一次(会话没有标题时它才真去生成;判据在标题器里,本文件不重复)。
+ *  · 没受理就收场(零工作的拒、受理前取消 / 拦截)⇒ 标题器不起:被拒的输入不花一次模型调用,也不被送去起名。
+ *    这次提交在提交门铸下的会话行照旧留下(无标题、零消息),与此前同 —— 「提交没让引擎受理就收场」的会话去留是另一件事,不在本文件。
+ *
+ * ## 谁喂它
+ * 三条提交腿(同步 / 流式 / durable)各在两处喂同一只:持流的那一形把每一帧交给 {@link RunAcceptance.observe};终局落行之后调一次
+ * {@link RunAcceptance.settle}。腿上不再有「什么时候起标题」的判断,标题器的唯一调用点是本文件的闩。座由提交门在 `prepareSpec` 里
+ * 随 spec 一起铸(`PreparedTaskSubmission.acceptance`);不经提交门的内部车道铸一只不带标题器的座,也就不起标题。
+ */
+export interface RunAcceptanceDeps {
+    /** 标题器(缺席 = 本部署不自动起名)。 */
+    sessionTitler?: {
+        maybeTitle(sessionId: string, objective: string, model?: string): void;
+    };
+}
+export interface RunAcceptanceInput {
+    sessionId?: string;
+    objective: string;
+    /** 本 turn 真实驱动的模型 id(标题器与 turn 同链路)。 */
+    model?: string;
+}
+export interface RunAcceptance {
+    /** 持流的腿逐帧调用(判哪一帧算受理只在这里)。不抛、不等。 */
+    observe(ev: {
+        type: string;
+    }): void;
+    /** 终局落行之后:还没在流上见过受理帧、而结果里跑过 turn(只回结果的腿)⇒ 受理。只读 `stats.turns`。不抛、不等。 */
+    settle(result: {
+        readonly stats: {
+            readonly turns: number;
+        };
+    }): void;
+}
+export declare function createRunAcceptance(deps: RunAcceptanceDeps, input: RunAcceptanceInput): RunAcceptance;
+//# sourceMappingURL=run-acceptance.d.ts.map

package/dist/run-acceptance.js

@@ -0,0 +1,27 @@
+function isObjectiveApplied(ev) {
+    if (ev.type !== "human_input")
+        return false;
+    const h = ev;
+    return h.carrier === "objective" && h.delivery === "applied";
+}
+export function createRunAcceptance(deps, input) {
+    let accepted = false;
+    const accept = () => {
+        if (accepted)
+            return;
+        accepted = true;
+        if (input.sessionId)
+            deps.sessionTitler?.maybeTitle(input.sessionId, input.objective, input.model);
+    };
+    return {
+        observe(ev) {
+            if (!accepted && isObjectiveApplied(ev))
+                accept();
+        },
+        settle(result) {
+            if (result.stats.turns > 0)
+                accept();
+        },
+    };
+}
+//# sourceMappingURL=run-acceptance.js.map

package/dist/run-local.d.ts

@@ -14,8 +14,9 @@ export interface RunLocalArgs {
     json: boolean;
     /** `--scenario <name>` — pick a capability bundle (default: config.defaultScenario). */
     scenario?: string;
-    /** `--session <id>` — REUSE a session across invocations (durable multi-turn). Default: a fresh id (the
-     *  session + its events still persist to disk, just not continued). */
+    /** `--session <uuid>` — REUSE a session across invocations (durable multi-turn). Only a canonical uuid (any version) is
+     *  accepted — the same one shape law as the HTTP submit door (`sessionIdShapeIssue`). Default: a fresh id (the session +
+     *  its events still persist to disk, just not continued). */
     session?: string;
     /** `--workspace <dir>` — the FIXED dir the agent's tool calls operate in (CC-like). Default: the cwd. The
      *  agent's file edits PERSIST there (never deleted) — this is the user's own directory, not a sandbox. */
@@ -96,8 +97,8 @@ export interface LocalGovernanceConfigView extends DeploymentGovernanceConfigVie
  *   test/run-local.test.ts(该钉已由 🟡 特征化翻成 🔴 正控)。
  * · **禁 memoize**:四个旋钮都是热改字段,每次装配现读活 config(与另两条腿同一姿势)。
  */
-/** @param engineDataRoot 本腿已铸的引擎记忆根(`memoryEngineBackendFor(config, root)?.root`,S-133 单一写者);`undefined` = 引擎未接。 */
-export declare function applyLocalGovernance(base: TaskSpec, config: LocalGovernanceConfigView, workspaceDir: string, engineDataRoot: string | undefined): TaskSpec;
+/** 豁免根(引擎数据根)不在这里:core 7.49.0 [ref] 起只从 `RunnerDeps.memoryEngineDir` 来(本腿 Runner 装配处,记忆引擎开不开都给)。 */
+export declare function applyLocalGovernance(base: TaskSpec, config: LocalGovernanceConfigView, workspaceDir: string): TaskSpec;
 /** {@link createLocalApprover} 的 io 面(全部可注入,所以两条臂都测得动)。 */
 export interface LocalApproverIo {
     /** 这次调用是不是接在一个人面前(生产里 = `process.stdin.isTTY`)。 */

package/dist/run-local.js

@@ -38,10 +38,10 @@ import { createRepoClient } from "./capabilities/repo-tools.js";
 import { webSearchConfigFromEnv, createWebSearchBackend } from "./plugins/web-search.js";
 import { buildScenarios, gateScenarioRequest, selectScenario, centerScenarios } from "./capabilities/scenarios.js";
 import { createTaskListLane } from "./boot/task-list-lane.js";
-import { pickHandsRunner, withoutExecutionEnv } from "./capabilities/hands-lane.js";
-import { HttpError } from "./security.js";
+import { pickHandsRunner, withoutHands } from "./capabilities/hands-lane.js";
+import { HttpError, sessionIdShapeIssue } from "./security.js";
 import { createMemoryEngineIncidentSink } from "./memory-incident-sink.js";
-import { memoryEngineBackendFor, memoryProjectKeyFor, memorySpecForRequest } from "./memory-scope.js";
+import { fileMemoryEngineRoot, memoryEngineBackendFor, memoryProjectKeyFor, memorySpecForRequest } from "./memory-scope.js";
 import { modelRouteEndpointRefusal } from "./model-route-endpoint.js";
 import { createMemorySyncRunner, createMemorySyncTransport } from "./memory-sync-client.js";
 import { buildPricing, cappedCeiling, createTracer } from "./budget.js";
@@ -68,9 +68,9 @@ export function parseArgs(argv) {
     let workspace;
     let user;
     let json = false;
-    const valueFlag = (i, name) => {
+    const valueFlag = (i, name, opts = {}) => {
         const v = argv[i];
-        if (v === undefined || v.trim() === "" || v.startsWith("--"))
+        if (v === undefined || (opts.blankIsValue !== true && v.trim() === "") || v.startsWith("--"))
             throw new UsageError(`${name} needs an argument`);
         return v;
     };
@@ -82,14 +82,18 @@ export function parseArgs(argv) {
             root = valueFlag(++i, "--root");
         else if (a === "--scenario")
             scenario = valueFlag(++i, "--scenario");
-        else if (a === "--session")
-            session = valueFlag(++i, "--session");
+        else if (a === "--session") {
+            session = valueFlag(++i, "--session", { blankIsValue: true });
+            const issue = sessionIdShapeIssue(session);
+            if (issue)
+                throw new UsageError(issue);
+        }
         else if (a === "--workspace")
             workspace = valueFlag(++i, "--workspace");
         else if (a === "--user")
             user = valueFlag(++i, "--user");
         else if (a === "--help" || a === "-h") {
-            throw new UsageError('usage: run-local "<objective>" [--root <dir>] [--json] [--scenario <name>] [--session <id>] [--workspace <dir>] [--user <id>]');
+            throw new UsageError('usage: run-local "<objective>" [--root <dir>] [--json] [--scenario <name>] [--session <uuid>] [--workspace <dir>] [--user <id>]');
         }
         else if (a.startsWith("--")) {
             throw new UsageError(`unknown flag: ${a}`);
@@ -133,8 +137,8 @@ export function missingGatewayRequirements(config) {
     return missing;
 }
 const RUN_LOCAL_APPROVAL_SEAT = { kind: "live" };
-export function applyLocalGovernance(base, config, workspaceDir, engineDataRoot) {
-    return applyRuntimeGovernance({ ...base, toolPolicy: createApprovalBaselinePolicy(config, RUN_LOCAL_APPROVAL_SEAT) }, createDeploymentGovernanceInputs(config, { env: new NodeExecutionEnv({ cwd: workspaceDir }), cwd: workspaceDir }, { engineDataRoot }));
+export function applyLocalGovernance(base, config, workspaceDir) {
+    return applyRuntimeGovernance({ ...base, toolPolicy: createApprovalBaselinePolicy(config, RUN_LOCAL_APPROVAL_SEAT) }, createDeploymentGovernanceInputs(config, { env: new NodeExecutionEnv({ cwd: workspaceDir }), cwd: workspaceDir }));
 }
 const NO_TTY_REFUSAL_REASON = "this run-local invocation has no TTY, so there is no one to put this approval to; it is refused fail-closed instead of being asked.";
 const UNDISPLAYABLE_ARGS_REFUSAL_REASON = "the call's arguments cannot be displayed, so there is nothing a person could review; it is refused fail-closed instead of being asked.";
@@ -145,6 +149,7 @@ export const NO_TTY_ASK_CLASS_ROW = {
     ancestor: { remedy: "terminal_only", autoBudgetReleases: false },
     dangerous_delete: { remedy: "terminal_only", autoBudgetReleases: false },
     unverifiable_delete: { remedy: "terminal_only", autoBudgetReleases: false },
+    unverifiable_shell_text: { remedy: "terminal_only", autoBudgetReleases: false },
     transcript_write: { remedy: "terminal_only", autoBudgetReleases: false },
     org_rule: { remedy: "terminal_only", autoBudgetReleases: false },
     governance_unavailable: { remedy: "terminal_only", autoBudgetReleases: false },
@@ -154,7 +159,7 @@ export const NO_TTY_ASK_CLASS_ROW = {
     classifier_no_ruling: { remedy: "terminal_only", autoBudgetReleases: false },
     operator_forced: { remedy: "deployment_mandate", autoBudgetReleases: false },
     shell_floor: { remedy: "shell_gate", autoBudgetReleases: false },
-    write_protection_unresolved: { remedy: "terminal_only", autoBudgetReleases: false },
+    target_unresolved: { remedy: "terminal_only", autoBudgetReleases: false },
     probe: { remedy: "terminal_only", autoBudgetReleases: false },
     write_protection: { remedy: "terminal_only", autoBudgetReleases: false },
     tool_marks_mcp: { remedy: "terminal_only", autoBudgetReleases: false },
@@ -441,6 +446,7 @@ export async function runLocal(argv, deps = {}) {
         : undefined;
     const lspManager = hostRx && config.lspHostEnabled && config.requirePrincipal !== true ? createHostLspManager(config, (event, fields) => logger.info(event, fields)) : undefined;
     const memoryEngine = memoryEngineBackendFor(config, root, memoryEngineIncident);
+    const engineDataRoot = fileMemoryEngineRoot(config, root);
     try {
         judgeConsolidationValve({ config, memoryEngine });
     }
@@ -547,6 +553,7 @@ export async function runLocal(argv, deps = {}) {
     const sharedRunnerDeps = createSharedRunnerDeps({
         metrics,
         config,
+        engineDataRoot,
         governanceSeams,
         logger,
         hands: { commitCoAuthor: "Sema <noreply@vivi-ai.com>" },
@@ -574,7 +581,7 @@ export async function runLocal(argv, deps = {}) {
     const runnerDeps = {
         ...sharedRunnerDeps,
         sessionStore,
-        ...(memoryEngine ? { memoryBackend: memoryEngine.backend, memoryEngineDir: memoryEngine.root } : {}),
+        ...(memoryEngine ? { memoryBackend: memoryEngine.backend } : {}),
         onError: engineOnError,
         onAsk,
         ...(config.projectMemoryEnabled
@@ -587,15 +594,14 @@ export async function runLocal(argv, deps = {}) {
     const runner = new Runner(runnerDeps);
     const subRunnerDeps = { ...sharedRunnerDeps, sessionStore: new ForkRoutingSessionStore(sessionStore, new TtlSessionStore({ defaultTtlDays: 1 / 24 })), onError: engineOnError, onAsk };
     const subRunner = new Runner(subRunnerDeps);
-    const handslessRunner = new Runner(withoutExecutionEnv(runnerDeps));
-    const handslessSubRunner = new Runner(withoutExecutionEnv(subRunnerDeps));
+    const handslessRunner = new Runner(withoutHands(runnerDeps));
     const skills = loadDeploymentSkills(config);
     const repoClient = config.gitApiBaseUrl ? createRepoClient(config.gitApiKind, config.gitApiBaseUrl, config.gitApiToken) : undefined;
     const webSearchCfg = webSearchConfigFromEnv();
     const webSearch = webSearchCfg ? createWebSearchBackend(webSearchCfg) : undefined;
     const taskListLane = createTaskListLane({ logger });
     const scenarioDeps = {
-        runner, subRunner, handslessSubRunner, model: DEFAULT_MODEL_REF, skills, repoClient, metrics, logger,
+        runner, subRunner, model: DEFAULT_MODEL_REF, skills, repoClient, logger,
         ...(webSearch ? { webSearch } : {}),
         backgroundAgentStore: fileBackend.backgroundAgentStore,
         taskListStoreFor: taskListLane.storeFor,
@@ -634,7 +640,7 @@ export async function runLocal(argv, deps = {}) {
     }
     const scope = args.user ?? "local";
     const taskTimeoutSec = Math.floor(parseNumOrFailNonNegative("TASK_TIMEOUT_SEC", process.env.TASK_TIMEOUT_SEC || "0"));
-    const timeoutSec = taskWallClockSec(taskTimeoutSec, false, scenarioName === "discuss");
+    const timeoutSec = taskWallClockSec(taskTimeoutSec, false);
     const mcp = mcpForScenario(config.mcpServers, scenarioName);
     const a2a = a2aForScenario(config.a2aPeers, scenarioName);
     const maxCostUsd = cappedCeiling(undefined, config.maxTaskCostUsd);
@@ -662,7 +668,7 @@ export async function runLocal(argv, deps = {}) {
         ...(mcp ? { mcp } : {}),
         ...(a2a ? { a2a } : {}),
         ...(Object.keys(limits).length > 0 ? { limits } : {}),
-    }, config, workspaceDir, memoryEngine?.root), onAsk);
+    }, config, workspaceDir), onAsk);
     logger.info("run_local_start", { scenario: scenarioName, model: spec.model, sessionId, exec: executionLaneOf(config.remoteExec?.provider) });
     const settleSessionBackground = async () => {
         const reaped = defaultTaskRegistry.reapSessionBackground(sessionId, scope);

package/dist/runs.d.ts

@@ -9,6 +9,7 @@ import type { QuestionCoordinator } from "./question.js";
 import { type ToolApprovalCoordinator } from "./tool-approval.js";
 import { type FleetRunPublisher } from "./fleet/fleet-bus.js";
 import { type WorkflowCompletionInbox } from "./orchestration/workflow-completion-inbox.js";
+import type { RunAcceptance } from "./run-acceptance.js";
 import type { VerifyRoundsSpec } from "./http/verify-rounds.js";
 import type { UserInputLedger } from "./user-input-ledger.js";
 /**
@@ -91,14 +92,6 @@ export declare function taskHandleStop(registry: typeof defaultTaskRegistry, han
  * 语义上这两种时序是同一件事:本请求赢下了这条 session,而这条 session 的连接是被人断掉的。
  */
 export declare function markChildrenStoppedByUserOnAbort(signal: AbortSignal, taskId: string, principal: string | null | undefined): void;
-/**
- * A session CAS conflict is swallowed by core into a failed `TaskResult` (it is not thrown from
- * `runTaskStream`), so detect it from the result. Prefer the structured `code` (core ≥1.8); fall
- * back to the conflict wording only for older results without one.
- */
-export declare function isSessionConflictResult(result: {
-    terminal: TerminalCause;
-}): boolean;
 export declare function resumeAtHttpStatus(result: {
     terminal: TerminalCause;
 }): number | undefined;
@@ -202,8 +195,6 @@ export declare function parkToolCallId(result: unknown, cs: ParkCheckpointReader
  *  不塞进 `checkpointGate`——那是 core 的类型,server 不改其形)。非 park / 无 token / tool-less /
  *  读失败 ⇒ **同一引用**原样返回(键缺席)。graft 不负责 strip——组合序恒为 graft → strip。 */
 export declare function graftParkToolCallId<T>(result: T, cs: ParkCheckpointReader | undefined): Promise<T>;
-/** Evict a stale warm-cache entry after a cross-instance write conflict (broken-affinity backstop). */
-export declare function evictIfConflict(runner: Runner, sessionId: string | undefined, result: TaskResult): void;
 /**
  * Drive a task to completion in the background, persisting its events to the durable run log (S2).
  *
@@ -328,7 +319,12 @@ trustedInternals?: Pick<RunInternals, "workflowParkedResume">,
  * 已收敛、未告知的崩溃丢失铸成 `task.user_steer_undrained` / `task.user_followup_undrained`(`cause:"crashed"`,码按受理时的车道选);腿收场时把本腿上的受理 settle 掉。
  * 缺席 ⇒ 两手都不做(与本参数存在之前逐字相同)。
  */
-userInputLedger?: UserInputLedger): Promise<void>;
+userInputLedger?: UserInputLedger, 
+/**
+ * 这次提交的受理座(`src/run-acceptance.ts`):标题器只在引擎受理之后起。普通流形逐帧喂;只回结果的 verify / cascade 形(以及终局写口的
+ * 重试腿)终局落行之后收尾一次。缺席 ⇒ 不起标题(起标题此前由路由层在建行时做)。
+ */
+acceptance?: RunAcceptance): Promise<void>;
 /** How often a running instance refreshes its run's updated_at (liveness, independent of events).
  *  Must stay strictly below `runStaleSec` (asserted at startup AND on every hot config candidate) or the
  *  reaper would race live runs. [ref]:数值的单源是 `config-invariants.ts`(那条不变量的属主),两个消费面