@sema-agent/server 7.144.0 → 7.146.0

package/dist/http/routes/memory-origin.js

@@ -1,7 +1,7 @@
 import { z } from "zod";
-import { ControlPlaneCorruptError } from "@sema-agent/core";
 import { sendJson, sendError } from "../send.js";
 import { sentMemoryStoreRefusal } from "../memory-store-refusal-reply.js";
+import { sentControlPlaneCorrupt } from "../memory-control-plane-corrupt-reply.js";
 import { buildOriginFence, readOriginAware } from "../../memory-origin-fence.js";
 import { readLayerSeat, sentMemoryLayerRefusal } from "../memory-layer-reply.js";
 import { gatedPrincipal, explicitOperatorOk, sendOperatorPrincipalsRequired, sendPrincipalRefusal } from "../principal-gate.js";
@@ -59,10 +59,8 @@ function sentClassifiedFailure(res, ctx, face, err) {
     }
     if (face !== "clearances" && sentMemoryStoreRefusal(res, err, ctx.deps.logger))
         return true;
-    if (err instanceof ControlPlaneCorruptError) {
-        sendError(res, 500, "internal.memory_control_plane_corrupt", err.message);
+    if (sentControlPlaneCorrupt(res, err, { kind: "operator" }))
         return true;
-    }
     ctx.deps.logger?.warn?.(`memory_origin_${face}_failed`, { err: String(err) });
     return false;
 }

package/dist/http/routes/memory-policy.js

@@ -1,4 +1,4 @@
-import { formatUserScope } from "@sema-agent/core";
+import { formatUserScope, isReplicableScope } from "@sema-agent/core";
 import { parseMemorySyncRequest } from "../../memory-sync.js";
 import { memorySyncIdentityRule } from "../../memory-sync-identity.js";
 import * as facts from "../../capability-facts.js";
@@ -160,6 +160,10 @@ export async function handleMemoryPolicy(req, res, match, ctx) {
                 sendError(res, 400, "memory_sync_invalid_scope", "missing :scope");
                 return;
             }
+            if (!isReplicableScope(scope)) {
+                sendError(res, 400, "memory_sync_invalid_scope", "a userlocal: memory layer never leaves the store it is written in — it is not synced");
+                return;
+            }
             if (sendScopeGateRefusal(res, await gateMemoryScope(deps, principal, scope, "write")))
                 return;
             const body = await readJson(req);

package/dist/http/routes/observability.js

@@ -12,12 +12,9 @@ export async function handleObservability(req, res, match, ctx) {
                 sendOperatorPrincipalsRequired(res);
                 return;
             }
