@sema-agent/client-core 0.84.0 → 0.85.0

package/dist/generated/engineNoticeTables.js

@@ -0,0 +1,156 @@
+export const CORE_ENGINE_NOTICE_CODES = Object.freeze([
+    "config.autocompact_window_clamped",
+    "config.env_timeout_discarded",
+    "config.materialize_env_discarded",
+    "config.models_swapped",
+    "config.context_settings_swapped",
+    "config.read_face_swapped",
+    "config.read_face_deployment_clamped",
+    "config.write_face_swapped",
+    "config.write_face_deployment_clamped",
+    "config.tool_model_gate_removed",
+    "config.tool_model_gate_unknown_class",
+    "config.tool_model_gate_env_invalid",
+    "config.artifact_host_invalid",
+    "config.task_root_not_canonical",
+    "config.write_protection_target_view_absent",
+    "config.write_protection_unresolved",
+    "config.execution_env_capability_invalid",
+    "config.tool_card_undeclared",
+    "config.tool_face_undeclared",
+    "config.tool_face_invalid",
+    "config.forward_sink_failed",
+    "config.durable_gate_unavailable",
+    "config.peer_admission_out_of_range",
+    "config.peer_lane_unmounted",
+    "config.secret_env_scrubbed",
+    "peer.inbound_disposition",
+    "peer.held_settled",
+    "peer.idle_subscription",
+    "classifier.denial_limit",
+    "classifier.fallback",
+    "classifier.role_defaulted",
+    "classifier.contract_broken",
+    "checkpoint.execution_outcome_unrecorded",
+    "delegation.transcript_integrity",
+    "delegation.ask_unresolvable",
+    "mcp.injection_dropped",
+    "mcp.revocation_probe_failed",
+    "mcp.server_redialed",
+    "workflow.governance_key_stripped",
+    "workflow.agent_option_ignored",
+    "memory.session_polluted",
+    "memory.harvest_quarantined",
+    "memory.delegation_static_mark_waived",
+    "memory.content_class_declared",
+    "memory.hold_opened",
+    "memory.hold_released",
+    "memory.hold_disposed",
+    "memory.consolidation_recommended",
+    "memory.consolidation_committed",
+    "memory.consolidation_conflict",
+    "memory.consolidation_incomplete",
+    "memory.consolidation_refused",
+    "memory.consolidation_withheld",
+    "memory.restore_withheld",
+    "memory.project_scope_absent",
+    "route.fallback_to_primary",
+    "route.classifier_unroutable",
+    "route.base_url_changed_key_unchanged",
+    "route.response_model_mismatch",
+    "task.user_steer_undrained",
+    "task.user_followup_undrained",
+    "steering.parked_input_blocked",
+    "task.turn_interrupted",
+    "task.halt_unconsumed",
+    "task.late_approval",
+    "task.interrupt_unconsumed",
+    "approval.read_root_granted",
+    "approval.read_root_grant_rejected",
+    "memory.capture_opted_out",
+    "memory.capture_optout_unpersisted",
+    "skills.listing_truncated",
+    "agents.listing_truncated",
+    "tool_result.offload_put_failed",
+]);
+export const CORE_NOTICE_AUDIENCE = Object.freeze({
+    "config.autocompact_window_clamped": "operator",
+    "config.env_timeout_discarded": "operator",
+    "config.materialize_env_discarded": "operator",
+    "config.models_swapped": "operator",
+    "config.context_settings_swapped": "operator",
+    "config.read_face_swapped": "operator",
+    "config.read_face_deployment_clamped": "operator",
+    "config.write_face_swapped": "operator",
+    "config.write_face_deployment_clamped": "operator",
+    "config.tool_model_gate_removed": "operator",
+    "config.tool_model_gate_unknown_class": "operator",
+    "config.tool_model_gate_env_invalid": "operator",
+    "config.artifact_host_invalid": "operator",
+    "config.task_root_not_canonical": "operator",
+    "config.write_protection_target_view_absent": "operator",
+    "config.write_protection_unresolved": "operator",
+    "config.execution_env_capability_invalid": "operator",
+    "config.tool_card_undeclared": "operator",
+    "config.tool_face_undeclared": "operator",
+    "config.tool_face_invalid": "operator",
+    "config.forward_sink_failed": "operator",
+    "config.durable_gate_unavailable": "user",
+    "config.peer_admission_out_of_range": "operator",
+    "config.peer_lane_unmounted": "operator",
+    "config.secret_env_scrubbed": "operator",
+    "peer.inbound_disposition": "user",
+    "peer.held_settled": "user",
+    "peer.idle_subscription": "user",
+    "classifier.denial_limit": "user",
+    "classifier.fallback": "operator",
+    "classifier.role_defaulted": "operator",
+    "classifier.contract_broken": "operator",
+    "checkpoint.execution_outcome_unrecorded": "operator",
+    "delegation.transcript_integrity": "operator",
+    "delegation.ask_unresolvable": "user",
+    "mcp.injection_dropped": "user",
+    "mcp.revocation_probe_failed": "operator",
+    "mcp.server_redialed": "operator",
+    "workflow.governance_key_stripped": "operator",
+    "workflow.agent_option_ignored": "operator",
+    "memory.session_polluted": "user",
+    "memory.harvest_quarantined": "user",
+    "memory.delegation_static_mark_waived": "user",
+    "memory.content_class_declared": "operator",
+    "memory.hold_opened": "user",
+    "memory.hold_released": "user",
+    "memory.hold_disposed": "user",
+    "memory.consolidation_recommended": "operator",
+    "memory.consolidation_committed": "operator",
+    "memory.consolidation_conflict": "operator",
+    "memory.consolidation_incomplete": "operator",
+    "memory.consolidation_refused": "operator",
+    "memory.consolidation_withheld": "operator",
+    "memory.restore_withheld": "operator",
+    "memory.project_scope_absent": "operator",
+    "route.fallback_to_primary": "operator",
+    "route.classifier_unroutable": "operator",
+    "route.base_url_changed_key_unchanged": "operator",
+    "route.response_model_mismatch": "operator",
+    "task.user_steer_undrained": "user",
+    "task.user_followup_undrained": "user",
+    "steering.parked_input_blocked": "user",
+    "task.turn_interrupted": "user",
+    "task.halt_unconsumed": "user",
+    "task.late_approval": "user",
+    "task.interrupt_unconsumed": "user",
+    "approval.read_root_granted": "user",
+    "approval.read_root_grant_rejected": "user",
+    "memory.capture_opted_out": "user",
+    "memory.capture_optout_unpersisted": "user",
+    "skills.listing_truncated": "operator",
+    "agents.listing_truncated": "operator",
+    "tool_result.offload_put_failed": "operator",
+});
+export const CORE_MCP_INJECTION_DROP_REASONS = Object.freeze([
+    "malformed_entry",
+    "name_reserved_by_deployment",
+    "gate_closed",
+    "over_cap",
+]);

