@sema-agent/core 5.13.0 → 5.15.0

package/dist/core/hooks.d.ts

@@ -1,5 +1,5 @@
 import type { DocumentContent, ImageContent, TextContent } from "../internal/llm.js";
-import type { SessionTreeEntry } from "../internal/harness-types.js";
+import type { ExecutionEnv, FileError, Result, SessionTreeEntry } from "../internal/harness-types.js";
 import type { PermissionResult, ResolvedAsk, ToolCallRequest } from "./tool-policy.js";
 export interface Hooks {
     preToolUse?(toolName: string, input: unknown, ctx: HookToolContext): PreToolUseResult | undefined | Promise<PreToolUseResult | undefined>;
@@ -72,9 +72,17 @@ export interface StopHookResult {
     block?: string;
     additionalContext?: string;
 }
+export interface HookEnvCapabilities {
+    canonicalPath?(path: string, abortSignal?: AbortSignal): Promise<Result<string, FileError>>;
+    exists?(path: string, abortSignal?: AbortSignal): Promise<Result<boolean, FileError>>;
+    readLink?(path: string, abortSignal?: AbortSignal): Promise<Result<string, FileError>>;
+    cwd?(): string;
+}
+export declare function createHookEnvCapabilities(env: ExecutionEnv): HookEnvCapabilities;
 export interface HookToolContext {
     toolCallId: string;
     toolName: string;
+    env?: HookEnvCapabilities;
 }
 export interface HookToolOutput {
     content: Array<TextContent | ImageContent | DocumentContent>;
@@ -103,6 +111,18 @@ export interface ToolGateResult {
     };
     preToolContext: string[];
 }
+export type ContentAskOutcome = {
+    kind: "answered";
+    presentedInput: unknown;
+} | {
+    kind: "unavailable";
+    presentedInput?: unknown;
+    parkDeclined: boolean;
+} | {
+    kind: "delivery_failure";
+    code: string;
+    presentedInput?: unknown;
+};
 export interface ToolGateInput {
     onNotifyError?: (failure: import("./safe-notify.js").SafeNotifyFailure) => void;
     event: {
@@ -111,9 +131,11 @@ export interface ToolGateInput {
         input: Record<string, unknown>;
     };
     preToolUse?: Hooks["preToolUse"];
+    hookEnv?: HookEnvCapabilities;
     adjudicate?: (req: ToolCallRequest) => Promise<PermissionResult>;
     resolveAsk: (decision: PermissionResult, req: ToolCallRequest) => Promise<ResolvedAsk>;
-    suspendAsk?: (req: ToolCallRequest, postHookArgs: unknown, safety?: import("./checkpoint-store.js").SafetyAxis, approverUnavailable?: boolean) => Promise<ToolGateResult["suspend"] | undefined>;
+    suspendAsk?: (req: ToolCallRequest, postHookArgs: unknown, safety?: import("./checkpoint-store.js").SafetyAxis, liveFaceUnavailable?: boolean) => Promise<ToolGateResult["suspend"] | undefined>;
+    resolveContentAsk?: (req: ToolCallRequest) => Promise<ContentAskOutcome>;
     egress?: boolean;
     irreversibility?: "never" | "maybe" | "always";
     reversibilityProbe?: (args: unknown) => {

package/dist/core/hooks.js

@@ -14,6 +14,67 @@ export function cloneObserverInput(input) {
         return input;
     }
 }
+const reflectApply = Reflect.apply;
+const getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;
+const getPrototypeOf = Object.getPrototypeOf;
+const objectPrototype = Object.prototype;
+function findEnvSlot(env, key) {
+    for (let o = env; o !== null && o !== objectPrototype; o = getPrototypeOf(o)) {
+        const desc = getOwnPropertyDescriptor(o, key);
+        if (desc !== undefined)
+            return { holder: o, desc };
+    }
+    return undefined;
+}
+function readEnvPrimitive(env, key) {
+    const slot = findEnvSlot(env, key);
+    if (slot === undefined)
+        return undefined;
+    return slot.desc.get !== undefined ? reflectApply(slot.desc.get, env, []) : slot.desc.value;
+}
+function createCwdReader(env) {
+    const slot = findEnvSlot(env, "cwd");
+    if (slot === undefined)
+        return undefined;
+    const getter = slot.desc.get;
+    const initial = getter !== undefined ? reflectApply(getter, env, []) : slot.desc.value;
+    if (typeof initial !== "string")
+        return undefined;
+    let last = initial;
+    return () => {
+        const desc = getOwnPropertyDescriptor(slot.holder, "cwd");
+        const value = desc === undefined
+            ? undefined
+            : desc.get !== undefined
+                ? desc.get === getter
+                    ? reflectApply(desc.get, env, [])
+                    : undefined
+                : desc.value;
+        if (typeof value === "string")
+            last = value;
+        return last;
+    };
+}
+export function createHookEnvCapabilities(env) {
+    const face = Object.create(null);
+    const canonicalPath = readEnvPrimitive(env, "canonicalPath");
+    const exists = readEnvPrimitive(env, "exists");
+    const readLink = readEnvPrimitive(env, "readLink");
+    const cwd = createCwdReader(env);
+    if (typeof canonicalPath === "function") {
+        face.canonicalPath = (path, abortSignal) => reflectApply(canonicalPath, env, [path, abortSignal]);
+    }
+    if (typeof exists === "function") {
+        face.exists = (path, abortSignal) => reflectApply(exists, env, [path, abortSignal]);
+    }
+    if (typeof readLink === "function") {
+        face.readLink = (path, abortSignal) => reflectApply(readLink, env, [path, abortSignal]);
+    }
+    if (cwd !== undefined) {
+        face.cwd = cwd;
+    }
+    return Object.freeze(face);
+}
 export function formatHookFeedback(text) {
     return `<system-reminder>\n${text}\n</system-reminder>`;
 }
@@ -61,6 +122,7 @@ function withProbeTimeout(p, ms, signal) {
 export async function runToolGate(input) {
     const { event, preToolUse, adjudicate, resolveAsk, suspendAsk } = input;
     const { toolCallId, toolName } = event;
+    const hookCtx = () => ({ toolCallId, toolName, ...(input.hookEnv !== undefined ? { env: input.hookEnv } : {}) });
     let currentInput = event.input;
     const preToolContext = [];
     let hookAsk;
@@ -68,7 +130,7 @@ export async function runToolGate(input) {
     if (preToolUse) {
         let r;
         try {
-            r = screenPreToolUseResult(await preToolUse(toolName, currentInput, { toolCallId, toolName }));
+            r = screenPreToolUseResult(await preToolUse(toolName, currentInput, hookCtx()));
         }
         catch (err) {
             const reason = preToolUseCrashReason(`this call to "${toolName}"`, err);
@@ -147,7 +209,10 @@ export async function runToolGate(input) {
             currentInput = policyRewrite;
             req.args = policyRewrite;
         }
-        if (input.autoMode && decision.action === "ask" && input.isMarkedUnresolvable?.(input.event.toolCallId) !== true) {
+        if (input.autoMode &&
+            decision.action === "ask" &&
+            req.toolName !== ASK_USER_QUESTION_TOOL_NAME &&
+            input.isMarkedUnresolvable?.(input.event.toolCallId) !== true) {
             const verdict = await input.autoMode.decider
                 .decide({ req, askMessage: decisionText(decision) }, input.abortSignal)
                 .catch(() => ({ kind: "unavailable", cause: "error" }));
@@ -180,13 +245,35 @@ export async function runToolGate(input) {
             }
         }
         if (decision.action === "ask" && req.toolName === ASK_USER_QUESTION_TOOL_NAME) {
-            decision = {
-                action: "deny",
-                message: "AskUserQuestion could not be parked for a durable human answer on this path (no checkpoint " +
-                    "facility, or the suspend failed) and a synchronous permission approver cannot carry an answer — " +
-                    "the question was NOT shown to anyone. Proceed with your best judgment and state the assumption " +
-                    "you made.",
-            };
+            const outcome = input.resolveContentAsk !== undefined ? await input.resolveContentAsk(req) : { kind: "unavailable", parkDeclined: false };
+            if (outcome.kind === "answered") {
+                decision = { action: "allow", updatedInput: outcome.presentedInput };
+            }
+            else if (outcome.kind === "unavailable") {
+                if (outcome.presentedInput !== undefined) {
+                    currentInput = outcome.presentedInput;
+                    req.args = outcome.presentedInput;
+                }
+                if (suspendAsk && outcome.parkDeclined) {
+                    const suspended = await suspendAsk(req, currentInput, safety, true);
+                    if (suspended) {
+                        return { suspend: suspended, preToolContext };
+                    }
+                }
+                decision = {
+                    action: "deny",
+                    message: "AskUserQuestion could not be parked for a durable human answer on this path (no checkpoint " +
+                        "facility, or the suspend failed) and a synchronous permission approver cannot carry an answer — " +
+                        "the question was NOT shown to anyone. Proceed with your best judgment and state the assumption " +
+                        "you made.",
+                };
+            }
+            else {
+                if (outcome.presentedInput !== undefined)
+                    decision = { action: "allow", updatedInput: outcome.presentedInput };
+                else
+                    decision = { action: "allow" };
+            }
         }
         if (decision.action === "ask") {
             const resolved = await resolveAsk(decision, req);
@@ -212,7 +299,7 @@ export async function runToolGate(input) {
                     if (preToolUse) {
                         let hr;
                         try {
-                            hr = screenPreToolUseResult(await preToolUse(toolName, editArgs, { toolCallId, toolName }));
+                            hr = screenPreToolUseResult(await preToolUse(toolName, editArgs, hookCtx()));
                         }
                         catch (err) {
                             traceHookCrash(input, err, notifier);

package/dist/core/human-input-projection.d.ts

@@ -0,0 +1,12 @@
+import { type ActorAssertion } from "../internal/llm.js";
+import type { HumanInputEvent, HumanInputSource, TaskEventIdentity } from "./types.js";
+export type { HumanInputSource, HumanInputDelivery, HumanInputEvent } from "./types.js";
+export interface HumanInputFrame {
+    text: string;
+    actor?: ActorAssertion;
+    source: HumanInputSource;
+}
+export declare function projectHumanInput(frame: HumanInputFrame): string;
+export declare function buildHumanInputEvent(input: Omit<HumanInputEvent, "type" | "inputId" | keyof TaskEventIdentity> & {
+    inputId?: string;
+}): HumanInputEvent;

package/dist/core/human-input-projection.js

@@ -0,0 +1,27 @@
+import { snapshotActorAssertion } from "../internal/llm.js";
+import { uuidv7 } from "../internal/harness.js";
+import { inlineUntrusted } from "./untrusted-text.js";
+import { attrEscape, EXTERNAL_SOURCE_MAX } from "./task-notification.js";
+export function projectHumanInput(frame) {
+    if (frame.actor === undefined || frame.source === "system")
+        return frame.text;
+    if (frame.text.trim().length === 0)
+        return frame.text;
+    const label = attrEscape(inlineUntrusted(frame.actor.id, EXTERNAL_SOURCE_MAX));
+    const mark = frame.actor.hostAsserted ? "" : " (unverified)";
+    return `[from "${label}"${mark}]\n${frame.text}`;
+}
+export function buildHumanInputEvent(input) {
+    return {
+        type: "human_input",
+        inputId: input.inputId ?? uuidv7(),
+        sessionSeq: input.sessionSeq,
+        carrier: input.carrier,
+        source: input.source,
+        delivery: input.delivery,
+        ...(input.issuer !== undefined ? { issuer: input.issuer } : {}),
+        ...(input.actor !== undefined ? { actor: snapshotActorAssertion(input.actor) } : {}),
+        ...(input.principal !== undefined ? { principal: input.principal } : {}),
+        ...(input.entryId !== undefined ? { entryId: input.entryId } : {}),
+    };
+}

package/dist/core/mcp.d.ts

@@ -5,8 +5,8 @@ import { type McpImageResizer } from "./image-downsample.js";
 import type { McpServerSpec, OnElicit, ToolEffect } from "./types.js";
 export interface McpToolAxis {
     name: string;
-    irreversibility?: "always";
-    egress?: true;
+    irreversibility?: "always" | "never";
+    egress?: boolean;
     effect?: ToolEffect;
 }
 export interface McpDroppedTool {
@@ -114,6 +114,11 @@ export type McpSchemaNormalizeResult = {
 export declare function normalizeMcpToolSchema(schema: unknown): McpSchemaNormalizeResult;
 export declare function mcpToolSchemaProblem(schema: unknown): string | undefined;
 export declare function materializeMcpTools(specs: McpServerSpec[], principal?: string, onElicit?: OnElicit, imageResizer?: McpImageResizer): Promise<MaterializedMcp>;
+export declare function applyCallerAxisOverride(name: string, hint: McpToolAxis | undefined, override: {
+    effect?: ToolEffect;
+    egress?: boolean;
+    irreversibility?: "always" | "never";
+} | undefined): McpToolAxis | undefined;
 export declare function classifyDirReadInvalidParams(message: string): "not_found" | "not_directory";
 export declare function parseCallToolResultLenient(data: unknown): {
     success: true;

package/dist/core/mcp.js

@@ -720,7 +720,7 @@ function mcpAxisFor(namespacedName, annotations) {
     }
     return any ? axis : undefined;
 }
-function applyCallerAxisOverride(name, hint, override) {
+export function applyCallerAxisOverride(name, hint, override) {
     if (!override)
         return hint;
     let effect = hint?.effect;
@@ -729,16 +729,16 @@ function applyCallerAxisOverride(name, hint, override) {
     if (override.effect !== undefined)
         effect = override.effect;
     if (override.egress !== undefined)
-        egress = override.egress ? true : undefined;
+        egress = override.egress;
     if (override.irreversibility !== undefined)
-        irrev = override.irreversibility === "always" ? "always" : undefined;
+        irrev = override.irreversibility;
     const axis = { name };
     if (effect !== undefined)
         axis.effect = effect;
-    if (egress)
-        axis.egress = true;
-    if (irrev)
-        axis.irreversibility = "always";
+    if (egress !== undefined)
+        axis.egress = egress;
+    if (irrev !== undefined)
+        axis.irreversibility = irrev;
     return axis.effect !== undefined || axis.egress !== undefined || axis.irreversibility !== undefined ? axis : undefined;
 }
 const LIST_MCP_RESOURCES = "ListMcpResourcesTool";

package/dist/core/memory-admission.d.ts

@@ -44,4 +44,8 @@ export interface OwnOrgAdmissionVerdict {
     scopes: readonly string[];
     writeScope: string | null;
 }
+export declare function readDurableOrgAdmission(row: {
+    admittedOrgScopes?: readonly string[];
+    admittedOrgWriteScope?: string | null;
+}): OwnOrgAdmissionVerdict;
 export declare function admitMemoryScopes(input: MemoryAdmissionInput): Promise<MemoryAdmissionOutcome>;

package/dist/core/memory-admission.js

@@ -7,6 +7,9 @@ function codedError(code, message) {
 export function foldAdmissionFreeze(input) {
     return input.delegated ? (input.inherited ?? []) : input.inherited;
 }
+export function readDurableOrgAdmission(row) {
+    return { scopes: row.admittedOrgScopes ?? [], writeScope: row.admittedOrgWriteScope ?? null };
+}
 const ORG_SHAPE = /^org:/;
 function orgScopesOf(spec) {
     if (spec.scopeContract !== "v2")

package/dist/core/memory-engine/engine.d.ts

@@ -49,7 +49,9 @@ export declare class MemoryEngine {
     constructor(opts: MemoryEngineOptions);
     private discloseAnnounceFailure;
     materialize(scopes: readonly string[], writeScope: string | null): Promise<MemorySessionHandle>;
-    inject(handle: MemorySessionHandle): MemoryInjection;
+    inject(handle: MemorySessionHandle, opts?: {
+        writeToolMounted?: boolean;
+    }): MemoryInjection;
     gateWrite(handle: MemorySessionHandle, canonicalPath: string, content: string): {
         ok: true;
     } | {

package/dist/core/memory-engine/engine.js

@@ -188,14 +188,15 @@ export class MemoryEngine {
         }
         return handle;
     }
-    inject(handle) {
-        const instruction = handle.writeScope !== null ? buildMemoryInstruction(handle.writableRoot) : "";
+    inject(handle, opts) {
+        const writeChannel = handle.writeScope !== null && opts?.writeToolMounted !== false;
+        const instruction = writeChannel ? buildMemoryInstruction(handle.writableRoot) : "";
         const indexPath = join(handle.writableRoot, MEMORY_INDEX_FILENAME);
         const onDisk = readSafe(indexPath);
         const indexText = onDisk !== undefined && onDisk.trim() !== "" ? onDisk : handle.indexText;
         const truncated = truncateIndex(indexText);
         const index = composeMemoryBlock(truncated, handle.writeScope ?? handle.scopes[0] ?? "memory");
-        const indexSeed = handle.writeScope !== null && onDisk !== undefined && (onDisk.trim() === "" || truncated === onDisk)
+        const indexSeed = writeChannel && onDisk !== undefined && (onDisk.trim() === "" || truncated === onDisk)
             ? { path: indexPath, content: onDisk }
             : undefined;
         let announcements;

package/dist/core/memory-recall.d.ts

@@ -36,7 +36,7 @@ export type SelectiveRecallResult = {
 export declare function resolveLinkedIds(headers: MemoryNoteHeader[], selected: MemoryNoteRecord[], max: number): string[];
 export declare function buildManifestText(headers: MemoryNoteHeader[]): string;
 export declare function validateSelectedIds(headers: MemoryNoteHeader[], ids: string[], max: number): string[];
-export declare function composeSelectiveBody(manifestText: string, selected: MemoryNoteRecord[], nowMs: number, linked?: MemoryNoteRecord[], recallable?: boolean): string;
+export declare function composeSelectiveBody(manifestText: string, selected: MemoryNoteRecord[], nowMs: number, linked?: MemoryNoteRecord[], recallable?: boolean, recallToolName?: string): string;
 export declare function encodeSurfacedKey(scope: string, id: string): string;
 export interface ScopedNoteHeader extends MemoryNoteHeader {
     scope: string;

package/dist/core/memory-recall.js

@@ -102,7 +102,7 @@ export function validateSelectedIds(headers, ids, max) {
     }
     return out;
 }
-export function composeSelectiveBody(manifestText, selected, nowMs, linked = [], recallable = true) {
+export function composeSelectiveBody(manifestText, selected, nowMs, linked = [], recallable = true, recallToolName) {
     const renderNote = (r, label) => {
         const ageMs = nowMs - r.mtimeMs;
         const verify = r.timestampMissing || ageMs > ONE_DAY_MS ? " — verify it's still current" : "";
@@ -124,8 +124,9 @@ export function composeSelectiveBody(manifestText, selected, nowMs, linked = [],
         body = `${buf.subarray(0, cut).toString("utf8")}\n<selected notes truncated to ${SELECTED_BODY_MAX_BYTES} bytes>`;
     }
     const selectedSection = selected.length > 0 ? `\n\nRelevant notes:\n${body}` : "\n\n(no notes selected as relevant to this task)";
+    const recallCall = recallToolName !== undefined ? `call ${recallToolName}` : `search the memory-recall tool bound to this scope`;
     const manifestSection = recallable
-        ? `Memory index — to load a note in full, call Recall with keywords from its description:\n${sanitizeUntrustedText(manifestText, ["user_memory"])}`
+        ? `Memory index — to load a note in full, ${recallCall} with keywords from its description:\n${sanitizeUntrustedText(manifestText, ["user_memory"])}`
         : "";
     return `${manifestSection}${selectedSection}`;
 }

package/dist/core/runner/assemble-result.d.ts

@@ -58,6 +58,7 @@ export interface ResultFlags {
     model?: string;
     unpricedSpend?: boolean;
     rewindNotes?: TaskResult["rewindNotes"];
+    strandedHumanAnswers?: TaskResult["strandedHumanAnswers"];
     remoteEnvFailures?: TaskResult["remoteEnvFailures"];
     retryAfterMs?: number;
     abortedForTimeout: boolean;

package/dist/core/runner/assemble-result.js

@@ -159,5 +159,5 @@ export function assembleResult(spec, sessionId, final, stats, flags) {
     void _internalCompaction;
     if (flags.unpricedSpend)
         delete publicStats.costMicroUsd;
-    return { taskId, sessionId, status, ...(flags.model !== undefined ? { model: flags.model } : {}), result: result.trim(), salvagedOutput, blockedReason, errorMessage, errorCode, ...(retryAfterMs !== undefined ? { retryAfterMs } : {}), checkpointToken, checkpointGate, ...(workspaceRestoreMode !== undefined ? { workspaceRestoreMode } : {}), ...(flags.rewindNotes !== undefined && flags.rewindNotes.length > 0 ? { rewindNotes: flags.rewindNotes } : {}), ...(flags.remoteEnvFailures !== undefined && flags.remoteEnvFailures.length > 0 ? { remoteEnvFailures: flags.remoteEnvFailures } : {}), stats: publicStats };
+    return { taskId, sessionId, status, ...(flags.model !== undefined ? { model: flags.model } : {}), result: result.trim(), salvagedOutput, blockedReason, errorMessage, errorCode, ...(retryAfterMs !== undefined ? { retryAfterMs } : {}), checkpointToken, checkpointGate, ...(workspaceRestoreMode !== undefined ? { workspaceRestoreMode } : {}), ...(flags.rewindNotes !== undefined && flags.rewindNotes.length > 0 ? { rewindNotes: flags.rewindNotes } : {}), ...(flags.remoteEnvFailures !== undefined && flags.remoteEnvFailures.length > 0 ? { remoteEnvFailures: flags.remoteEnvFailures } : {}), ...(flags.strandedHumanAnswers !== undefined && flags.strandedHumanAnswers.length > 0 ? { strandedHumanAnswers: flags.strandedHumanAnswers } : {}), stats: publicStats };
 }

package/dist/core/runner/prepare-memory.d.ts

@@ -8,6 +8,7 @@ export interface PrepareMemoryInput {
     memoryWriteGateRef: {
         current?: BeforeWriteHook;
     };
+    writeToolsMounted: boolean;
     admissionCtx: {
         orgMemoryDenied: boolean;
         complianceDegraded: boolean;

package/dist/core/runner/prepare-memory.js

@@ -135,7 +135,7 @@ export async function prepareMemory(input) {
                 const writeIsPersonal = p.writePlane === "personal";
                 writeEngine = writeIsPersonal ? personalEngine : projectEngine;
                 writeHandle = writeIsPersonal ? personalHandle : projectHandle;
-                injectFn = () => mergeInjections(projectEngine.inject(projectHandle), personalEngine.inject(personalHandle));
+                injectFn = () => mergeInjections(projectEngine.inject(projectHandle, { writeToolMounted: input.writeToolsMounted }), personalEngine.inject(personalHandle, { writeToolMounted: input.writeToolsMounted }));
                 harvestBoth = async () => {
                     const writeFirst = writeIsPersonal ? [personalEngine, personalHandle] : [projectEngine, projectHandle];
                     const readOther = writeIsPersonal ? [projectEngine, projectHandle] : [personalEngine, personalHandle];
@@ -159,7 +159,7 @@ export async function prepareMemory(input) {
                 const handle = await personalEngine.materialize(memorySpec.scopes, memorySpec.writeScope);
                 writeEngine = personalEngine;
                 writeHandle = handle;
-                injectFn = () => personalEngine.inject(handle);
+                injectFn = () => personalEngine.inject(handle, { writeToolMounted: input.writeToolsMounted });
                 harvestBoth = () => personalEngine.harvest(handle);
             }
             else {
@@ -171,7 +171,7 @@ export async function prepareMemory(input) {
                 const handle = await engine.materialize(memorySpec.scopes, memorySpec.writeScope);
                 writeEngine = engine;
                 writeHandle = handle;
-                injectFn = () => engine.inject(handle);
+                injectFn = () => engine.inject(handle, { writeToolMounted: input.writeToolsMounted });
                 harvestBoth = () => engine.harvest(handle);
             }
             memoryWriteGateRef.current = (w) => writeEngine.gateWrite(writeHandle, w.key, w.content);

package/dist/core/runner/prepare-task.d.ts

@@ -16,11 +16,13 @@ import { type BrainCallGuardrailRef } from "../../brain/timeout.js";
 import { type OutputRef, type BlockedRef, type SkillListingEntry } from "./synthetic-tools.js";
 import type { MemoryEngine } from "../memory-engine/engine.js";
 import { type ToolManifestRow } from "../../prompt-assembly/tool-catalog.js";
+import type { ToolDisclosureManifest } from "../trace.js";
 import type { TaskNotificationPayload } from "../task-notification.js";
 import { type CwdRef } from "../../tools/fs/index.js";
 import { type WorkflowSizeGuideline } from "../../orchestration/workflow-size-guideline.js";
 import type { Runner } from "./runtask.js";
-import { type CheckpointGate, type CheckpointState, type CheckpointStore, type CheckpointToken, type ResourceLedger, type PlatformLimitReason, type ResourceLimitReason } from "../checkpoint-store.js";
+import { type CheckpointGate, type CheckpointState, type CheckpointToken, type ResourceLedger, type PlatformLimitReason, type ResourceLimitReason } from "../checkpoint-store.js";
+import { type WiringManifest } from "../wiring-manifest.js";
 import type { ActiveWorktreeSession, AgentMessage, AgentTool, ExecutionEnv } from "../../internal/harness.js";
 import type { NestedUsageAccum, RunnerDeps, TaskEvent, TaskLimits, TaskResult, TaskSpec, ToolActivity, ToolEffect } from "../types.js";
 import type { RepairBundle } from "../../agents/repair-loop.js";
@@ -44,11 +46,7 @@ export declare function checkpointScopeOf(spec: {
     };
     principal?: string;
 }): string;
-export declare function resolveCheckpointStore(spec: {
-    checkpointStore?: CheckpointStore | null;
-}, deps: {
-    checkpointStore?: CheckpointStore;
-}): CheckpointStore | undefined;
+export { resolveCheckpointStore } from "../checkpoint-store.js";
 export interface Prepared {
     harness: AgentHarness;
     session: StoredSession;
@@ -81,11 +79,16 @@ export interface Prepared {
     denyNarrowingPolicy?: ToolPolicy;
     basePolicyForResumeEdit?: ToolPolicy;
     releaseSignal: () => void;
+    settleContentAskBindings: () => ReadonlyArray<{
+        deliveryId: string;
+        toolCallId: string;
+    }>;
     cacheBreakDetector?: CacheBreakDetector;
     cacheFingerprint?: {
         systemPrompt: string;
         tools: ToolFingerprintInput[];
     };
+    wiringManifest: WiringManifest;
     promptManifest: {
         constitution: "core" | "replaced" | "provider-assembled";
         blocks: Array<{
@@ -109,6 +112,7 @@ export interface Prepared {
             elements: import("../../prompt-assembly/turn-snapshot.js").CacheIdentityElements;
         };
         lowering?: import("../../prompt-assembly/turn-snapshot.js").LoweringRecord;
+        toolDisclosure?: ToolDisclosureManifest;
     };
     epochDeclaredSections: import("../../prompt-assembly/epoch.js").EpochDeclaredSections;
     turnSnapshot?: import("../../prompt-assembly/turn-snapshot.js").TurnPromptSnapshot;
@@ -123,6 +127,7 @@ export interface Prepared {
     activeTools: Set<string>;
     deferredToolNames?: ReadonlySet<string>;
     toolMaterializeStatic: boolean;
+    staticFaceFor?: (name: string) => boolean;
     memoryEngineSession?: {
         engine: MemoryEngine;
         handle: MemorySessionHandle;
@@ -294,6 +299,8 @@ export interface PrepareResume {
         }>;
     };
     workspaceHandle?: import("../remote-env.js").WorkspaceHandle;
+    redeemedContentAskCallId?: string;
+    redeemedContentAskQuestionsHash?: string;
     executesApprovedAction?: boolean;
 }
 export interface InheritedGate {
@@ -325,8 +332,13 @@ export declare function resolveModelPromptTraits(model: {
 };
 export interface RunInternals {
     repairBundle?: RepairBundle;
+    questionFaceStripped?: true;
+    parentInteractionPosture?: "interactive" | "headless";
     afterCheckpointResolve?: () => Promise<void>;
     inheritedGate?: InheritedGate;
+    ownOrgAdmissionRef?: {
+        current: import("../memory-admission.js").OwnOrgAdmissionVerdict | undefined;
+    };
     workflowDepth?: number;
     insideFork?: boolean;
     isDelegatedChild?: boolean;
@@ -338,6 +350,7 @@ export interface RunInternals {
     explicitAgentName?: string;
     parentTaskId?: string;
     parentSessionId?: string;
+    delegationTaskType?: import("../types.js").DelegationTaskType;
     rootSessionId?: string;
     registryScope?: string;
     parentCenterArtifactDigest?: string;