-            if (deps.config.requirePrincipal) {
-                const principal = gatedPrincipal(req, deps.config);
-                if (!explicitOperatorOk(principal, deps.config)) {
-                    sendError(res, 403, "auth.operator_only", "outcomes view is operator-only on a multi-tenant worker");
-                    return;
-                }
+            if (!explicitOperatorOk(gatedPrincipal(req, deps.config), deps.config)) {
+                sendError(res, 403, "auth.operator_only", "the outcomes view is operator-only");
+                return;
             }
             if (!fact.available) {
                 switch (fact.why) {

package/dist/http/routes/rules.d.ts

@@ -3,7 +3,7 @@
  *
  *   POST   /v1/rules                    → 写一条**收紧**规则(deny/ask)进 durable 分区,单步、无票仪式
  *   POST   /v1/rules/cc-import/prepare  → 预览 + 一张**一次性、principal 绑定、有期、载荷绑定**的票
- *   POST   /v1/rules/cc-import/redeem   → 原子消费票 → confirm → 批量兑付进店
+ *   POST   /v1/rules/cc-import/redeem   → 原子消费票 → confirm → 批量兑付进店 → 回执 `{ members, rev }`(与 local-import 口同一张,{@link sendImportReceipt})
  *   GET    /v1/rules                    → 列出自己名下**活着**的规则(keyset 分页,游标绑 rev)
  *   DELETE /v1/rules                    → 按 (rule, scope) 内容撤销,**恒经** core `removePersistedRule`
  *

package/dist/http/routes/rules.js

@@ -159,7 +159,7 @@ export async function handleRules(req, res, match, ctx) {
         }
         const redeemed = await lane.redeemLocalImport(principal, parsed.data.ticket);
         if (redeemed.ok) {
-            sendJson(res, 200, { members: redeemed.outcome.members, rev: redeemed.outcome.rev });
+            sendImportReceipt(res, redeemed.outcome);
             return;
         }
         logger.info("local rule import ticket refused", { reason: redeemed.reason, detail: redeemed.detail, retryable: redeemed.reason !== "ticket-unusable" && redeemed.reason !== "in-flight" && redeemed.retryable === true });
@@ -218,7 +218,10 @@ export async function handleRules(req, res, match, ctx) {
         sendError(res, 404, "not_found.rule_ticket", "no such import ticket");
         return;
     }
-    sendJson(res, 200, { result: redeemed.result });
+    sendImportReceipt(res, redeemed.outcome);
+}
+function sendImportReceipt(res, outcome) {
+    sendJson(res, 200, { members: outcome.members, rev: outcome.rev });
 }
 function resolveTargetPrincipal(requested, caller, config) {
     if (requested === undefined || requested === caller)

package/dist/http/routes/runs.js

@@ -4,7 +4,7 @@ import { z } from "zod";
 import { uuidv7, mintCheckpointToken, CheckpointError, policyCannotAnswer, validatePendingSteer, TASK_OUTPUT_REPLAY_KINDS, isSystemInjectionPriority } from "@sema-agent/core";
 import { isTerminalRunStatus, isParkedRunStatus, runProvenElsewhere } from "../../plugins/store-contracts.js";
 import { askOwnerAdmits, askRowCarriesOwner } from "../../plugins/approval-ask-store-sql.js";
-import { LIVE_RUN_GATE_KINDS, TERMINAL_PARK_GATE_KINDS } from "../../plugins/checkpoint-store-sql.js";
+import { LIVE_RUN_GATE_KINDS, TERMINAL_PARK_GATE_KINDS } from "../../plugins/checkpoint-store-face.js";
 import { redactSecrets } from "../../trace/redact.js";
 import { isUuidV7, encodeCheckpointScope } from "../../security.js";
 import { redactSteerIn, STEER_IN_MAX_CHARS, STEER_IN_MAX_REQUEST_CHARS } from "../../orchestration/workflow-agent-steer.js";
@@ -1578,7 +1578,7 @@ export async function handleRunVerbs(req, res, match, ctx) {
 export async function createDurableRun(req, res, ctx, prepared, idem) {
     const { deps } = ctx;
     const { idemCache } = ctx.registry;
-    const { leaseDenied, usageWindowDenied } = ctx.helpers;
+    const { leaseDenied, usageWindowDenied, admitRun } = ctx.helpers;
     const source = ctx.req.source;
     const runs = facts.durableRuns(deps);
     if (!runs.available) {
@@ -1600,6 +1600,9 @@ export async function createDurableRun(req, res, ctx, prepared, idem) {
     }
     if ((await leaseDenied(req, res)) || (await usageWindowDenied(req, res)))
         return null;
+    const runSlot = admitRun(req, res);
+    if (runSlot === undefined)
+        return null;
     return await idemCache.run(idem !== undefined ? inflightKeyOf(idem, "durable", clientTaskId) : undefined, async () => {
         const out = await mintAndDriveDurableRun({ deps, registry: ctx.registry, helpers: ctx.helpers, local: ctx.local, legs: ctx.legs }, runStore, {
             prepared,
@@ -1609,9 +1612,10 @@ export async function createDurableRun(req, res, ctx, prepared, idem) {
             elicitOwner: submitter ?? null,
             source,
             identity: runIdentityOf(req, deps.config, prepared.auth?.principal ?? null),
+            runSlot,
         });
         return out.existing ? await replayOfExistingRun(out.existing, caller, "durable", deps, runStore) : out;
-    });
+    }).finally(() => runSlot.release());
 }
 function clientTaskIdOf(body) {
     const raw = typeof body === "object" && body !== null ? body.taskId : undefined;

package/dist/http/routes/session-sync.js

@@ -1,18 +1,18 @@
 import { once } from "node:events";
-import { randomBytes } from "node:crypto";
-import { sessionLogDigest, sessionLogDigestsComparable, StreamingImportValidator, validateFileHistoryExport } from "@sema-agent/core";
+import { sessionLogDigest, sessionLogDigestsComparable, validateFileHistoryExport } from "@sema-agent/core";
 import { StringDecoder } from "node:string_decoder";
 import { FileHistoryUnreadableError, blobGetterOf, exportSessionManifest, exportedFileHistory, fileHistoryImportFace, replayFileHistory, replayPolicyRecords, wipeSessionAttendants } from "../../session-sync.js";
 import * as facts from "../../capability-facts.js";
-import { classifySyncRelationshipByIds, readImportAnchors, SyncConflictError } from "../../session-sync-kernel.js";
+import { classifySyncRelationshipByIds, createStagedLogFeed, MalformedImportEntryError, newStagingToken, readImportAnchors, SyncConflictError } from "../../session-sync-kernel.js";
 import { isUuidShape, legacyUnownedSessionOk, sessionOwnerCellOf } from "../../security.js";
 import { sendJson, sendError, sendSessionError, sendSessionPolicyError, logRequestError, msg } from "../send.js";
+import { StampedSessionArchiveError } from "../../session-error-wire.js";
+import { readSessionAgent } from "../../session-agent.js";
 import { buildDisplaySafeUrl } from "../../trace/redact.js";
 import { storeFaultClassOf } from "../../plugins/store-fault.js";
 import { fleetViewOf, gatedPrincipal, explicitOperatorOk, sendUnauthorized, sessionCallerOf } from "../principal-gate.js";
 const SYNC_BLOB_MAX_BYTES = 64 * 1024 * 1024;
 const SYNC_NDJSON_LINE_MAX_BYTES = 8 * 1024 * 1024;
-const SYNC_IMPORT_BATCH = 500;
 import { SHA256_HEX_RE } from "../../digest-form.js";
 import { assertNever, SESSION_NOT_FOUND_MESSAGE } from "../route-ctx.js";
 import { readSessionRulesRecords, describeSessionRulesRecordProblem } from "../../session-policy-wire.js";
@@ -359,6 +359,16 @@ export async function handleSessionSync(req, res, match, ctx) {
                 const dstIds = (await sessionStorage.listEntryIds?.(sessionId)) ?? null;
                 const relA = classifySyncRelationshipByIds(entryIds, dstIds);
                 if ((relA.relation === "fork" || relA.relation === "stale") && resolution !== "overwrite-dst") {
+                    if (sessionStorage.assertArchiveAnonymous !== undefined && (await readSessionAgent(sessionStorage, sessionId)) === undefined) {
+                        try {
+                            await sessionStorage.assertArchiveAnonymous(sessionId);
+                        }
+                        catch (e) {
+                            if (e instanceof StampedSessionArchiveError && sendSessionError(res, e, "import"))
+                                return;
+                            throw e;
+                        }
+                    }
                     sendError(res, 409, "conflict", "sync conflict", { relation: relA });
                     return;
                 }
@@ -489,7 +499,7 @@ export async function handleSessionSync(req, res, match, ctx) {
                 }
                 const importingPrincipal = scope.fleetWide ? (owner ?? null) : scope.gateOwner;
                 const operatorOk = explicitOperatorOk(gatedPrincipal(req, deps.config), deps.config);
-                const token = randomBytes(8).toString("hex");
+                const token = newStagingToken();
                 const handle = sessionStorage.beginImportStaging(sessionId, token);
                 const stagingId = handle.stagingId;
                 importLeases.set(sessionId, { at: Date.now(), stagingId });
@@ -515,13 +525,8 @@ export async function handleSessionSync(req, res, match, ctx) {
                     sendError(res, 404, "not_found.staging", "staging not found");
                     return;
                 }
-                const validator = new StreamingImportValidator();
+                const feed = createStagedLogFeed(pending.handle);
                 let lineBuf = "";
-                let pendingBatch = [];
-                const flush = async () => { if (pendingBatch.length) {
-                    await pending.handle.appendBatch(pendingBatch);
-                    pendingBatch = [];
-                } };
                 class PrecheckError extends Error {
                     status;
                     constructor(status, msg) {
@@ -530,12 +535,7 @@ export async function handleSessionSync(req, res, match, ctx) {
                     }
                 }
                 const streamedIds = new Set();
-                const onEntry = (e) => {
-                    if (!e || typeof e !== "object" || typeof e.id !== "string")
-                        throw new PrecheckError(422, "malformed entry (missing id)");
-                    streamedIds.add(e.id);
-                    validator.step(e);
-                };
+                const onEntry = async (e) => { streamedIds.add(await feed.push(e)); };
                 const utf8 = new StringDecoder("utf8");
                 try {
                     for await (const chunk of req) {
@@ -556,10 +556,7 @@ export async function handleSessionSync(req, res, match, ctx) {
                             catch {
                                 throw new PrecheckError(400, "malformed NDJSON line");
                             }
-                            onEntry(e);
-                            pendingBatch.push(e);
-                            if (pendingBatch.length >= SYNC_IMPORT_BATCH)
-                                await flush();
+                            await onEntry(e);
                         }
                     }
                     lineBuf += utf8.end();
@@ -572,11 +569,9 @@ export async function handleSessionSync(req, res, match, ctx) {
                         catch {
                             throw new PrecheckError(400, "malformed NDJSON line");
                         }
-                        onEntry(e);
-                        pendingBatch.push(e);
+                        await onEntry(e);
                     }
-                    await flush();
-                    validator.finish();
+                    await feed.finish();
                     if (streamedIds.size !== pending.declaredEntryIds.length || !pending.declaredEntryIds.every((id) => streamedIds.has(id))) {
                         throw new PrecheckError(422, "streamed entries do not match the Phase-A declared entryIds");
                     }
@@ -588,6 +583,10 @@ export async function handleSessionSync(req, res, match, ctx) {
                         sendError(res, e.status, "invalid_entries", e.message);
                         return;
                     }
+                    if (e instanceof MalformedImportEntryError) {
+                        sendError(res, 422, "invalid_entries", e.message);
+                        return;
+                    }
                     if (sendSessionError(res, e, "import"))
                         return;
                     throw e;

package/dist/http/routes/sessions-list.d.ts

@@ -2,7 +2,7 @@
  * [ref] A9 域模块 —— 会话列表 / 发件链接列表。
  *
  * 路由:`GET /v1/sessions`(CC /resume picker,keyset 分页)、`GET /v1/sendfile-links`。
- * owner-scope 与 trace 列表同一权威模型(`fleetViewOf` 读档:service 凭据不报主体 / 只读 trace 凭据 / dev-open = fleet-wide;带验过的主体 = 钉住那位主体)。本域零可变状态。
+ * owner-scope 与 trace 列表同一权威模型(`fleetViewOf` 读档:service 凭据不报主体〔部署声明 `SERVICE_TOKEN_ACTS_FOR_DEPLOYMENT=false` 时不算〕/ 只读 trace 凭据 / dev-open = fleet-wide;带验过的主体 = 钉住那位主体)。本域零可变状态。
  */
 import type { IncomingMessage, ServerResponse } from "node:http";
 import { type SessionListItem } from "../../security.js";

package/dist/http/routes/sessions.js

@@ -8,6 +8,7 @@ import { recordFailOpen } from "../../observability/fail-open.js";
 import { MCP_DIAL_DEADLINE_MS, raceDeadline } from "../mcp-dial-deadline.js";
 import { sentMemoryComplianceFailure } from "../memory-compliance-failure-reply.js";
 import { readLayerSeat, sentMemoryLayerRefusal } from "../memory-layer-reply.js";
+import { DEPLOYMENT_SHAPE_PREDICATES } from "../../deployment-shape.js";
 import { MAX_SETTINGS_OUTPUT_STYLE_CHARS, MAX_SETTINGS_ENV_VARS, MAX_SETTINGS_ENV_KEY_CHARS, MAX_SETTINGS_ENV_VALUE_CHARS } from "../../task-settings.js";
 import { readWritableSessionPermissionRules } from "../../session-policy-wire.js";
 import { sendJson, sendError, sendSessionError, sendSessionPolicyError, sseHeaders, httpErrorBody } from "../send.js";
@@ -615,6 +616,7 @@ export async function handleSessions(req, res, match, ctx) {
                         memoryStatusCache.delete(cacheKey); });
                 }
                 const s = await pending;
+                const workerPathsDisclosed = DEPLOYMENT_SHAPE_PREDICATES.callerOwnsWorkerDisk.holds(deps.config);
                 sendJson(res, 200, {
                     sessionId,
                     autoConsolidationArmed: deps.memoryAutoConsolidationArmed,
@@ -624,6 +626,8 @@ export async function handleSessions(req, res, match, ctx) {
                     ...(s.foldedCount !== undefined ? { foldedCount: s.foldedCount } : {}),
                     ...(s.optOutSource !== undefined ? { optOutSource: s.optOutSource } : {}),
                     ...(s.lastCaptureAt !== undefined ? { lastCaptureAt: s.lastCaptureAt } : {}),
+                    ...(s.writeHome !== undefined && workerPathsDisclosed ? { writeHome: s.writeHome } : {}),
+                    ...(s.planes !== undefined && workerPathsDisclosed ? { planes: s.planes.map((row) => ({ plane: row.plane, ...(row.status.writeHome !== undefined ? { writeHome: row.status.writeHome } : {}) })) } : {}),
                 });
             }
             catch (err) {

package/dist/http/routes/tasks.js

@@ -5,7 +5,7 @@ import { graftParkToolCallId, markChildrenStoppedByUserOnAbort, syncRefusalHttpS
 import { atHostBoundary, sealResultForExit, outwardPlane } from "../../terminal.js";
 import { voidVerifierPauseCard } from "../../verifier-pause-card.js";
 import { withPrincipal } from "../../observability/principal-context.js";
-import { fleetRunPublisher, fleetRunLabels, fleetRunResiduals } from "../../fleet/fleet-bus.js";
+import { fleetRunPublisher, fleetRunLabels, fleetRunResiduals, nameFleetRowOnDelivery } from "../../fleet/fleet-bus.js";
 import { defaultSubagentTailBus } from "../../fleet/subagent-tail-bus.js";
 import { createLiveModelText, modelStreamOfTask } from "../../trace/model-segment.js";
 import { emitPendingWorkflowCompletions, taskNotificationInboxEntry, taskNotificationStreamKeyOf, NotifiedKeys } from "../../orchestration/workflow-completion-inbox.js";
@@ -17,7 +17,7 @@ import { recordResourceWindow } from "../../resource-window.js";
 import { redactSecrets } from "../../trace/redact.js";
 import { writeLiveFrame, writeLiveHeartbeat } from "../live-frame.js";
 import { contextUsageEventData, turnEndEventData, toolStartEventData, toolEndEventData, taskProgressEventData, taskStartedEventData, taskNotificationEventData, compactedEventData, diagnosticsEventData, brainStatusEventData, steeringInjectedEventData, compactionOutcomeEventData, compactionStartedEventData, workspaceChangedEventData, wiringManifestFaceEventData, toolRosterDeltaEventData, toolProgressEventData, toolDisclosureEventData, humanInputEventData, appendModelUsageDelta, attachModelUsage, liveIdentityFields } from "../../trace/project.js";
-import { cascadeConfig, runMeta } from "../run-meta.js";
+import { cascadeConfig, fillRunPreviewOnDelivery, runMeta } from "../run-meta.js";
 import { idemCallerOf, inflightKeyOf, submissionIdemOf } from "../idempotency.js";
 import { replayOfExistingRun } from "../submit-replay.js";
 import { httpErrorCode, sendJson, sendError, sseHeaders } from "../send.js";
@@ -33,8 +33,7 @@ import { failOpenTagForDroppedFrame, recordFailOpen } from "../../observability/
 import { buildSyncSubmitBody } from "../sync-submit-body.js";
 import { assertNever } from "../route-ctx.js";
 import * as facts from "../../capability-facts.js";
-import { persistSubmitCtx } from "../submit-ctx.js";
-import { serviceVersion } from "../../service-version.js";
+import { persistSubmissionCtx } from "../submit-ctx.js";
 import { withModelReachScope } from "../../model-reach-scope.js";
 import { createInstructionSelectionLeg } from "../../instruction-selection.js";
 import { fieldConflictFacts } from "../../field-conflict.js";
@@ -77,7 +76,7 @@ const MULTI_ATTEMPT_NO_EVENT_CHANNEL_NOTICE = "verify / cascade ran with their n
 export async function handleTasks(req, res, match, ctx) {
     const { deps } = ctx;
     const { idemCache, inflightRuns, steerableRuns, counters } = ctx.registry;
-    const { readJson, rateLimited, quotaExceeded, leaseDenied, usageWindowDenied } = ctx.helpers;
+    const { readJson, rateLimited, quotaExceeded, leaseDenied, usageWindowDenied, admitRun } = ctx.helpers;
     const { prepareSpec, finalizeTaskResult } = ctx.legs;
     const reqState = ctx.req;
     const source = ctx.req.source;
@@ -145,10 +144,14 @@ export async function handleTasks(req, res, match, ctx) {
         }
         if (rateLimited(req, res) || quotaExceeded(req, res) || (await leaseDenied(req, res)) || (await usageWindowDenied(req, res)))
             return;
+        let runSlot = undefined;
         const prepared = await prepareSpec(req, res, keyedBody, undefined, { liveStream });
         if (!prepared)
             return;
         try {
+            runSlot = admitRun(req, res);
+            if (runSlot === undefined)
+                return;
             const declaredFamilies = declaredApprovalFrameFamilies(prepared.body.settings);
             const approvalLegInput = (streamApprovalOn) => {
                 const legWalltimeMs = typeof prepared.spec.limits?.maxWalltimeMs === "number" ? prepared.spec.limits.maxWalltimeMs : undefined;
@@ -185,7 +188,7 @@ export async function handleTasks(req, res, match, ctx) {
                 sseHeaders(res, earlyDurableTid ? { "x-task-id": earlyDurableTid } : undefined);
                 if (earlyDurableTid)
                     writeMetaFrame(res, earlyDurableTid, prepared.spec.sessionId, prepared.warnings);
-                const ac = createRunAbort();
+                const ac = createRunAbort(prepared.auth?.principal ?? null);
                 let closed = false;
                 let detachLogged = false;
                 let disconnectParkGrace;
@@ -326,9 +329,10 @@ export async function handleTasks(req, res, match, ctx) {
                             return placementReject;
                         }
                         durableTaskId = tid;
+                        fillRunPreviewOnDelivery(prepared.acceptance, deps.runStore, tid);
                     }
                     if (deps.checkpointStore) {
-                        const ctxRefusal = await persistSubmitCtx(deps.checkpointStore, deps, durableTaskId !== undefined && deps.runStore ? { runStore: deps.runStore, taskId: durableTaskId } : undefined, prepared.spec.sessionId, { body: prepared.body, memoryScope: prepared.auth?.memoryScope, writerVersion: serviceVersion() });
+                        const ctxRefusal = await persistSubmissionCtx(deps.checkpointStore, deps, durableTaskId !== undefined && deps.runStore ? { runStore: deps.runStore, taskId: durableTaskId } : undefined, prepared);
                         if (ctxRefusal) {
                             writeLiveFrame(res, { type: "done", result: doneResultOfOutcome(ctxRefusal) });
                             return ctxRefusal;
@@ -355,14 +359,17 @@ export async function handleTasks(req, res, match, ctx) {
                         }, HEARTBEAT_MS);
                         durableHeartbeat.unref?.();
                         inflightRuns.set(tid, ac);
+                        runSlot?.release();
                         void Promise.resolve(rs.isCancelRequested?.(tid, owner)).then((c) => { if (c && !ac.signal.aborted)
                             abortFromVerb(); }).catch(() => undefined);
                     }
                     let fleetPub;
                     try {
                         fleetPub = durableTaskId
-                            ? fleetRunPublisher(deps.fleetBus, { runId: durableTaskId, scope: gatedPrincipal(req, deps.config) ?? "default", rootTaskId: durableTaskId, sessionId: prepared.spec.sessionId, ...fleetRunLabels(prepared.spec.objective) })
+                            ? fleetRunPublisher(deps.fleetBus, { runId: durableTaskId, scope: gatedPrincipal(req, deps.config) ?? "default", rootTaskId: durableTaskId, sessionId: prepared.spec.sessionId, ...fleetRunLabels(prepared.acceptance.objectiveAtSubmit) })
                             : undefined;
+                        if (fleetPub)
+                            nameFleetRowOnDelivery(prepared.acceptance, fleetPub);
                     }
                     catch (e) {
                         if (durableHeartbeat)
@@ -499,7 +506,7 @@ export async function handleTasks(req, res, match, ctx) {
                                         userMsgEntryId = promptEntryId;
                                     const causeAtDone = ev.type === "done" ? ac.cause() : undefined;
                                     await deps.userInputLedger?.observeLegEvent(liveStream, ev);
-                                    prepared.acceptance.observe(ev);
+                                    await prepared.acceptance.observe(ev);
                                     await liveWorkspace.observe(ev);
                                     if (ev.type === "done") {
                                         finalResult = await mintSubmitExitResult(ev.result, deps.checkpointStore);
@@ -847,7 +854,10 @@ export async function handleTasks(req, res, match, ctx) {
                 };
                 counters.uncountedBillableInflight++;
                 try {
-                    resp = await idemCache.run(inflightKey, async () => withRunReceipt(await runStreamSubmitLeg()));
+                    const settling = idemCache.run(inflightKey, async () => withRunReceipt(await runStreamSubmitLeg()));
+                    if (!ranLive)
+                        runSlot?.release();
+                    resp = await settling;
                 }
                 catch (e) {
                     deps.logger?.error("stream_error", { closed, err: redactHead(e instanceof Error ? e.message : String(e), 2000) });
@@ -894,14 +904,15 @@ export async function handleTasks(req, res, match, ctx) {
                         if (placementReject)
                             return placementReject;
                         durableTaskId = tid;
+                        fillRunPreviewOnDelivery(prepared.acceptance, deps.runStore, tid);
                     }
                     if (deps.checkpointStore) {
-                        const ctxRefusal = await persistSubmitCtx(deps.checkpointStore, deps, durableTaskId !== undefined && deps.runStore ? { runStore: deps.runStore, taskId: durableTaskId } : undefined, prepared.spec.sessionId, { body: prepared.body, memoryScope: prepared.auth?.memoryScope, writerVersion: serviceVersion() });
+                        const ctxRefusal = await persistSubmissionCtx(deps.checkpointStore, deps, durableTaskId !== undefined && deps.runStore ? { runStore: deps.runStore, taskId: durableTaskId } : undefined, prepared);
                         if (ctxRefusal)
                             return ctxRefusal;
                     }
                     commitSessionInheritEnv(deps, prepared.spec.sessionId, prepared.body);
-                    const syncCancelCtrl = createRunAbort();
+                    const syncCancelCtrl = createRunAbort(principal ?? null);
                     markChildrenStoppedByUserOnAbort(syncCancelCtrl.signal, durableTaskId ?? prepared.spec.sessionId, prepared.auth?.principal);
                     if (durableTaskId && deps.runStore) {
                         const rs = deps.runStore;
@@ -917,11 +928,13 @@ export async function handleTasks(req, res, match, ctx) {
                         }, HEARTBEAT_MS);
                         durableHeartbeat.unref?.();
                         inflightRuns.set(tid, syncCancelCtrl);
+                        runSlot?.release();
                         void Promise.resolve(rs.isCancelRequested?.(tid, owner)).then((c) => { if (c && !syncCancelCtrl.signal.aborted)
                             abortFromVerb(); }).catch(() => undefined);
                     }
                     else if (durableTaskId) {
                         inflightRuns.set(durableTaskId, syncCancelCtrl);
+                        runSlot?.release();
                     }
                     const specWithSignal = { ...prepared.spec, signal: syncCancelCtrl.signal, ...(durableTaskId ? { taskId: durableTaskId } : {}) };
                     const observeSyncLegEvent = (ev) => {
@@ -940,7 +953,7 @@ export async function handleTasks(req, res, match, ctx) {
                             const syncWorkspace = createSessionWorkspaceRecorder(sessionWorkspaceStoreOf(deps.sessionStorage), prepared.legFacts?.sessionWitness);
                             for await (const ev of stream) {
                                 observeSyncLegEvent(ev);
-                                prepared.acceptance.observe(ev);
+                                await prepared.acceptance.observe(ev);
                                 await syncWorkspace.observe(ev);
                             }
                             return stream.result();
@@ -998,12 +1011,20 @@ export async function handleTasks(req, res, match, ctx) {
                     noteRunOutcome(result);
                     return { status: 200, body: withSyncSubmitKeys(buildSyncSubmitBody(exitResult)) };
                 };
-                const resp = await idemCache.run(inflightKey, async () => withRunReceipt(await runSyncSubmitLeg()));
+                let ranSyncLeg = false;
+                const settling = idemCache.run(inflightKey, async () => {
+                    ranSyncLeg = true;
+                    return withRunReceipt(await runSyncSubmitLeg());
+                });
+                if (!ranSyncLeg)
+                    runSlot?.release();
+                const resp = await settling;
                 sendSubmitResult(res, resp);
             }
             return;
         }
         finally {
+            runSlot?.release();
             prepared.peerLease.release();
         }
     }

package/dist/http/routes/trace-usage.js

@@ -102,7 +102,7 @@ export async function handleTraceUsage(req, res, match, ctx) {
             };
             const now = Date.now();
             const from = parseT(q.get("from"), now - 7 * 86_400_000);
-            const to = parseT(q.get("to"), now);
+            const to = parseT(q.get("to"), now + 1);
             if (Number.isNaN(from) || Number.isNaN(to) || from >= to) {
                 sendError(res, 400, "request.query_invalid", "invalid from/to (ISO-8601 or epoch-ms; from < to)");
                 return;

package/dist/http/run-concurrency-cap.d.ts

@@ -0,0 +1,86 @@
+/**
+ * 在飞 run 并发帽 —— `RUN_MAX_CONCURRENT`(本副本全局)/ `RUN_MAX_CONCURRENT_PER_PRINCIPAL`(同一已验提交主体),缺省 0 = 关。
+ *
+ * ## 为什么有这一只
+ * 共享一台 GPU / 一只小模型网关的部署,调用方自己限并发不可靠(多个调用方、重试风暴、脚本一把梭)。`RATE_LIMIT_RPM` 是速率桶(每分钟几条),
+ * 不是「此刻有几条在跑」;一条 run 可以跑几十分钟,速率桶放行的新提交会在同一台机器上叠起来。本帽数的就是后一个量。
+ *
+ * ## 数什么
+ * **同一份**在飞集:`inflightRuns ∪ steerableRuns`({@link liveRunIdsOf} —— `drainState.inflight` 读的也是它;`isRunLiveOnThisReplica`(`http/server.ts`)是同一并集的逐 id 判,
+ * 另写成两只 `has` 的析取,不经本函数;计数只有这一处写法,不另造第二份)。按主体数时读 `inflightRuns` 值上的 `owner`({@link RunAbort.owner} —— 句柄与腿同寿,不另起旁表);
+ * 只在 `steerableRuns` 里的键没有属主可读,只计入全局(今天每条可 steer 的腿都同时登记在 `inflightRuns`,这是形式上的保守)。
+ * 数的是**本副本**:副本之间不共享,多副本部署的整体并发 = 各副本的帽之和。
+ *
+ * ## 判点(哪几扇门判、哪几扇不判)
+ * 判 = **新提交要起一条 run** 的三个提交门(`routes/runs.ts` 的 `createDurableRun` —— `POST /v1/runs` 与 A2A `message/send` 共用的建行腿、
+ * `routes/tasks.ts` 的 `POST /v1/tasks` 与 `POST /v1/tasks/stream`),且排在**幂等重放之后**(同键 / 自带 taskId 的重试拿回自己的回执,不吃新 429)。
+ * 不判 = 已有 run 的延续与作答:续跑、唤醒、审批 / 问答作答、`/decide` —— 它们不是新提交,在飞时照样占一格(被数;没有 run 行的老形续跑不登记进在飞集,不被数),
+ * 但拒它们会把一张已经在等人的卡卡死。所以帽闸的是**新提交**,不是在飞总数的硬上限:一条停驻的 run 续跑回来时,在飞数可以越过帽。
+ * leader 口的后台 run 不在 `inflightRuns` 里(drain 靠 `uncountedBillableInflight` 看见它),本帽不数它也不判它。
+ * 位置的两个如实:三个口的帽都排在受理漏斗(`prepareSpec`,可能为新会话做登记)**之后**、建行与 SSE 头之前 —— `POST /v1/runs` 与 A2A 口因自带 `taskId` 的重放在漏斗之后才答、帽必须排在它后面
+ * (与 lease / 治理窗的 429 同位),`POST /v1/tasks` 两口与它们同位;拒时漏斗已做的会话登记不撤。同键的并发重复提交若赶在首发还在受理(尚未落行、尚未进在飞合流)的窗里到达,按新提交判,
+ * 帽满时与其它准入门(速率 / 配额)同形可能拿到一次 429 + `Retry-After`,按它重投即拿回首发的回执。
+ *
+ * ## 席位(为什么放行不是「读一下数就完了」)
+ * 判完帽到这条 run 登记进 `inflightRuns` 之间隔着若干次 await(建行、执行放置、续跑输入落库 …)。并发一阵提交若都只「读数」,会全部在登记之前读到同一个数、
+ * 一起放行 —— 越帽。所以放行即**占一枚席位**({@link RunSlot}),在飞数 = 在飞集 + 未放的席位。席位在这条 run 登记进在飞集的那一拍放掉:
+ * 三个提交门同形:建行腿 `mintAndDriveDurableRun` 在 `runInBackground`(返回前同步登记)返回后就地放(`runSlot` 入参),`POST /v1/tasks` / `/v1/tasks/stream` 两腿在各自的
+ * `inflightRuns.set` 之后就地放;提交门的 `finally` 总再放一次兜底(早退、被别的门拒、抛 —— `release` 幂等)。登记到放席位之间没有 await,别的提交读不到
+ * 「既在集里又占着席位」的中间态,所以不重复计。
+ * 两个尾巴:合流进别人在飞建行的重复提交(同键赛过 `peek`)自己不建行 —— `POST /v1/tasks` 一族席位当场放回;`POST /v1/runs`(与 A2A 提交)的席位到这一次提交的整段结清(`.finally`)才放,
+ *   合流的那一次要等共享铸件结清,帽边上可多答一次 429;没有 run store 的部署上同步 / 流式腿根本不登记进在飞集
+ * (drain 靠 `uncountedBillableInflight` 数它们),它们的席位就活到请求结束 —— 帽照样数得到它们。
+ *
+ * ## 拒的形
+ * 429 `limit.rate_exceeded`(沿用现有限流码,不新铸一枚:消费端的分支同「稍后再来」)+ 体里机读 `reason`(闭集 {@link RATE_EXCEEDED_REASONS},今天一词)
+ * + `retryAfterSec`(固定 {@link RUN_CONCURRENCY_RETRY_AFTER_SEC});头 `Retry-After` 与体里同值,同其它限流 / 配额门的发送形(`res.setHeader("retry-after")` + `sendError`)。
+ * 拒在建行、认领会话与 SSE 头之前(受理漏斗已做的会话登记见上面「位置的两个如实」)。
+ *
+ * ## 谁需要 / 谁受伤 / 补偿
+ * 需要:共享一台 GPU 或一只小模型网关的家用 / 小团队部署。受伤:超帽者拿 429(新行为,缺省关)。补偿:缺省 0 = 关(升级零变化)+ `Retry-After` 给退避。
+ * 无主体请求(无头 service 凭据、`REQUIRE_PRINCIPAL=false` 的单用户部署)只受全局帽 —— 按主体帽对它不判(没有主体可分账)。
+ */
+import type { IncomingMessage, ServerResponse } from "node:http";
+import type { RunAbort } from "../run-cancel-context.js";
+import { type RefusalBody } from "./refusal-body.js";
+import type { FlatServiceDeps } from "./server.js";
+/**
+ * 本副本在飞 run 的 id 集 —— `inflightRuns`(durable 腿)∪ `steerableRuns`(活流)的**唯一**并集写法:
+ * `drainState.inflight`(排空等多久)、`isRunLiveOnThisReplica`(这条 run 是不是在本副本跑)与并发帽读的是同一份。
+ * 参数取 `ReadonlyMap`:读法不改登记簿。
+ */
+export declare function liveRunIdsOf(inflightRuns: ReadonlyMap<string, unknown>, steerableRuns: ReadonlyMap<string, unknown>): Set<string>;
+/** 并发帽拒的机读 `reason` 词。 */
+export declare const RUN_CONCURRENCY_CAP_REASON: "run_concurrency_cap";
+/**
+ * 429 `limit.rate_exceeded` 体上机读 `reason` 的**闭集**(穷举读它;加一种拒因 ⇒ 这里加一词,`switch` 的消费端编译红)。
+ * 其余 `limit.rate_exceeded` 的产地(速率桶、赎回准入、MCP 探活、烘焙提交)不带 `reason` —— 读法是「有 `reason` 才分」。
+ */
+export declare const RATE_EXCEEDED_REASONS: readonly ["run_concurrency_cap"];
+export type RateExceededReason = (typeof RATE_EXCEEDED_REASONS)[number];
+/** 退避提示:固定 5 秒(是提示不是承诺 —— 在飞的 run 可能再跑很久;帽满只说「稍后再来」)。 */
+export declare const RUN_CONCURRENCY_RETRY_AFTER_SEC = 5;
+/** 一枚席位:放行与登记进在飞集之间占着的那一格。`release` 幂等(登记点放一次,提交门的 `finally` 再放一次兜底)。 */
+export interface RunSlot {
+    release(): void;
+}
+/** 并发帽拒的 `{status, body, retryAfterSec}`(体经全仓唯一组句器;状态与退避供发送口用)。 */
+export declare function runConcurrencyRefusalOf(): {
+    readonly status: 429;
+    readonly body: RefusalBody;
+    readonly retryAfterSec: number;
+};
+export interface RunConcurrencyGate {
+    /**
+     * 提交门的并发帽准入:放行 ⇒ 交回席位(调用点登记那一拍 / `finally` 放);超帽 ⇒ 已应答 429(+ `Retry-After`),交回 `undefined`,调用点 `return`。
+     * 位序:在幂等重放、`rateLimited` / `quotaExceeded` / `leaseDenied` / `usageWindowDenied` 之后,任何建行 / 认领 / SSE 头之前。
+     */
+    admitRun(req: IncomingMessage, res: ServerResponse): RunSlot | undefined;
+}
+/** 装配口:`deps` 只读 `config`(两旋钮,每次判时现读)与 `logger`;在飞集由 server 装配层交来(两张登记簿本身,不拷)。 */
+export declare function createRunConcurrencyGate(ctx: {
+    deps: Pick<FlatServiceDeps, "config" | "logger">;
+    inflightRuns: ReadonlyMap<string, RunAbort>;
+    steerableRuns: ReadonlyMap<string, unknown>;
+}): RunConcurrencyGate;
+//# sourceMappingURL=run-concurrency-cap.d.ts.map

package/dist/http/run-concurrency-cap.js

@@ -0,0 +1,54 @@
+import { gatedPrincipal } from "./principal-gate.js";
+import { refusalBody } from "./refusal-body.js";
+import { sendError } from "./send.js";
+export function liveRunIdsOf(inflightRuns, steerableRuns) {
+    return new Set([...inflightRuns.keys(), ...steerableRuns.keys()]);
+}
+export const RUN_CONCURRENCY_CAP_REASON = "run_concurrency_cap";
+export const RATE_EXCEEDED_REASONS = [RUN_CONCURRENCY_CAP_REASON];
+export const RUN_CONCURRENCY_RETRY_AFTER_SEC = 5;
+const UNTRACKED_SLOT = { release: () => undefined };
+export function runConcurrencyRefusalOf() {
+    return {
+        status: 429,
+        body: refusalBody({
+            errorCode: "limit.rate_exceeded",
+            message: "too many runs are in flight on this server right now — nothing was started; retry after the Retry-After interval",
+            facts: { reason: RUN_CONCURRENCY_CAP_REASON, retryAfterSec: RUN_CONCURRENCY_RETRY_AFTER_SEC },
+        }),
+        retryAfterSec: RUN_CONCURRENCY_RETRY_AFTER_SEC,
+    };
+}
+export function createRunConcurrencyGate(ctx) {
+    const { deps, inflightRuns, steerableRuns } = ctx;
+    const seats = new Set();
+    function admitRun(req, res) {
+        const { runMaxConcurrent: globalCap, runMaxConcurrentPerPrincipal: ownCap } = deps.config;
+        if (globalCap === 0 && ownCap === 0)
+            return UNTRACKED_SLOT;
+        const owner = gatedPrincipal(req, deps.config);
+        const live = liveRunIdsOf(inflightRuns, steerableRuns);
+        const inFlight = live.size + seats.size;
+        let scope;
+        if (globalCap > 0 && inFlight >= globalCap)
+            scope = "global";
+        else if (ownCap > 0 && owner !== undefined) {
+            const holders = [...[...live].map((id) => inflightRuns.get(id)?.owner), ...[...seats].map((seat) => seat.owner)];
+            if (holders.filter((o) => o === owner).length >= ownCap)
+                scope = "principal";
+        }
+        if (scope !== undefined) {
+            deps.logger?.info?.("run_concurrency_cap_refused", { scope, inFlight, cap: scope === "global" ? globalCap : ownCap, hasPrincipal: owner !== undefined });
+            const refusal = runConcurrencyRefusalOf();
+            const { error, errorCode, ...extra } = refusal.body;
+            res.setHeader("retry-after", String(refusal.retryAfterSec));
+            sendError(res, refusal.status, errorCode, error, extra);
+            return undefined;
+        }
+        const seat = { owner };
+        seats.add(seat);
+        return { release: () => void seats.delete(seat) };
+    }
+    return { admitRun };
+}
+//# sourceMappingURL=run-concurrency-cap.js.map