@sema-agent/core 7.6.2 → 7.7.0

package/dist/core/runner/runtask.js

@@ -7,13 +7,13 @@ import { planRejectionClears, resolveTriggerWindow } from "../context-edit.js";
 import { AgentHarness, DEFAULT_COMPACTION_SETTINGS, isSyntheticApiErrorMessage, uuidv7 } from "../../internal/harness.js";
 import { snapshotActorAssertion } from "../../internal/llm.js";
 import { CheckpointError, BINDING_CHECKPOINT_VERSION, checkpointVersionOf, F012_CHECKPOINT_VERSION, MAX_SUPPORTED_CHECKPOINT_VERSION, REAL_APPROVAL_CHECKPOINT_VERSION, FACE_CHECKPOINT_VERSION, remainingBudgetMicroUsd, readPendingSteerQueue, remainingTokens, resolveCheckpointStore, LEGACY_PENDING_STEER_INPUT_ID, MAX_STEER_INPUT_ID_CHARS, validatePendingSteer, winnerFromOutcome, realApprovalOrgFact } from "../checkpoint-store.js";
-import { GIT_STATUS_ECHO_PREVIEW, branchCarriesVisiblePositiveGitFrame, newestEngineGitFrame, stripGitStatusUnits } from "./git-status-frame.js";
-import { gitFrameContextVisible, normalizeGitAnnouncement } from "../../internal/harness.js";
+import { GIT_STATUS_ECHO_PREVIEW, stripGitStatusUnits } from "./git-status-frame.js";
+import { settleExecutionRecord } from "./execution-record.js";
 import { engineVersion } from "../version.js";
 import { CONFIG_CATALOG_VERSION, declarationReasons, resolveEffectiveConfig } from "../../config/catalog.js";
 import { eventDefaultOn } from "../../prompt-assembly/event-registry.js";
 import { DEFAULT_COMPACTION_INSTRUCTIONS, createRapidRefillState, isCompactionManualCancel, maybeCompact, nextTrimForceBackoff, recordCompactionAndCheckRapidRefill, sanitizeCompactionSettings } from "../auto-compaction.js";
-import { ASK_USER_QUESTION_TOOL_NAME, canonicalizeCapturedPlainData, classifyQuestionOutcome, isLiveQuestionFace, markBoundOnlyQuestionFace } from "../ask-question.js";
+import { ASK_USER_QUESTION_TOOL_NAME, canonicalizeCapturedPlainData, classifyQuestionOutcome, isLiveQuestionFace } from "../ask-question.js";
 import { boundInputHashOf } from "../canonical-json.js";
 import { computeCostMicroUsd, isModelPriced, malformedPricingField, modelCostToPricing } from "../pricing.js";
 import { emitTrace } from "../trace.js";
@@ -39,12 +39,10 @@ import { amendTerminal, terminalProjection } from "./terminal-projection.js";
 import { ATTACHMENT_BYTE_CAP, CHANGED_FILES_MAX, TOTAL_TOKENS_REMINDER_DEFAULT_MODE, AGENT_LISTING_REMOVED_HEADER, SKILLS_LISTING_DELTA_HEADER, SKILLS_LISTING_REMOVED_HEADER, advanceCadenceClock, agentListingDeltaHeader, attachmentEnvelopeTags, agentListingInitialHeader, replayAnnouncedListing, replayAnnouncedModels, clipToBytes, collectDateChange, collectDueAttachments, collectInstructionsChange, commitAgentListing, commitInstructionsChange, commitSkillsListing, createAttachmentState, rebaseCadenceWindows, reduceToolEnd, renderAgentListingDelta, renderMcpDroppedTools, renderMcpInstructionsDelta, renderOrphanedBackgroundTasks, selectMcpDroppedBatch, renderSkillsListingDelta, renderToolsDelta, stampWriteAnchor } from "./turn-attachments.js";
 import { buildWorkingFileAttachments, centerAdoptionOption, contextInstructionFilesOption, emitInputTruncated, forkContextOption } from "./compaction-call-options.js";
 import { effectiveDelegationFacts, prepareTask } from "./prepare-task.js";
-import { drainForwardedFramesBeforeDone } from "./prepare-run-refs.js";
 import { gatedCallIdOf } from "./park-commit.js";
 import { placementValueOrAbsent } from "./checkpoint-scope.js";
 import { SessionReadFileStates } from "./prepare-hands-readface.js";
 import { settleTeardownLeg } from "./teardown-bounded.js";
-import { TOOL_SEARCH_NAME } from "./tool-disclosure.js";
 import { hasVerifiableStructureSignal } from "./grounding-signal.js";
 import { hasDestroy, isIsolated } from "../remote-env.js";
 import { hasBackgroundShell, sweepBackgroundShells } from "../background-shell.js";
@@ -59,333 +57,29 @@ import { isAskOrigin } from "../ask-origin.js";
 import { isGateKind, PAUSE_REGISTRY, resumeGateMatches } from "../pause-registry.js";
 import { checkToolPolicyProjection, constraintChainDigest, constraintChainEntryOfSuppliedLayer, refuseOutOfContractDecision, screenApproverAttribution, toolPolicyNameSets } from "../tool-policy.js";
 import { mintGateOutcome } from "./gate-exit.js";
-import { MCP_DELIVERY_VERDICTS } from "../mcp-failure.js";
 import { defaultTaskRegistry } from "../task-registry.js";
 import { discloseDroppedPending, isDelegatedAgentTerminal, isSystemInjectionPriority, isTerminalTaskNotification, PendingSessionNotifications, renderTaskNotificationXml, SYSTEM_INJECTION_PRIORITIES, SystemInjectionQueue, taskNotificationDedupKey } from "../task-notification.js";
 import { ToolDetachHub } from "../tool-detach.js";
 import { createPeerInboundChainRef, createPeerSelfRef } from "../../agents/peer-admission.js";
 import { workflowSizeGuidelineChangeNotice } from "../../orchestration/workflow-size-guideline.js";
