@sema-agent/core 5.13.0 → 5.14.0

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/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-task.d.ts

@@ -20,7 +20,8 @@ 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 +45,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 +78,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<{
@@ -294,6 +296,8 @@ export interface PrepareResume {
         }>;
     };
     workspaceHandle?: import("../remote-env.js").WorkspaceHandle;
+    redeemedContentAskCallId?: string;
+    redeemedContentAskQuestionsHash?: string;
     executesApprovedAction?: boolean;
 }
 export interface InheritedGate {
@@ -325,8 +329,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 +347,7 @@ export interface RunInternals {
     explicitAgentName?: string;
     parentTaskId?: string;
     parentSessionId?: string;
+    delegationTaskType?: import("../types.js").DelegationTaskType;
     rootSessionId?: string;
     registryScope?: string;
     parentCenterArtifactDigest?: string;