@sema-agent/server 7.147.0 → 7.149.0

package/dist/run-local.d.ts

@@ -32,10 +32,18 @@ export interface RunLocalDeps {
     fetchImpl?: typeof fetch;
     /** Structured logger (defaults to the real one at config.logLevel). */
     logger?: Logger;
-    /** stdout sink for the human/JSON result (defaults to console.log). */
-    print?: (line: string) => void;
-    /** stderr sink for the "you still need to set …" guidance (defaults to console.error). */
-    printErr?: (line: string) => void;
+    /** stdout sink for the human/JSON result (defaults to the log seam's declared non-log result exit `writeCliResult` — unscreened product output).
+     *  A sink may be async: `runLocal` awaits what it returns at every call site, so the entry never returns (and `main()` never `process.exit`s)
+     *  before the result bytes are handed to the stream — a piped stdout would otherwise lose the tail of a large result. A plain synchronous sink returns `void`.
+     *  A sink that throws or rejects propagates out of `runLocal` (as a synchronous throw always did); one that never settles holds it. `writeCliResult` never rejects —
+     *  it settles when the stream has taken the bytes (a reader that stops reading the pipe holds it until the reader reads or closes). */
+    print?: (text: string) => Promise<void> | void;
+    /** stderr sink for the short sentences (usage / refusals / "you still need to set …" guidance / the unfinished-stop footer; defaults to the log seam's text
+     *  exit `writeLogText` — screened). Same law as {@link RunLocalDeps.print}: a sink may be async — `runLocal` (and the no-TTY notice of {@link createLocalApprover})
+     *  awaits what it returns at every call site, so the entry never returns (and `main()` never `process.exit`s) before the sentence is handed to the stream — a piped
+     *  stderr would otherwise cut the tail of a longer sentence. A plain synchronous sink returns `void`; a sink that throws or rejects propagates; one that never
+     *  settles holds the entry. The default never rejects (it settles when the stream has taken the bytes). */
+    printErr?: (line: string) => Promise<void> | void;
     /** [ref] 件三: override the TTY detection behind the {@link createLocalApprover} seat
      *  (defaults to `process.stdin.isTTY === true`) — lets a test drive BOTH arms deterministically. */
     isTty?: boolean;
@@ -105,8 +113,8 @@ export interface LocalApproverIo {
     readonly isTty: boolean;
     /** TTY 臂的问人器(默认 {@link promptYesNoOnTty} 的 readline y/N;`signal`=core 取消透传)。 */
     readonly askYesNo: (prompt: string, signal?: AbortSignal) => Promise<boolean>;
-    /** 非 TTY 臂的告知面(stderr)。 */
-    readonly printErr: (line: string) => void;
+    /** 非 TTY 臂的告知面(stderr)。可等:席在告知句交给流之后才交出拒答({@link RunLocalDeps.printErr} 同一条律)。 */
+    readonly printErr: (line: string) => Promise<void> | void;
     /** [ref]:本席**没有人被问**就拒了一只 ask(无 TTY / 参数展示不出)的事实出口 —— 退出码的判据之一(见 {@link unfinishedStopOf}):
      *  这一拒交给 core 的是部署政策拒(不停批、不记人拒),「活没干完」于是不再经 core 的人拒标记传出来,由本席自己说。 */
     readonly noteRefusedWithoutPerson: () => void;

package/dist/run-local.js

@@ -1,14 +1,13 @@
 #!/usr/bin/env node
-import { DEFAULT_AT_MENTION, DEFAULT_MODEL_REF, resolveTaskModel } from "./model-select.js";
-import { defaultModelRefusal, modelUnavailableMessage } from "./model-entry-refusal.js";
+import { DEFAULT_MODEL_REF, pickUserModel } from "./model-select.js";
+import { defaultModelRefusal, modelNotAllowedMessage, modelUnavailableMessage } from "./model-entry-refusal.js";
 import { servedModelTableLeg } from "./model-select.js";
-import { createDurableAbsenceSeat } from "./observability/corrupt-read-seat.js";
-import { outwardPlane } from "./terminal.js";
+import { outwardPlane, sealResultForExit } from "./terminal.js";
 import { join } from "node:path";
 import { realpathSync } from "node:fs";
 import { createInterface } from "node:readline/promises";
 import { fileURLToPath } from "node:url";
-import { BIDI_CONTROL_CHARS, Runner, uuidv7, FileStorageBackend, NodeExecutionEnv, TtlSessionStore, CenterPromptSource, FilePromptArtifactStore, FilePromptSourceStateStore, MemoryPromptArtifactStore, MemoryPromptSourceStateStore, defaultTaskRegistry } from "@sema-agent/core";
+import { BIDI_CONTROL_CHARS, Runner, uuidv7, NodeExecutionEnv, TtlSessionStore, CenterPromptSource, FilePromptArtifactStore, FilePromptSourceStateStore, MemoryPromptArtifactStore, MemoryPromptSourceStateStore, defaultTaskRegistry } from "@sema-agent/core";
 import { readAskClassPair } from "./approval-card.js";
 import { singleUserAutoAcceptBaselineApplies } from "./approval.js";
 import { withUnattendedLeg } from "./unattended-permission-mode.js";
@@ -20,16 +19,18 @@ import { ForkRoutingSessionStore } from "./plugins/fork-routing-session-store.js
 import { taskWallClockSec } from "./task-workflow.js";
 import { applyCenterArtifact, centerSourceOnError } from "./capabilities/center-prompts.js";
 import { buildUnpricedCeilingNotice, isRosterGateArmed, loadConfig, logConfigDiagnostics, parseConfigProvider, parseNumOrFailNonNegative } from "./config.js";
-import { buildStoreOpenRefusalTail } from "./plugins/store-open-refusal.js";
-import { acquireLocalBackendWithWait } from "./plugins/store-lock-wait.js";
+import { admitLocalDataRoot } from "./plugins/local-data-root-admission.js";
+import { openLocalBackend } from "./plugins/store-backend.js";
+import { runAndLogOneTimeMigrations } from "./plugins/one-time-migrations.js";
 import { configLocalRoot, createConfigProvider } from "./config-provider.js";
 import { CONFIG_DOMAIN_INVALID_NOTE, buildCandidateRejectedFields, buildCandidateRejectionNotes, judgeConfigCandidate } from "./web-admin-client/candidate-gate.js";
 import { buildUnreadConfigFileFields, buildUnreadConfigKeyFields } from "./web-admin-client/read-warnings.js";
-import { composeExecutionLane, settleHostLaneShell, warnReadDenyFloorUnkept } from "./boot/execution-lane.js";
+import { composeExecutionLane, settleHostLaneShell, settleReadDenyFloor } from "./boot/execution-lane.js";
 import { judgeConsolidationValve } from "./boot/memory-consolidation.js";
 import { logConfigDirMigration, migrateLocalConfigDirectory } from "./config-d-migration.js";
 import { logEnvModelsMigration, runEnvModelsMigration } from "./config-root-migration.js";
 import { assertLocalConfigDirTrusted, ConfigDirUntrustedError } from "./config-dir-trust.js";
+import { ConfigPullError, asConfigPullError, configPullFailureNote } from "./config-pull-failure.js";
 import { applyEffective, applyCenterReadFace, applySkillsManifest, resolveMcpServers, mcpForScenario, resolveA2aPeers, a2aForScenario } from "./web-admin-client/facade.js";
 import { hostExecutionEnvFactory } from "./plugins/remote-env-host.js";
 import { buildLaneHomeClaim, executionLaneOf } from "./execution-lane-caps.js";
@@ -43,12 +44,13 @@ import { createTaskListLane } from "./boot/task-list-lane.js";
 import { pickHandsRunner, withoutHands } from "./capabilities/hands-lane.js";
 import { HttpError, sessionIdShapeIssue } from "./security.js";
 import { createMemoryEngineIncidentSink } from "./memory-incident-sink.js";
-import { fileMemoryEngineRoot, memoryEngineBackendFor, memorySpecForRequest } from "./memory-scope.js";
+import { announceMemoryLedgerForm, fileMemoryEngineRoot, memoryEngineBackendFor, memorySpecForRequest } from "./memory-scope.js";
 import { createMemoryScopeStores } from "./memory-scope-stores.js";
 import { createMemoryProjectLayers } from "./memory-project-layer.js";
 import { assertProjectLayerOwnable } from "./project-identity.js";
 import { declaredCredential } from "./model-route-gap.js";
 import { judgeServedModelRoute } from "./model-route-endpoint.js";
+import { warnAssumedContextWindows } from "./context-window-notice.js";
 import { startMemorySyncRunner } from "./memory-sync-client.js";
 import { buildPricing, cappedCeiling, createTracer } from "./budget.js";
 import { createSharedRunnerDeps, installDefaultEngineNoticeSeat } from "./boot/runner-deps.js";
@@ -58,14 +60,16 @@ import { assertRetentionLaneWirable } from "./boot/retention-lane.js";
 import { createOrgMemoryAdmissionWiring } from "./boot/org-memory.js";
 import { assembleDeploymentMods } from "./boot/deployment-mods.js";
 import { createKeyResolver } from "./key-resolver.js";
-import { createLogger } from "./observability/logger.js";
+import { createLogger, writeCliResult, writeLogText, ttyPromptOutput } from "./observability/logger.js";
 import { fatalExit } from "./boot/fatal-exit.js";
 import { installProcessExitBoundary } from "./boot/exit-boundary.js";
 import { createMetrics } from "./observability/metrics.js";
 import { installSecretEnvScrubRecorder } from "./observability/secret-env-scrub.js";
-import { createHostLspManager } from "./host-lsp-manager.js";
+import { createLspManager } from "./host-lsp-manager.js";
 import { installOutboundDispatcher } from "./outbound-dispatcher.js";
-import { provisionSemaConfigDir } from "./sema-config-dir.js";
+import { announceConfigRootEnclosingWorkspace, provisionSemaConfigDir } from "./sema-config-dir.js";
+import { launchWorkspaceOf } from "./task-cwd.js";
+import { DEPLOYMENT_SHAPE_PREDICATES } from "./deployment-shape.js";
 import { bindOwnCredentialsConfig, declareServerWithheldEnv } from "./server-secret-env.js";
 export function parseArgs(argv) {
     let objective;
@@ -207,12 +211,12 @@ export function createLocalApprover(io) {
     };
     return async (req, signal) => {
         if (!io.isTty) {
-            io.printErr(`denied "${terminalSafeText(req.toolName)}" (${terminalSafeText(req.message)}) — this run-local invocation has no TTY, so there is nobody to ask. ${buildNoTtyRemedySentence(req)}`);
+            await io.printErr(`denied "${terminalSafeText(req.toolName)}" (${terminalSafeText(req.message)}) — this run-local invocation has no TTY, so there is nobody to ask. ${buildNoTtyRemedySentence(req)}`);
             return refuseWithoutPerson(NO_TTY_REFUSAL_REASON);
         }
         const argsShown = argsDisplayOf(req.args);
         if (!argsShown.ok) {
-            io.printErr(`denied "${terminalSafeText(req.toolName)}" (${terminalSafeText(req.message)}) — its arguments cannot be displayed ` +
+            await io.printErr(`denied "${terminalSafeText(req.toolName)}" (${terminalSafeText(req.message)}) — its arguments cannot be displayed ` +
                 `(${terminalSafeText(argsShown.reason)}), so there is nothing a person could review; refusing instead of asking.`);
             return refuseWithoutPerson(UNDISPLAYABLE_ARGS_REFUSAL_REASON);
         }
@@ -269,7 +273,7 @@ function inputAlreadyEnded(input) {
     const state = input;
     return state.readableEnded === true || state.destroyed === true;
 }
-export async function promptYesNoOnTty(prompt, signal, streams = { input: process.stdin, output: process.stderr }) {
+export async function promptYesNoOnTty(prompt, signal, streams = { input: process.stdin, output: ttyPromptOutput() }) {
     if (signal?.aborted || inputAlreadyEnded(streams.input))
         return false;
     const rl = createInterface({ input: streams.input, output: streams.output });
@@ -321,22 +325,22 @@ export const RUN_LOCAL_CONFIG_SOURCE_REFUSAL = "CONFIG_PROVIDER=remote: run-loca
     "(center credential renewal, sealed model keys and the roster gate are assembled by the HTTP service). Unset CONFIG_PROVIDER or set " +
     "CONFIG_PROVIDER=local for this command, or run the HTTP service to use the center.";
 export async function runLocal(argv, deps = {}) {
-    const print = deps.print ?? ((l) => console.log(l));
-    const printErr = deps.printErr ?? ((l) => console.error(l));
+    const print = deps.print ?? writeCliResult;
+    const printErr = deps.printErr ?? ((l) => writeLogText("stderr", l));
     let args;
     try {
         args = parseArgs(argv);
     }
     catch (err) {
         if (err instanceof UsageError) {
-            printErr(err.message);
+            await printErr(err.message);
             return 2;
         }
         throw err;
     }
     const configWord = parseConfigProvider();
     if (configWord === "remote") {
-        printErr(RUN_LOCAL_CONFIG_SOURCE_REFUSAL);
+        await printErr(RUN_LOCAL_CONFIG_SOURCE_REFUSAL);
         return 2;
     }
     if (configWord === undefined)
@@ -355,36 +359,45 @@ export async function runLocal(argv, deps = {}) {
     installSecretEnvScrubRecorder({ logger, metrics });
     installDefaultEngineNoticeSeat(logger, metrics);
     logConfigDiagnostics(logger);
-    provisionSemaConfigDir(loaded, logger);
+    let admission;
+    try {
+        admission = admitLocalDataRoot(root);
+    }
+    catch (e) {
+        await printErr(e instanceof Error ? e.message : String(e));
+        return 2;
+    }
     installOutboundDispatcher(logger);
     const providerInput = { provider: "local", localDir: root, localOwnerUid: loaded.configLocalOwnerUid };
     try {
         await assertLocalConfigDirTrusted({ root, declaredOwnerUid: loaded.configLocalOwnerUid });
     }
     catch (err) {
-        printErr(err instanceof Error ? err.message : String(err));
+        await printErr(err instanceof Error ? err.message : String(err));
         return 2;
     }
-    const envModelsMigration = { root, env: process.env, envTableIsPlaceholder: isRosterGateArmed(loaded.webAdmin) };
-    logEnvModelsMigration(logger, envModelsMigration, await runEnvModelsMigration(envModelsMigration));
     logConfigDirMigration(logger, await migrateLocalConfigDirectory(root));
     let config;
     try {
         config = await composeExecutionLane(loaded, { configSource: "local", localRoot: root, logger, entry: RUN_LOCAL_LANE_ENTRY });
     }
     catch (err) {
-        printErr(err instanceof Error ? err.message : String(err));
+        await printErr(err instanceof Error ? err.message : String(err));
         return 2;
     }
+    provisionSemaConfigDir(config, logger);
+    const envModelsMigration = { root, env: process.env, envTableIsPlaceholder: isRosterGateArmed(config.webAdmin) };
+    logEnvModelsMigration(logger, envModelsMigration, await runEnvModelsMigration(envModelsMigration));
     const configProvider = createConfigProvider(providerInput);
     const peerDesk = createPeerDesk({ log: logger });
     const rosterLease = peerDesk.lease("roster");
     let effective;
     let candidatePrompts;
     let candidateRejectionNotes;
-    let applying = false;
     try {
-        const r = await configProvider.fetchEffective(undefined);
+        const r = await configProvider.fetchEffective(undefined).catch((err) => {
+            throw asConfigPullError(err);
+        });
         if (r) {
             const verdict = judgeConfigCandidate(r);
             if (verdict.verdict === "rejected") {
@@ -400,7 +413,6 @@ export async function runLocal(argv, deps = {}) {
                     logger.warn("config_unread_key", buildUnreadConfigKeyFields(k, configProvider.kind === "local" ? root : undefined));
                 for (const d of r.droppedEntries ?? [])
                     logger.warn("config_entry_dropped", { domain: d.domain, entry: d.entry, reasonCode: d.reasonCode, error: d.error, version: r.effective.version, phase: "boot", note: "this one entry failed its domain schema and was dropped on its own — the rest of the candidate applies (per-entry tolerance); fix the named entry to bring it back" });
-                applying = true;
                 applyEffective(config, r.effective, logger, { leg: "boot", catalogSource: r.catalogSource });
                 effective = r.effective;
                 candidatePrompts = verdict.prompts;
@@ -415,13 +427,13 @@ export async function runLocal(argv, deps = {}) {
     }
     catch (err) {
         if (err instanceof ConfigDirUntrustedError) {
-            printErr(err.message);
+            await printErr(err.message);
             return 2;
         }
-        if (applying)
-            logger.warn("config_apply_refused", { source: configProvider.kind, err: String(err), note: "the candidate failed to apply at boot — running on env (run-local has no LKG); none of the candidate's domains is adopted; this is not a reachability failure" });
+        if (err instanceof ConfigPullError)
+            logger.warn("config_source_unreachable_using_env", { source: configProvider.kind, cause: err.pullCause, err: String(err), note: configPullFailureNote(err.pullCause) });
         else
-            logger.warn("config_source_unreachable_using_env", { source: configProvider.kind, err: String(err) });
+            logger.warn("config_apply_refused", { source: configProvider.kind, err: String(err), note: "the candidate failed to apply at boot — running on env (run-local has no LKG); none of the candidate's domains is adopted; this is not a reachability failure" });
     }
     const noDefaultModel = defaultModelRefusal({ models: config.models, modelRefusals: config.modelRefusals, candidateRejectionNotes }, servedModelTableLeg(config));
     if (noDefaultModel !== undefined)
@@ -429,6 +441,7 @@ export async function runLocal(argv, deps = {}) {
     const routeVerdict = judgeServedModelRoute(config, { envTableIsPlaceholder: false });
     if (routeVerdict !== undefined)
         throw new Error(routeVerdict.reason);
+    warnAssumedContextWindows(config, logger, { envTableIsPlaceholder: false });
     const unpricedCeiling = buildUnpricedCeilingNotice(config.models, config);
     if (unpricedCeiling)
         logger.warn(unpricedCeiling.event, unpricedCeiling.fields);
@@ -436,8 +449,8 @@ export async function runLocal(argv, deps = {}) {
         assertGuardPatternsUsable(config);
     }
     catch (e) {
-        printErr(e instanceof Error ? e.message : String(e));
-        printErr(`(local config root: ${root} — fix it in ${join(root, ".env")} or your shell env; \`SENSITIVE_WRITE_PATTERNS=off\` disables the guard set)`);
+        await printErr(e instanceof Error ? e.message : String(e));
+        await printErr(`(local config root: ${root} — fix it in ${join(root, ".env")} or your shell env; \`SENSITIVE_WRITE_PATTERNS=off\` disables the guard set)`);
         return 2;
     }
     const ungatedCompensation = buildOnlySensitiveBaselineWarning(config, {
@@ -452,47 +465,53 @@ export async function runLocal(argv, deps = {}) {
     if (!deps.brain) {
         const missing = missingGatewayRequirements(config);
         if (missing.length > 0) {
-            printErr("cannot run: you still need to set:");
+            await printErr("cannot run: you still need to set:");
             for (const m of missing)
-                printErr(`  - ${m}`);
-            printErr(`(local config root: ${root} — put them in ${join(root, ".env")} or your shell env)`);
+                await printErr(`  - ${m}`);
+            await printErr(`(local config root: ${root} — put them in ${join(root, ".env")} or your shell env)`);
             return 2;
         }
     }
     const brain = deps.brain ?? createBrain(config, deps.fetchImpl ? { fetchImpl: deps.fetchImpl } : {});
     const pricing = buildPricing(config.models);
-    let fileBackend;
+    let backend;
+    try {
+        backend = openLocalBackend({ ...config, localDataRoot: root }, { lane: "run-local", admission, onWarn: (msg, fields) => logger.warn(msg, fields), onError: (msg, fields) => logger.error(msg, fields) });
+    }
+    catch (e) {
+        await printErr(e instanceof Error ? e.message : String(e));
+        return 2;
+    }
     try {
-        fileBackend = acquireLocalBackendWithWait(() => new FileStorageBackend({
-            root,
-            ...(config.fileHistory !== undefined ? { fileHistory: config.fileHistory } : {}),
-            onCorruptRead: createDurableAbsenceSeat(logger.warn.bind(logger), root, "file-snapshot = a snapshot or scope read as missing"),
-        }), config.storeLockWaitMs, (fields) => logger.warn("store_dir_lock_wait", { ...fields }));
+        await backend.ensureSchema();
+        await runAndLogOneTimeMigrations(logger, backend);
     }
     catch (e) {
-        printErr(`cannot open local data dir ${root}: ${e instanceof Error ? e.message : String(e)}`);
-        const tail = buildStoreOpenRefusalTail(e, "run-local");
-        if (tail !== undefined)
-            printErr(tail);
+        await printErr(e instanceof Error ? e.message : String(e));
+        await backend.close();
         return 2;
     }
-    const sessionStore = fileBackend.sessionStore;
+    const sessionStore = backend.session();
+    const engineStores = backend.engineFileStores();
     const keyResolver = createKeyResolver(config.modelApiKeyEnv, process.env, config.modelApiKeys);
     const hostRx = config.remoteExec.provider === "host" ? config.remoteExec : undefined;
-    const workspaceDir = args.workspace ?? hostRx?.workspaceBase ?? process.cwd();
+    const launchWorkspace = launchWorkspaceOf(config, args.workspace);
+    const workspaceDir = launchWorkspace.dir;
+    announceConfigRootEnclosingWorkspace(config, logger, launchWorkspace);
     await settleHostLaneShell(config, logger);
-    warnReadDenyFloorUnkept(config, logger);
+    settleReadDenyFloor(config, logger);
     const homeDirSeat = buildLaneHomeClaim(config);
     const executionEnvFactory = hostRx
         ? hostExecutionEnvFactory({
             workspaceDir,
             ...homeDirSeat,
-            backgroundShell: config.requirePrincipal !== true,
+            backgroundShell: DEPLOYMENT_SHAPE_PREDICATES.backgroundShell.holds(config),
             ...(hostRx.commandTimeoutMs != null ? { commandTimeoutMs: hostRx.commandTimeoutMs } : {}),
         })
         : undefined;
-    const lspManager = hostRx && config.lspHostEnabled && config.requirePrincipal !== true ? createHostLspManager(config, (event, fields) => logger.info(event, fields)) : undefined;
+    const lspManager = createLspManager(config, (event, fields) => logger.info(event, fields));
     const engineDataRoot = fileMemoryEngineRoot(config, root);
+    await announceMemoryLedgerForm(config, root, logger);
     const fileEngine = memoryEngineBackendFor(config, root, memoryEngineIncident);
     const memoryEngine = fileEngine !== undefined
         ? createMemoryScopeStores({ backend: fileEngine.backend, root: engineDataRoot, onIncident: memoryEngineIncident })
@@ -501,9 +520,9 @@ export async function runLocal(argv, deps = {}) {
         judgeConsolidationValve({ config, memoryEngine });
     }
     catch (err) {
-        printErr(err instanceof Error ? err.message : String(err));
+        await printErr(err instanceof Error ? err.message : String(err));
         void lspManager?.dispose();
-        await fileBackend.dispose();
+        await backend.close();
         return 2;
     }
     let memorySync;
@@ -565,9 +584,9 @@ export async function runLocal(argv, deps = {}) {
         orgMemoryAdmission = createOrgMemoryAdmissionWiring({ config, logger, metrics });
     }
     catch (e) {
-        printErr(`MEMORY_ORG_DIRECTORY_JSON is invalid: ${e instanceof Error ? e.message : String(e)}`);
-        printErr(`(local config root: ${root} — fix it in ${join(root, ".env")} or your shell env, or unset it)`);
-        await fileBackend.dispose();
+        await printErr(`MEMORY_ORG_DIRECTORY_JSON is invalid: ${e instanceof Error ? e.message : String(e)}`);
+        await printErr(`(local config root: ${root} — fix it in ${join(root, ".env")} or your shell env, or unset it)`);
+        await backend.close();
         return 2;
     }
     assertRetentionLaneWirable({
@@ -575,8 +594,8 @@ export async function runLocal(argv, deps = {}) {
         executor: undefined,
         stores: [
             { name: "sessionStore", store: sessionStore },
-            { name: "checkpointStore", store: fileBackend.checkpointStore },
-            { name: "toolResultStore", store: fileBackend.toolResultStore },
+            { name: "checkpointStore", store: engineStores.checkpointStore },
+            { name: "toolResultStore", store: backend.toolResult() },
         ],
         locked: (config.lockedConfigKeys ?? []).includes("retentionPolicy"),
     });
@@ -585,8 +604,8 @@ export async function runLocal(argv, deps = {}) {
         logger,
         retentionStores: [
             { name: "sessionStore", store: sessionStore },
-            { name: "checkpointStore", store: fileBackend.checkpointStore },
-            { name: "toolResultStore", store: fileBackend.toolResultStore },
+            { name: "checkpointStore", store: engineStores.checkpointStore },
+            { name: "toolResultStore", store: backend.toolResult() },
         ],
         retentionExecutor: null,
     });
@@ -598,21 +617,22 @@ export async function runLocal(argv, deps = {}) {
         engineDataRoot,
         governanceSeams,
         logger,
-        hands: { commitCoAuthor: "Sema <noreply@vivi-ai.com>" },
+        commitCoAuthor: "Sema <noreply@vivi-ai.com>",
         brain,
         pricing,
         tracer: createTracer(metrics),
         promptSource,
         executionEnvFactory,
         lspManager,
-        backgroundAgentStore: fileBackend.backgroundAgentStore,
-        mailboxStore: fileBackend.mailboxStore,
-        rosterStore: fileBackend.rosterStore,
+        backgroundAgentStore: engineStores.backgroundAgentStore,
+        mailboxStore: engineStores.mailboxStore,
+        rosterStore: engineStores.rosterStore,
         deploymentMods,
-        toolResultStore: fileBackend.toolResultStore,
+        toolResultStore: backend.toolResult(),
+        fileHistoryStore: undefined,
         checkpointStore: undefined,
-        sessionPolicyStore: fileBackend.sessionPolicyStore,
-        usageWindowStore: config.usageWindows ? fileBackend.usageWindowStore : undefined,
+        sessionPolicyStore: backend.sessionPolicy(),
+        usageWindowStore: config.usageWindows ? backend.fileUsageWindowStore() : undefined,
         orgMemoryAdmission,
         sharedMemoryStores: undefined,
         mcpRevocations: undefined,
@@ -644,7 +664,7 @@ export async function runLocal(argv, deps = {}) {
     const scenarioDeps = {
         runner, subRunner, model: DEFAULT_MODEL_REF, skills, repoClient, logger,
         ...(webSearch ? { webSearch } : {}),
-        backgroundAgentStore: fileBackend.backgroundAgentStore,
+        backgroundAgentStore: engineStores.backgroundAgentStore,
         taskListStoreFor: taskListLane.storeFor,
     };
     const scenarios = buildScenarios(scenarioDeps);
@@ -661,21 +681,25 @@ export async function runLocal(argv, deps = {}) {
     }
     catch (err) {
         if (err instanceof HttpError) {
-            printErr(`cannot run scenario "${scenarioName}": ${err.message}`);
+            await printErr(`cannot run scenario "${scenarioName}": ${err.message}`);
             if (scenarioName === "scan")
-                printErr("(the `scan` scenario needs a git API base URL and a repo — run-local cannot supply a repo; use the default scenario)");
+                await printErr("(the `scan` scenario needs a git API base URL and a repo — run-local cannot supply a repo; use the default scenario)");
             void lspManager?.dispose();
-            await fileBackend.dispose();
+            await backend.close();
             return 2;
         }
         throw err;
     }
-    const mention = resolveTaskModel(undefined, args.objective, config.models, DEFAULT_AT_MENTION, config.modelRefusals);
-    if (mention.unavailable !== undefined) {
-        const { requested, name, refusal } = mention.unavailable;
-        printErr(`cannot run: ${modelUnavailableMessage("@-mention", requested, name, refusal)}`);
+    const { picked: mention } = pickUserModel(config, undefined, args.objective);
+    const mentionRefusal = mention.unavailable !== undefined
+        ? modelUnavailableMessage("@-mention", mention.unavailable.requested, mention.unavailable.name, mention.unavailable.refusal)
+        : mention.notAllowed !== undefined
+            ? modelNotAllowedMessage("@-mention", mention.notAllowed.requested, mention.notAllowed.resolved)
+            : undefined;
+    if (mentionRefusal !== undefined) {
+        await printErr(`cannot run: ${mentionRefusal}`);
         void lspManager?.dispose();
-        await fileBackend.dispose();
+        await backend.close();
         return 2;
     }
     const scope = args.user ?? "local";
@@ -684,9 +708,9 @@ export async function runLocal(argv, deps = {}) {
             assertProjectLayerOwnable(scope, "--user");
         }
         catch (err) {
-            printErr(err instanceof Error ? err.message : String(err));
+            await printErr(err instanceof Error ? err.message : String(err));
             void lspManager?.dispose();
-            await fileBackend.dispose();
+            await backend.close();
             return 2;
         }
     }
@@ -732,7 +756,7 @@ export async function runLocal(argv, deps = {}) {
         const deadline = Date.now() + 5_000;
         try {
             for (;;) {
-                const running = (await fileBackend.backgroundAgentStore.listByScope(scope, { status: "running" })).length;
+                const running = (await engineStores.backgroundAgentStore.listByScope(scope, { status: "running" })).length;
                 if (running === 0)
                     return;
                 if (Date.now() >= deadline) {
@@ -753,30 +777,33 @@ export async function runLocal(argv, deps = {}) {
         result = await taskRunner.runTask(spec);
     }
     catch (err) {
-        printErr(`task crashed: ${err instanceof Error ? err.message : String(err)}`);
+        await printErr(`task crashed: ${err instanceof Error ? err.message : String(err)}`);
         await settleSessionBackground();
         runner.sessions.dispose();
         subRunner.sessions.dispose();
         void lspManager?.dispose();
-        await fileBackend.dispose();
+        await backend.close();
         return 1;
     }
     const unfinishedStop = unfinishedStopOf(result, refusedWithoutPerson);
+    const shown = sealResultForExit(result);
     if (args.json) {
-        print(JSON.stringify(result, null, 2));
+        await print(JSON.stringify(shown, null, 2));
     }
-    else if (result.terminal.kind === "completed") {
-        print(result.result);
+    else if (shown.terminal.kind === "completed") {
+        await print(shown.result);
         if (unfinishedStop !== undefined)
-            printErr(buildUnfinishedStopFooter(unfinishedStop, sessionId));
+            await printErr(buildUnfinishedStopFooter(unfinishedStop, sessionId));
     }
     else {
-        const plane = outwardPlane(result.terminal);
-        const salvage = result.result || result.salvagedOutput || plane.blockedReason || "";
+        const plane = outwardPlane(shown.terminal);
+        const salvage = shown.result || shown.salvagedOutput || plane.blockedReason || "";
         if (salvage)
-            print(salvage);
-        printErr(`task ${plane.status}${plane.errorCode ? ` (${plane.errorCode})` : ""}${plane.errorMessage ? `: ${plane.errorMessage}` : ""}`);
+            await print(salvage);
+        await printErr(`task ${plane.status}${plane.errorCode ? ` (${plane.errorCode})` : ""}${plane.errorMessage ? `: ${plane.errorMessage}` : ""}`);
     }
+    if (!args.json && shown.readDenyFloor !== undefined)
+        await printErr(shown.readDenyFloor.message);
     if (result.terminal.kind !== "completed" || unfinishedStop !== undefined)
         exitCode = 1;
     if (memorySync)
@@ -785,7 +812,7 @@ export async function runLocal(argv, deps = {}) {
     runner.sessions.dispose();
     subRunner.sessions.dispose();
     void lspManager?.dispose();
-    await fileBackend.dispose();
+    await backend.close();
     return exitCode;
 }
 const RUN_LOCAL_SIGNAL_EXIT_CODE = { SIGINT: 130, SIGTERM: 143 };

package/dist/run-stale-default.d.ts

@@ -0,0 +1,7 @@
+/**
+ * `REAP_RUN_STALE_SEC` 的缺省值(秒)—— 唯一字面量。读者两处:配置装配(`config.ts`,env 缺席时)与 run 店的缺省判活窗
+ * (`plugins/store-contracts.ts` 的 {@link RUN_STALL_DEFAULT_WIRING}:不经后端装配、直接构造的店用它;生产装配一律递活配置的 getter)。
+ * 纯叶:零 import(配置层不得值引 plugins 层,所以它不住在店的契约文件里)。
+ */
+export declare const RUN_STALE_SEC_DEFAULT = 120;
+//# sourceMappingURL=run-stale-default.d.ts.map

package/dist/run-stale-default.js

@@ -0,0 +1,2 @@
+export const RUN_STALE_SEC_DEFAULT = 120;
+//# sourceMappingURL=run-stale-default.js.map