-import { structuredFrom, toolOutputFrom } from "./tool-output-projection.js";
-function createRunState() {
-    return {
-        telemetry: { cacheFamily: "input-excludes-cached", pricing: { inputPer1M: 0, outputPer1M: 0 }, pricingConfigured: true, unpricedSpend: false, tracer: undefined, taskId: "", runId: "", taskStart: 0, taskStartMonotonic: 0, cacheBreakReported: false },
-        degrade: { degradeToModel: undefined, degraded: undefined, outputErrorStreak: 0, outputInvalid: false, recordDegraded: () => { } },
-        limits: { turnsExceeded: false, budgetHit: undefined, budgetAxis: undefined, platformTerminal: undefined, outputRetryCap: 0, effectiveMaxTurns: undefined },
-        budget: { remainingMicroUsd: undefined, maxCostMicroUsd: undefined, remainingTokens: undefined, maxTokensWindow: undefined, overBudget: () => undefined, streamCancel: false, callOutputChars: 0, lastStreamBudgetCheck: 0, projectedOverBudget: () => undefined },
-        turn: { callStartAt: undefined, firstTokenAt: undefined, turnUsage: undefined, turnUsageMissing: false, turnStopReason: undefined, lastTurnHadToolCalls: false, toolBatch: [] },
-        counters: { approachNoticesSent: 0, walltimeSyncBackstopFired: false, compactionFloor: 0, trimForceBackoff: false, repetitionCuts: 0, repetitionSpared: 0, repetitionEvents: [], REPETITION_EVENTS_CAP: 0, preemptIgnoredReported: false, wroteThisRun: false, finalVerifyInjections: 0, groundingSignalPreR9: false, groundingSignalPostR9: false, cadenceTurns: 0 },
-        attach: { attachmentsCfg: undefined, agentListingOn: false, skillsListingOn: false, attachState: undefined, dateState: undefined, instrProbe: undefined, instrState: undefined, sizeGuidelineState: undefined, attachmentsInjected: 0 },
-    };
-}
-const humanInputOrdinals = new WeakMap();
-function nextHumanInputSeq(key) {
-    let box = humanInputOrdinals.get(key);
-    if (box === undefined) {
-        box = { n: 0 };
-        humanInputOrdinals.set(key, box);
-    }
-    return ++box.n;
-}
-function sameAcceptedSteerInput(a, b) {
-    return (a.payload === b.payload &&
-        a.trusted === b.trusted &&
-        a.priority === b.priority &&
-        a.actor?.id === b.actor?.id &&
-        a.actor?.hostAsserted === b.actor?.hostAsserted &&
-        a.actor?.issuer === b.actor?.issuer);
-}
+import { createRunState } from "./initial-run-state.js";
+import { nextHumanInputSeq, sameAcceptedSteerInput } from "./steer-admission.js";
+import { batchResponseDigest, reconciledToolEndBody, toolEndBodyFrom, toolResultMsg, writeFamilyOfCanonical } from "./tool-end-body.js";
+import { answerFaceForRedeemedCall, assertOutcomeText, deepJsonEqual, DEFERRED_REISSUE, describeSuppliedValue, pendingContentAskCallId, resumeContinuation, resumeDecisionWasNegative, sameWinner } from "./decide-continuation.js";
+import { awaitChargeWithSlowDisclosure, DEFAULT_PRECALL_OUTPUT_TOKENS, discloseUnevaluableWindow, ENV_DUE_GOVERNANCE_READ_BUDGET_MS, GOVERNANCE_READ_STALLED, LIMIT_APPROACH_DEFAULT_THRESHOLDS, limitApproachFrames, platformLimitTerminal, raceUntilDeadline, resolveMaxTurns, startTimeout, TIMER_LATENESS_REPORT_MS } from "./clock-and-limits.js";
+import { gitRestateOption, resolveGitLegDelivery, wrapGitFrame } from "./git-leg-delivery.js";
 const MAX_CONSECUTIVE_COMPACTION_FAILURES = 3;
 const RESUME_PREFLIGHT_DEFAULT_TIMEOUT_MS = 10_000;
 const STOP_HOOK_BLOCK_CAP = 8;
 const COMPACTION_REGROWTH_FACTOR = 1.5;
 const COMPACTION_FREED_EPSILON = 256;
-const BATCH_RESPONSE_MAX_CHARS = 500;
 const ORG_DISCLOSURE_MAX_CHARS = 600;
-function batchResponseDigest(result) {
-    const content = result !== null && typeof result === "object" ? result.content : result;
-    if (content === undefined || content === null)
-        return undefined;
-    let text;
-    if (typeof content === "string") {
-        text = content;
-    }
-    else if (Array.isArray(content)) {
-        text = content
-            .map((c) => (c !== null && typeof c === "object" && typeof c.text === "string" ? c.text : ""))
-            .filter((t) => t.length > 0)
-            .join("\n");
-    }
-    else {
-        try {
-            text = JSON.stringify(content) ?? "";
-        }
-        catch {
-            return undefined;
-        }
-    }
-    if (text.length === 0)
-        return undefined;
-    return text.length > BATCH_RESPONSE_MAX_CHARS
-        ? `${text.slice(0, BATCH_RESPONSE_MAX_CHARS)}…[+${text.length - BATCH_RESPONSE_MAX_CHARS} chars truncated]`
-        : text;
-}
 const BATCH_CONTEXT_MIN_KEEP_BYTES = 160;
 const BATCH_TRUNCATION_MARKER = "\n…[truncated]";
 const SUGGESTIONS_DEFAULT_COUNT = 3;
 const SUGGESTIONS_MAX_COUNT = 8;
 const SUGGESTIONS_TIMEOUT_MS = 30_000;
 const SUGGESTIONS_TRANSCRIPT_MESSAGES = 12;
