@sema-agent/server 7.47.0 → 7.48.0

package/dist/hooks/hook-runner.js

@@ -1,6 +1,8 @@
 import { spawn } from "node:child_process";
 import { hostShell, resolveHostShell } from "../plugins/host-platform.js";
 import { HooksConfig, DEFAULT_HOOK_TIMEOUT_SECONDS, HOOK_EVENT_OWNER, } from "@sema-agent/registry-core/hooks";
+import { boundedNoticeText } from "../fleet/fleet-bus.js";
+import { recordFailOpen } from "../observability/fail-open.js";
 import { redactSecrets } from "../trace/redact.js";
 import { ccPromptSystemFor, wrapCondition, parseCcVerdict, CC_EVALUATOR_MAX_OUTPUT_TOKENS } from "./cc-stop-prompt.js";
 import { ccAgentHookSystemFor } from "./cc-agent-hook-prompt.js";
@@ -144,6 +146,52 @@ const DEFAULT_AGENT_HOOK_TIMEOUT_SECONDS = 120;
 function clip(s, n) {
     return s.length > n ? `${s.slice(0, n)}…(${s.length})` : s;
 }
+function hookDisplayName(entry) {
+    if (typeof entry.statusMessage === "string" && entry.statusMessage.length > 0)
+        return entry.statusMessage;
+    switch (entry.type) {
+        case "command":
+            return entry.command;
+        case "http":
+            return entry.url.split(/[?#]/, 1)[0] ?? entry.url;
+        case "prompt":
+        case "agent":
+            return entry.prompt;
+    }
+}
+function toolNameOf(payload) {
+    const v = payload?.tool_name;
+    return typeof v === "string" ? v : undefined;
+}
+function eventOfPayload(payload) {
+    const v = payload?.hook_event_name;
+    return typeof v === "string" ? v : "";
+}
+function emitHookNotice(ctx, n) {
+    try {
+        ctx.onHookNotice?.(n);
+    }
+    catch (e) {
+        recordFailOpen("server.hooks.notice-sink-threw", `kind=${n.kind} event=${n.event}`);
+        ctx.logger.warn("hook_notice_sink_threw", { kind: n.kind, event: n.event, error: clip(String(e), 200) });
+    }
+}
+function noteHookFailure(ctx, args) {
+    if (!ctx.onHookNotice)
+        return;
+    const stderr = boundedNoticeText((args.stderr ?? "").trim());
+    emitHookNotice(ctx, {
+        kind: "hook_non_blocking_failure",
+        event: args.event,
+        reason: args.reason,
+        hookName: boundedNoticeText(hookDisplayName(args.entry)),
+        entryType: args.entry.type,
+        ...(typeof args.exitCode === "number" ? { exitCode: args.exitCode } : {}),
+        ...(args.toolName !== undefined ? { toolName: args.toolName } : {}),
+        ...(stderr.length > 0 ? { stderr } : {}),
+        ...(args.detail !== undefined ? { detail: boundedNoticeText(args.detail) } : {}),
+    });
+}
 export function buildHookContext(parts) {
     const present = parts.filter((p) => p.length > 0).map(readHookContextPart);
     if (present.length === 0)
@@ -276,7 +324,9 @@ function fireAsyncCommandHook(entry, payload, ctx, event) {
             stdio: ["pipe", "ignore", rewake ? "pipe" : "ignore"],
             detached: true,
         });
+        let killedByTimeout = false;
         const timer = setTimeout(() => {
+            killedByTimeout = true;
             try {
                 if (child.pid)
                     process.kill(-child.pid, "SIGKILL");
@@ -296,9 +346,14 @@ function fireAsyncCommandHook(entry, payload, ctx, event) {
             });
             child.stderr?.unref?.();
         }
-        child.on("error", () => clearTimeout(timer));
+        child.on("error", (e) => {
+            clearTimeout(timer);
+            ctx.logger.warn("hook_async_failed", { event, reason: "spawn_failed", error: clip(String(e), 300) });
+            noteHookFailure(ctx, { event, entry, reason: "spawn_failed", stderr: String(e), toolName: toolNameOf(payload) });
+        });
         child.on("close", (code) => {
             clearTimeout(timer);
+            noteAsyncOutcome(entry, ctx, event, payload, { code, rewake, killedByTimeout });
             if (!rewake || code !== 2)
                 return;
             const text = stderr.trim();
@@ -321,9 +376,32 @@ function fireAsyncCommandHook(entry, payload, ctx, event) {
         child.stdin?.end(`${JSON.stringify(boundedToolInputPayload(payload))}\n`);
         child.unref();
     }
-    catch {
+    catch (e) {
+        ctx.logger.warn("hook_async_failed", { event, reason: "spawn_failed", error: clip(String(e), 300) });
+        noteHookFailure(ctx, { event, entry, reason: "spawn_failed", stderr: String(e), toolName: toolNameOf(payload) });
     }
 }
+function noteAsyncOutcome(entry, ctx, event, payload, outcome) {
+    const { code, rewake, killedByTimeout } = outcome;
+    if (killedByTimeout) {
+        ctx.logger.warn("hook_async_failed", { event, reason: "timeout", timeoutSec: Math.min(entry.timeout ?? DEFAULT_HOOK_TIMEOUT_SECONDS, MAX_HOOK_TIMEOUT_SECONDS) });
+        noteHookFailure(ctx, { event, entry, reason: "timeout", toolName: toolNameOf(payload) });
+        return;
+    }
+    if (code === 0 || code === null)
+        return;
+    if (rewake && code === 2)
+        return;
+    ctx.logger.warn("hook_async_failed", { event, reason: "exit_nonzero", code });
+    noteHookFailure(ctx, {
+        event,
+        entry,
+        reason: "exit_nonzero",
+        exitCode: code,
+        toolName: toolNameOf(payload),
+        ...(code === 2 ? { detail: "exit 2 on a fire-and-forget async hook: there is no blocking or wake face to honor it (asyncRewake would wake the model)" } : {}),
+    });
+}
 async function runLlmHook(entry, payload, ctx, extra) {
     const call = entry.type === "prompt" ? ctx.hookLlm : ctx.hookAgent;
     if (!call)
@@ -349,17 +427,19 @@ async function runLlmHook(entry, payload, ctx, extra) {
             hardTop,
         ]).catch((e) => ({ ok: false, error: String(e) }));
         let res = await invoke();
+        let noticed = false;
         if (extra && !res.ok && res.code === "no_content") {
             ctx.logger.warn("hook_llm_no_content_retry", { event: extra.event });
             res = await invoke();
             if (!res.ok && res.code === "no_content") {
-                ctx.onHookNotice?.({ kind: "hook_decision_unavailable", event: extra.event, reason: "no_content", detail: "carrier returned no content (after one retry)" });
+                emitHookNotice(ctx, { kind: "hook_decision_unavailable", event: extra.event, reason: "no_content", detail: "carrier returned no content (after one retry)" });
+                noticed = true;
             }
         }
         if (!res.ok) {
             return res.code === "hard_timeout"
-                ? { code: null, stdout: "", stderr: "", timedOut: true }
-                : { code: null, stdout: "", stderr: "", timedOut: false, spawnError: clip(res.error, 500) };
+                ? { code: null, stdout: "", stderr: "", timedOut: true, ...(noticed ? { noticed } : {}) }
+                : { code: null, stdout: "", stderr: "", timedOut: false, spawnError: clip(res.error, 500), ...(noticed ? { noticed } : {}) };
         }
         return { code: 0, stdout: clip(res.text, 1024 * 1024), stderr: "", timedOut: false };
     }
@@ -416,6 +496,14 @@ async function runHttpHook(entry, payload, ctx) {
                 return { code: 0, stdout: "{}", stderr: "", timedOut: false };
             if (!parseHookStdout(body)) {
                 ctx.logger.warn("hook_http_non_json_response", { url: clip(entry.url, 300), preview: clip(trimmed, 200) });
+                noteHookFailure(ctx, {
+                    event: eventOfPayload(payload),
+                    entry,
+                    reason: "bad_json",
+                    exitCode: 0,
+                    stderr: trimmed,
+                    toolName: toolNameOf(payload),
+                });
                 return { code: 0, stdout: "", stderr: "", timedOut: false };
             }
             return { code: 0, stdout: body, stderr: "", timedOut: false };
@@ -452,6 +540,17 @@ function boundedToolInputPayload(payload) {
     const bounded = boundedInputValue(p.tool_input);
     return bounded === p.tool_input ? payload : { ...p, tool_input: bounded };
 }
+function readHookStdout(run, entry, event, ctx, payload) {
+    const out = parseHookStdout(run.stdout);
+    if (out !== undefined)
+        return out;
+    const t = run.stdout.trim();
+    if (t.startsWith("{") || t.startsWith("[")) {
+        ctx.logger.warn("hook_bad_json_output", { event, type: entry.type, preview: clip(t, 200) });
+        noteHookFailure(ctx, { event, entry, reason: "bad_json", exitCode: run.code, stderr: run.stderr, toolName: toolNameOf(payload) });
+    }
+    return undefined;
+}
 function parseHookStdout(stdout) {
     const t = stdout.trim();
     if (!t.startsWith("{"))
@@ -528,10 +627,14 @@ async function runMatchingEntries(event, groups, matchValue, payload, ctx, onceF
                     : await runCommandHook(entry, payload, ctx);
             if (run.spawnError) {
                 ctx.logger.warn(entry.type === "http" ? "hook_http_request_failed" : entry.type === "prompt" || entry.type === "agent" ? "hook_llm_failed" : "hook_command_spawn_failed", { event, type: entry.type, error: clip(run.spawnError, 300) });
+                if (!run.noticed)
+                    noteHookFailure(ctx, { event, entry, reason: "spawn_failed", exitCode: run.code, stderr: run.spawnError, toolName: toolNameOf(payload) });
                 continue;
             }
             if (run.timedOut) {
                 ctx.logger.warn("hook_command_timeout", { event, timeoutSec: Math.min(entry.timeout ?? DEFAULT_HOOK_TIMEOUT_SECONDS, MAX_HOOK_TIMEOUT_SECONDS) });
+                if (!run.noticed)
+                    noteHookFailure(ctx, { event, entry, reason: "timeout", exitCode: run.code, stderr: run.stderr, toolName: toolNameOf(payload) });
                 continue;
             }
             results.push({ entry, run });
@@ -552,12 +655,21 @@ function ignoreMatchers(groups) {
 }
 async function runObserveOnlyEvent(event, groups, matchValue, payload, ctx, onceFired) {
     const singles = await runMatchingEntries(event, groups, matchValue, payload, ctx, onceFired, Date.now() + MAX_HOOK_EVENT_TOTAL_SECONDS * 1000);
-    for (const { run } of singles) {
+    for (const { entry, run } of singles) {
         if (run.code !== 0) {
             ctx.logger.warn("hook_command_failed", { event, code: run.code, stderr: clip(run.stderr, 300) });
+            noteHookFailure(ctx, {
+                event,
+                entry,
+                reason: "exit_nonzero",
+                exitCode: run.code,
+                stderr: run.stderr,
+                toolName: toolNameOf(payload),
+                ...(run.code === 2 ? { detail: `exit 2 on ${event}: this event has no blocking face, so the hook's blocking intent could not be honored` } : {}),
+            });
             continue;
         }
-        const out = parseHookStdout(run.stdout);
+        const out = readHookStdout(run, entry, event, ctx, payload);
         if (!out)
             continue;
         if (typeof out.systemMessage === "string")
@@ -621,16 +733,17 @@ export function createTaskHooks(config, ctx) {
                     tool_use_id: tctx.toolCallId,
                 };
                 const singles = await runMatchingEntries("PreToolUse", [{ ...group, matcher: undefined }], toolName, payload, ctx, onceFired, deadlineAt, `PreToolUse:${gi}`);
-                for (const { run } of singles) {
+                for (const { entry, run } of singles) {
                     if (run.code === 2) {
                         const reason = clip(run.stderr.trim(), MAX_HOOK_FEEDBACK_CHARS) || "blocked by a PreToolUse hook";
                         return { action: "deny", message: reason, ...buildHookContextField(contexts) };
                     }
                     if (run.code !== 0) {
                         ctx.logger.warn("hook_command_failed", { event: "PreToolUse", code: run.code, stderr: clip(run.stderr, 300) });
+                        noteHookFailure(ctx, { event: "PreToolUse", entry, reason: "exit_nonzero", exitCode: run.code, stderr: run.stderr, toolName });
                         continue;
                     }
-                    const out = parseHookStdout(run.stdout);
+                    const out = readHookStdout(run, entry, "PreToolUse", ctx, payload);
                     if (!out)
                         continue;
                     if (typeof out.systemMessage === "string")
@@ -716,7 +829,7 @@ export function createTaskHooks(config, ctx) {
                 tool_use_id: tctx.toolCallId,
             };
             const singles = await runMatchingEntries("PostToolUse", post, toolName, payload, ctx, onceFired, Date.now() + MAX_HOOK_EVENT_TOTAL_SECONDS * 1000);
-            for (const { run } of singles) {
+            for (const { entry, run } of singles) {
                 if (run.code === 2) {
                     const fb = clip(run.stderr.trim(), MAX_HOOK_FEEDBACK_CHARS);
                     if (fb)
@@ -725,9 +838,10 @@ export function createTaskHooks(config, ctx) {
                 }
                 if (run.code !== 0) {
                     ctx.logger.warn("hook_command_failed", { event: "PostToolUse", code: run.code, stderr: clip(run.stderr, 300) });
+                    noteHookFailure(ctx, { event: "PostToolUse", entry, reason: "exit_nonzero", exitCode: run.code, stderr: run.stderr, toolName });
                     continue;
                 }
-                const out = parseHookStdout(run.stdout);
+                const out = readHookStdout(run, entry, "PostToolUse", ctx, payload);
                 if (!out)
                     continue;
                 if (typeof out.systemMessage === "string")
@@ -765,7 +879,7 @@ export function createTaskHooks(config, ctx) {
                 is_interrupt: f.isInterrupt,
             };
             const singles = await runMatchingEntries("PostToolUseFailure", postFailure, toolName, payload, ctx, onceFired, Date.now() + MAX_HOOK_EVENT_TOTAL_SECONDS * 1000);
-            for (const { run } of singles) {
+            for (const { entry, run } of singles) {
                 if (run.code === 2) {
                     const fb = clip(run.stderr.trim(), MAX_HOOK_FEEDBACK_CHARS);
                     if (fb)
@@ -774,9 +888,10 @@ export function createTaskHooks(config, ctx) {
                 }
                 if (run.code !== 0) {
                     ctx.logger.warn("hook_command_failed", { event: "PostToolUseFailure", code: run.code, stderr: clip(run.stderr, 300) });
+                    noteHookFailure(ctx, { event: "PostToolUseFailure", entry, reason: "exit_nonzero", exitCode: run.code, stderr: run.stderr, toolName });
                     continue;
                 }
-                const out = parseHookStdout(run.stdout);
+                const out = readHookStdout(run, entry, "PostToolUseFailure", ctx, payload);
                 if (!out)
                     continue;
                 if (typeof out.systemMessage === "string")
@@ -811,7 +926,7 @@ export function createTaskHooks(config, ctx) {
                 })),
             };
             const singles = await runMatchingEntries("PostToolBatch", ignoreMatchers(postBatch), "", payload, ctx, onceFired, Date.now() + MAX_HOOK_EVENT_TOTAL_SECONDS * 1000);
-            for (const { run } of singles) {
+            for (const { entry, run } of singles) {
                 if (run.code === 2) {
                     const fb = clip(run.stderr.trim(), MAX_HOOK_FEEDBACK_CHARS);
                     if (fb)
@@ -820,9 +935,10 @@ export function createTaskHooks(config, ctx) {
                 }
                 if (run.code !== 0) {
                     ctx.logger.warn("hook_command_failed", { event: "PostToolBatch", code: run.code, stderr: clip(run.stderr, 300) });
+                    noteHookFailure(ctx, { event: "PostToolBatch", entry, reason: "exit_nonzero", exitCode: run.code, stderr: run.stderr });
                     continue;
                 }
-                const out = parseHookStdout(run.stdout);
+                const out = readHookStdout(run, entry, "PostToolBatch", ctx, payload);
                 if (!out)
                     continue;
                 if (typeof out.systemMessage === "string")
@@ -844,16 +960,17 @@ export function createTaskHooks(config, ctx) {
             const contexts = [];
             const payload = { ...basePayload(ctx), hook_event_name: "UserPromptSubmit", prompt: clip(prompt, MAX_TOOL_INPUT_CHARS) };
             const singles = await runMatchingEntries("UserPromptSubmit", ignoreMatchers(promptSubmit), "", payload, ctx, onceFired, Date.now() + MAX_HOOK_EVENT_TOTAL_SECONDS * 1000);
-            for (const { run } of singles) {
+            for (const { entry, run } of singles) {
                 if (run.code === 2) {
                     const reason = clip(run.stderr.trim(), MAX_HOOK_FEEDBACK_CHARS) || "blocked by a UserPromptSubmit hook";
                     return { block: reason, ...buildHookContextField(contexts) };
                 }
                 if (run.code !== 0) {
                     ctx.logger.warn("hook_command_failed", { event: "UserPromptSubmit", code: run.code, stderr: clip(run.stderr, 300) });
+                    noteHookFailure(ctx, { event: "UserPromptSubmit", entry, reason: "exit_nonzero", exitCode: run.code, stderr: run.stderr });
                     continue;
                 }
-                const out = parseHookStdout(run.stdout);
+                const out = readHookStdout(run, entry, "UserPromptSubmit", ctx, payload);
                 if (!out)
                     continue;
                 if (typeof out.systemMessage === "string")
@@ -886,7 +1003,7 @@ export function createTaskHooks(config, ctx) {
             if (wantsPrompt) {
                 if (ctx.stopPromptTranscript === false) {
                     ctx.logger.warn("hook_entries_skipped", { event: "Stop", type: "prompt", reason: "stop_prompt_transcript_disabled" });
-                    ctx.onHookNotice?.({ kind: "hook_decision_unavailable", event: "Stop", reason: "skipped", detail: "transcript disabled" });
+                    emitHookNotice(ctx, { kind: "hook_decision_unavailable", event: "Stop", reason: "skipped", detail: "transcript disabled" });
                 }
                 else {
                     let branch;
@@ -902,7 +1019,7 @@ export function createTaskHooks(config, ctx) {
                     }
                     else {
                         ctx.logger.warn("hook_entries_skipped", { event: "Stop", type: "prompt", reason: `stop_prompt_no_evidence:${rendered.reason}` });
-                        ctx.onHookNotice?.({ kind: "hook_decision_unavailable", event: "Stop", reason: "skipped", detail: `no evidence: ${rendered.reason}` });
+                        emitHookNotice(ctx, { kind: "hook_decision_unavailable", event: "Stop", reason: "skipped", detail: `no evidence: ${rendered.reason}` });
                     }
                 }
             }
@@ -922,6 +1039,7 @@ export function createTaskHooks(config, ctx) {
                 }
                 if (run.code !== 0) {
                     ctx.logger.warn("hook_command_failed", { event: "Stop", code: run.code, stderr: clip(run.stderr, 300) });
+                    noteHookFailure(ctx, { event: "Stop", entry, reason: "exit_nonzero", exitCode: run.code, stderr: run.stderr });
                     continue;
                 }
                 if (llmExtra && entry.type === "prompt" && parseCcVerdict(run.stdout)) {
@@ -936,11 +1054,11 @@ export function createTaskHooks(config, ctx) {
                         block = clip(v.reason?.trim() || "stop condition not satisfied", MAX_HOOK_FEEDBACK_CHARS);
                     continue;
                 }
-                const out = parseHookStdout(run.stdout);
+                const out = llmExtra && entry.type === "prompt" ? parseHookStdout(run.stdout) : readHookStdout(run, entry, "Stop", ctx, payload);
                 if (!out) {
                     if (llmExtra && entry.type === "prompt") {
                         ctx.logger.warn("hook_llm_unparsed_verdict", { event: "Stop", head: clip(run.stdout.trim(), 200) });
-                        ctx.onHookNotice?.({ kind: "hook_decision_unavailable", event: "Stop", reason: "unparsed" });
+                        emitHookNotice(ctx, { kind: "hook_decision_unavailable", event: "Stop", reason: "unparsed" });
                     }
                     continue;
                 }
@@ -991,15 +1109,16 @@ export function createTaskHooks(config, ctx) {
                 custom_instructions: pctx.customInstructions ?? null,
             };
             const singles = await runMatchingEntries("PreCompact", preCompactEntries, pctx.trigger, payload, ctx, onceFired, Date.now() + MAX_HOOK_EVENT_TOTAL_SECONDS * 1000);
-            for (const { run } of singles) {
+            for (const { entry, run } of singles) {
                 if (run.code === 2) {
                     return { block: clip(run.stderr.trim(), MAX_HOOK_FEEDBACK_CHARS) || "blocked by a PreCompact hook" };
                 }
                 if (run.code !== 0) {
                     ctx.logger.warn("hook_command_failed", { event: "PreCompact", code: run.code, stderr: clip(run.stderr, 300) });
+                    noteHookFailure(ctx, { event: "PreCompact", entry, reason: "exit_nonzero", exitCode: run.code, stderr: run.stderr });
                     continue;
                 }
-                const out = parseHookStdout(run.stdout);
+                const out = readHookStdout(run, entry, "PreCompact", ctx, payload);
                 if (!out)
                     continue;
                 if (typeof out.systemMessage === "string")

package/dist/http/route-ctx.d.ts

@@ -237,6 +237,30 @@ export declare function noteResumeClientGone(res: ServerResponse, out: {
 }, logger: {
     info?: (msg: string, fields?: Record<string, unknown>) => void;
 } | undefined): void;
+/**
+ * #359②(A-075.6)—— resume 族四腿(`/decide` / `/assistant/tasks/:id/resume` / `/plan_review` /
+ * `/wake`)的**唯一**回执发送口。
+ *
+ * 为什么是一个函数而不是「在四处各加一行 `res.setHeader`」:这四条腿此前已经各自记得调
+ * {@link noteResumeClientGone},而那正是「靠人记得」的形 —— S-1 落地时就漏挂过一腿(三腿有、
+ * `/decide` 没有,见 `approvals-assistant.ts` 那条注)。把留痕 + 退避头 + 发送折进一次调用,
+ * 第五条腿加进来时只有一个正确写法。
+ *
+ * 🔴 **`Retry-After` 的判据与体里那份同源**:头只在体**真带** `retryAfterSec` 且是**有限非负数**时发。
+ * 全仓每一处带 `retryAfterSec` 的响应(429 `limit.rate_exceeded` / `limit.cost_quota_exceeded` /
+ * `quota_exhausted` / `usage.window_exhausted` / rule-import retry)都同发这个标准头,唯独 resume 族的
+ * retriable 409 漏了。头与体不是重复,是**两个读者**:体那份给应用逻辑,头那份给通道
+ * (代理 / SDK / fetch 重试中间件读的是头,读不到就只能盲等或立刻重投 —— 而立刻重投必然又是一次空转)。
+ * 体里没有等待 ⇒ 头也不发:凭空补一个退避值就是编造一条服务端并没有做出的时间承诺。
+ *
+ * @param extraBody 这条腿自己要并进回执的键(今天只有 `/decide` 的 `rememberApplied`)。
+ */
+export declare function sendResumeOutcome(res: ServerResponse, out: {
+    status: number;
+    body: object;
+}, logger: {
+    info?: (msg: string, fields?: Record<string, unknown>) => void;
+} | undefined, extraBody?: Record<string, unknown>): void;
 export interface RouteCtxBase {
     deps: FlatServiceDeps;
     registry: RunRegistry;

package/dist/http/route-ctx.js

@@ -1,3 +1,4 @@
+import { sendJson } from "./send.js";
 export function noteResumeClientGone(res, out, logger) {
     if (out.status !== 200 || out.body.status !== "resuming")
         return;
@@ -9,6 +10,13 @@ export function noteResumeClientGone(res, out, logger) {
         ...(out.body.sessionId !== undefined ? { sessionId: out.body.sessionId } : {}),
     });
 }
+export function sendResumeOutcome(res, out, logger, extraBody) {
+    noteResumeClientGone(res, out, logger);
+    const wait = out.body.retryAfterSec;
+    if (typeof wait === "number" && Number.isFinite(wait) && wait >= 0)
+        res.setHeader("retry-after", String(Math.ceil(wait)));
+    sendJson(res, out.status, extraBody === undefined ? out.body : { ...out.body, ...extraBody });
+}
 export const RUN_NOT_FOUND_MESSAGE = "run not found — the id belongs to no run in this deployment's run store (a run from another server process, or an in-memory store that did not survive a restart, is not visible here)";
 export function runNotFoundMessage(id) {
     const aStar = /^(?:a|wa)[0-9a-f]{4,}$/i.test(id);

package/dist/http/routes/approvals-assistant.js

@@ -9,7 +9,7 @@ import { bindSseLifecycle } from "../sse-lifecycle.js";
 import { sendJson, sendError, sseHeaders, SSE_MAX_STREAM_MS, SSE_HEARTBEAT_IDLE_MS } from "../send.js";
 import { gatedPrincipal, explicitOperatorOk, isOperator } from "../principal-gate.js";
 import { governanceOriginOf } from "../active-run-conflict.js";
-import { noteResumeClientGone } from "../route-ctx.js";
+import { sendResumeOutcome } from "../route-ctx.js";
 export const ASSISTANT_PREEMPT_RE = /^\/v1\/assistant\/tasks\/([^/]+)\/preempt$/;
 export const ASSISTANT_RESUME_RE = /^\/v1\/assistant\/tasks\/([^/]+)\/resume$/;
 export const ASSISTANT_PLAN_REVIEW_RE = /^\/v1\/assistant\/tasks\/([^/]+)\/plan_review$/;
@@ -249,8 +249,7 @@ async function handleApprovalsAssistantBody(req, res, url, ctx, miss) {
                 return;
             }
             const out = await resumePreempted(run.sessionId, req, true);
-            noteResumeClientGone(res, out, deps.logger);
-            sendJson(res, out.status, out.body);
+            sendResumeOutcome(res, out, deps.logger);
             return;
         }
         const planReviewMatch = req.method === "POST" ? ASSISTANT_PLAN_REVIEW_RE.exec(url) : null;
@@ -316,8 +315,7 @@ async function handleApprovalsAssistantBody(req, res, url, ctx, miss) {
                 return;
             }
             const out = await resumePlanReview(run.sessionId, decision, decision === "edit" ? body.editedPlan : undefined, typeof body.reason === "string" ? body.reason : undefined, req, { taskId, principalPresent: principal !== undefined }, true);
-            noteResumeClientGone(res, out, deps.logger);
-            sendJson(res, out.status, out.body);
+            sendResumeOutcome(res, out, deps.logger);
             return;
         }
         const m = /^\/v1\/approvals\/([^/]+)\/decide$/.exec(url);
@@ -442,12 +440,7 @@ async function handleApprovalsAssistantBody(req, res, url, ctx, miss) {
                 }
                 : undefined;
             const out = await resumeCheckpoint(sessionId, decision, body.reason ?? undefined, "human", req, answer, binding, grantOnCommit, true);
-            noteResumeClientGone(res, out, deps.logger);
-            if (remember && deps.approvalExemptionStore) {
-                sendJson(res, out.status, { ...out.body, rememberApplied });
-                return;
-            }
-            sendJson(res, out.status, out.body);
+            sendResumeOutcome(res, out, deps.logger, remember && deps.approvalExemptionStore ? { rememberApplied } : undefined);
             return;
         }
         sendError(res, 404, "not_found.route", "not found");

package/dist/http/routes/capabilities.js

@@ -49,7 +49,7 @@ async function handleCapabilitiesBody(req, res, url, ctx, miss) {
             sessions: Boolean(deps.sessionAudit),
             sessionEvents: Boolean(deps.sessionWatch && deps.sessionStorage?.getLeafId && deps.sessionStorage?.ownerOf),
             fleet: deps.fleetBus
-                ? { stream: true, sessionScope: true, observe: true, resume: "snapshot", bgNotifyFailClosed: true, steerPriority: "advisory" }
+                ? { stream: true, sessionScope: true, observe: true, resume: "snapshot", bgNotifyFailClosed: true, steerPriority: "advisory", hookFailureNotice: true }
                 : false,
             workspace: (() => {
                 const wfs = deps.fileSnapshotStore;

package/dist/http/routes/fleet.js

@@ -1,3 +1,4 @@
+import { hookNoticeWire } from "../../fleet/fleet-bus.js";
 import { FLEET_SNAPSHOT_TERMINAL_MAX_ROWS, isTerminalWorkflowRowStatus, recentTerminalWorkflowRows } from "../../fleet/fleet-terminal-window.js";
 import { taskNotificationFoldKey } from "../../orchestration/workflow-completion-inbox.js";
 import { sendJson, sendError, sseHeaders } from "../send.js";
@@ -142,8 +143,7 @@ function streamFleet(req, res, bus, callerScope, callerSession = null, completio
                     const hScopeOk = callerScope === null || hn.ownerScope === callerScope;
                     const hSessionOk = callerSession === null || hn.ownerSessionId === callerSession;
                     if (hScopeOk && hSessionOk) {
-                        const { ownerScope: _hs, ownerSessionId: _hsid, ...wire } = hn;
-                        send("hook_notice", { type: "hook_notice", ...wire, ts: frame.ts });
+                        send("hook_notice", { type: "hook_notice", ...hookNoticeWire(hn), ts: frame.ts });
                     }
                     break;
                 }

package/dist/http/routes/notify-wake.js

@@ -1,7 +1,7 @@
 import { taskNotificationInboxEntry } from "../../orchestration/workflow-completion-inbox.js";
 import { sendJson, sendError } from "../send.js";
 import { gatedPrincipal, explicitOperatorOk } from "../principal-gate.js";
-import { noteResumeClientGone } from "../route-ctx.js";
+import { sendResumeOutcome } from "../route-ctx.js";
 export const SESSION_WAKE_RE = /^\/v1\/sessions\/[^/]+\/wake$/;
 export async function handleNotifyWake(req, res, url, ctx) {
     const miss = { fell: false };
@@ -129,8 +129,7 @@ async function handleNotifyWakeBody(req, res, url, ctx, miss) {
             return;
         }
         const out = await resumeWake(wakeSession, wakeBody.message, principal, req, true);
-        noteResumeClientGone(res, out, deps.logger);
-        sendJson(res, out.status, out.body);
+        sendResumeOutcome(res, out, deps.logger);
         return;
     }
     miss.fell = true;

package/dist/http/routes/runs.js

@@ -21,6 +21,7 @@ import { normalizeRunEventType } from "../../trace/project.js";
 import { sendJson, sendError, httpErrorCode, sseHeaders } from "../send.js";
 import { buildActiveRunConflict } from "../active-run-conflict.js";
 import { clearTurnActivity, readTurnActivityMs } from "../../turn-activity.js";
+import { buildCrossSliceUsage, readResourceWindow, recordResourceWindow } from "../../resource-window.js";
 import { headerStr, gatedPrincipal, explicitOperatorOk } from "../principal-gate.js";
 import { ActorAssertionWire } from "@sema-agent/registry-core";
 import { RUN_NOT_FOUND_MESSAGE, runNotFoundMessage } from "../route-ctx.js";
@@ -192,7 +193,20 @@ async function handleRunsBody(req, res, url, ctx, miss) {
             const infraRates = deps.config.infraCostRates;
             const needCost = Boolean(run.result?.stats && !stale && infraRates && hasInfraPricing(infraRates));
             const needSuggestions = !stale && run.status === "completed";
-            const events = (needCost || needSuggestions) && deps.runStore.getEvents ? await deps.runStore.getEvents(taskId, 0).catch(() => []) : undefined;
+            const resourceWindow = run.status === "running" && !stale ? readResourceWindow(run.taskId) : undefined;
+            let events;
+            let eventsUnavailable = false;
+            if (needCost || needSuggestions || resourceWindow !== undefined) {
+                if (deps.runStore.getEvents) {
+                    events = await deps.runStore.getEvents(taskId, 0).catch(() => {
+                        eventsUnavailable = true;
+                        return [];
+                    });
+                }
+                else {
+                    eventsUnavailable = true;
+                }
+            }
             let supervisorCost;
             if (needCost && events && run.result?.stats) {
                 const durMs = new Date(run.updatedAt).getTime() - new Date(run.createdAt).getTime();
@@ -208,11 +222,19 @@ async function handleRunsBody(req, res, url, ctx, miss) {
                     suggestions = arr.map((s) => String(s));
             }
             const lastActivityAt = run.status === "running" && !stale ? readTurnActivityMs(run.taskId) : undefined;
+            let crossSliceUsage;
+            if (resourceWindow !== undefined) {
+                if (eventsUnavailable || events === undefined)
+                    recordFailOpen("server.runs.cross-slice-usage-unavailable");
+                else
+                    crossSliceUsage = buildCrossSliceUsage(resourceWindow, events);
+            }
             sendJson(res, 200, {
                 taskId: run.taskId,
                 sessionId: run.sessionId,
                 status: stale ? "failed" : run.status,
                 ...(lastActivityAt !== undefined ? { msSinceLastActivity: Math.max(0, Date.now() - lastActivityAt) } : {}),
+                ...(crossSliceUsage !== undefined ? { crossSliceUsage } : {}),
                 result: run.result ?? undefined,
                 supervisorCost,
                 suggestions,
@@ -1070,7 +1092,7 @@ async function handleRunVerbsBody(req, res, url, ctx, miss) {
         }
         const { status, body: respBody } = await deps.toolApproval.respond(id, principal, body, req);
         const retryAfterSec = respBody.retryAfterSec;
-        if (status === 429 && typeof retryAfterSec === "number" && Number.isFinite(retryAfterSec) && retryAfterSec >= 0) {
+        if (typeof retryAfterSec === "number" && Number.isFinite(retryAfterSec) && retryAfterSec >= 0) {
             res.setHeader("retry-after", String(Math.ceil(retryAfterSec)));
         }
         sendJson(res, status, respBody);
@@ -1330,6 +1352,8 @@ export async function createDurableRun(req, res, ctx, prepared, idemKey) {
         const created = await runStore.createRun(taskId, sessionId, prepared.auth?.principal ?? null, deps.instanceId ?? "default", runMeta(prepared, source));
         if (created.ok)
             clearTurnActivity(taskId);
+        if (created.ok)
+            recordResourceWindow(taskId, prepared.spec.resourceSuspend);
         if (created.ok)
             deps.sessionTitler?.maybeTitle(sessionId, prepared.spec.objective, typeof prepared.spec.model === "string" ? prepared.spec.model : prepared.spec.model?.id);
         if (!created.ok) {

package/dist/http/routes/tasks.js

@@ -7,6 +7,7 @@ import { emitPendingWorkflowCompletions, taskNotificationInboxEntry, taskNotific
 import { createLedgerSink } from "../../trace/ledger-sink.js";
 import { registerEngineNoticeLeg } from "../../trace/engine-notice-wire.js";
 import { clearTurnActivity, readTurnActivityMs, recordTurnActivity } from "../../turn-activity.js";
+import { recordResourceWindow } from "../../resource-window.js";
 import { redactSecrets } from "../../trace/redact.js";
 import { contextUsageEventData, toolStartEventData, toolEndEventData, taskProgressEventData, taskNotificationEventData, compactedEventData, diagnosticsEventData, brainStatusEventData, steeringInjectedEventData, compactionOutcomeEventData, workspaceChangedEventData, wiringManifestEventData, wiringManifestOperatorEventData, humanInputEventData, appendModelUsageDelta, attachModelUsage } from "../../trace/project.js";
 import { cascadeConfig, runMeta } from "../run-meta.js";
@@ -192,6 +193,8 @@ async function handleTasksBody(req, res, url, ctx, miss) {
                     const created = await deps.runStore.createRun(tid, prepared.spec.sessionId, principal ?? null, deps.instanceId ?? "default", runMeta(prepared, source));
                     if (created.ok)
                         clearTurnActivity(tid);
+                    if (created.ok)
+                        recordResourceWindow(tid, prepared.spec.resourceSuspend);
                     if (created.ok)
                         deps.sessionTitler?.maybeTitle(prepared.spec.sessionId, prepared.spec.objective, typeof prepared.spec.model === "string" ? prepared.spec.model : prepared.spec.model?.id);
                     if (!created.ok) {
@@ -715,6 +718,8 @@ async function handleTasksBody(req, res, url, ctx, miss) {
                     const created = await deps.runStore.createRun(tid, prepared.spec.sessionId, principal ?? null, deps.instanceId ?? "default", runMeta(prepared, source));
                     if (created.ok)
                         clearTurnActivity(tid);
+                    if (created.ok)
+                        recordResourceWindow(tid, prepared.spec.resourceSuspend);
                     if (!created.ok)
                         return { status: 409, body: await buildActiveRunConflict({ runStore: deps.runStore, checkpointStore: deps.checkpointStore, governance: deps.config, runStaleSec: deps.config.runStaleSec, turnActivity: readTurnActivityMs }, prepared.spec.sessionId, created.activeTaskId) };
                     deps.sessionTitler?.maybeTitle(prepared.spec.sessionId, prepared.spec.objective, typeof prepared.spec.model === "string" ? prepared.spec.model : prepared.spec.model?.id);

package/dist/http/server.js

@@ -14,6 +14,7 @@ import { normalizeApproachNotice, validateTaskAgents } from "../spec-fields.js";
 import { isValidCwd, MAX_ADDITIONAL_DIRS } from "../task-cwd.js";
 import { runInBackground, evictIfConflict, stripCheckpointToken, parkToolCallId, TurnAnchorCapture, HEARTBEAT_MS, markChildrenStoppedByUserOnAbort } from "../runs.js";
 import { readTurnActivityMs, recordTurnActivity } from "../turn-activity.js";
+import { recordResumeResourceWindow } from "../resource-window.js";
 import { publicStoreProbeError } from "../store-live-probe.js";
 import { looksLikeJwt } from "@sema-agent/registry-core/api/auth-bridge";
 import {} from "../orchestration/workflow-agent-steer.js";
@@ -1140,6 +1141,8 @@ export function createHttpServer(rawDeps) {
             ? fleetRunPublisher(deps.fleetBus, { runId: taskId, scope: fleetScope, rootTaskId: taskId, ...fleetRunLabels(resumeObjective) })
             : undefined;
         const resumeTaskConfig = taskId ? { ...taskConfig, taskId } : taskConfig;
+        if (taskId && resumeTaskConfig.resourceSuspend)
+            recordResumeResourceWindow(taskId, resumeTaskConfig.resourceSuspend);
         let fleetSettled = false;
         const settleFleet = (status, residuals) => {
             if (fleetSettled)
@@ -1608,6 +1611,7 @@ export function createHttpServer(rawDeps) {
                 return {
                     status,
                     body: {
+                        ...(taskId !== undefined ? { taskId } : {}),
                         error: e.message,
                         errorCode: e.code === "checkpoint.invalid_outcome"
                             ? (outcome.gate === "policy_ask" ? "approval_binding_mismatch" : "resume_outcome_invalid")