@sema-agent/core 5.12.0 → 5.14.0

package/dist/core/session-store.d.ts

@@ -1,5 +1,6 @@
 import { type SessionRepo } from "../internal/harness.js";
 import { type AcquiredSession, type SessionStore, type SessionStoreSummary } from "./session.js";
+import type { StoreDurability } from "./checkpoint-store.js";
 import { SESSION_DEFAULT_TTL_DAYS } from "../config/defaults.js";
 export { SESSION_DEFAULT_TTL_DAYS };
 export type EvictPolicy = "delete" | "forget";
@@ -8,8 +9,11 @@ export interface TtlSessionStoreOptions {
     sweepIntervalMs?: number;
     repo?: SessionRepo;
     evict?: EvictPolicy;
+    durability?: StoreDurability;
 }
 export declare class TtlSessionStore implements SessionStore {
+    readonly retention: "none";
+    readonly durability?: StoreDurability;
     private repo;
     private entries;
     private owners;

package/dist/core/session-store.js

@@ -4,6 +4,8 @@ const DAY_MS = 24 * 60 * 60 * 1000;
 import { SESSION_DEFAULT_TTL_DAYS } from "../config/defaults.js";
 export { SESSION_DEFAULT_TTL_DAYS };
 export class TtlSessionStore {
+    retention = "none";
+    durability;
     repo;
     entries = new Map();
     owners = new Map();
@@ -14,6 +16,9 @@ export class TtlSessionStore {
     sweepTimer;
     constructor(opts = {}) {
         this.repo = opts.repo ?? new InMemorySessionRepo();
+        const durability = opts.durability ?? (opts.repo === undefined ? "process-local" : undefined);
+        if (durability !== undefined)
+            this.durability = durability;
         this.defaultTtlMs = (opts.defaultTtlDays ?? SESSION_DEFAULT_TTL_DAYS) * DAY_MS;
         this.evictPolicy = opts.evict ?? (opts.repo ? "forget" : "delete");
         if (opts.sweepIntervalMs !== undefined && opts.sweepIntervalMs > 0) {

package/dist/core/session.d.ts

@@ -20,6 +20,7 @@ export interface SessionStoreSummary {
     forkedFrom?: string;
 }
 export interface SessionStore {
+    readonly durability?: import("./checkpoint-store.js").StoreDurability;
     acquire(sessionId?: string, opts?: {
         requireExisting?: boolean;
     }): Promise<AcquiredSession>;

package/dist/core/store-contracts/background-agent-store-contract.js

@@ -52,6 +52,25 @@ export async function backgroundAgentStoreContract(mk, runAssertion) {
         assert.equal(await store.get("a1", "tenant-C"), null, "an unrelated scope must not see the row");
         assert.equal(await store.get("a-missing", S), null);
     });
+    run("the org-admission fields round-trip, and ABSENT stays absent (a backend must not invent a verdict)", async (make) => {
+        const store = make();
+        await store.put(record({ handle: "a1", admittedOrgScopes: ["org:acme", "org:beta"], admittedOrgWriteScope: "org:acme" }));
+        const withVerdict = await held(store, "a1");
+        assert.deepEqual(withVerdict.admittedOrgScopes, ["org:acme", "org:beta"]);
+        assert.equal(withVerdict.admittedOrgWriteScope, "org:acme");
+        await store.put(record({ handle: "a2", admittedOrgScopes: [], admittedOrgWriteScope: null }));
+        const readOnly = await held(store, "a2");
+        assert.deepEqual(readOnly.admittedOrgScopes, []);
+        assert.equal(readOnly.admittedOrgWriteScope, null);
+        await store.put(record({ handle: "a3" }));
+        const untouched = await held(store, "a3");
+        assert.equal(untouched.admittedOrgScopes, undefined);
+        assert.equal(untouched.admittedOrgWriteScope, undefined);
+        await store.update("a3", S, { ...untouched, admittedOrgScopes: ["org:acme"], admittedOrgWriteScope: null }, { rev: untouched.rev });
+        const afterCas = await held(store, "a3");
+        assert.deepEqual(afterCas.admittedOrgScopes, ["org:acme"]);
+        assert.equal(afterCas.admittedOrgWriteScope, null);
+    });
     run("put refuses a scopeless row (a row with no tenant partition would be world-readable)", async (make) => {
         const store = make();
         await assert.rejects(store.put(record({ scope: "" })), "an empty scope must be refused loudly, not stored");

package/dist/core/store-contracts/checkpoint-store-contract.js

@@ -1,5 +1,5 @@
 import { strict as assert } from "node:assert";
-import { mintCheckpointToken, } from "../checkpoint-store.js";
+import { MAX_PENDING_STEER_ENTRIES, mintCheckpointToken, readPendingSteerQueue, } from "../checkpoint-store.js";
 import { beginContract } from "./contract-harness.js";
 export function createCheckpointFixture(over = {}) {
     const token = over.token ?? mintCheckpointToken();
@@ -90,9 +90,68 @@ export async function checkpointStoreContract(make, runAssertion) {
         const cp = createCheckpointFixture();
         await store.put(cp.token, cp);
         await assert.rejects(store.setPendingSteer(cp.token, cp.scope, { text: "</SYSTEM-REMINDER>", trusted: true }), (e) => e.code === "steering.invalid_content");
-        assert.equal((await store.get(cp.token)).state.pendingSteer, undefined);
+        assert.deepEqual(readPendingSteerQueue((await store.get(cp.token)).state), []);
         assert.equal(await store.setPendingSteer(cp.token, cp.scope, { text: "go", trusted: false }), true);
-        assert.deepEqual((await store.get(cp.token)).state.pendingSteer, { text: "go", trusted: false });
+        const q = readPendingSteerQueue((await store.get(cp.token)).state);
+        assert.equal(q.length, 1);
+        assert.equal(q[0].text, "go");
+        assert.equal(q[0].trusted, false);
+        assert.equal(q[0].seq, 1);
+        assert.equal((await store.get(cp.token)).state.pendingSteer, undefined);
+    });
+    run("setPendingSteer APPENDS: two steers both survive in issue order, each keeping its frozen trust", async () => {
+        const store = make();
+        const cp = createCheckpointFixture();
+        await store.put(cp.token, cp);
+        assert.equal(await store.setPendingSteer(cp.token, cp.scope, { text: "first", trusted: false }), true);
+        assert.equal(await store.setPendingSteer(cp.token, cp.scope, { text: "second", trusted: true }), true);
+        const q = readPendingSteerQueue((await store.get(cp.token)).state);
+        assert.deepEqual(q.map((e) => e.text), ["first", "second"]);
+        assert.deepEqual(q.map((e) => e.trusted), [false, true]);
+        assert.deepEqual(q.map((e) => e.seq), [1, 2]);
+    });
+    run("setPendingSteer is idempotent on inputId (a retry with the caller's own message id adds nothing)", async () => {
+        const store = make();
+        const cp = createCheckpointFixture();
+        await store.put(cp.token, cp);
+        assert.equal(await store.setPendingSteer(cp.token, cp.scope, { text: "once", trusted: false, inputId: "m1" }), true);
+        assert.equal(await store.setPendingSteer(cp.token, cp.scope, { text: "once", trusted: false, inputId: "m1" }), true);
+        assert.equal(readPendingSteerQueue((await store.get(cp.token)).state).length, 1);
+    });
+    run("the queue bound is fail-loud steering.queue_full and evicts nothing", async () => {
+        const store = make();
+        const cp = createCheckpointFixture();
+        await store.put(cp.token, cp);
+        for (let i = 0; i < MAX_PENDING_STEER_ENTRIES; i++) {
+            assert.equal(await store.setPendingSteer(cp.token, cp.scope, { text: `s${i}`, trusted: false }), true);
+        }
+        await assert.rejects(store.setPendingSteer(cp.token, cp.scope, { text: "overflow", trusted: false }), (e) => e.code === "steering.queue_full");
+        const q = readPendingSteerQueue((await store.get(cp.token)).state);
+        assert.equal(q.length, MAX_PENDING_STEER_ENTRIES);
+        assert.deepEqual(q.map((e) => e.text), Array.from({ length: MAX_PENDING_STEER_ENTRIES }, (_, i) => `s${i}`));
+    });
+    run("a queue entry round-trips every FROZEN field (actor/inputId/priority included)", async () => {
+        const store = make();
+        const cp = createCheckpointFixture();
+        await store.put(cp.token, cp);
+        assert.equal(await store.setPendingSteer(cp.token, cp.scope, {
+            text: "attributed",
+            trusted: true,
+            actor: { id: "slack:U1", hostAsserted: true, issuer: "slack-app:A1" },
+            inputId: "m-42",
+            priority: "now",
+        }), true);
+        const q = readPendingSteerQueue((await store.get(cp.token)).state);
+        assert.deepEqual(q, [
+            { text: "attributed", trusted: true, actor: { id: "slack:U1", hostAsserted: true, issuer: "slack-app:A1" }, inputId: "m-42", priority: "now", seq: 1 },
+        ]);
+    });
+    run("an unknown steering field is REFUSED (a producer must not have its new field silently dropped)", async () => {
+        const store = make();
+        const cp = createCheckpointFixture();
+        await store.put(cp.token, cp);
+        await assert.rejects(store.setPendingSteer(cp.token, cp.scope, { text: "go", trusted: false, futureField: 1 }), (e) => e.code === "steering.invalid_content");
+        assert.deepEqual(readPendingSteerQueue((await store.get(cp.token)).state), []);
     });
     run("expire vs resolve on the same row → exactly one wins; reap expires past-deadline pending in scope", async () => {
         const store = make();

package/dist/core/task-notification.d.ts

@@ -41,6 +41,8 @@ export interface SystemInjection<TPayload = unknown> {
 }
 export declare function taskNotificationDedupKey(n: Pick<TaskNotificationPayload, "task_id" | "task_type" | "status" | "seq">): string;
 export declare function taskNotificationLaneKey(n: Pick<TaskNotificationPayload, "task_id" | "task_type">): string;
+export declare function attrEscape(value: string): string;
+export declare const EXTERNAL_SOURCE_MAX = 120;
 export declare function renderTaskNotificationXml(n: TaskNotificationPayload): string;
 export declare const MAX_PENDING_EVENTS_PER_TASK = 50;
 export declare const MAX_PENDING_EVENTS_PER_SESSION = 200;

package/dist/core/task-notification.js

@@ -38,10 +38,10 @@ export function taskNotificationDedupKey(n) {
 export function taskNotificationLaneKey(n) {
     return n.task_type === "external" ? `external:${n.task_id}` : n.task_id;
 }
-function attrEscape(value) {
+export function attrEscape(value) {
     return value.replace(/&/g, "&amp;").replace(/"/g, "&quot;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
 }
-const EXTERNAL_SOURCE_MAX = 120;
+export const EXTERNAL_SOURCE_MAX = 120;
 export function renderTaskNotificationXml(n) {
     const usage = n.usage === undefined
         ? undefined
@@ -54,7 +54,9 @@ export function renderTaskNotificationXml(n) {
             }
         })();
     const open = n.task_type === "external"
-        ? `<task-notification type="external"${n.source !== undefined ? ` from="${attrEscape(inlineUntrusted(n.source, EXTERNAL_SOURCE_MAX))}"` : ""}>`
+        ? `<task-notification type="external"${n.source !== undefined
+            ? ` from="${attrEscape(inlineUntrusted(n.source, EXTERNAL_SOURCE_MAX))}" from-unverified="true"`
+            : ""}>`
         : "<task-notification>";
     return [
         open,

package/dist/core/task-registry-agent.d.ts

@@ -28,6 +28,7 @@ export declare function reapDurableAgentsLane(core: DurableAgentCore, scope: str
 }>;
 export declare function releaseDurableTranscriptAnchorLane(core: DurableAgentCore, id: string): void;
 export declare function bindBackgroundAgentSessionLane(core: DurableAgentCore, id: string, sessionId: string): void;
+export declare function recordBackgroundAgentOrgAdmissionLane(core: DurableAgentCore, id: string, verdict: import("./memory-admission.js").OwnOrgAdmissionVerdict): void;
 export declare function registerBackgroundAgentLane(core: DurableAgentCore, input: RegisterBackgroundAgentInput): string;
 export declare function parkBackgroundAgentLane(core: DurableAgentCore, id: string, park: {
     checkpointToken: string;

package/dist/core/task-registry-agent.js

@@ -247,6 +247,12 @@ export function bindBackgroundAgentSessionLane(core, id, sessionId) {
     handle.sessionId = sessionId;
     durableAgentWriteLane(handle, { sessionId });
 }
+export function recordBackgroundAgentOrgAdmissionLane(core, id, verdict) {
+    const handle = core.handles.get(id);
+    if (!handle || handle.type !== "background_agent")
+        return;
+    durableAgentWriteLane(handle, { admittedOrgScopes: [...verdict.scopes], admittedOrgWriteScope: verdict.writeScope });
+}
 export function registerBackgroundAgentLane(core, input) {
     assertOwnership(input, "registerBackgroundAgent");
     if (input.id !== undefined && !DURABLE_AGENT_HANDLE_RE.test(input.id)) {

package/dist/core/task-registry.d.ts

@@ -101,6 +101,7 @@ export declare class TaskRegistry {
     releaseDurableTranscriptAnchor(id: string): void;
     bindBackgroundAgentSession(id: string, sessionId: string): void;
     registerBackgroundAgent(input: RegisterBackgroundAgentInput): string;
+    recordBackgroundAgentOrgAdmission(id: string, verdict: import("./memory-admission.js").OwnOrgAdmissionVerdict): void;
     parkBackgroundAgent(id: string, park: {
         checkpointToken: string;
         seq?: number;

package/dist/core/task-registry.js

@@ -10,7 +10,7 @@ import { registerWorkflowLane, pollWorkflowLane, stopWorkflowLane } from "./task
 import { mintCompletionId, canAccessWorkflowRun, formatWorkflowRun, clipTaskOutput, assertOwnership, sleepPollStep, statusFromBackground, rollSpoolText, accountDroppedBytes, renderSpoolBody, spoolDropNote, droppedGapNote, alreadyTerminalStopNote, terminalTaskSummary, TASK_OUTPUT_MAX_CHARS, MONITOR_BATCH_WINDOW_MS, MONITOR_DEFAULT_TIMEOUT_MS, MONITOR_MAX_TIMEOUT_MS, MONITOR_MAX_BATCHES_PER_MINUTE, canAccess, DURABLE_AGENT_HANDLE_RE, } from "./task-registry-shared.js";
 export { normalizeAgentName, DURABLE_AGENT_HEARTBEAT_MS, DURABLE_AGENT_HANDLE_RE, BG_AGENT_REAP_STOP_ERROR } from "./task-registry-shared.js";
 import { TASK_OUTPUT_TOOL_NAME, TASK_STOP_TOOL_NAME, TASK_OUTPUT_CONTRACT, TASK_STOP_CONTRACT, TASK_OUTPUT_MISSING_ID_MESSAGE, TASK_STOP_MISSING_ID_MESSAGE, TASK_STOP_PARAMS, resolveTaskIdArg, REGISTRY_TASK_TOOL_CAPS, composeTaskOutputDescription, composeTaskOutputParams, composeTaskStopDescription, } from "./task-tool-shape.js";
-import { durableAgentArmedLane, durableAgentRowProbeLane, beginDurableClaimLane, endDurableClaimLane, reapDurableAgentsLane, noteBackgroundAgentActivityLane, reapStaleSessionBackgroundAgentsLane, releaseDurableTranscriptAnchorLane, bindBackgroundAgentSessionLane, registerBackgroundAgentLane, parkBackgroundAgentLane, reconcileParkedAgentsLane, claimParkedAgentLane, rollbackParkedClaimLane, consumeParkedFlipLane, finalizeParkedResumeLane, settleBackgroundAgentLane, abortBackgroundAgentsForOwnerLane, serveDurableAgentRowLane, resolveBackgroundAgentByNameLane, markRetainedContinuationLane, reviveBackgroundAgentLane, settleRevivedAgentLane, unmarkRetainedContinuationLane, attachAgentNotifyLane, deliverToRunningAgentLane, runningBackgroundAgentLabelsLane, runningAgentFooterLane, notFoundRunningAgentsTail, pollBackgroundAgentLane, stopBackgroundAgentLane, } from "./task-registry-agent.js";
+import { durableAgentArmedLane, durableAgentRowProbeLane, beginDurableClaimLane, endDurableClaimLane, reapDurableAgentsLane, noteBackgroundAgentActivityLane, reapStaleSessionBackgroundAgentsLane, releaseDurableTranscriptAnchorLane, bindBackgroundAgentSessionLane, registerBackgroundAgentLane, recordBackgroundAgentOrgAdmissionLane, parkBackgroundAgentLane, reconcileParkedAgentsLane, claimParkedAgentLane, rollbackParkedClaimLane, consumeParkedFlipLane, finalizeParkedResumeLane, settleBackgroundAgentLane, abortBackgroundAgentsForOwnerLane, serveDurableAgentRowLane, resolveBackgroundAgentByNameLane, markRetainedContinuationLane, reviveBackgroundAgentLane, settleRevivedAgentLane, unmarkRetainedContinuationLane, attachAgentNotifyLane, deliverToRunningAgentLane, runningBackgroundAgentLabelsLane, runningAgentFooterLane, notFoundRunningAgentsTail, pollBackgroundAgentLane, stopBackgroundAgentLane, } from "./task-registry-agent.js";
 export { canAccessWorkflowRun, clipTaskOutput, MONITOR_BATCH_WINDOW_MS, MONITOR_DEFAULT_TIMEOUT_MS, MONITOR_MAX_TIMEOUT_MS, MONITOR_MAX_BATCHES_PER_MINUTE };
 const BLOCK_DEFAULT_TIMEOUT_MS = 30_000;
 const BLOCK_MAX_TIMEOUT_MS = 600_000;
@@ -146,6 +146,9 @@ export class TaskRegistry {
     registerBackgroundAgent(input) {
         return registerBackgroundAgentLane(this.core, input);
     }
+    recordBackgroundAgentOrgAdmission(id, verdict) {
+        return recordBackgroundAgentOrgAdmissionLane(this.core, id, verdict);
+    }
     parkBackgroundAgent(id, park) {
         return parkBackgroundAgentLane(this.core, id, park);
     }

package/dist/core/tool-policy.d.ts

@@ -80,12 +80,17 @@ export interface AskRequest {
     toolCallId: string;
     args: unknown;
     readonly preview?: unknown;
+    readonly boundInputHash?: string;
     message: string;
     readonly principal?: string;
     readonly sourceTaskId?: string;
     readonly fromSubagent?: true;
     readonly sourceAgentName?: string;
     readonly requiresRealApproval?: boolean;
+    readonly riskAxes?: {
+        readonly irreversible?: boolean;
+        readonly egress?: boolean;
+    };
     readonly delegation?: AskDelegationProvenance;
 }
 export type OnAsk = "deny" | "allow" | ((req: AskRequest, signal?: AbortSignal) => AskOutcome | Promise<AskOutcome>);

package/dist/core/tool-policy.js

@@ -1,6 +1,7 @@
 import { homedir } from "node:os";
 import { isAbsolute, join, normalize as normalizePath, sep } from "node:path";
 import { BASH_READONLY_DEFAULT_ALLOW, parseLeadingCommandName } from "../tools/fs/index.js";
+import { boundInputHashOf } from "./canonical-json.js";
 import { writeTargetPath } from "../tools/fs/safety.js";
 export function decisionText(d) {
     return d.message;
@@ -606,7 +607,7 @@ export async function resolveAsk(req, onAsk, signal) {
                 decisionReason: "mode",
             };
         }
-        ok = await onAsk({ ...req, args: approverView.value }, signal);
+        ok = await onAsk({ ...req, boundInputHash: boundInputHashOf(presented.value), args: approverView.value }, signal);
     }
     catch (err) {
         return {

package/dist/core/tool-result-store.d.ts

@@ -1,5 +1,6 @@
 import type { AgentTool } from "../internal/harness-types.js";
 export interface ToolResultStore {
+    readonly retention?: import("./retention.js").RetentionDeclaration;
     put(ref: string, content: string): Promise<void> | void;
     get(ref: string, opts?: {
         offset?: number;
@@ -15,6 +16,7 @@ export interface ToolResultSlice {
 }
 export declare class InMemoryToolResultStore implements ToolResultStore {
     private readonly opts?;
+    readonly retention: "none";
     private readonly map;
     private totalChars;
     constructor(opts?: {

package/dist/core/tool-result-store.js

@@ -25,6 +25,7 @@ function refSegment(raw) {
 }
 export class InMemoryToolResultStore {
     opts;
+    retention = "none";
     map = new Map();
     totalChars = 0;
     constructor(opts) {

package/dist/core/types.d.ts

@@ -1,6 +1,6 @@
 import type { TSchema } from "typebox";
 import type { AgentTool, ThinkingLevel } from "../internal/harness.js";
-import type { CompleteSimpleFn, DocumentContent, ImageContent, Model, ResilienceOptions, StreamFn, TextContent } from "../internal/llm.js";
+import type { ActorAssertion, CompleteSimpleFn, DocumentContent, ImageContent, Model, ResilienceOptions, StreamFn, TextContent } from "../internal/llm.js";
 import type { TaskNotificationPayload } from "./task-notification.js";
 export type ModelRef = string | Model;
 export interface StaleToolResultOffloadOptions {
@@ -129,6 +129,7 @@ export interface ToolExecuteContext {
     taskId?: string;
     sessionId?: string;
     backgroundScope?: "task" | "session";
+    interactionPosture?: "interactive" | "headless";
     onBackgroundChildEvent?: (event: BackgroundChildEvent) => void;
     onTaskNotification?: (n: import("./task-notification.js").TaskNotificationPayload, opts?: {
         priority?: import("./task-notification.js").SystemInjectionPriority;
@@ -274,6 +275,9 @@ export interface TaskSpec {
     taskId?: string;
     objective: string;
     principal?: string;
+    actor?: ActorAssertion;
+    interactionPosture?: "interactive" | "headless";
+    interactiveQuestionFallback?: boolean;
     images?: ImageInput[];
     sessionId?: string;
     requireExistingSession?: boolean;
@@ -436,6 +440,10 @@ export interface TaskResult {
         code: "conversation_only" | "files_env_unsupported" | "snapshot_store_unconfigured";
         message: string;
     }>;
+    strandedHumanAnswers?: ReadonlyArray<{
+        deliveryId: string;
+        toolCallId: string;
+    }>;
     stats: {
         turns: number;
         tokens: number;
@@ -517,6 +525,9 @@ export interface ToolActivity {
     arg?: string;
     isError?: boolean;
 }
+export type HumanInputSource = "objective" | "steer" | "next_turn" | "wake" | "external" | "system";
+export type HumanInputDelivery = "applied" | "queued" | "parked_for_wake";
+export type DelegationTaskType = Extract<TaskNotificationPayload["task_type"], "background_agent" | "workflow">;
 export type TaskEvent = ({
     type: "text_delta";
     delta: string;
@@ -584,7 +595,7 @@ export type TaskEvent = ({
     reason?: string;
 } & TaskEventIdentity) | ({
     type: "steering_injected";
-    source: "limit_approach" | "todo_reminder" | "task_reminder" | "tool_search_usage_reminder" | "changed_files" | "plan_mode" | "date_change" | "instructions_change" | "workflow_size_guideline_change" | "budget_usd" | "background_tasks" | "tools_delta" | "agent_listing" | "skills_listing" | "mcp_instructions" | "mcp_dropped_tools";
+    source: "limit_approach" | "todo_reminder" | "task_reminder" | "tool_search_usage_reminder" | "changed_files" | "plan_mode" | "date_change" | "instructions_change" | "workflow_size_guideline_change" | "budget_usd" | "background_tasks" | "tools_delta" | "agent_listing" | "skills_listing" | "mcp_instructions" | "mcp_dropped_tools" | "final_verification";
     preview: string;
 } & TaskEventIdentity) | ({
     type: "diagnostics";
@@ -613,6 +624,17 @@ export type TaskEvent = ({
     entryId: string;
     role: "user" | "assistant" | "toolResult";
     toolCallId?: string;
+} & TaskEventIdentity) | ({
+    type: "human_input";
+    inputId: string;
+    sessionSeq: number;
+    carrier: string;
+    source: HumanInputSource;
+    issuer?: string;
+    actor?: ActorAssertion;
+    delivery: HumanInputDelivery;
+    principal?: string;
+    entryId?: string;
 } & TaskEventIdentity) | ({
     type: "status";
 } & BrainStatus & TaskEventIdentity) | ({
@@ -621,6 +643,7 @@ export type TaskEvent = ({
 } & TaskEventIdentity) | ({
     type: "task_progress";
     taskId: string;
+    taskType?: DelegationTaskType;
     workflowRunId?: string;
     workflowAgentLabel?: string;
     parentTaskId?: string;
@@ -635,16 +658,23 @@ export type TaskEvent = ({
 } & TaskEventIdentity) | ({
     type: "workspace_changed";
     cwd: string;
+} & TaskEventIdentity) | ({
+    type: "wiring_manifest";
+    manifest: import("./wiring-manifest.js").WiringManifest;
 } & TaskEventIdentity) | {
     type: "done";
     result: TaskResult;
 };
+export type HumanInputEvent = Extract<TaskEvent, {
+    type: "human_input";
+}>;
 export type CompactOutcome = "compacted" | "failed" | "mooted" | "noop" | "blocked" | "disabled";
 export interface TaskStream extends AsyncIterable<TaskEvent> {
     result(): Promise<TaskResult>;
     suggestions(): Promise<string[]>;
     steer(text: string, options?: {
         trusted?: boolean;
+        actor?: ActorAssertion;
     }): Promise<void>;
     notify(payload: import("./task-notification.js").ExternalNotificationInput, opts?: {
         priority?: import("./task-notification.js").SystemInjectionPriority;
@@ -737,6 +767,11 @@ export interface RunnerDeps {
     fileSnapshotStore?: import("./file-snapshot-store.js").FileSnapshotStore;
     sessionPolicyStore?: import("./session-policy-store.js").SessionPolicyStore;
     runtimeCapsResolver?: (principal: string | undefined) => RuntimeCaps | undefined | Promise<RuntimeCaps | undefined>;
+    lockedConfig?: import("./locked-config.js").LockedConfig;
+    compliancePostureResolver?: (principal: string | undefined) => import("./compliance.js").CompliancePosture | undefined | Promise<import("./compliance.js").CompliancePosture | undefined>;
+    memoryScopeAdmission?: import("./memory-admission.js").MemoryScopeAdmission;
+    deploymentMemoryScopes?: readonly string[];
+    retentionPolicy?: import("./retention.js").RetentionPolicy;
     autoMode?: {
         rules?: import("./auto-mode-prompt.js").AutoModeRules;
         settingsDenyRules?: readonly string[];
@@ -793,6 +828,7 @@ export interface RunnerDeps {
     toolPolicy?: import("./tool-policy.js").ToolPolicy;
     onAsk?: import("./tool-policy.js").OnAsk;
     onQuestion?: import("./ask-question.js").OnQuestion;
+    interactionPosture?: "interactive" | "headless";
     lspManager?: import("./lsp.js").LspServerManager;
     hooks?: import("./hooks.js").Hooks;
     allowImageUrl?: (url: string) => boolean;

package/dist/core/wiring-manifest.d.ts

@@ -0,0 +1,97 @@
+import type { RunnerDeps, TaskSpec } from "./types.js";
+import { type StoreDurability } from "./checkpoint-store.js";
+export type { StoreDurability };
+export type ManifestDurability = "declared_durable" | "process_local";
+export type WiringLegKind = "root" | "child" | "resume";
+export type AskSeamForm = "callback" | "allow" | "deny" | "absent";
+export type AskEffective = "human_reachable" | "auto_allow" | "auto_deny" | "park_only" | "unresolved";
+export type QuestionChannelState = "wired" | "absent" | "stripped_bg_lane";
+export type SeamProvenance = "spec" | "deps";
+export type ParkLaneReason = "no_checkpoint_store" | "no_durable_approval_opt_in" | "no_force_durable_gate" | "no_armed_safety_vocabulary" | "await_runtime_caps" | "await_tool_vocabulary";
+export interface WiringManifest {
+    schemaVersion: 1;
+    leg?: {
+        kind: WiringLegKind;
+    };
+    ask: {
+        form: AskSeamForm;
+        provenance?: SeamProvenance;
+        effective?: AskEffective;
+    };
+    question: {
+        wired: QuestionChannelState;
+        provenance?: SeamProvenance;
+        interactiveToolsWithoutDeliveryFace?: true;
+    };
+    interaction: {
+        posture: "interactive" | "headless" | "absent";
+    };
+    elicit: {
+        seamWired: boolean;
+        serversOptedIn: number;
+    };
+    parkLane: {
+        capable: boolean;
+        effective: boolean | "unresolved";
+        reasons: readonly ParkLaneReason[];
+        checkpointDurability?: ManifestDurability;
+    };
+    session: {
+        store: ManifestDurability;
+    };
+    fleet: {
+        backgroundAgentStore: boolean;
+        hostChildEventSink: boolean;
+    };
+    governance: {
+        audience: "operator";
+        lockedConfig: boolean;
+        compliance: boolean;
+        memoryAdmission: boolean;
+        retention: boolean;
+    };
+    configFingerprint?: string;
+}
+export interface WiringFacts {
+    half: "static" | "effective";
+    leg?: WiringLegKind;
+    askForm: AskSeamForm;
+    askProvenance?: SeamProvenance;
+    questionWired: boolean;
+    questionProvenance?: SeamProvenance;
+    questionStrippedByEngine?: boolean;
+    interactiveToolsWithoutDeliveryFace?: boolean;
+    interactionPosture?: "interactive" | "headless";
+    elicitSeamWired: boolean;
+    elicitServersOptedIn: number;
+    parkCapable: boolean;
+    parkDurableApprovalOptIn: boolean;
+    parkForceDurableGate?: boolean;
+    parkSafetyVocabularyArmed?: boolean;
+    checkpointDurability?: StoreDurability;
+    sessionDurability: StoreDurability;
+    backgroundAgentStoreWired: boolean;
+    hostChildEventSinkWired: boolean;
+    lockedConfigWired: boolean;
+    complianceWired: boolean;
+    memoryAdmissionWired: boolean;
+    retentionPolicyWired: boolean;
+}
+export type StaticWiringDeps = Pick<RunnerDeps, "onAsk" | "onQuestion" | "interactionPosture" | "onElicit" | "checkpointStore" | "sessionStore" | "backgroundAgentStore" | "onBackgroundChildEvent" | "lockedConfig" | "compliancePostureResolver" | "memoryScopeAdmission" | "retentionPolicy">;
+export type StaticWiringSpec = Pick<TaskSpec, "onAsk" | "onQuestion" | "checkpointStore" | "durableApproval" | "mcp" | "interactiveTools" | "interactionPosture">;
+export declare function resolveDeclaredDurability(store: {
+    readonly durability?: StoreDurability;
+} | undefined, storeName: string): StoreDurability;
+export declare function deriveAskEffective(form: AskSeamForm, parkEffective: boolean | "unresolved"): AskEffective;
+export declare function deriveWiringManifest(facts: WiringFacts): WiringManifest;
+export declare function resolveAskSeamForm(spec: Pick<TaskSpec, "onAsk">, deps: Pick<RunnerDeps, "onAsk">): {
+    form: AskSeamForm;
+    provenance?: SeamProvenance;
+};
+export declare function resolveQuestionSeam(spec: Pick<TaskSpec, "onQuestion">, deps: Pick<RunnerDeps, "onQuestion">): {
+    wired: boolean;
+    provenance?: SeamProvenance;
+};
+export declare function countElicitOptIns(spec: Pick<TaskSpec, "mcp">): number;
+export declare function resolveElicitSeam(deps: Pick<RunnerDeps, "onElicit">): boolean;
+export declare function describeStaticWiring(deps: StaticWiringDeps, spec?: StaticWiringSpec): WiringManifest;