-const LIMIT_APPROACH_DEFAULT_THRESHOLDS = [0.8, 0.95];
-const DEFAULT_PRECALL_OUTPUT_TOKENS = 4096;
-function limitApproachFrames(index, axis, percent, mark) {
-    return index === 0
-        ? `${openSystemReminder(mark)}[limit approach] This task has used about ${percent}% of its ${axis}. ` +
-            `Start converging: finish the step you are on, drop work that is not required for the deliverable, and ` +
-            `avoid starting anything you cannot complete within what is left.</system-reminder>`
-        : `${openSystemReminder(mark)}[limit approach] About ${percent}% of the ${axis} is gone. Deliver now: ` +
-            `stop exploring, write up what you have — including what is incomplete and what you would do next — ` +
-            `and end the task. Work that is not reported before the allowance runs out is lost.</system-reminder>`;
-}
-function resolveMaxTurns(limits) {
-    return limits?.maxTurns;
-}
-function resumeDecisionWasNegative(resume) {
-    const o = resume.outcome;
-    return o.decision === "reject" || o.decision === "deny";
-}
-const DEFERRED_REISSUE = "[DEFERRED] This tool call shared a batch with a call that suspended for durable approval, so it was " +
-    "NOT executed on resume. If you still need it, issue it again now.";
-function toolEndBodyFrom(result, isError, gate, gatedCallIdOfRun) {
-    const o = toolOutputFrom(result);
-    const st = structuredFrom(result);
-    const det = isError ? result?.details : undefined;
-    const codeRaw = det?.code;
-    const kindRaw = det?.errorKind;
-    const code = typeof codeRaw === "string" ? codeRaw : typeof kindRaw === "string" ? kindRaw : undefined;
-    const deliveredRaw = det?.delivered;
-    const delivered = typeof deliveredRaw === "string" && MCP_DELIVERY_VERDICTS.includes(deliveredRaw) ? deliveredRaw : undefined;
-    const gatedCallId = code === "gate.parked" ? gatedCallIdOfRun : undefined;
-    return {
-        ...(o !== undefined ? { output: o.output, ...(o.truncated ? { truncated: true } : {}), ...(o.totalChars !== undefined ? { totalChars: o.totalChars } : {}) } : {}),
-        ...(st !== undefined ? { structured: st } : {}),
-        ...(typeof code === "string" ? { errorCode: code } : {}),
-        ...(delivered !== undefined ? { delivered } : {}),
-        ...(gatedCallId !== undefined ? { gatedCallId } : {}),
-        ...(gate !== undefined ? { gate } : {}),
-    };
-}
-export function reconciledToolEndBody(orphan) {
-    return toolEndBodyFrom({ content: orphan.text, details: { code: orphan.errorKind } }, true);
-}
-function deepJsonEqual(a, b) {
-    if (a === b)
-        return true;
-    if (typeof a !== typeof b || a === null || b === null || typeof a !== "object") {
-        return false;
-    }
-    const aArr = Array.isArray(a);
-    const bArr = Array.isArray(b);
-    if (aArr !== bArr)
-        return false;
-    if (aArr && bArr) {
-        if (a.length !== b.length)
-            return false;
-        for (let i = 0; i < a.length; i++) {
-            if (!deepJsonEqual(a[i], b[i]))
-                return false;
-        }
-        const aExtra = Object.keys(a).filter((k) => !isCanonicalIndexKey(k, a.length));
-        const bExtra = Object.keys(b).filter((k) => !isCanonicalIndexKey(k, b.length));
-        if (aExtra.length !== bExtra.length)
-            return false;
-        return aExtra.every((k) => Object.prototype.hasOwnProperty.call(b, k) && deepJsonEqual(Reflect.get(a, k), Reflect.get(b, k)));
-    }
-    const ao = a;
-    const bo = b;
-    const aKeys = Object.keys(ao);
-    const bKeys = Object.keys(bo);
-    if (aKeys.length !== bKeys.length)
-        return false;
-    return aKeys.every((k) => Object.prototype.hasOwnProperty.call(bo, k) && deepJsonEqual(ao[k], bo[k]));
-}
-function isCanonicalIndexKey(key, length) {
-    return /^(0|[1-9]\d*)$/.test(key) && Number(key) < length;
-}
-function sameWinner(incoming, persisted) {
-    return (incoming.boundCallId === persisted.boundCallId &&
-        incoming.decision === persisted.decision &&
-        deepJsonEqual(incoming.updatedInput, persisted.updatedInput) &&
-        deepJsonEqual(incoming.answer, persisted.answer) &&
-        (persisted.reason === undefined || incoming.reason === persisted.reason));
-}
-function pendingContentAskCallId(cp) {
-    return cp.pendingAction.kind === "tool_approval" && cp.pendingAction.toolName === ASK_USER_QUESTION_TOOL_NAME
-        ? cp.pendingAction.toolCallId
-        : undefined;
-}
-function answerFaceForRedeemedCall(answer, redeemedCallId, base, redeemedQuestionsHash) {
-    let consumed = false;
-    const face = async (req, signal) => {
-        if (!consumed && req.toolCallId === redeemedCallId && boundInputHashOf(req.questions) === redeemedQuestionsHash) {
-            consumed = true;
-            return answer;
-        }
-        if (base !== undefined)
-            return base(req, signal);
-        throw new Error("this resumed leg's answer was bound to the decided question only — a new question has no answer on this leg");
-    };
-    return isLiveQuestionFace(base) ? face : markBoundOnlyQuestionFace(face);
-}
-function writeFamilyOfCanonical(name) {
-    if (name === "TaskCreate" || name === "TaskUpdate")
-        return "task";
-    if (name === "TodoWrite")
-        return "todo";
-    if (name === TOOL_SEARCH_NAME)
-        return "tool_search";
-    return undefined;
-}
-function toolResultMsg(toolCallId, toolName, text, isError) {
-    return {
-        role: "toolResult",
-        toolCallId,
-        toolName,
-        content: [{ type: "text", text }],
-        isError,
-        timestamp: Date.now(),
-    };
-}
-function describeSuppliedValue(value) {
-    return typeof value === "string" ? value : value === null ? "null" : typeof value;
-}
-function assertOutcomeText(value, field) {
-    if (value !== undefined && typeof value !== "string") {
-        throw new CheckpointError("checkpoint.invalid_outcome", `resume \`${field}\` is not a plain string (got ${typeof value}) — a decide's text payload is an operator's plain data, not a live object; refusing pre-CAS, the checkpoint stays pending`);
-    }
-}
-function resumeContinuation(resume, mark) {
-    if (resume.outcome.gate === "wake") {
-        return formatHookFeedback("You were WOKEN from a parked pause by an operator. Before continuing, re-orient from the workspace: " +
-            "run `git status` and review your recent changes / last commits to confirm what is already done, then " +
-            "continue the remaining work. Do NOT restart the task or re-run work that is already committed.", mark);
-    }
-    if (resume.outcome.gate === "resource_limit") {
-        return formatHookFeedback("You were resumed after a pause. Before continuing, re-orient from the workspace: run `git status` and " +
-            "review your recent changes / last commits to confirm what is already done, then continue the " +
-            "remaining work. Do NOT restart the task or re-run work that is already committed.", mark);
-    }
-    if (resume.outcome.gate === "dry_run_review") {
-        const verdict = resume.outcome.decision === "approve"
-            ? "Your predicted change was REVIEWED and APPROVED; it has been applied"
-            : `Your predicted change was REVIEWED and REJECTED${resume.outcome.reason ? `: ${delimitUntrusted("reviewer note", resume.outcome.reason, REVIEWER_NOTE_MAX_BODY)}` : ""}; it was NOT applied`;
-        return formatHookFeedback(`You were resumed after a dry-run review. ${verdict}. Before continuing, re-orient from the workspace ` +
-            "(run `git status` and review your recent changes) to confirm the current state, then continue the " +
-            "remaining work. Do NOT restart the task or re-run work that is already done.", mark);
-    }
-    if (resume.outcome.gate === "plan_review") {
-        if (resume.outcome.decision === "approve") {
-            return formatHookFeedback("Your proposed PLAN was REVIEWED and APPROVED. Proceed with that plan now — begin executing it. " +
-                "This is a RESUMED task; do NOT re-plan or restart from scratch, just carry out the approved plan.", mark);
-        }
-        if (resume.outcome.decision === "edit") {
-            if (!resume.outcome.editedPlan) {
-                return formatHookFeedback("Your proposed PLAN was REVIEWED and EDITED, but no revised plan text was supplied — proceed with your " +
-                    "ORIGINAL plan as-is, begin executing it now. This is a RESUMED task; do NOT re-plan or restart from scratch.", mark);
-            }
-            return formatHookFeedback("Your proposed PLAN was REVIEWED and EDITED by a human reviewer. Proceed with the REVISED plan below " +
-                "(it supersedes your earlier plan); begin executing it now. This is a RESUMED task; do NOT re-plan " +
-                "or restart from scratch, just carry out the revised plan.\n\nThe REVISED plan to follow is:\n" +
-                delimitUntrusted("revised plan", resume.outcome.editedPlan), mark);
-        }
-        const why = resume.outcome.reason ? ` Reviewer note: ${delimitUntrusted("reviewer note", resume.outcome.reason, REVIEWER_NOTE_MAX_BODY)}` : "";
-        return formatHookFeedback(`Your proposed PLAN was REVIEWED and REJECTED; it was NOT executed.${why} Produce a NEW plan that ` +
-            "addresses the concern, then continue. This is a RESUMED task — re-plan from the current state; do " +
-            "NOT execute the rejected plan.", mark);
-    }
-    const { pendingAction } = resume.cp;
-    if (pendingAction.kind !== "tool_approval") {
-        return formatHookFeedback("This is a RESUMED task — continue from where you left off without restarting or re-running prior work.", mark);
-    }
-    const decided = resume.outcome.decision === "allow"
-        ? "was APPROVED and has now been executed — its result is in the tool results above"
-        : `was DENIED${resume.outcome.reason ? `: ${delimitUntrusted("reviewer note", resume.outcome.reason, REVIEWER_NOTE_MAX_BODY)}` : ""}`;
-    const remaining = pendingAction.batchToolCallIds.filter((id) => id !== pendingAction.toolCallId && !pendingAction.completedCallIds.includes(id)).length;
-    const batchNote = remaining > 0
-        ? ` ${remaining} other tool call(s) from that batch were returned as deferred and not run — re-issue any you still need.`
-        : "";
-    return formatHookFeedback(`The pending tool call "${pendingAction.toolName}" ${decided}.${batchNote} ` +
-        `This is a RESUMED task — every step before this point is already done and its results are in the ` +
-        `conversation above. Do NOT restart the task or re-run any tool you already ran; continue from this ` +
-        `exact point, building on the existing results, and finish the remaining work.`, mark);
-}
-const ENV_DUE_GOVERNANCE_READ_BUDGET_MS = 5_000;
-const MAX_TIMER_DELAY_MS = 2_147_483_647;
-const DEADLINE_TICK = Symbol("deadline-tick");
-export const GOVERNANCE_READ_STALLED = Symbol("governance-read-stalled");
-const CHARGE_SETTLE_DISCLOSE_MS = 10_000;
-export async function awaitChargeWithSlowDisclosure(charge, onSlow, discloseAfterMs = CHARGE_SETTLE_DISCLOSE_MS) {
-    let timer = setTimeout(() => {
-        timer = undefined;
-        try {
-            onSlow();
-        }
-        catch {
-        }
-    }, discloseAfterMs);
-    try {
-        return await charge;
-    }
-    finally {
-        if (timer !== undefined)
-            clearTimeout(timer);
-    }
-}
-export async function raceUntilDeadline(p, deadline) {
-    for (let firstPass = true;; firstPass = false) {
-        const remaining = deadline - Date.now();
-        if (remaining <= 0 && !firstPass)
-            return GOVERNANCE_READ_STALLED;
-        let timer;
-        const tick = new Promise((res) => {
-            timer = setTimeout(() => res(DEADLINE_TICK), Math.max(0, Math.min(remaining, MAX_TIMER_DELAY_MS)));
-        });
-        const out = await Promise.race([p, tick]).finally(() => clearTimeout(timer));
-        if (out !== DEADLINE_TICK)
-            return out;
-    }
-}
-function platformLimitTerminal(reason, retryAfterMs, moment = "turn_boundary") {
-    const message = moment === "entry"
-        ? `a deployment usage window is exhausted (RunnerDeps.usageWindows), so the task was refused before its first model call — nothing ran and nothing was spent. There is no checkpoint to suspend into at this point, so the caller re-submits after the window frees, in ${String(retryAfterMs ?? 0)}ms.`
-        : moment === "resume"
-            ? `a deployment usage window is exhausted (RunnerDeps.usageWindows), so the resumed leg was stopped BEFORE its first model call — nothing was delivered or executed on this leg. The window frees in ${String(retryAfterMs ?? 0)}ms.`
-            : reason === "env_lifetime"
-                ? "the execution environment's declared lifetime is expiring and the run could not be suspended durably (not eligible, or the suspend was refused — see remoteEnvFailures / onError). It was stopped at a clean turn boundary instead of being killed mid-turn when the platform reclaims the environment."
-                : `a deployment usage window is exhausted (RunnerDeps.usageWindows) and the run could not be suspended durably, so it was stopped at a clean turn boundary. The window frees in ${String(retryAfterMs ?? 0)}ms.`;
-    const e = new Error(message);
-    e.code = reason === "env_lifetime" ? "env.lifetime_expired" : "usage.window_exhausted";
-    if (retryAfterMs !== undefined)
-        e.retryAfterMs = retryAfterMs;
-    return e;
-}
-const disclosedUnevaluableWindow = new WeakSet();
-function discloseUnevaluableWindow(u, prepared, tracer, taskId, onError) {
-    if (disclosedUnevaluableWindow.has(prepared))
-        return;
-    disclosedUnevaluableWindow.add(prepared);
-    emitTrace(tracer, () => ({ kind: "compaction.unevaluable", version: 1, taskId, estTokens: u.estTokens, ts: Date.now() }));
-    const modelClause = u.modelId !== undefined ? ` "${u.modelId}"` : "";
-    const cause = u.windowValue !== undefined
-        ? `its \`${u.windowField}\` is ${u.windowValue}, which is not a positive number of tokens — that field takes precedence over the ` +
-            `others, so fixing or removing it is what restores the threshold`
-        : `it declares no context window at all (\`autoCompactTokens\` / \`contextTokens\` / \`contextWindow\` are all absent) — declare one to restore the threshold`;
-    try {
-        onError?.(new Error(`auto-compaction cannot run for model${modelClause}: ${cause}. Until then there is no threshold to compare against, so the ` +
-            `context will grow until the provider refuses the request. The conversation is already about ${u.estTokens} estimated tokens.`), { phase: "config", sessionId: prepared.sessionId });
-    }
-    catch {
-    }
-}
 function makeTurnBoundary(prepared, stats, rs, deps) {
     const { spec, queue, manualCompactRef, todoToolMounted, taskToolsMounted, walltimeMonotonicDeadline, timeout, ident, postToolBatchHook, batchArgs, compactionBrain, withinTaskCompaction, compactionBreaker, windowSafetyOptions, rapidRefill, drainManualCompact, runnerHooks } = deps;
     let finalVerifySeenAtLastBoundary = 0;
@@ -1059,96 +753,6 @@ function makeTurnBoundary(prepared, stats, rs, deps) {
     };
     return onTurnBoundary;
 }