package/dist/generated/toolNameTables.d.ts

@@ -0,0 +1,2 @@
+export declare const CORE_PROTOCOL_PREFIXES: readonly ["mcp__", "a2a__"];
+export declare const CORE_RETIRED_TOOL_CURRENT_NAMES: ReadonlyMap<string, string | null>;

package/dist/generated/toolNameTables.js

@@ -0,0 +1,43 @@
+export const CORE_PROTOCOL_PREFIXES = ["mcp__", "a2a__"];
+export const CORE_RETIRED_TOOL_CURRENT_NAMES = new Map([
+    ["read_file", "Read"],
+    ["edit_file", "Edit"],
+    ["write_file", "Write"],
+    ["bash", "Bash"],
+    ["bash_readonly", null],
+    ["glob", "Glob"],
+    ["grep", "Grep"],
+    ["web_fetch", "WebFetch"],
+    ["tool_search", "ToolSearch"],
+    ["skill", "Skill"],
+    ["present_plan", "ExitPlanMode"],
+    ["enter_plan_mode", "EnterPlanMode"],
+    ["spawn_subagent", "Agent"],
+    ["CronCancel", "CronDelete"],
+    ["lsp", "LSP"],
+    ["submit_output", "StructuredOutput"],
+    ["repo_map", "RepoMap"],
+    ["read_tool_result", "ReadToolResult"],
+    ["report_blocked", "ReportBlocked"],
+    ["declare_done", "DeclareDone"],
+    ["run_workflow", "Workflow"],
+    ["RunWorkflow", "Workflow"],
+    ["Task", "Agent"],
+    ["BashOutput", "TaskOutput"],
+    ["AgentOutputTool", "TaskOutput"],
+    ["BashOutputTool", "TaskOutput"],
+    ["AgentOutput", "TaskOutput"],
+    ["WorkflowStatus", null],
+    ["KillShell", "TaskStop"],
+    ["KillBash", "TaskStop"],
+    ["ListMcpResources", "ListMcpResourcesTool"],
+    ["ReadMcpResource", "ReadMcpResourceTool"],
+    ["ReadMcpResourceDir", "ReadMcpResourceDirTool"],
+    ["MultiEdit", null],
+    ["Fork", null],
+    ["Sleep", null],
+    ["Remember", null],
+    ["remember", null],
+    ["Recall", null],
+    ["recall", null],
+]);

