@sema-agent/client-core 0.104.1 → 0.106.0

package/dist/errorSupplementRoles.js

@@ -4,6 +4,7 @@ import { resumeRefusalContent, resumeContextUnavailableContent, requireExistingS
 import { resumeReopenContent } from './hitl/suspendedReopen.js';
 import { idempotencyPayloadMismatchContent } from './engineErrorCodes.js';
 import { inheritEnvRefusalContent } from './inheritEnvWire.js';
+import { projectSeedRefusalContent } from './projectSeed.js';
 import { usageWindowExhaustedContent, fleetLeaseUnavailableContent, settingsPermissionBucketRefusalContent, fieldLimitRefusalContent, autonomyLaneRefusalContent, unsupportedRuleRefusalContent, admissionWallRefusalContent, hostPostureRefusalContent, toolDeclarationRefusalContent, } from './wireRefusalCopy.js';
 const ROLE_BY_READER = new Map([
     [corruptSessionContent, 'replacement'],
@@ -20,6 +21,7 @@ const ROLE_BY_READER = new Map([
     [autonomyLaneRefusalContent, 'replacement'],
     [idempotencyPayloadMismatchContent, 'replacement'],
     [unsupportedRuleRefusalContent, 'replacement'],
+    [projectSeedRefusalContent, 'replacement'],
     [admissionWallRefusalContent, 'supplement'],
     [hostPostureRefusalContent, 'supplement'],
     [toolDeclarationRefusalContent, 'supplement'],

package/dist/eventLeg.d.ts

@@ -2,7 +2,7 @@ import type { AgentEvent } from '@sema-agent/sdk';
 import type { EngineBoundRun } from './engineRowRef.js';
 import { type AskGateWireDeps } from './hitl/askGateWire.js';
 import { type ActiveRunBusySignal } from './adapter/runStream.js';
-import type { ApprovalRequestChromeEvent, ApprovalRevokeChromeEvent } from './seam.js';
+import type { ApprovalCompleteChromeEvent, ApprovalRequestChromeEvent, ApprovalRevokeChromeEvent } from './seam.js';
 export declare const EVENT_LEG_KINDS: readonly ["live", "durable", "continuation"];
 export type EventLegKind = (typeof EVENT_LEG_KINDS)[number];
 export type EventLegStage = 'bindRun' | 'stampOwner' | 'hitlFrames' | 'askBridge' | 'idleTriage';
@@ -71,7 +71,7 @@ export interface ApprovalFrameContext {
     readonly receivedAtMs: number;
     readonly streamEnded: AbortSignal;
 }
-export declare function approvalFrameContextOf(arm: ApprovalRequestChromeEvent | ApprovalRevokeChromeEvent): ApprovalFrameContext | undefined;
+export declare function approvalFrameContextOf(arm: ApprovalRequestChromeEvent | ApprovalCompleteChromeEvent | ApprovalRevokeChromeEvent): ApprovalFrameContext | undefined;
 export interface EventLegPorts {
     readonly run?: EventLegRunPorts;
     readonly owner?: EventLegOwnerPorts;
@@ -81,7 +81,7 @@ export interface EventLegPorts {
     readonly signal?: AbortSignal;
     readonly taps?: readonly EventLegTap[];
 }
-export type EventLegPortName = 'run.headerRunId' | 'run.onBound' | 'run.onRefused' | 'run.onTerminal' | 'run.isCurrent' | 'hitl.question' | 'hitl.elicitation' | 'hitl.toolApproval' | 'askBridge.respondToolApproval' | 'taps';
+export type EventLegPortName = 'run.headerRunId' | 'run.onBound' | 'run.onRefused' | 'run.onTerminal' | 'run.isCurrent' | 'hitl.question' | 'hitl.elicitation' | 'hitl.toolApproval' | 'askBridge.respondToolApproval' | 'askBridge.onBreak' | 'taps';
 export interface EventLegReport {
     readonly missingPorts: readonly EventLegPortName[];
     readonly portFaults: Readonly<Partial<Record<EventLegPortName, number>>>;

package/dist/eventLeg.js

@@ -3,11 +3,13 @@ import { bridgeAskUserQuestionGates } from './hitl/askGateWire.js';
 import { diagnoseSseIdleTear } from './sseIdleTriage.js';
 import { recordSubagentOwnerFromProgress } from './subagentContentStore.js';
 import { activeRunBusySignal } from './adapter/runStream.js';
-import { invokeHostCallbackIsolated } from './hostCallbackGuard.js';
+import { frameProvesDelivery } from './promptDelivery.js';
+import { faultText, invokeHostCallbackIsolated } from './hostCallbackGuard.js';
 import { hostLog } from './host.js';
 import { guardedRead, readOwnDataNonEmptyString, readOwnDataValue } from './ownKey.js';
 import { settleEngineClosedApproval } from './hitl/approvalHolds.js';
 import { approvalCompleteParked } from './hitl/approvalCompleteParked.js';
+import { setBridgeRunHandleFallback } from './hitl/frameRouter.js';
 export const EVENT_LEG_KINDS = Object.freeze(['live', 'durable', 'continuation']);
 export const EVENT_LEG_TABLE = Object.freeze({
     live: Object.freeze({ stages: Object.freeze(['bindRun', 'stampOwner', 'hitlFrames', 'askBridge', 'idleTriage']), windowIsCurrent: true }),
@@ -108,7 +110,7 @@ export function composeEventLeg(source, leg, ports) {
             return port.call(runPorts) === true;
         }
         catch (e) {
-            fault('run.isCurrent', String(e));
+            fault('run.isCurrent', faultText(e));
             return false;
         }
     };
@@ -131,7 +133,7 @@ export function composeEventLeg(source, leg, ports) {
             return undefined;
         }
         catch (e) {
-            fault('run.headerRunId', String(e));
+            fault('run.headerRunId', faultText(e));
             return undefined;
         }
     };
@@ -179,7 +181,7 @@ export function composeEventLeg(source, leg, ports) {
                 if (taskId === undefined && streamKind === 'live')
                     taskId = readHeaderRunId();
                 const refusal = streamKind === 'live' && !runEvidence && inDomain('bindRun', ev.type) ? refusalOf(ev, taskId) : undefined;
-                if (!inDomain('bindRun', ev.type))
+                if (frameProvesDelivery(ev))
                     runEvidence = true;
                 if (refusal !== undefined) {
                     if (runPorts !== undefined && typeof runPorts.onRefused === 'function' && isCurrentNow())
@@ -232,13 +234,32 @@ export function composeEventLeg(source, leg, ports) {
             windowOpen = false;
             return streamOf(hostBridge.runsEvents(taskId, opts), 'continuation', taskId);
         };
+        const onBreak = (event) => {
+            if (!isCurrentNow())
+                return;
+            let port;
+            try {
+                port = hostBridge.onBreak;
+            }
+            catch (e) {
+                fault('askBridge.onBreak', faultText(e));
+                port = undefined;
+            }
+            if (typeof port !== 'function')
+                return;
+            if (!isCurrentNow() || ports.signal?.aborted === true)
+                return;
+            callPort('askBridge.onBreak', () => port.call(hostBridge, event));
+        };
         const deps = hostView(hostBridge, {
             runsEvents: () => runsEvents,
             approvalLane: () => {
                 const lane = hostBridge.approvalLane;
                 return typeof lane === 'object' && lane !== null ? hostView(lane, { windowIsCurrent: () => windowOpen }) : Object.freeze({ windowIsCurrent: windowOpen });
             },
+            onBreak: () => onBreak,
         });
+        setBridgeRunHandleFallback(deps, () => lastBound?.taskId);
         inner = bridgeAskUserQuestionGates(inner, deps, { ...(ports.signal !== undefined ? { signal: ports.signal } : {}), ...(legRunId !== undefined ? { taskId: legRunId } : {}) });
     }
     const baseUrl = ports.idleTriage?.baseUrl;

package/dist/fleet/fleetProjection.js

@@ -3,7 +3,8 @@ import { rowIdTail } from '../workflow.js';
 import { cycleSeqValue } from '../cycleOrder.js';
 import { frozenSet } from '../frozenSet.js';
 import { guardedRead, readOwnDataValue } from '../ownKey.js';
-import { CORE_RESERVED_AGENT_NAMES } from '../generated/engineFactTables.js';
+import { CORE_RESERVED_AGENT_NAMES, CORE_WORKFLOW_AGENT_PARKED_ERROR_CODE } from '../generated/engineFactTables.js';
+import { runParkedOf as coreRunParkedOf } from '../coreValuePorts.js';
 export function coerceTaskStatus(s) {
     if (s === 'parked')
         return 'awaiting approval';
@@ -31,9 +32,9 @@ export function coerceWorkflowStatus(s) {
 }
 export function workflowRunDisplayStatusOf(run) {
     const status = runField(run, 'status');
-    if (runField(run, 'parked') === true)
+    if (parkedWindowOf(run, status))
         return 'awaiting approval';
-    if (status === 'failed' && runField(run, 'errorCode') === WORKFLOW_AGENT_PARKED_ERROR_CODE)
+    if (status === 'failed' && runField(run, 'errorCode') === CORE_WORKFLOW_AGENT_PARKED_ERROR_CODE)
         return 'awaiting approval';
     switch (status) {
         case 'completed':
@@ -52,7 +53,27 @@ export function workflowRunDisplayStatusOf(run) {
             return 'idle';
     }
 }
-const WORKFLOW_AGENT_PARKED_ERROR_CODE = 'workflow.agent_parked';
+function parkedWindowOf(run, status) {
+    if (runField(run, 'parked') === true)
+        return true;
+    if (guardedRead(() => (typeof run === 'object' && run !== null ? !Object.hasOwn(run, 'parked') : undefined)) !== true)
+        return false;
+    const agents = runField(run, 'agents');
+    if (typeof status !== 'string' || guardedRead(() => Array.isArray(agents)) !== true)
+        return false;
+    return guardedRead(() => {
+        const rows = [];
+        const list = agents;
+        for (const k of Object.keys(list)) {
+            if (!/^(?:0|[1-9]\d*)$/.test(k))
+                continue;
+            const a = readOwnDataValue(list, k);
+            const st = typeof a === 'object' && a !== null ? runField(a, 'status') : undefined;
+            rows.push({ status: typeof st === 'string' ? st : '' });
+        }
+        return coreRunParkedOf({ status, agents: rows });
+    }) === true;
+}
 function runField(run, key) {
     return guardedRead(() => typeof run === 'object' && run !== null && !Array.isArray(run) ? readOwnDataValue(run, key) : undefined);
 }
@@ -362,7 +383,7 @@ export const FLEET_WORKFLOW_ROW_KEYS_NOT_PROJECTED = {
     errorCode: {
         kind: 'by-design',
         owner: 'client-core 0.103.0 提货',
-        reason: '折进 status:只有停驻终态码 workflow.agent_parked 改显示状态(awaiting approval,停驻不是失败),读法唯一处 workflowRunDisplayStatusOf;' +
+        reason: '折进 status:只有引擎的停驻终态码(值取自引擎包根导出,经生成表读)改显示状态(awaiting approval,停驻不是失败),读法唯一处 workflowRunDisplayStatusOf;' +
             '0.95.0 CC-388 把它从视图退出时服务端还不铸,现在铸了也不回到视图 —— run 级别的其它码走 workflow 读面。',
     },
     parked: {

package/dist/generated/engineFactTables.d.ts

@@ -48,7 +48,7 @@ export declare const CORE_TASK_NOTIFICATION_TERMINAL_STATUSES: readonly ["comple
 export declare const CORE_RESUME_STARTUP_CAUSES: readonly ["environment", "session_gone", "transcript_corrupt", "tool_unavailable", "configuration", "decision_rejected"];
 export declare const CORE_BUILTIN_SUBAGENT_TYPES: readonly ["Explore", "Plan", "fork", "general-purpose"];
 export declare const CORE_RULE_OFFERS_ABSENCES: readonly ["mandated", "allow_outranked", "ask_rule_matched", "lane_cannot_speak"];
-export declare const CORE_TOOL_APPROVAL_CARDS: readonly ["file-edit", "file-write", "notebook-edit", "shell", "fetch", "skill", "workflow", "plan", "question", "generic"];
+export declare const CORE_TOOL_APPROVAL_CARDS: readonly ["file-edit", "file-write", "notebook-edit", "shell", "fetch", "skill", "workflow", "plan", "question", "generic", "computer-access", "computer-control"];
 export declare const CORE_MCP_FAILURE_KINDS: readonly ["connect_refused", "connection_failed", "connection_closed", "unauthorized", "http_status", "not_mcp_response", "spawn_failed", "timeout", "protocol", "invalid_config", "credential_unavailable", "host_refused", "unknown"];
 export declare const CORE_MCP_AUTHORIZATION_REASONS: readonly ["rejected", "scope", "none"];
 export declare const CORE_PERSISTED_RULE_MATCHES: readonly ["exact", "prefix", "wildcard", "pattern", "subpath", "path", "name", "name_prefix", "host", "subdomain", "tool"];
@@ -71,3 +71,5 @@ export interface CoreUserAttachmentSeat {
 export declare const CORE_USER_ATTACHMENT_SEAT: CoreUserAttachmentSeat;
 export declare const CORE_USER_ATTACHMENTS_MAX: number;
 export declare const CORE_USER_ATTACHMENT_LABEL_MAX: number;
+export declare const CORE_PRESENT_PLAN_TOOL_NAME: "ExitPlanMode";
+export declare const CORE_WORKFLOW_AGENT_PARKED_ERROR_CODE: "workflow.agent_parked";

package/dist/generated/engineFactTables.js

@@ -76,7 +76,6 @@ export const CORE_ENGINE_CARD_TYPES = Object.freeze([
     "repo-map",
     "artifact",
     "worktree",
-    "task-output",
     "task-stop",
     "monitor-start",
     "send-message",
@@ -366,6 +365,8 @@ export const CORE_TOOL_APPROVAL_CARDS = Object.freeze([
     "plan",
     "question",
     "generic",
+    "computer-access",
+    "computer-control",
 ]);
 export const CORE_MCP_FAILURE_KINDS = Object.freeze([
     "connect_refused",
@@ -463,3 +464,5 @@ export const CORE_USER_ATTACHMENT_SEAT = Object.freeze({
 });
 export const CORE_USER_ATTACHMENTS_MAX = 20;
 export const CORE_USER_ATTACHMENT_LABEL_MAX = 4096;
+export const CORE_PRESENT_PLAN_TOOL_NAME = "ExitPlanMode";
+export const CORE_WORKFLOW_AGENT_PARKED_ERROR_CODE = "workflow.agent_parked";

package/dist/generated/engineNoticeTables.js

@@ -18,6 +18,7 @@ export const CORE_ENGINE_NOTICE_CODES = Object.freeze([
     "config.path_view_unresolved",
     "config.execution_env_capability_invalid",
     "config.read_deny_floor_unkept",
+    "config.read_floor_confinement_unavailable",
     "config.tool_card_undeclared",
     "config.tool_face_undeclared",
     "config.tool_face_invalid",
@@ -86,7 +87,8 @@ export const CORE_ENGINE_NOTICE_CODES = Object.freeze([
     "model.capability_downgraded",
     "model.role_defaulted",
     "context.tool_turn_repaired",
-    "context.image_removed",
+    "context.media_removed",
+    "context.tool_schema_removed",
     "task.user_steer_undrained",
     "task.user_followup_undrained",
     "steering.parked_input_blocked",
@@ -104,6 +106,9 @@ export const CORE_ENGINE_NOTICE_CODES = Object.freeze([
     "tool_result.offload_put_failed",
     "tool_result.media_refused",
     "config.image_processor_unavailable",
+    "fs.staging_file_left",
+    "fs.staging_file_swept",
+    "session.lineage_rerooted",
     "instructions.source_changed",
     "session.records_skipped",
     "memory.layer_locked_legacy",
@@ -130,6 +135,7 @@ export const CORE_NOTICE_AUDIENCE = Object.freeze({
     "config.path_view_unresolved": "operator",
     "config.execution_env_capability_invalid": "operator",
     "config.read_deny_floor_unkept": "operator",
+    "config.read_floor_confinement_unavailable": "operator",
     "config.tool_card_undeclared": "operator",
     "config.tool_face_undeclared": "operator",
     "config.tool_face_invalid": "operator",
@@ -155,7 +161,7 @@ export const CORE_NOTICE_AUDIENCE = Object.freeze({
     "peer.idle_subscription": "user",
     "classifier.denial_limit": "user",
     "classifier.fallback": "operator",
-    "classifier.seat_rate_limited": "operator",
+    "classifier.seat_rate_limited": "user",
     "classifier.role_defaulted": "operator",
     "classifier.contract_broken": "operator",
     "classifier.unavailable": "user",
@@ -198,7 +204,8 @@ export const CORE_NOTICE_AUDIENCE = Object.freeze({
     "model.capability_downgraded": "user",
     "model.role_defaulted": "operator",
     "context.tool_turn_repaired": "operator",
-    "context.image_removed": "user",
+    "context.media_removed": "user",
+    "context.tool_schema_removed": "user",
     "task.user_steer_undrained": "user",
     "task.user_followup_undrained": "user",
     "steering.parked_input_blocked": "user",
@@ -216,6 +223,9 @@ export const CORE_NOTICE_AUDIENCE = Object.freeze({
     "tool_result.offload_put_failed": "operator",
     "tool_result.media_refused": "operator",
     "config.image_processor_unavailable": "operator",
+    "fs.staging_file_left": "operator",
+    "fs.staging_file_swept": "operator",
+    "session.lineage_rerooted": "user",
     "instructions.source_changed": "user",
     "session.records_skipped": "user",
     "memory.layer_locked_legacy": "operator",
@@ -248,6 +258,7 @@ export const CORE_NOTICE_MINTER = Object.freeze({
     "config.path_view_unresolved": "engine",
     "config.execution_env_capability_invalid": "engine",
     "config.read_deny_floor_unkept": "engine",
+    "config.read_floor_confinement_unavailable": "engine",
     "config.tool_card_undeclared": "engine",
     "config.tool_face_undeclared": "engine",
     "config.tool_face_invalid": "engine",
@@ -316,7 +327,8 @@ export const CORE_NOTICE_MINTER = Object.freeze({
     "model.capability_downgraded": "engine",
     "model.role_defaulted": "engine",
     "context.tool_turn_repaired": "engine",
-    "context.image_removed": "engine",
+    "context.media_removed": "engine",
+    "context.tool_schema_removed": "engine",
     "task.user_steer_undrained": "engine",
     "task.user_followup_undrained": "engine",
     "steering.parked_input_blocked": "engine",
@@ -334,6 +346,9 @@ export const CORE_NOTICE_MINTER = Object.freeze({
     "tool_result.offload_put_failed": "engine",
     "tool_result.media_refused": "engine",
     "config.image_processor_unavailable": "engine",
+    "fs.staging_file_left": "engine",
+    "fs.staging_file_swept": "engine",
+    "session.lineage_rerooted": "engine",
     "instructions.source_changed": "server",
     "session.records_skipped": "server",
     "memory.layer_locked_legacy": "server",

package/dist/generated/sdkFactTables.d.ts

@@ -5,3 +5,8 @@ export declare const SDK_ASK_ROW_ENDING_CAUSES: readonly ["routing_failure_fail_
 export declare const SDK_RUN_DEATH_VERDICT_CODES: readonly ["run.stalled", "run.orphaned", "approval.expired"];
 export declare const SDK_APPROVAL_DECIDE_GATE_KINDS: readonly ["human", "irreversible_ask"];
 export declare const SDK_PLAN_REVIEW_GATE_KINDS: readonly ["plan_review"];
+export declare const SDK_PERMISSION_MODE_ADMISSION_FOLDS: readonly ["entry_floor", "disable_auto_mode"];
+export declare const SDK_PERMISSION_MODE_PERSIST_MISSES: readonly ["claim_released", "context_absent", "store_failed"];
+export declare const SDK_DECIDE_BINDING_KEYS: readonly ["boundCallId", "boundInputHash"];
+export declare const SDK_APPROVAL_QUEUE_KINDS: readonly ["checkpoint", "peer_inbound"];
+export declare const SDK_SESSION_MEMORY_UNOBSERVED_REASONS: readonly ["no_settled_run", "run_result_missing", "run_result_unobserved", "memory_not_mounted", "no_leaf"];

package/dist/generated/sdkFactTables.js

@@ -39,3 +39,27 @@ export const SDK_APPROVAL_DECIDE_GATE_KINDS = Object.freeze([
 export const SDK_PLAN_REVIEW_GATE_KINDS = Object.freeze([
     "plan_review",
 ]);
+export const SDK_PERMISSION_MODE_ADMISSION_FOLDS = Object.freeze([
+    "entry_floor",
+    "disable_auto_mode",
+]);
+export const SDK_PERMISSION_MODE_PERSIST_MISSES = Object.freeze([
+    "claim_released",
+    "context_absent",
+    "store_failed",
+]);
+export const SDK_DECIDE_BINDING_KEYS = Object.freeze([
+    "boundCallId",
+    "boundInputHash",
+]);
+export const SDK_APPROVAL_QUEUE_KINDS = Object.freeze([
+    "checkpoint",
+    "peer_inbound",
+]);
+export const SDK_SESSION_MEMORY_UNOBSERVED_REASONS = Object.freeze([
+    "no_settled_run",
+    "run_result_missing",
+    "run_result_unobserved",
+    "memory_not_mounted",
+    "no_leaf",
+]);

package/dist/generated/settingsSchemaFns.d.ts

@@ -51,6 +51,17 @@ export declare const SETTINGS_IS_AT_LEAST: (layer: string, minTrust: string) =>
 export declare const SETTINGS_MEMBER_ADMISSION: (category: string, member: string) => object;
 export declare const SETTINGS_SAFETY_MERGE_SPEC: object;
 export declare const SETTINGS_LAYER_ADMISSION: (source: string, workspace: string, category: string, member?: string) => string;
+export declare const SETTINGS_BUILD_LAYER_PARTS_UNREAD_NOTICE: (input: {
+    readonly source: string;
+    readonly workspace: string;
+    readonly file: string;
+    readonly parts: readonly string[];
+}) => {
+    readonly code: string;
+    readonly source: string;
+    readonly parts: readonly string[];
+    readonly line: string;
+} | undefined;
 export declare const SETTINGS_RESOLVE_ACTIVE_TIERS: (models: {
     readonly tierGroups?: readonly {
         readonly name: string;

package/dist/generated/settingsSchemaFns.js

@@ -182,8 +182,9 @@ const SETTINGS_SAFETY_MERGE = SETTINGS_SAFETY_MERGE_CLOSURE(SETTINGS_MIN_TRUST_W
 export const SETTINGS_IS_AT_LEAST = SETTINGS_SAFETY_MERGE.isAtLeast;
 export const SETTINGS_MEMBER_ADMISSION = SETTINGS_SAFETY_MERGE.memberAdmission;
 export const SETTINGS_SAFETY_MERGE_SPEC = SETTINGS_SAFETY_MERGE.SAFETY_MERGE_SPEC;
-const SETTINGS_LAYER_SOURCES = SETTINGS_LAYER_SOURCES_CLOSURE(SETTINGS_SAFETY_MERGE_SPEC, SETTINGS_IS_AT_LEAST, SETTINGS_MEMBER_ADMISSION);
+const SETTINGS_LAYER_SOURCES = SETTINGS_LAYER_SOURCES_CLOSURE(SETTINGS_SAFETY_MERGE_SPEC, SETTINGS_IS_AT_LEAST, SETTINGS_MEMBER_ADMISSION, SETTINGS_ECHO_CALLER_TEXT, SETTINGS_STRIP_CONTROL_AND_BIDI);
 export const SETTINGS_LAYER_ADMISSION = SETTINGS_LAYER_SOURCES.layerAdmission;
+export const SETTINGS_BUILD_LAYER_PARTS_UNREAD_NOTICE = SETTINGS_LAYER_SOURCES.buildLayerPartsUnreadNotice;
 const SETTINGS_ACTIVE_TIERS = SETTINGS_ACTIVE_TIERS_CLOSURE();
 export const SETTINGS_RESOLVE_ACTIVE_TIERS = SETTINGS_ACTIVE_TIERS.resolveActiveTiers;
 const SETTINGS_TIER_WORDS = SETTINGS_TIER_WORDS_CLOSURE();

package/dist/generated/settingsSchemaSafetyMergeSpec.js

@@ -53,7 +53,7 @@ export const SETTINGS_SAFETY_MERGE_CLOSURE = (MIN_TRUST_WORDS) => {
         model: { mergeShape: "replace", minTrust: "session", tighten: { rule: "none" }, enforcement: "client", fail: "open", seam: "RoleSpec / TaskSpec.{model,thinking}" },
         env: { mergeShape: "concat", minTrust: "project", tighten: { rule: "none" }, enforcement: "resolver", fail: "open", seam: "NodeExecutionEnv.shellEnv (later layer overrides same name)" },
         envSecret: { mergeShape: "replace", minTrust: "global", tighten: { rule: "none" }, enforcement: "resolver", fail: "closed", seam: "§7 secret-ref resolution" },
-        memoryScopes: { mergeShape: "concat", minTrust: "global", tighten: { rule: "none" }, enforcement: "client", fail: "open", seam: "MemoryStore" },
+        memoryScopes: { mergeShape: "concat", minTrust: "global", tighten: { rule: "none" }, enforcement: "client", fail: "open", seam: "MemoryEngine" },
         autoCompaction: { mergeShape: "replace", minTrust: "session", tighten: { rule: "none" }, enforcement: "client", fail: "open", seam: "compaction config" },
         ui: { mergeShape: "replace", minTrust: "local", tighten: { rule: "none" }, enforcement: "client", fail: "open", seam: "shell-only (theme/keybindings/statusLine) — never touches the engine" },
         org: { mergeShape: "replace", minTrust: "managed", tighten: { rule: "none" }, enforcement: "server", fail: "closed", seam: "web-admin → governanceBaseline (SSO/SCIM/audit/budget, TOB-only)" },

package/dist/generated/settingsSchemaSettingsSources.d.ts

@@ -1 +1 @@
-export declare const SETTINGS_LAYER_SOURCES_CLOSURE: (SAFETY_MERGE_SPEC: object, isAtLeast: (layer: string, minTrust: string) => boolean, memberAdmission: (category: string, member: string) => object) => any;
+export declare const SETTINGS_LAYER_SOURCES_CLOSURE: (SAFETY_MERGE_SPEC: object, isAtLeast: (layer: string, minTrust: string) => boolean, memberAdmission: (category: string, member: string) => object, echoCallerText: (text: string) => string, stripControlAndBidi: (text: string) => string) => any;

package/dist/generated/settingsSchemaSettingsSources.js

@@ -1,4 +1,4 @@
-export const SETTINGS_LAYER_SOURCES_CLOSURE = (SAFETY_MERGE_SPEC, isAtLeast, memberAdmission) => {
+export const SETTINGS_LAYER_SOURCES_CLOSURE = (SAFETY_MERGE_SPEC, isAtLeast, memberAdmission, echoCallerText, stripControlAndBidi) => {
     const SETTINGS_SOURCES = ["userSettings", "projectSettings", "localSettings", "flagSettings", "policySettings", "foreignProjectSettings"];
     const SETTINGS_SOURCE_CONTRACT = {
         userSettings: { trust: "global", repoControllable: false },
@@ -41,6 +41,26 @@ export const SETTINGS_LAYER_SOURCES_CLOSURE = (SAFETY_MERGE_SPEC, isAtLeast, mem
         const accepted = workspaceAccepted(workspace);
         return layer.tightenOnly === true || (layer.repoControllable && !accepted);
     }
+    const LAYER_PARTS_UNREAD_CODE = "settings.layer_parts_unread";
+    const NOTICE_PARTS_SHOWN = 16;
+    function buildLayerPartsUnreadNotice(input) {
+        const layer = settingsSourceContract(input.source);
+        if (!readsTightenOnly(layer, input.workspace)) {
+            throw new RangeError(`buildLayerPartsUnreadNotice: source '${input.source}' is not read in the tighten direction only under workspace reading '${input.workspace}' — there is nothing "read for restrictions only" to disclose`);
+        }
+        if (input.parts.length === 0)
+            return undefined;
+        const cause = layer.tightenOnly === true ? "it is written for another tool" : "this workspace is not trusted";
+        const shown = input.parts.slice(0, NOTICE_PARTS_SHOWN).map(echoCallerText);
+        const rest = input.parts.length - shown.length;
+        const named = rest > 0 ? `${shown.join(", ")}, +${rest} more` : shown.join(", ");
+        return {
+            code: LAYER_PARTS_UNREAD_CODE,
+            source: input.source,
+            parts: [...input.parts],
+            line: `${stripControlAndBidi(input.file)}: read for restrictions only (${cause}) — not read: ${named}`,
+        };
+    }
     function workspaceAccepted(workspace) {
         switch (workspace) {
             case "accepted":
@@ -54,5 +74,5 @@ export const SETTINGS_LAYER_SOURCES_CLOSURE = (SAFETY_MERGE_SPEC, isAtLeast, mem
             }
         }
     }
-    return { layerAdmission };
+    return { layerAdmission, buildLayerPartsUnreadNotice };
 };

package/dist/headlessReconnectWire.js

@@ -3,7 +3,17 @@ import { hostEnv } from './hostEnv.js';
 import { isSdkRunFrameSynthesizable } from './terminalStatuses.js';
 import { createStreamDrainingLegs } from './streamDrainingLegs.js';
 import { abortableSleep } from './abortableSleep.js';
+import { mintRunNotFollowed, registerRunNotFollowed } from './runFollow.js';
+import { classifyTurnWireError } from './wireErrorTriage.js';
 export const HEADLESS_RECONNECT_MAX = 2;
+function guardedTransport(e) {
+    try {
+        return classifyTurnWireError(e).kind === 'transport';
+    }
+    catch {
+        return false;
+    }
+}
 function debugLog(msg) {
     if (hostEnv().SEMA_DEBUG) {
         console.error(`[sema] headless reconnect: ${msg}`);
@@ -46,6 +56,12 @@ export async function* withHeadlessR1Reconnect(live, deps) {
     let isRecoverableTear;
     const drains = createStreamDrainingLegs();
     let drainReopenAfterMs;
+    let lastBreak;
+    const giveUp = (fact) => {
+        if (typeof originalTearErr === 'object' && originalTearErr !== null)
+            registerRunNotFollowed(originalTearErr, fact);
+        throw originalTearErr;
+    };
     const terminalFromRunRow = async (taskId) => {
         const row = await deps.getRun(taskId).catch(() => null);
         const terminal = terminalEventFromRunRow(row);
@@ -60,9 +76,18 @@ export async function* withHeadlessR1Reconnect(live, deps) {
             isRecoverableTear = isSseIdleError(originalTearErr);
         if (!isRecoverableTear)
             throw originalTearErr;
-        const taskId = deps.getTaskId();
-        if (!taskId)
-            throw originalTearErr;
+        let handle;
+        try {
+            handle = deps.getTaskId();
+        }
+        catch {
+            return giveUp(mintRunNotFollowed('bad_input'));
+        }
+        if (handle === null || handle === undefined)
+            return giveUp(mintRunNotFollowed('no_run_id'));
+        if (typeof handle !== 'string' || handle === '')
+            return giveUp(mintRunNotFollowed('bad_input'));
+        const taskId = handle;
         if (drainReopenAfterMs !== undefined) {
             const waitMs = drainReopenAfterMs;
             drainReopenAfterMs = undefined;
@@ -74,7 +99,7 @@ export async function* withHeadlessR1Reconnect(live, deps) {
         else {
             if (attempts >= HEADLESS_RECONNECT_MAX) {
                 debugLog(`budget exhausted (${attempts}/${HEADLESS_RECONNECT_MAX}) — falling to the honest death path`);
-                throw originalTearErr;
+                return giveUp(mintRunNotFollowed('reattach_exhausted', taskId, lastBreak));
             }
             attempts++;
             if (!(await probe(deps.baseUrl)))
@@ -111,6 +136,7 @@ export async function* withHeadlessR1Reconnect(live, deps) {
             if (deps.signal?.aborted)
                 return;
             const drained = drains.legEnded('returned');
+            lastBreak = drained !== undefined ? 'stream_draining' : undefined;
             if (drained !== undefined) {
                 if ('reconnectAfterMs' in drained) {
                     drainReopenAfterMs = drained.reconnectAfterMs;
@@ -128,6 +154,7 @@ export async function* withHeadlessR1Reconnect(live, deps) {
         }
         catch (contErr) {
             drains.legEnded('threw');
+            lastBreak = guardedTransport(contErr) ? 'connection_lost' : undefined;
             debugLog(`runs.events continuation failed: ${contErr instanceof Error ? contErr.message : String(contErr)}`);
             if (deps.signal?.aborted)
                 throw originalTearErr;

package/dist/hitl/approvalLiveFace.d.ts

@@ -0,0 +1,17 @@
+import type { ApprovalMandateWord } from '../gateVocabulary.js';
+export declare const APPROVAL_LIVE_FACE_KEYS: readonly ["mandate", "mandated", "origin"];
+export declare function hasOwnStrictTrue(v: object, key: string): boolean;
+export interface ApprovalLiveFaceFacts {
+    mandated?: true;
+    mandate?: ApprovalMandateWord;
+    origin?: string;
+}
+export interface ApprovalLiveFace {
+    readonly facts: Readonly<ApprovalLiveFaceFacts>;
+    readonly layerUnknown?: 'marked' | 'absent';
+}
+export declare function approvalLiveFaceOf(live: object): ApprovalLiveFace;
+export type ApprovalLiveFaceCarried = ApprovalLiveFaceFacts & {
+    readonly liveFactsUnknown?: true;
+};
+export declare function liveFaceCarried(face: ApprovalLiveFace): ApprovalLiveFaceCarried;

package/dist/hitl/approvalLiveFace.js

@@ -0,0 +1,35 @@
+import { readAskOrigin } from '../ownKey.js';
+import { slotPresenceOf, slotReadOf } from '../wireFailureShape.js';
+import { readApprovalMandate } from './toolApprovalWire.js';
+export const APPROVAL_LIVE_FACE_KEYS = Object.freeze(['mandate', 'mandated', 'origin']);
+export function hasOwnStrictTrue(v, key) {
+    return Object.hasOwn(v, key) && v[key] === true;
+}
+const APPROVAL_LIVE_FACTS_UNKNOWN_KEY = 'liveFactsUnknown';
+function guarded(read) {
+    try {
+        return read();
+    }
+    catch {
+        return undefined;
+    }
+}
+export function approvalLiveFaceOf(live) {
+    const marker = slotReadOf(live, APPROVAL_LIVE_FACTS_UNKNOWN_KEY);
+    const marked = marker.presence === 'unreadable' || (marker.presence === 'present' && marker.value === true);
+    const layerAbsent = !marked && APPROVAL_LIVE_FACE_KEYS.every((k) => slotPresenceOf(live, k) === 'absent');
+    const facts = {};
+    if (guarded(() => hasOwnStrictTrue(live, 'mandated')) === true)
+        facts.mandated = true;
+    const mandate = guarded(() => readApprovalMandate(live));
+    if (mandate !== undefined)
+        facts.mandate = mandate;
+    const origin = guarded(() => readAskOrigin(live));
+    if (origin !== undefined)
+        facts.origin = origin;
+    const layerUnknown = marked ? 'marked' : layerAbsent ? 'absent' : undefined;
+    return Object.freeze({ facts: Object.freeze(facts), ...(layerUnknown !== undefined ? { layerUnknown } : {}) });
+}
+export function liveFaceCarried(face) {
+    return face.layerUnknown === 'marked' ? { ...face.facts, [APPROVAL_LIVE_FACTS_UNKNOWN_KEY]: true } : { ...face.facts };
+}

package/dist/hitl/approvalQueueRow.d.ts

@@ -0,0 +1,21 @@
+import { SDK_APPROVAL_QUEUE_KINDS } from '../generated/sdkFactTables.js';
+export type ApprovalQueueKind = (typeof SDK_APPROVAL_QUEUE_KINDS)[number];
+export type ApprovalQueueRowFamily = ApprovalQueueKind | 'unknown' | 'unreadable';
+export declare function approvalQueueRowFamilyOf(row: object): ApprovalQueueRowFamily;
+export type CheckpointQueueRowSort = 'checkpoint' | 'excluded' | 'unreadable';
+export declare function checkpointQueueRowSortOf(row: object | null | undefined): CheckpointQueueRowSort;
+export declare const QUEUE_ROW_FAMILY_UNREADABLE_GATE = "(unreadable)";
+export interface ApprovalQueuePeerInboundRow {
+    readonly id: string;
+    readonly recipientSessionId: string;
+    readonly lane?: string;
+    readonly cause?: string;
+    readonly content?: string;
+    readonly sentAt?: number;
+    readonly heldAt?: number;
+    readonly deadline?: number;
+    readonly fromSession?: string;
+    readonly fromName?: string;
+    readonly fromScope?: string;
+}
+export declare function peerInboundQueueRowOf(row: object): ApprovalQueuePeerInboundRow | undefined;