-function wrapGitFrame(body, mark) {
-    return mintSystemReminder(sanitizeUntrustedText(body, SHELLED_BODY_ENVELOPE_TAGS), mark);
-}
-async function resolveGitLegDelivery(prepared, cpMirror, report) {
-    const ref = prepared.gitStatusRef;
-    const frame = ref.frame;
-    if (frame === undefined)
-        return undefined;
-    let prior;
-    let pending = false;
-    try {
-        const branchReadout = await prepared.session.getGitAnnouncement?.();
-        if (branchReadout !== undefined) {
-            if (branchReadout.status === "pending") {
-                pending = true;
-                prior = { kind: branchReadout.kind, hash: branchReadout.hash };
-            }
-            else {
-                prior = { kind: branchReadout.kind, hash: branchReadout.hash, ...(branchReadout.entryId !== undefined ? { entryId: branchReadout.entryId } : {}) };
-            }
-        }
-        else {
-            const shaped = normalizeGitAnnouncement(cpMirror);
-            if (shaped !== undefined) {
-                if (shaped.pending === true || shaped.entryId === undefined) {
-                    pending = true;
-                    prior = { kind: shaped.kind, hash: shaped.hash };
-                }
-                else if (gitFrameContextVisible(await prepared.session.getBranch(), shaped.entryId)) {
-                    prior = { kind: shaped.kind, hash: shaped.hash, entryId: shaped.entryId };
-                }
-                else {
-                    pending = true;
-                    prior = { kind: shaped.kind, hash: shaped.hash };
-                }
-            }
-        }
-    }
-    catch (err) {
-        pending = true;
-        report(err instanceof Error ? err : new Error(String(err)));
-    }
-    if (prior !== undefined && !pending && prior.entryId !== undefined) {
-        try {
-            const newest = newestEngineGitFrame(await prepared.session.getBranch(), prepared.reminderMark);
-            if (newest === undefined || newest.entryId !== prior.entryId)
-                pending = true;
-        }
-        catch (err) {
-            pending = true;
-            report(err instanceof Error ? err : new Error(String(err)));
-        }
-    }
-    if (prior !== undefined)
-        ref.announced = pending ? { ...prior, pending: true } : { ...prior };
-    const negative = frame.kind === "unavailable" || frame.kind === "non-repo";
-    if (negative) {
-        if (prior === undefined && !pending) {
-            let mustDisown;
-            try {
-                mustDisown = branchCarriesVisiblePositiveGitFrame(await prepared.session.getBranch(), prepared.reminderMark);
-            }
-            catch (err) {
-                mustDisown = true;
-                report(err instanceof Error ? err : new Error(String(err)));
-            }
-            return mustDisown ? frame.body : undefined;
-        }
-        if (prior !== undefined && !pending && prior.kind === frame.kind && prior.hash === frame.hash)
-            return undefined;
-        return frame.body;
-    }
-    if (!pending && prior !== undefined && prior.kind === frame.kind && prior.hash === frame.hash) {
-        ref.protectedText = wrapGitFrame(frame.body, prepared.reminderMark);
-        if (frame.kind === "full" && frame.shrunk !== undefined) {
-            ref.wrappedShrink = { find: ref.protectedText, replace: wrapGitFrame(frame.shrunk.body, prepared.reminderMark) };
-        }
-        return undefined;
-    }
-    return frame.body;
-}
-function gitRestateOption(prepared) {
-    const ref = prepared.gitStatusRef;
-    if (ref.frame === undefined || ref.announced === undefined || ref.reassert === undefined)
-        return {};
-    const use = ref.overBudgetShrunk && ref.frame.shrunk !== undefined
-        ? { kind: "degraded", hash: ref.frame.shrunk.hash }
-        : { kind: ref.frame.kind, hash: ref.frame.hash };
-    return { gitRestate: { pending: use, land: ref.reassert } };
-}
 function makeHarnessHandlers(prepared, stats, rs, deps) {
     const { spec, queue, internals, ident, parentToolCallId, subagentName, pushContent, emitCommitted, startedToolCallIds, toolStartAt, writeFamilyOf, toolLabels, postToolBatchHook, batchArgs } = deps;
     const internalsNotifier = createSafeNotifier({
@@ -1838,7 +1442,6 @@ export class Runner {
                     onError: (f) => console.warn(`[sema-core] ${f.site}: delegation-lifecycle observer threw (contained; further failures counted, not re-disclosed): ${f.error.message}`),
                 }), "runtask.onDelegationLifecycle");
             }