package/dist/headlessPermissionModeWire.js

@@ -1,11 +1,9 @@
 import { permissionModeField } from './permissionWireCaps.js';
 import { hostEnv } from './hostEnv.js';
 import { lastFlagValue } from './argvFlagValue.js';
+import { PERMISSION_MODE_WORDS } from './taskRequestWords.js';
 export const HEADLESS_PERMISSION_MODE_ENV = 'SEMA_HEADLESS_PERMISSION_MODE';
-const HEADLESS_PERMISSION_WIRE_MODE_TUPLE = ['default', 'plan', 'acceptEdits', 'bypassPermissions', 'auto'];
-const _headlessPermissionModePins = [true, true];
-void _headlessPermissionModePins;
-export const HEADLESS_PERMISSION_WIRE_MODES = HEADLESS_PERMISSION_WIRE_MODE_TUPLE;
+export const HEADLESS_PERMISSION_WIRE_MODES = [...PERMISSION_MODE_WORDS];
 const SHELL_INTERNAL_MODE_TO_WIRE = new Map([
     ['manual', 'default'],
     ['dontAsk', 'default'],

package/dist/hitl/askGateWire.d.ts

@@ -8,7 +8,7 @@ export type { AskAnsweredOutput } from './gateLedger.js';
 export { SEMA_COLLATERAL_ABORT_KEY } from './gateLedger.js';
 export { SEMA_DENIAL_KIND_KEY } from './gateLedger.js';
 export type { GateDenyAttribution } from './gateLedger.js';
-export { toAnsweredOutput, isAlreadyResolvedGateReason, isGateStandingErrorCode, GATE_FAILURE_CODES, nextHopBudget, MAX_GATE_HOPS, MAX_TOTAL_PARKS } from './parkResolver.js';
+export { toAnsweredOutput, isAlreadyResolvedGateReason, isGateStandingErrorCode, isCodeClassifiedGateFailure, GATE_FAILURE_CODES, nextHopBudget, MAX_GATE_HOPS, MAX_TOTAL_PARKS } from './parkResolver.js';
 export type { HopBudget, HopRound } from './parkResolver.js';
 export type { GateOutcome, GateFailureCode } from './parkResolver.js';
 export declare function bridgeAskUserQuestionGates(source: AsyncGenerator<AgentEvent>, deps: AskGateWireDeps, opts?: {

package/dist/hitl/askGateWire.js

@@ -6,7 +6,7 @@ export { HITL_INTERRUPT_MESSAGE_FOR_TOOL_USE } from './frameRouter.js';
 export { HITL_POLICY_DENY_MESSAGE } from './frameRouter.js';
 export { SEMA_COLLATERAL_ABORT_KEY } from './gateLedger.js';
 export { SEMA_DENIAL_KIND_KEY } from './gateLedger.js';
-export { toAnsweredOutput, isAlreadyResolvedGateReason, isGateStandingErrorCode, GATE_FAILURE_CODES, nextHopBudget, MAX_GATE_HOPS, MAX_TOTAL_PARKS } from './parkResolver.js';
+export { toAnsweredOutput, isAlreadyResolvedGateReason, isGateStandingErrorCode, isCodeClassifiedGateFailure, GATE_FAILURE_CODES, nextHopBudget, MAX_GATE_HOPS, MAX_TOTAL_PARKS } from './parkResolver.js';
 export async function* bridgeAskUserQuestionGates(source, deps, opts) {
     const led = createGateLedger();
     const taskId = { current: opts?.taskId };

package/dist/hitl/frameRouter.js

@@ -6,7 +6,9 @@ import { readRunTerminal, runTerminalCode, runTerminalGateKind, runTerminalGateT
 import { surfaceForCurrentSession } from './hitlHostSurface.js';
 import { SEMA_DENIAL_KIND_KEY } from './gateLedger.js';
 import { ccToolDenialKindForSettledBy } from '../gateVocabulary.js';
-export const HITL_REJECT_MESSAGE = "The user doesn't want to proceed with this tool use. The tool use was rejected (eg. if it was a file edit, the new_string was NOT written to the file). STOP what you are doing and wait for the user to tell you how to proceed.";
+import { REJECT_MESSAGE } from '../adapt/wireShapes.js';
+import { RUN_CANCELLED_CODE } from '../runCancelContext.js';
+export const HITL_REJECT_MESSAGE = REJECT_MESSAGE;
 export const HITL_POLICY_DENY_MESSAGE = 'Permission for this tool use was denied: it requires interactive approval, and permission prompts are ' +
     'not available in this session. The action was NOT performed. Do not claim it succeeded, and do not retry ' +
     'it in this session \u2014 report the limitation to the user, or suggest an alternative.';
@@ -31,7 +33,7 @@ function denyStampedEnd(ev, attribution) {
     };
 }
 export const HITL_INTERRUPT_MESSAGE_FOR_TOOL_USE = '[Request interrupted by user for tool use]';
-const RUN_CANCELLED_ERROR_CODE = 'cancelled';
+const RUN_CANCELLED_ERROR_CODE = RUN_CANCELLED_CODE;
 export const ENGINE_ABORT_TOOL_RESULT = 'Operation aborted';
 export function toolEndOutputText(output) {
     if (typeof output === 'string')

package/dist/hitl/hitlHostSurface.js

@@ -113,7 +113,7 @@ export function observeCancelByDeny(settle, taskId) {
             hostLog('debug', `[hitl-cancel-deny] cancel-by-deny no_pending for run ${taskId} (benign — already resolved)`);
             return;
         }
-        const rowNote = decideFailureNote(e);
+        const rowNote = decideFailureNote(e, 'deny');
         hostLog('error', `[hitl-cancel-deny] cancel-by-deny FAILED for run ${taskId}: ${String(e)}${rowNote}`);
         surfaceCancelDenyWarn(`${CANCEL_DENY_WARN_TEXT}${rowNote}`);
     })

package/dist/hitl/parkResolver.d.ts

@@ -34,6 +34,7 @@ export type GateOutcome = {
 };
 export declare function isAlreadyResolvedGateReason(reason: unknown): boolean;
 export declare function isGateStandingErrorCode(code: string | null | undefined): boolean;
+export declare function isCodeClassifiedGateFailure(code: string | null | undefined): boolean;
 export declare function toAnsweredOutput(questions: unknown[], answer: QuestionAnswer): AskAnsweredOutput;
 export type ParkResolution = {
     kind: 'reattach';

package/dist/hitl/parkResolver.js

@@ -1,6 +1,6 @@
 import { putOwnKey } from '../ownKey.js';
 import { DecideTransportRetryExhaustedError, HitlBridge, HitlSafetyError, findPendingForTask, readDecideCurrentPending, readWireErrorCode, } from './hitlBridge.js';
-import { RESUME_POLICY_FOLD_CODE } from '../engineErrorCodes.js';
+import { PARKED_RESUME_STARTUP_FAILED, RESUME_POLICY_FOLD_CODE, isDecideParkMovedCode } from '../engineErrorCodes.js';
 import { publishQuestionFrame, registerLocalQuestionResponder, hasQuestionOverlay, } from '../liveQuestionStore.js';
 import { hostLog } from '../host.js';
 import { surfaceFsApprovalAndDecide } from './toolApprovalWire.js';
@@ -44,13 +44,18 @@ function isAlreadyResolvedFailure(outcome) {
     const code = 'code' in outcome && isGateFailureCode(outcome.code) ? outcome.code : undefined;
     if (code !== undefined)
         return code === 'no_pending';
-    if ('errorCode' in outcome && isGateStandingErrorCode(outcome.errorCode))
+    if ('errorCode' in outcome && isCodeClassifiedGateFailure(outcome.errorCode))
         return false;
+    if ('errorCode' in outcome && isDecideParkMovedCode(outcome.errorCode))
+        return true;
     return isAlreadyResolvedGateReason(outcome.reason);
 }
 export function isGateStandingErrorCode(code) {
     return code === RESUME_POLICY_FOLD_CODE || code === 'corrupt';
 }
+export function isCodeClassifiedGateFailure(code) {
+    return isGateStandingErrorCode(code) || code === PARKED_RESUME_STARTUP_FAILED;
+}
 export function toAnsweredOutput(questions, answer) {
     const answers = {};
     const annotations = {};
@@ -122,10 +127,12 @@ async function surfaceGateAndDecide(deps, taskId, askArgsByCall, signal, parkGat
         return { kind: 'aborted', gatedCallId };
     }
     let declinedReceipt;
+    let attemptedDecision;
     try {
         const entries = answer.answers ?? [];
         const hasContent = entries.some(a => (a.selected?.length ?? 0) > 0 || (a.note?.length ?? 0) > 0);
         if (hasContent) {
+            attemptedDecision = 'approve';
             const raw = await bridge.answerQuestion(entries, gatedCallId, signal ? { signal } : undefined, pending);
             const receipt = readDecideReceipt(raw);
             return {
@@ -136,6 +143,7 @@ async function surfaceGateAndDecide(deps, taskId, askArgsByCall, signal, parkGat
             };
         }
         else {
+            attemptedDecision = 'deny';
             const raw = await bridge.decideTool({ decision: 'deny', reason: 'User declined to answer' }, gatedCallId, signal ? { signal } : undefined, pending);
             declinedReceipt = readDecideReceipt(raw);
         }
@@ -149,7 +157,7 @@ async function surfaceGateAndDecide(deps, taskId, askArgsByCall, signal, parkGat
             kind: 'failed',
             stage: 'decide',
             gatedCallId,
-            reason: `decide failed: ${String(e)}${decideFailureNote(e)}`,
+            reason: `decide failed: ${String(e)}${decideFailureNote(e, attemptedDecision)}`,
             ...(code !== undefined ? { code } : {}),
             ...(e instanceof DecideTransportRetryExhaustedError ? { retryExhausted: true } : {}),
             ...(currentPending !== undefined ? { currentPending } : {}),

package/dist/hitl/planReviewWire.d.ts

@@ -1,5 +1,6 @@
 import { type QuestionAnswer } from '../liveQuestionStore.js';
 import { type PlanReviewModeAfter } from './hitlBridge.js';
+import type { AgentClient } from '@sema-agent/sdk';
 import type { ReopenCardVerdict } from '../adapter/activeRunSelfHeal.js';
 export declare const PLAN_REVIEW_APPROVE_LABEL = "Yes, approve and run the plan";
 export declare const PLAN_REVIEW_REJECT_LABEL = "No, reject it (keep planning)";
@@ -28,10 +29,13 @@ export declare function _resetArmedPlanReviewsForTest(): void;
 export type PlanReviewReopenTrigger = 'user' | 'automatic';
 export type PlanReviewGateInstanceReader = (taskId: string) => Promise<ReadonlySet<string> | null>;
 export declare function clearPlanReviewUserDismissals(sessionKey?: string): void;
-export declare function armPlanReviewApproval(result: unknown, sessionKey?: string, opts?: {
+export interface ArmPlanReviewOptions {
     submittedInPlanMode?: boolean;
     readGateInstanceKeys?: PlanReviewGateInstanceReader;
-}): boolean;
+    wire?: PlanReviewWire;
+    onOutcome?: PlanReviewDeliveryOptions['onOutcome'];
+}
+export declare function armPlanReviewApproval(result: unknown, sessionKey?: string, opts?: ArmPlanReviewOptions): boolean;
 export type PlanReviewDecisionEffect = 'took_effect' | 'advanced' | 'still_parked' | 'not_sent' | 'not_applied' | 'unconfirmed';
 export interface PlanReviewOutcomeMeta {
     taskId: string;
@@ -40,16 +44,50 @@ export interface PlanReviewOutcomeMeta {
     effect: PlanReviewDecisionEffect;
 }
 export declare function planReviewOutcomeTail(taskId: string, decision: 'approve' | 'reject', effect: PlanReviewDecisionEffect): string;
+export type PlanReviewWireClient = {
+    assistant: Pick<AgentClient['assistant'], 'planReview'>;
+    runs: Pick<AgentClient['runs'], 'get'>;
+};
+export interface PlanReviewWire {
+    client: PlanReviewWireClient;
+    capsBaseUrl?: string;
+}
+export interface PlanReviewDecisionOutcome extends PlanReviewOutcomeMeta {
+    detail: string;
+    tail: string;
+    prompt: string;
+    status?: string;
+}
+export interface PlanReviewDeliveryOptions {
+    wire?: PlanReviewWire;
+    onOutcome?: (outcome: PlanReviewDecisionOutcome) => void;
+}
+export interface DecidePlanReviewOptions extends PlanReviewDeliveryOptions {
+    reason?: string;
+}
+export interface PlanReviewDecisionHandle {
+    settle(): void;
+    revoke(): void;
+}
+export declare function notePlanReviewDecisionHandedOver(taskId: string): PlanReviewDecisionHandle | null;
+export declare function planReviewPendingReadMark(): number;
+export declare function planReviewDecisionInFlight(taskId: string, pendingReadStartedAt?: number): boolean;
+export declare function notePlanReviewDecisionNotApplied(taskId: string): void;
+export declare function notePlanReviewGateLeft(taskId: string): void;
+export declare function latestPlanReviewDecisionMark(taskId: string): number | null;
 export declare function __resetPlanReviewDecisionLatchForTests(): void;
-export declare function decidePlanReview(taskId: string, decision: 'approve' | 'reject', permissionModeAfter?: string): Promise<void>;
+export declare function decidePlanReview(taskId: string, decision: 'approve' | 'reject', permissionModeAfter?: string, opts?: DecidePlanReviewOptions): Promise<void>;
 export interface ReopenPlanReviewOpts {
     mintFreshQuestionId?: boolean;
     deliverDecision?: (taskId: string, decision: 'approve' | 'reject') => void | Promise<void>;
     sessionKey?: string;
+    wire?: PlanReviewWire;
+    onOutcome?: PlanReviewDeliveryOptions['onOutcome'];
     presentationReceiptMs?: number;
     trigger?: PlanReviewReopenTrigger;
     readGateInstanceKeys?: PlanReviewGateInstanceReader;
     decisionHandedOver?: (taskId: string) => boolean;
+    pendingReadStartedAt?: number;
 }
 export declare function _resetActiveReopenRespondersForTest(): void;
 export declare function reopenPlanReviewCard(taskId: string, opts: ReopenPlanReviewOpts & {