-            await drainForwardedFramesBeforeDone(spec);
             queue.push({ type: "done", result: resultValue });
             queue.close();
         });
@@ -4278,7 +3881,6 @@ export class Runner {
                 drainManualCompact("mooted");
             }
             manualCompactRef.emitMooted = undefined;
-            await drainForwardedFramesBeforeDone(spec);
             queue.push({ type: "done", result });
             queue.close();
             await prepared.fileHistoryBoundary?.settle();
@@ -4986,7 +4588,7 @@ export class Runner {
         if (plainPolicyOutcome !== undefined) {
             const parkedOrigin = cp.pendingAction.kind === "tool_approval" ? cp.pendingAction.origin : undefined;
             if (!isAskOrigin(parkedOrigin)) {
-                throw new CheckpointError("checkpoint.unsupported_version", "this checkpoint's pending approval carries no origin word (a row minted before the ask's origin was persisted on the park) — its settlement cannot be recorded; the checkpoint stays pending", { reason: "origin_missing" });
+                throw new CheckpointError("checkpoint.unsupported_version", "this checkpoint's pending approval carries no origin word (a row minted before the ask's origin was persisted on the park) — its settlement cannot be recorded; the checkpoint stays pending");
             }
             const facts = plainPolicyOutcome.hostDecision;
             const approverCell = facts.approver !== undefined ? { approver: facts.approver } : {};
@@ -5150,6 +4752,7 @@ export class Runner {
             ...(answerFace !== undefined ? { onQuestion: answerFace } : {}),
         };
         const reopenFn = store.reopen?.bind(store);
+        const recordExecutionOutcome = (gate) => store.recordExecutionOutcome(token, cp.scope, gate);
         const onEnvRestoreFailed = reopenFn
             ? async (reason) => {
                 const reopened = await reopenFn(token, cp.scope, reason);
@@ -5178,7 +4781,7 @@ export class Runner {
                     ? new CheckpointError("checkpoint.reopen_failed", "the resume was aborted before the approved action could run AND the store refused to reopen the checkpoint — the approval is terminally consumed and the suspended work was not executed; a retry needs a fresh approval")
                     : new CheckpointError("checkpoint.reopen_failed", "the resume was aborted before the approved action could run and the reopen attempt FAILED IN FLIGHT — the checkpoint's state is unprovable from here: it may already be pending again. Re-read it before deciding; do NOT issue a fresh approval on the assumption the old one is dead (the approved action did NOT run either way)");
         }
-        return this.runTaskStream(spec, { cp, outcome: outcomeForStore, onEnvRestoreFailed, ...(wakeMessage !== undefined ? { wakeMessage } : {}), ...(wakeHookContext !== undefined ? { wakeMessageHookContext: wakeHookContext } : {}) }, resumeInternals);
+        return this.runTaskStream(spec, { cp, outcome: outcomeForStore, onEnvRestoreFailed, recordExecutionOutcome, ...(wakeMessage !== undefined ? { wakeMessage } : {}), ...(wakeHookContext !== undefined ? { wakeMessageHookContext: wakeHookContext } : {}) }, resumeInternals);
     }
     async applyResumeDecision(prepared, resume, emit, emitCommitted, onResolvedToolSuccess, onExecuteStart) {
         const { pendingAction } = resume.cp;
@@ -5234,10 +4837,18 @@ export class Runner {
         const { outcome } = resume;
         if (pendingAction.kind !== "tool_approval" || outcome.gate !== "policy_ask")
             return;
+        const decidedGate = outcome.gateOutcome;
+        if (decidedGate === undefined) {
+            throw new CheckpointError("checkpoint.invalid_outcome", "pending action reached the resolver with no settlement record on its decision (gateOutcome) — refusing to execute or settle a decision that carries no record");
+        }
         const resolvedArgs = pendingAction.toolName === ASK_USER_QUESTION_TOOL_NAME ? pendingAction.args : (outcome.updatedInput !== undefined ? outcome.updatedInput : pendingAction.args);
         const pendingLabel = (() => { const l = prepared.tools.find((t) => t.name === pendingAction.toolName)?.label; return l !== undefined && l !== pendingAction.toolName ? { label: l } : {}; })();
         emit({ type: "tool_start", toolCallId: pendingAction.toolCallId, toolName: pendingAction.toolName, ...pendingLabel, args: resolvedArgs });
-        const emitEnd = (isError, result, gate = outcome.gateOutcome) => emit({ type: "tool_end", toolCallId: pendingAction.toolCallId, toolName: pendingAction.toolName, ...pendingLabel, isError, ...toolEndBodyFrom(result, isError, gate) });
+        const settleEnd = async (isError, result, gate = decidedGate) => {
+            emit({ type: "tool_end", toolCallId: pendingAction.toolCallId, toolName: pendingAction.toolName, ...pendingLabel, isError, ...toolEndBodyFrom(result, isError, gate) });
+            const word = await resume.recordExecutionOutcome(gate);
+            settleExecutionRecord(this.deps.onNotice, word, { toolName: pendingAction.toolName, gate, sessionId: prepared.sessionId, runId: prepared.runId, scope: resume.cp.scope, ...(resume.cp.checkpointId !== undefined ? { checkpointId: resume.cp.checkpointId } : {}) });
+        };
         const vetoed = (layer) => mintGateOutcome({
             deniedBy: layer,
             ...(outcome.gateOutcome?.settlement !== undefined && outcome.gateOutcome.origin !== undefined ? { settled: { settlement: outcome.gateOutcome.settlement, origin: outcome.gateOutcome.origin } } : {}),
@@ -5247,7 +4858,7 @@ export class Runner {
                 ? `No one answered the approval request for the pending tool call "${pendingAction.toolName}" — the approval window elapsed with no answer, so it was not executed.`
                 : `The pending tool call "${pendingAction.toolName}" was denied by an approver.`;
             const reason = outcome.reason ? delimitUntrusted("reviewer note", outcome.reason, REVIEWER_NOTE_MAX_BODY) : defaultDenial;
-            emitEnd(true, { content: formatHookFeedback(reason, prepared.reminderMark) });
+            await settleEnd(true, { content: formatHookFeedback(reason, prepared.reminderMark) });
             const eid = await prepared.session.appendMessage(toolResultMsg(pendingAction.toolCallId, pendingAction.toolName, formatHookFeedback(reason, prepared.reminderMark), true));
             emitCommitted(eid, "toolResult", pendingAction.toolCallId);
             return;
@@ -5272,7 +4883,7 @@ export class Runner {
                 (rechecked.updatedInput !== undefined && !deepJsonEqual(rechecked.updatedInput, resolvedArgs));
             if (beltUnsafe) {
                 const editedDenial = formatHookFeedback(`The approver EDITED this call's input; the edited call is refused by the deployment's tool policy and was not executed${rechecked.action === "deny" && rechecked.message ? `: ${rechecked.message}` : " (the policy rewrote the edit to a value that was not approved)"}.`, prepared.reminderMark);
-                emitEnd(true, { content: editedDenial }, vetoed("policy"));
+                await settleEnd(true, { content: editedDenial }, vetoed("policy"));
                 const eid = await prepared.session.appendMessage(toolResultMsg(pendingAction.toolCallId, pendingAction.toolName, editedDenial, true));
                 emitCommitted(eid, "toolResult", pendingAction.toolCallId);
                 return;
@@ -5282,7 +4893,7 @@ export class Runner {
         const gateOrgGoverned = realApprovalOrgFact(gateRealApproval) !== undefined;
         if (gateOrgGoverned && prepared.permissionRuleOrg === undefined) {
             const unwiredDenial = formatHookFeedback(`The approved tool call "${pendingAction.toolName}" was not executed: its approval was minted under organization governance (${gateRealApproval.origin}), and this worker has no org adjudication wiring — a governed approval may only be redeemed where governance can be enforced. This approval is spent; re-issue the call on an org-wired worker.`, prepared.reminderMark);
-            emitEnd(true, { content: unwiredDenial }, vetoed("org"));
+            await settleEnd(true, { content: unwiredDenial }, vetoed("org"));
             const eid = await prepared.session.appendMessage(toolResultMsg(pendingAction.toolCallId, pendingAction.toolName, unwiredDenial, true));
             emitCommitted(eid, "toolResult", pendingAction.toolCallId);
             return;
@@ -5313,7 +4924,7 @@ export class Runner {
                     ? ` Governance disclosures: ${inlineUntrusted(org.disclosures.join("; "), ORG_DISCLOSURE_MAX_CHARS)}.`
                     : "";
                 const orgDenial = formatHookFeedback(`The approved tool call "${pendingAction.toolName}" was not executed: ${blocked}.${orgDisclosures} This approval is spent — the call has to be re-issued and approved again once organization policy permits it.`, prepared.reminderMark);
-                emitEnd(true, { content: orgDenial }, vetoed("org"));
+                await settleEnd(true, { content: orgDenial }, vetoed("org"));
                 const eid = await prepared.session.appendMessage(toolResultMsg(pendingAction.toolCallId, pendingAction.toolName, orgDenial, true));
                 emitCommitted(eid, "toolResult", pendingAction.toolCallId);
                 return;
@@ -5329,7 +4940,7 @@ export class Runner {
             }, prepared.abortController.signal));
             if (narrowed.action === "deny") {
                 const narrowedDenial = formatHookFeedback(`The approved tool call "${pendingAction.toolName}" is now denied by a session rule and was not executed${narrowed.message ? `: ${narrowed.message}` : ""}.`, prepared.reminderMark);
-                emitEnd(true, { content: narrowedDenial }, vetoed("policy"));
+                await settleEnd(true, { content: narrowedDenial }, vetoed("policy"));
                 const eid = await prepared.session.appendMessage(toolResultMsg(pendingAction.toolCallId, pendingAction.toolName, narrowedDenial, true));
                 emitCommitted(eid, "toolResult", pendingAction.toolCallId);
                 return;
@@ -5362,13 +4973,13 @@ export class Runner {
                     d = { ...(d ?? {}), errorKind: src.errorKind };
                 return d;
             })();
-            emitEnd(true, { content: execError, ...(marks !== undefined ? { details: marks } : {}) });
+            await settleEnd(true, { content: execError, ...(marks !== undefined ? { details: marks } : {}) });
             const eid = await prepared.session.appendMessage(toolResultMsg(pendingAction.toolCallId, pendingAction.toolName, execError, true));
             emitCommitted(eid, "toolResult", pendingAction.toolCallId);
             return;
         }
         const executedIsError = res.isError === true;
-        emitEnd(executedIsError, res);
+        await settleEnd(executedIsError, res);
         onResolvedToolSuccess?.(pendingAction.toolName, executedIsError ? undefined : res.details);
         const eid = await prepared.session.appendMessage({
             role: "toolResult",
@@ -5550,36 +5161,3 @@ export class Runner {
 export function runTask(spec, deps) {
     return new Runner(deps).runTask(spec);
 }
-const WALLTIME_SUSPEND_GRACE_SEC = 120;
-const TIMER_LATENESS_REPORT_MS = 5_000;
-function startTimeout(harness, abortController, remainingMs, softSuspendable = false) {
-    const state = { fired: false, clear: () => { } };
-    if (remainingMs !== undefined) {
-        const hardMs = Math.max(0, remainingMs + (softSuspendable ? WALLTIME_SUSPEND_GRACE_SEC * 1000 : 0));
-        const scheduledAtMs = Date.now() + hardMs;
-        let leftMs = hardMs;
-        let timer;
-        const armChunk = () => {
-            const chunk = Math.max(0, Math.min(leftMs, MAX_TIMER_DELAY_MS));
-            timer = setTimeout(() => {
-                leftMs -= chunk;
-                if (leftMs > 0) {
-                    armChunk();
-                    return;
-                }
-                fireHardAbort();
-            }, chunk);
-        };
-        const fireHardAbort = () => {
-            if (state.fired)
-                return;
-            state.fired = true;
-            state.latenessMs = Math.max(0, Date.now() - scheduledAtMs);
-            abortController.abort();
-            void harness.abort();
-        };
-        armChunk();
-        state.clear = () => clearTimeout(timer);
-    }
-    return state;
-}

package/dist/core/runner/steer-admission.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Admission bookkeeping for HUMAN INPUTS accepted mid-run (design/171 §6.2–§6.3): the per-leg ordinal an
+ * accepted input is stamped with, and the field-for-field "is this repeat the same instruction" test the
+ * live steer verb applies under an already-used `inputId`. Two accepting arms share both — the stream's
+ * `steer` verb and the run body — which is why the ordinal is keyed on the leg's harness in a module-level
+ * WeakMap rather than held by either arm: one counter per leg, one ascending sequence across both.
+ *
+ * Run-loop machinery (layer 1), not a driven lane: nothing here takes an Input or hands back a Result, and
+ * nothing here reads host state. Named without the `run-` family prefix for that reason.
+ */
+import type { AcceptedSteerInput } from "./contracts.js";
+export declare function nextHumanInputSeq(key: object): number;
+/** design/171 §6.3 parity, LIVE leg — is a repeat under an already-accepted `inputId` the SAME
+ *  instruction (an idempotent retry) or a different one wearing a used key? Compared field for field,
+ *  exactly like the parked leg's replay check: the key alone is never evidence of a replay, and two
+ *  callers colliding on one id must not silently lose the second instruction. */
+export declare function sameAcceptedSteerInput(a: AcceptedSteerInput, b: AcceptedSteerInput): boolean;