@dudousxd/nestjs-agent-core 0.39.0 → 0.40.0

package/dist/index.cjs

@@ -53,6 +53,8 @@ __export(src_exports, {
   APPROVAL_EXPIRED_REASON: () => APPROVAL_EXPIRED_REASON,
   ASK_TOOL_DESCRIPTION: () => ASK_TOOL_DESCRIPTION,
   ASK_TOOL_NAME: () => ASK_TOOL_NAME,
+  ActionProposalExecutor: () => ActionProposalExecutor,
+  ActionProposalWorker: () => ActionProposalWorker,
   AgentRegistry: () => AgentRegistry,
   AgentStreamError: () => AgentStreamError,
   CONFIRM_JSON_SCHEMA_PROPERTIES: () => CONFIRM_JSON_SCHEMA_PROPERTIES,
@@ -73,6 +75,7 @@ __export(src_exports, {
   DefaultRolesPolicy: () => DefaultRolesPolicy,
   ELICITATION_INPUT_TYPES: () => ELICITATION_INPUT_TYPES,
   GLOBAL_SCOPE: () => GLOBAL_SCOPE,
+  InMemoryActionProposalStore: () => InMemoryActionProposalStore,
   InMemoryAgentStore: () => InMemoryAgentStore,
   InMemoryConfirmTokenStore: () => InMemoryConfirmTokenStore,
   MAX_ASK_QUESTIONS: () => MAX_ASK_QUESTIONS,
@@ -96,15 +99,25 @@ __export(src_exports, {
   THREAD_DETAIL_CONTENT_CHARS: () => THREAD_DETAIL_CONTENT_CHARS,
   ToolDisabledError: () => ToolDisabledError,
   ToolForbiddenError: () => ToolForbiddenError,
+  ToolInputDriftError: () => ToolInputDriftError,
   ToolInputInvalidError: () => ToolInputInvalidError,
   ToolNotFoundError: () => ToolNotFoundError,
+  ToolPreflightDeniedError: () => ToolPreflightDeniedError,
   ToolRegistry: () => ToolRegistry,
   UNFINISHED_TOOL_CALL: () => UNFINISHED_TOOL_CALL,
+  actionProposalCreationMatches: () => actionProposalCreationMatches,
+  actionProposalOutcomeFenceValid: () => actionProposalOutcomeFenceValid,
+  actionProposalOutcomeScope: () => actionProposalOutcomeScope,
+  actionProposalOutcomeText: () => actionProposalOutcomeText,
+  actionProposalReceipt: () => actionProposalReceipt,
+  actionProposalScopeMatches: () => actionProposalScopeMatches,
   actorScope: () => actorScope,
   agentDiagnosticKey: () => agentDiagnosticKey,
   agentFailureCode: () => agentFailureCode,
   askInputSchema: () => askInputSchema,
   askToolDefinition: () => askToolDefinition,
+  assertIndependentActionCapabilities: () => assertIndependentActionCapabilities,
+  attachActionProposalOutcome: () => attachActionProposalOutcome,
   bucketByActor: () => bucketByActor,
   bucketByModel: () => bucketByModel,
   bucketByThread: () => bucketByThread,
@@ -112,12 +125,15 @@ __export(src_exports, {
   buildMemoryBlock: () => buildMemoryBlock,
   buildSkillsBlock: () => buildSkillsBlock,
   canActorUseTool: () => canActorUseTool,
+  canonicalActionProposalJson: () => canonicalActionProposalJson,
   canonicalJson: () => canonicalJson,
+  claimActionProposalOutcome: () => claimActionProposalOutcome,
   closeEmptyRoles: () => closeEmptyRoles,
   compositeSkillProvider: () => compositeSkillProvider,
   confirmTokenExpiry: () => confirmTokenExpiry,
   createFrameBuffer: () => createFrameBuffer,
   createIncrementalGate: () => createIncrementalGate,
+  createNegotiatedUiCollector: () => createNegotiatedUiCollector,
   createNoopEmitUi: () => createNoopEmitUi,
   createUiCollector: () => createUiCollector,
   danglingToolCallIds: () => danglingToolCallIds,
@@ -130,6 +146,7 @@ __export(src_exports, {
   detachedStarted: () => detachedStarted,
   detachedUnsettled: () => detachedUnsettled,
   encodeStreamEvent: () => encodeStreamEvent,
+  escapeUnsafeToolUiText: () => escapeUnsafeToolUiText,
   estimateCost: () => estimateCost,
   estimateMessageTokens: () => estimateMessageTokens,
   exhaustedWindow: () => exhaustedWindow,
@@ -144,6 +161,7 @@ __export(src_exports, {
   gateFollowUps: () => gateFollowUps,
   gateTail: () => gateTail,
   hashConfirmToken: () => hashConfirmToken,
+  initialActionProposal: () => initialActionProposal,
   intersectAllowLists: () => intersectAllowLists,
   invokeWithTransientRetry: () => invokeWithTransientRetry,
   isChatQueueStore: () => isChatQueueStore,
@@ -162,7 +180,9 @@ __export(src_exports, {
   observeTurnFrames: () => observeTurnFrames,
   offerMemories: () => offerMemories,
   offerSkills: () => offerSkills,
+  parseTextActionProposalCommand: () => parseTextActionProposalCommand,
   personaCatalogEntry: () => personaCatalogEntry,
+  prepareActionProposal: () => prepareActionProposal,
   publishAgentDelegated: () => publishAgentDelegated,
   publishAgentMemoryResolved: () => publishAgentMemoryResolved,
   publishAgentMemoryWritten: () => publishAgentMemoryWritten,
@@ -188,12 +208,14 @@ __export(src_exports, {
   rememberToolDefinition: () => rememberToolDefinition,
   renderElicitationAnswers: () => renderElicitationAnswers,
   repairInstruction: () => repairInstruction,
+  resolveActionProposalApproval: () => resolveActionProposalApproval,
   resolveElicitation: () => resolveElicitation,
   resolveGateLookback: () => resolveGateLookback,
   resolveMemoryDigest: () => resolveMemoryDigest,
   resolveOutputGateMode: () => resolveOutputGateMode,
   resolvePersonaAlias: () => resolvePersonaAlias,
   resolveSkillCatalog: () => resolveSkillCatalog,
+  resolveTextActionProposalDecision: () => resolveTextActionProposalDecision,
   resolveToolTransientRetryNumbers: () => resolveToolTransientRetryNumbers,
   rollupThreadUsage: () => rollupThreadUsage,
   runAgentLoop: () => runAgentLoop,
@@ -210,6 +232,7 @@ __export(src_exports, {
   skillInputSchema: () => skillInputSchema,
   skillToolDefinition: () => skillToolDefinition,
   skillWriteVerdict: () => skillWriteVerdict,
+  snapshotActionProposal: () => snapshotActionProposal,
   stampToolKinds: () => stampToolKinds,
   staticModelCatalog: () => staticModelCatalog,
   staticSkillProvider: () => staticSkillProvider,
@@ -220,8 +243,18 @@ __export(src_exports, {
   toolCallContext: () => toolCallContext,
   traceLlmTurn: () => traceLlmTurn,
   traceToolExecution: () => traceToolExecution,
+  transitionActionProposalClaim: () => transitionActionProposalClaim,
+  transitionActionProposalDecision: () => transitionActionProposalDecision,
+  transitionActionProposalLease: () => transitionActionProposalLease,
+  transitionActionProposalSettlement: () => transitionActionProposalSettlement,
+  transitionActionProposalSupersession: () => transitionActionProposalSupersession,
   truncateDetailContent: () => truncateDetailContent,
   unwrapToolStepOutput: () => unwrapToolStepOutput,
+  validateActionProposalCreation: () => validateActionProposalCreation,
+  validateActionProposalDiscoveryIndexBatch: () => validateActionProposalDiscoveryIndexBatch,
+  validateActionProposalExpiryBatch: () => validateActionProposalExpiryBatch,
+  validateActionProposalListQuery: () => validateActionProposalListQuery,
+  validateActionProposalWorkerClaim: () => validateActionProposalWorkerClaim,
   validateElicitationAnswer: () => validateElicitationAnswer,
   validateElicitationValue: () => validateElicitationValue,
   validateStructured: () => validateStructured,
@@ -234,6 +267,7 @@ __export(src_exports, {
   withSkillTool: () => withSkillTool,
   withToolTimeout: () => withToolTimeout,
   withTurnFrames: () => withTurnFrames,
+  wrapToolPreflightDenied: () => wrapToolPreflightDenied,
   wrapToolStepOutput: () => wrapToolStepOutput,
   writeMemory: () => writeMemory
 });
@@ -407,16 +441,16 @@ function observeTurnFrames(writer, now = Date.now) {
   };
 }
 __name(observeTurnFrames, "observeTurnFrames");
-function withTurnFrames(result, frames) {
+function withTurnFrames(result2, frames) {
   return {
-    ...result,
-    ...result.reasoning === void 0 && frames.reasoning !== void 0 ? {
+    ...result2,
+    ...result2.reasoning === void 0 && frames.reasoning !== void 0 ? {
       reasoning: frames.reasoning
     } : {},
-    ...result.reasoningMs === void 0 && frames.reasoningMs !== void 0 ? {
+    ...result2.reasoningMs === void 0 && frames.reasoningMs !== void 0 ? {
       reasoningMs: frames.reasoningMs
     } : {},
-    ...result.ui === void 0 && frames.ui !== void 0 ? {
+    ...result2.ui === void 0 && frames.ui !== void 0 ? {
       ui: frames.ui
     } : {}
   };
@@ -425,8 +459,9 @@ __name(withTurnFrames, "withTurnFrames");
 
 // src/tool-ui.ts
 var TOOL_STEP_UI = "@@nestjs-agent/tool-step-ui";
-function wrapToolStepOutput(output, ui) {
-  if (ui.length === 0) {
+function wrapToolStepOutput(output, ui, text) {
+  const reserved = typeof output === "object" && output !== null && TOOL_STEP_UI in output;
+  if (ui.length === 0 && !reserved && !text) {
     return output;
   }
   const wrapped = {
@@ -434,17 +469,36 @@ function wrapToolStepOutput(output, ui) {
     output,
     ui: [
       ...ui
-    ]
+    ],
+    ...text ? {
+      text
+    } : {}
   };
   return wrapped;
 }
 __name(wrapToolStepOutput, "wrapToolStepOutput");
+function wrapToolPreflightDenied(reason) {
+  const wrapped = {
+    [TOOL_STEP_UI]: 1,
+    output: null,
+    ui: [],
+    preflightDenied: reason
+  };
+  return wrapped;
+}
+__name(wrapToolPreflightDenied, "wrapToolPreflightDenied");
 function unwrapToolStepOutput(raw) {
   if (typeof raw === "object" && raw !== null && raw[TOOL_STEP_UI] === 1) {
     const wrapped = raw;
     return {
       output: wrapped.output,
-      ui: Array.isArray(wrapped.ui) ? wrapped.ui : []
+      ui: Array.isArray(wrapped.ui) ? wrapped.ui : [],
+      ...typeof wrapped.text === "string" ? {
+        text: wrapped.text
+      } : {},
+      ...typeof wrapped.preflightDenied === "string" ? {
+        preflightDenied: wrapped.preflightDenied
+      } : {}
     };
   }
   return {
@@ -493,6 +547,14 @@ function createUiCollector(toolCallId, write) {
       ...options.version !== void 0 ? {
         version: options.version
       } : {},
+      ...options.fallbackText !== void 0 ? {
+        fallbackText: options.fallbackText
+      } : {},
+      ...options.componentVersions !== void 0 ? {
+        componentVersions: {
+          ...options.componentVersions
+        }
+      } : {},
       toolCallId
     };
     pushed.set(id, entry);
@@ -527,6 +589,10 @@ function mergeUi(...lists) {
   ];
 }
 __name(mergeUi, "mergeUi");
+function escapeUnsafeToolUiText(text) {
+  return text.replaceAll("\0", "\\u0000").replace(/[\uD800-\uDFFF]/gu, (unit) => `\\u${unit.charCodeAt(0).toString(16).padStart(4, "0")}`);
+}
+__name(escapeUnsafeToolUiText, "escapeUnsafeToolUiText");
 
 // src/tool-presentation.ts
 var ALL_AGENTS = "*";
@@ -738,12 +804,18 @@ function toolCallApprovalFromRow(row) {
   if (row.approver === null || row.approver === void 0) {
     return null;
   }
-  const status = row.status === "pending_approval" ? "pending" : row.status === "rejected" ? "rejected" : row.status === "expired" ? "expired" : "approved";
+  const status = row.status === "pending_approval" || row.status === "proposed" ? "pending" : row.status === "rejected" ? "rejected" : row.status === "expired" ? "expired" : "approved";
   const expiresAt = row.expiresAt instanceof Date ? row.expiresAt.toISOString() : typeof row.expiresAt === "string" ? row.expiresAt : void 0;
   const decided = status === "approved" || status === "rejected";
   return {
     toolCallId: row.toolCallId,
+    ...row.proposalId != null ? {
+      proposalId: row.proposalId
+    } : {},
     approver: row.approver,
+    ...row.confirmation != null ? {
+      confirmation: row.confirmation
+    } : {},
     status,
     ...expiresAt !== void 0 ? {
       expiresAt
@@ -794,9 +866,9 @@ function bucketByModel(rows, prices) {
     bucket.costUsd += rowCost(row, prices);
     byModel.set(row.modelId, bucket);
   }
-  const result = [];
+  const result2 = [];
   for (const [modelId, bucket] of byModel) {
-    result.push({
+    result2.push({
       modelId,
       requests: bucket.requests,
       inputTokens: bucket.inputTokens,
@@ -804,8 +876,8 @@ function bucketByModel(rows, prices) {
       costUsd: bucket.costUsd
     });
   }
-  result.sort((left, right) => right.costUsd - left.costUsd || left.modelId.localeCompare(right.modelId));
-  return result;
+  result2.sort((left, right) => right.costUsd - left.costUsd || left.modelId.localeCompare(right.modelId));
+  return result2;
 }
 __name(bucketByModel, "bucketByModel");
 function bucketByActor(rows, prices) {
@@ -823,9 +895,9 @@ function bucketByActor(rows, prices) {
     bucket.threadIds.add(row.threadId);
     byActor.set(row.actorRef, bucket);
   }
-  const result = [];
+  const result2 = [];
   for (const [actorRef, bucket] of byActor) {
-    result.push({
+    result2.push({
       actorRef,
       requests: bucket.requests,
       totalTokens: bucket.totalTokens,
@@ -833,8 +905,8 @@ function bucketByActor(rows, prices) {
       threadCount: bucket.threadIds.size
     });
   }
-  result.sort((left, right) => right.costUsd - left.costUsd || left.actorRef.localeCompare(right.actorRef));
-  return result;
+  result2.sort((left, right) => right.costUsd - left.costUsd || left.actorRef.localeCompare(right.actorRef));
+  return result2;
 }
 __name(bucketByActor, "bucketByActor");
 function bucketByThread(rows, prices, threads, options) {
@@ -850,13 +922,13 @@ function bucketByThread(rows, prices, threads, options) {
     bucket.costUsd += rowCost(row, prices);
     byThread.set(row.threadId, bucket);
   }
-  const result = [];
+  const result2 = [];
   for (const [threadId, bucket] of byThread) {
     const thread = threads.get(threadId);
     if (thread === void 0 && !options.includeUnknownThreads) {
       continue;
     }
-    result.push({
+    result2.push({
       threadId,
       title: thread?.title ?? "",
       actorRef: thread?.actorRef ?? "",
@@ -865,8 +937,8 @@ function bucketByThread(rows, prices, threads, options) {
       costUsd: bucket.costUsd
     });
   }
-  result.sort((left, right) => right.costUsd - left.costUsd || left.threadId.localeCompare(right.threadId));
-  return result.slice(0, options.limit);
+  result2.sort((left, right) => right.costUsd - left.costUsd || left.threadId.localeCompare(right.threadId));
+  return result2.slice(0, options.limit);
 }
 __name(bucketByThread, "bucketByThread");
 function rollupThreadUsage(rows, prices) {
@@ -898,16 +970,16 @@ function bucketUsageTrend(rows, prices) {
     bucket.costUsd += rowCost(row, prices);
     byDay.set(row.day, bucket);
   }
-  const result = [];
+  const result2 = [];
   for (const [day, bucket] of byDay) {
-    result.push({
+    result2.push({
       day,
       totalTokens: bucket.totalTokens,
       costUsd: bucket.costUsd
     });
   }
-  result.sort((left, right) => left.day.localeCompare(right.day));
-  return result;
+  result2.sort((left, right) => left.day.localeCompare(right.day));
+  return result2;
 }
 __name(bucketUsageTrend, "bucketUsageTrend");
 function dayBoundsUtc(range) {
@@ -1351,13 +1423,13 @@ async function validateStructured(schema, text, reported) {
       issues: []
     };
   }
-  const result = await schema["~standard"].validate(candidate);
-  return result.issues !== void 0 ? {
+  const result2 = await schema["~standard"].validate(candidate);
+  return result2.issues !== void 0 ? {
     ok: false,
-    issues: result.issues
+    issues: result2.issues
   } : {
     ok: true,
-    value: result.value
+    value: result2.value
   };
 }
 __name(validateStructured, "validateStructured");
@@ -2536,12 +2608,12 @@ function memoryWriteVerdict(request) {
   };
 }
 __name(memoryWriteVerdict, "memoryWriteVerdict");
-function memoryForgetVerdict({ record, actor }) {
-  return record.scope === actorScope(actor) ? {
+function memoryForgetVerdict({ record: record2, actor }) {
+  return record2.scope === actorScope(actor) ? {
     allowed: true
   } : {
     allowed: false,
-    reason: `"${record.scope}" is not this actor's own scope; deleting it is an administrative action`
+    reason: `"${record2.scope}" is not this actor's own scope; deleting it is an administrative action`
   };
 }
 __name(memoryForgetVerdict, "memoryForgetVerdict");
@@ -2584,7 +2656,7 @@ async function writeMemory({ config, digest, call, ctx, runId }) {
       error: verdict.reason
     };
   }
-  const record = await write({
+  const record2 = await write({
     key,
     text,
     scope,
@@ -2598,7 +2670,7 @@ async function writeMemory({ config, digest, call, ctx, runId }) {
   });
   return {
     ok: true,
-    record
+    record: record2
   };
 }
 __name(writeMemory, "writeMemory");
@@ -2650,7 +2722,7 @@ function danglingToolCallIds(messages) {
     if (message.role !== "assistant" || calls.length === 0) {
       continue;
     }
-    const settled = new Set((message.toolResults ?? []).map((result) => result.id));
+    const settled = new Set((message.toolResults ?? []).map((result2) => result2.id));
     for (const call of calls) {
       if (!settled.has(call.id)) {
         ids.push(call.id);
@@ -2718,7 +2790,7 @@ function settleDanglingToolCalls(messages, outcomes = []) {
       return message;
     }
     const results = message.toolResults ?? [];
-    const settled = new Set(results.map((result) => result.id));
+    const settled = new Set(results.map((result2) => result2.id));
     const missing = calls.filter((call) => !settled.has(call.id));
     if (missing.length === 0) {
       return message;
@@ -2826,6 +2898,1111 @@ async function settleUnsettledDelegation(args) {
 }
 __name(settleUnsettledDelegation, "settleUnsettledDelegation");
 
+// src/action-proposal-discovery.ts
+function validateActionProposalWorkerClaim(command, now) {
+  if (!Number.isSafeInteger(now)) throw new RangeError("Invalid action proposal clock");
+  if (typeof command.workerId !== "string" || command.workerId.length === 0) throw new TypeError("workerId must be a nonempty string");
+  if (!Number.isSafeInteger(command.leaseMs) || command.leaseMs <= 0 || !Number.isSafeInteger(now + command.leaseMs)) throw new RangeError("leaseMs must be positive safe integer milliseconds");
+}
+__name(validateActionProposalWorkerClaim, "validateActionProposalWorkerClaim");
+function validateActionProposalExpiryBatch(command, now) {
+  if (!Number.isSafeInteger(now)) throw new RangeError("Invalid action proposal clock");
+  validateActionProposalDiscoveryIndexBatch(command);
+}
+__name(validateActionProposalExpiryBatch, "validateActionProposalExpiryBatch");
+function validateActionProposalDiscoveryIndexBatch(command) {
+  if (!Number.isInteger(command.limit) || command.limit < 1 || command.limit > 1e3) throw new RangeError("limit must be an integer from 1 to 1000");
+}
+__name(validateActionProposalDiscoveryIndexBatch, "validateActionProposalDiscoveryIndexBatch");
+
+// src/action-proposal-outcome.ts
+function attachActionProposalOutcome(row, now, ui = [], text) {
+  if (row.outcome) return row;
+  const execution = row.execution;
+  const outcome = {
+    id: `${row.id}:outcome:1`,
+    proposalId: row.id,
+    outcomeVersion: 1,
+    tenantRef: row.tenantRef,
+    actorRef: row.actorRef,
+    threadId: row.threadId,
+    originRunId: row.originRunId,
+    originToolCallId: row.originToolCallId,
+    toolName: row.toolName,
+    decision: row.decision,
+    ui,
+    createdAt: now,
+    ...text !== void 0 ? {
+      text
+    } : {},
+    ...execution?.status === "succeeded" || execution?.status === "failed" ? {
+      executionStatus: execution.status
+    } : {},
+    ...execution && Object.hasOwn(execution, "result") ? {
+      result: execution.result
+    } : {},
+    ...execution?.error !== void 0 ? {
+      error: execution.error
+    } : row.decisionAudit?.reason !== void 0 ? {
+      error: row.decisionAudit.reason
+    } : {}
+  };
+  return snapshotActionProposal({
+    ...row,
+    outcome,
+    outcomeDelivery: {
+      status: "pending",
+      generation: 0,
+      lease: null
+    }
+  });
+}
+__name(attachActionProposalOutcome, "attachActionProposalOutcome");
+function claimActionProposalOutcome(row, command, now, token) {
+  validateActionProposalWorkerClaim(command, now);
+  const delivery = row.outcomeDelivery;
+  if (!row.outcome || !delivery || delivery.status !== "pending" || delivery.lease && now < delivery.lease.expiresAt) return null;
+  const generation = delivery.generation + 1;
+  return snapshotActionProposal({
+    ...row,
+    outcomeDelivery: {
+      ...delivery,
+      generation,
+      lease: {
+        token,
+        generation,
+        workerId: command.workerId,
+        expiresAt: now + command.leaseMs
+      }
+    }
+  });
+}
+__name(claimActionProposalOutcome, "claimActionProposalOutcome");
+function actionProposalOutcomeFenceValid(row, command, now) {
+  if (!Number.isSafeInteger(now)) throw new RangeError("Invalid server clock");
+  if (typeof command.token !== "string" || !command.token || !Number.isSafeInteger(command.generation) || command.generation < 1 || typeof command.outcomeId !== "string" || !command.outcomeId) throw new TypeError("Invalid outcome fence");
+  const delivery = row.outcomeDelivery;
+  return row.outcome?.id === command.outcomeId && delivery?.status === "pending" && delivery.generation === command.generation && delivery.lease?.token === command.token && delivery.lease.generation === command.generation && now < delivery.lease.expiresAt;
+}
+__name(actionProposalOutcomeFenceValid, "actionProposalOutcomeFenceValid");
+function outcomeSummary(outcome) {
+  if (outcome.executionStatus === "succeeded") return `Action ${JSON.stringify(outcome.toolName)} completed (proposal ${JSON.stringify(outcome.proposalId)}).${Object.hasOwn(outcome, "result") ? ` Result: ${JSON.stringify(outcome.result)}` : ""}`;
+  if (outcome.executionStatus === "failed") return `Action ${JSON.stringify(outcome.toolName)} failed (proposal ${JSON.stringify(outcome.proposalId)}): ${JSON.stringify(outcome.error ?? "Execution failed")}`;
+  return `Action ${JSON.stringify(outcome.toolName)} was ${outcome.decision} (proposal ${JSON.stringify(outcome.proposalId)}) and was not executed.${outcome.error ? ` Reason: ${JSON.stringify(outcome.error)}` : ""}`;
+}
+__name(outcomeSummary, "outcomeSummary");
+function actionProposalOutcomeScope(outcome) {
+  return {
+    tenantRef: outcome.tenantRef,
+    actorRef: outcome.actorRef,
+    threadId: outcome.threadId
+  };
+}
+__name(actionProposalOutcomeScope, "actionProposalOutcomeScope");
+function actionProposalOutcomeText(outcome) {
+  return outcomeSummary(outcome) + (outcome.text ? ` UI: ${JSON.stringify(outcome.text)}` : "");
+}
+__name(actionProposalOutcomeText, "actionProposalOutcomeText");
+
+// src/genui/schema.ts
+function isStandardSchema(schema) {
+  return typeof schema === "object" && schema !== null && "~standard" in schema && typeof schema["~standard"]?.validate === "function";
+}
+__name(isStandardSchema, "isStandardSchema");
+function toJsonSchema(schema) {
+  if (!isStandardSchema(schema)) {
+    return schema;
+  }
+  const standard = schema["~standard"];
+  const converter = standard.jsonSchema;
+  if (converter === void 0 || typeof converter.input !== "function") {
+    return void 0;
+  }
+  try {
+    return converter.input({
+      target: "draft-07"
+    });
+  } catch {
+    return void 0;
+  }
+}
+__name(toJsonSchema, "toJsonSchema");
+async function validateProps(schema, value, validator) {
+  if (isStandardSchema(schema)) {
+    const result2 = await schema["~standard"].validate(value);
+    if (result2.issues !== void 0) {
+      return {
+        ok: false,
+        issues: toGenuiIssues(result2.issues)
+      };
+    }
+    return {
+      ok: true,
+      value: result2.value
+    };
+  }
+  const issues = validator.validate(schema, value);
+  return issues.length > 0 ? {
+    ok: false,
+    issues
+  } : {
+    ok: true,
+    value
+  };
+}
+__name(validateProps, "validateProps");
+function validatePropsSync(schema, value, validator) {
+  if (!isStandardSchema(schema)) {
+    const issues = validator.validate(schema, value);
+    return issues.length > 0 ? {
+      ok: false,
+      issues
+    } : {
+      ok: true,
+      value
+    };
+  }
+  const result2 = schema["~standard"].validate(value);
+  if (result2 instanceof Promise) {
+    result2.catch(() => void 0);
+    return void 0;
+  }
+  return result2.issues !== void 0 ? {
+    ok: false,
+    issues: toGenuiIssues(result2.issues)
+  } : {
+    ok: true,
+    value: result2.value
+  };
+}
+__name(validatePropsSync, "validatePropsSync");
+function toGenuiIssues(issues) {
+  return issues.map((issue4) => ({
+    path: (issue4.path ?? []).map((segment) => typeof segment === "object" && segment !== null && "key" in segment ? segment.key : segment),
+    message: issue4.message
+  }));
+}
+__name(toGenuiIssues, "toGenuiIssues");
+function formatIssues(issues) {
+  return issues.map((issue4) => `${issue4.path.length > 0 ? formatPath(issue4.path) : "(root)"}: ${issue4.message}`).join("; ");
+}
+__name(formatIssues, "formatIssues");
+function formatPath(path) {
+  return path.map((segment, index) => typeof segment === "number" ? `[${segment}]` : index === 0 ? segment : `.${segment}`).join("");
+}
+__name(formatPath, "formatPath");
+var builtinJsonSchemaValidator = {
+  validate(schema, value) {
+    const issues = [];
+    check(schema, value, [], schema, issues, 0);
+    return issues;
+  }
+};
+var MAX_DEPTH = 64;
+function typeOf(value) {
+  if (value === null) return "null";
+  if (Array.isArray(value)) return "array";
+  return typeof value;
+}
+__name(typeOf, "typeOf");
+function matchesType(type, value) {
+  switch (type) {
+    case "integer":
+      return typeof value === "number" && Number.isInteger(value);
+    case "number":
+      return typeof value === "number" && Number.isFinite(value);
+    case "object":
+      return typeof value === "object" && value !== null && !Array.isArray(value);
+    default:
+      return typeOf(value) === type;
+  }
+}
+__name(matchesType, "matchesType");
+function resolveRef(root, ref) {
+  if (ref === "#") return root;
+  if (!ref.startsWith("#/")) return void 0;
+  let current = root;
+  for (const raw of ref.slice(2).split("/")) {
+    const key = raw.replace(/~1/g, "/").replace(/~0/g, "~");
+    if (typeof current !== "object" || current === null) return void 0;
+    current = current[key];
+  }
+  return typeof current === "object" && current !== null ? current : void 0;
+}
+__name(resolveRef, "resolveRef");
+function deepEqual(a, b) {
+  if (a === b) return true;
+  if (typeof a !== "object" || typeof b !== "object" || a === null || b === null) return false;
+  if (Array.isArray(a) !== Array.isArray(b)) return false;
+  const keysA = Object.keys(a);
+  const keysB = Object.keys(b);
+  if (keysA.length !== keysB.length) return false;
+  return keysA.every((key) => deepEqual(a[key], b[key]));
+}
+__name(deepEqual, "deepEqual");
+function check(schema, value, path, root, issues, depth) {
+  if (schema === true || schema === void 0) return;
+  if (schema === false) {
+    issues.push({
+      path,
+      message: "is not allowed"
+    });
+    return;
+  }
+  if (typeof schema !== "object" || schema === null) return;
+  if (depth > MAX_DEPTH) {
+    issues.push({
+      path,
+      message: "is nested too deeply"
+    });
+    return;
+  }
+  const s = schema;
+  if (typeof s.$ref === "string") {
+    const target = resolveRef(root, s.$ref);
+    if (target === void 0) {
+      issues.push({
+        path,
+        message: `references unknown schema ${s.$ref}`
+      });
+      return;
+    }
+    check(target, value, path, root, issues, depth + 1);
+  }
+  if (s.type !== void 0) {
+    const types = Array.isArray(s.type) ? s.type : [
+      s.type
+    ];
+    if (!types.some((type) => matchesType(type, value))) {
+      issues.push({
+        path,
+        message: `must be ${types.join(" or ")}`
+      });
+      return;
+    }
+  }
+  if (Array.isArray(s.enum) && !s.enum.some((option) => deepEqual(option, value))) {
+    issues.push({
+      path,
+      message: `must be one of ${s.enum.map((option) => JSON.stringify(option)).join(", ")}`
+    });
+  }
+  if ("const" in s && !deepEqual(s.const, value)) {
+    issues.push({
+      path,
+      message: `must be ${JSON.stringify(s.const)}`
+    });
+  }
+  if (typeof value === "string") {
+    if (typeof s.minLength === "number" && value.length < s.minLength) {
+      issues.push({
+        path,
+        message: `must be at least ${s.minLength} characters`
+      });
+    }
+    if (typeof s.maxLength === "number" && value.length > s.maxLength) {
+      issues.push({
+        path,
+        message: `must be at most ${s.maxLength} characters`
+      });
+    }
+    if (typeof s.pattern === "string") {
+      let pattern;
+      try {
+        pattern = new RegExp(s.pattern, "u");
+      } catch {
+        pattern = void 0;
+      }
+      if (pattern !== void 0 && !pattern.test(value)) {
+        issues.push({
+          path,
+          message: `must match ${s.pattern}`
+        });
+      }
+    }
+  }
+  if (typeof value === "number") {
+    if (typeof s.minimum === "number" && value < s.minimum) {
+      issues.push({
+        path,
+        message: `must be >= ${s.minimum}`
+      });
+    }
+    if (typeof s.maximum === "number" && value > s.maximum) {
+      issues.push({
+        path,
+        message: `must be <= ${s.maximum}`
+      });
+    }
+  }
+  if (Array.isArray(value)) {
+    if (typeof s.minItems === "number" && value.length < s.minItems) {
+      issues.push({
+        path,
+        message: `must have at least ${s.minItems} items`
+      });
+    }
+    if (typeof s.maxItems === "number" && value.length > s.maxItems) {
+      issues.push({
+        path,
+        message: `must have at most ${s.maxItems} items`
+      });
+    }
+    if (s.items !== void 0 && !Array.isArray(s.items)) {
+      value.forEach((item, index) => {
+        check(s.items, item, [
+          ...path,
+          index
+        ], root, issues, depth + 1);
+      });
+    }
+  }
+  if (matchesType("object", value)) {
+    const record2 = value;
+    const properties = typeof s.properties === "object" && s.properties !== null ? s.properties : {};
+    if (Array.isArray(s.required)) {
+      for (const key of s.required) {
+        if (record2[key] === void 0) {
+          issues.push({
+            path: [
+              ...path,
+              key
+            ],
+            message: "is required"
+          });
+        }
+      }
+    }
+    for (const [key, entry] of Object.entries(record2)) {
+      if (key in properties) {
+        if (entry !== void 0) {
+          check(properties[key], entry, [
+            ...path,
+            key
+          ], root, issues, depth + 1);
+        }
+      } else if (s.additionalProperties === false) {
+        issues.push({
+          path: [
+            ...path,
+            key
+          ],
+          message: "is not a known property"
+        });
+      } else if (typeof s.additionalProperties === "object" && s.additionalProperties !== null) {
+        check(s.additionalProperties, entry, [
+          ...path,
+          key
+        ], root, issues, depth + 1);
+      }
+    }
+  }
+  if (Array.isArray(s.allOf)) {
+    for (const sub of s.allOf) check(sub, value, path, root, issues, depth + 1);
+  }
+  if (Array.isArray(s.anyOf) || Array.isArray(s.oneOf)) {
+    const options = Array.isArray(s.anyOf) ? s.anyOf : s.oneOf;
+    const passing = options.filter((sub) => {
+      const nested = [];
+      check(sub, value, path, root, nested, depth + 1);
+      return nested.length === 0;
+    }).length;
+    if (Array.isArray(s.anyOf) ? passing === 0 : passing !== 1) {
+      issues.push({
+        path,
+        message: Array.isArray(s.anyOf) ? "does not match any allowed shape" : "must match exactly one allowed shape"
+      });
+    }
+  }
+  if (s.not !== void 0) {
+    const nested = [];
+    check(s.not, value, path, root, nested, depth + 1);
+    if (nested.length === 0) {
+      issues.push({
+        path,
+        message: "matches a shape that is not allowed"
+      });
+    }
+  }
+}
+__name(check, "check");
+
+// src/genui/catalog.ts
+var COMPONENT_NAME = /^[A-Za-z][A-Za-z0-9]{0,63}$/;
+function defineComponent(definition) {
+  if (!COMPONENT_NAME.test(definition.name)) {
+    throw new Error(`genui: component name "${definition.name}" must be letters and digits, starting with a letter (e.g. DataTable)`);
+  }
+  if (definition.version !== void 0 && (!Number.isSafeInteger(definition.version) || definition.version <= 0)) throw new RangeError("genui: component version must be a positive safe integer");
+  if (definition.fallbackText !== void 0 && typeof definition.fallbackText !== "function") throw new TypeError("genui: fallbackText must be a function");
+  return definition;
+}
+__name(defineComponent, "defineComponent");
+function defineCatalog(components, options = {}) {
+  const byName = /* @__PURE__ */ new Map();
+  for (const component of components) {
+    defineComponent(component);
+    if (byName.has(component.name)) {
+      throw new Error(`genui: component "${component.name}" is defined twice in one catalog`);
+    }
+    byName.set(component.name, component);
+  }
+  return buildCatalog(byName, options.jsonSchemaValidator ?? builtinJsonSchemaValidator);
+}
+__name(defineCatalog, "defineCatalog");
+function buildCatalog(byName, validator) {
+  const list = Object.freeze([
+    ...byName.values()
+  ]);
+  return {
+    components: list,
+    validator,
+    get: /* @__PURE__ */ __name((name) => byName.get(name), "get"),
+    has: /* @__PURE__ */ __name((name) => byName.has(name), "has"),
+    modelComponents: /* @__PURE__ */ __name(() => list.filter((component) => component.internal !== true), "modelComponents"),
+    async validate(component, props) {
+      const definition = byName.get(component);
+      if (definition === void 0) {
+        return {
+          ok: false,
+          issues: [
+            {
+              path: [],
+              message: `unknown component "${component}"`
+            }
+          ]
+        };
+      }
+      const result2 = await validateProps(definition.props, props, validator);
+      return result2;
+    },
+    validateSync(component, props) {
+      const definition = byName.get(component);
+      if (definition === void 0) {
+        return {
+          ok: false,
+          issues: [
+            {
+              path: [],
+              message: `unknown component "${component}"`
+            }
+          ]
+        };
+      }
+      return validatePropsSync(definition.props, props, validator);
+    },
+    jsonSchemaFor(component) {
+      const definition = byName.get(component);
+      return definition === void 0 ? void 0 : toJsonSchema(definition.props);
+    },
+    extend(more) {
+      const next = new Map(byName);
+      for (const component of more) {
+        defineComponent(component);
+        next.set(component.name, component);
+      }
+      return buildCatalog(next, validator);
+    }
+  };
+}
+__name(buildCatalog, "buildCatalog");
+
+// src/genui/tree.ts
+var GENUI_TREE_COMPONENT = "genui:tree";
+async function validateTree(catalog, tree, limits = {}) {
+  const maxDepth = limits.maxDepth ?? 12;
+  const maxNodes = limits.maxNodes ?? 200;
+  const issues = [];
+  let nodes = 0;
+  const visit = /* @__PURE__ */ __name(async (node, path, depth) => {
+    nodes += 1;
+    if (nodes > maxNodes) {
+      if (nodes === maxNodes + 1) {
+        issues.push({
+          path,
+          message: `the tree has more than ${maxNodes} elements`
+        });
+      }
+      return void 0;
+    }
+    if (depth > maxDepth) {
+      issues.push({
+        path,
+        message: `the tree is nested deeper than ${maxDepth} levels`
+      });
+      return void 0;
+    }
+    if (typeof node !== "object" || node === null || Array.isArray(node)) {
+      issues.push({
+        path,
+        message: "must be an element object { type, props, children? }"
+      });
+      return void 0;
+    }
+    const element = node;
+    if (typeof element.type !== "string") {
+      issues.push({
+        path: [
+          ...path,
+          "type"
+        ],
+        message: "must be a component name"
+      });
+      return void 0;
+    }
+    const definition = catalog.get(element.type);
+    if (definition === void 0 || definition.internal === true) {
+      issues.push({
+        path: [
+          ...path,
+          "type"
+        ],
+        message: `unknown component "${element.type}" (allowed: ${catalog.modelComponents().map((component) => component.name).join(", ")})`
+      });
+      return void 0;
+    }
+    const validated = await catalog.validate(element.type, element.props ?? {});
+    let props = {};
+    if (!validated.ok) {
+      for (const issue4 of validated.issues) {
+        issues.push({
+          path: [
+            ...path,
+            "props",
+            ...issue4.path
+          ],
+          message: issue4.message
+        });
+      }
+    } else {
+      props = validated.value;
+    }
+    const rawChildren = parseChildrenIfStringified(element.children);
+    if (rawChildren === void 0 || rawChildren === null) {
+      return {
+        type: element.type,
+        props
+      };
+    }
+    if (!Array.isArray(rawChildren)) {
+      issues.push({
+        path: [
+          ...path,
+          "children"
+        ],
+        message: "must be an array of elements (a literal array, not a string)"
+      });
+      return void 0;
+    }
+    if (rawChildren.length > 0 && definition.children !== true) {
+      issues.push({
+        path: [
+          ...path,
+          "children"
+        ],
+        message: `${element.type} does not take children`
+      });
+      return void 0;
+    }
+    const children = [];
+    for (const [index, child] of rawChildren.entries()) {
+      const next = await visit(child, [
+        ...path,
+        "children",
+        index
+      ], depth + 1);
+      if (next !== void 0) {
+        children.push(next);
+      }
+    }
+    return children.length > 0 ? {
+      type: element.type,
+      props,
+      children
+    } : {
+      type: element.type,
+      props
+    };
+  }, "visit");
+  const root = await visit(tree, [], 1);
+  return issues.length > 0 || root === void 0 ? {
+    ok: false,
+    issues: issues.length > 0 ? issues : [
+      {
+        path: [],
+        message: "is invalid"
+      }
+    ]
+  } : {
+    ok: true,
+    value: root
+  };
+}
+__name(validateTree, "validateTree");
+function parseChildrenIfStringified(value) {
+  if (typeof value !== "string") return value;
+  const trimmed = value.trim();
+  if (!trimmed.startsWith("[")) return value;
+  return leadingJsonArray(trimmed) ?? value;
+}
+__name(parseChildrenIfStringified, "parseChildrenIfStringified");
+function leadingJsonArray(text) {
+  let depth = 0;
+  let inString = false;
+  let escaped = false;
+  for (let index = 0; index < text.length; index += 1) {
+    const char = text[index];
+    if (inString) {
+      if (escaped) escaped = false;
+      else if (char === "\\") escaped = true;
+      else if (char === '"') inString = false;
+      continue;
+    }
+    if (char === '"') inString = true;
+    else if (char === "[" || char === "{") depth += 1;
+    else if (char === "]" || char === "}") {
+      depth -= 1;
+      if (depth === 0) {
+        try {
+          const parsed = JSON.parse(text.slice(0, index + 1));
+          return Array.isArray(parsed) ? parsed : void 0;
+        } catch {
+          return void 0;
+        }
+      }
+    }
+  }
+  return void 0;
+}
+__name(leadingJsonArray, "leadingJsonArray");
+
+// src/genui/text.ts
+function componentToText(catalog, component, props) {
+  if (component === GENUI_TREE_COMPONENT) {
+    const root = props.root;
+    return root === void 0 ? "" : treeToText(catalog, root);
+  }
+  const fallback = catalog.get(component)?.fallbackText;
+  if (fallback !== void 0) {
+    try {
+      const text = fallback(props);
+      if (typeof text === "string" && text.trim().length > 0) return text;
+    } catch {
+    }
+  }
+  return jsonBlock(props);
+}
+__name(componentToText, "componentToText");
+function treeToText(catalog, root) {
+  const out = [];
+  const visit = /* @__PURE__ */ __name((node, depth) => {
+    if (depth > 32) return;
+    const definition = catalog.get(node.type);
+    if (definition?.fallbackText !== void 0) {
+      try {
+        const text = definition.fallbackText(node.props);
+        out.push(typeof text === "string" && text.trim().length > 0 ? text : jsonBlock(node.props));
+      } catch {
+        out.push(jsonBlock(node.props));
+      }
+    } else if (definition?.children !== true) {
+      out.push(jsonBlock(node.props));
+    }
+    for (const child of node.children ?? []) visit(child, depth + 1);
+  }, "visit");
+  visit(root, 0);
+  return out.filter((line) => line.trim().length > 0).join("\n");
+}
+__name(treeToText, "treeToText");
+function jsonBlock(props) {
+  const title = typeof props.title === "string" && props.title.length > 0 ? `*${props.title}*
+` : "";
+  return `${title}\`\`\`
+${JSON.stringify(props, null, 2)}
+\`\`\``;
+}
+__name(jsonBlock, "jsonBlock");
+
+// src/genui/capabilities.ts
+function validateUiCapabilities(value) {
+  if (!record(value) || Object.keys(value).some((key) => key !== "components") || !Array.isArray(value.components)) throw new TypeError("Invalid UI capabilities");
+  const seen = /* @__PURE__ */ new Set();
+  const components = value.components.map((component) => {
+    if (!record(component) || Object.keys(component).some((key) => key !== "name" && key !== "version") || typeof component.name !== "string" || !COMPONENT_NAME.test(component.name) || !Number.isSafeInteger(component.version) || Number(component.version) <= 0 || seen.has(component.name)) throw new TypeError("Invalid UI component capability");
+    seen.add(component.name);
+    return {
+      name: component.name,
+      version: Number(component.version)
+    };
+  });
+  return {
+    components
+  };
+}
+__name(validateUiCapabilities, "validateUiCapabilities");
+function record(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+__name(record, "record");
+function negotiateCatalog(catalog, capabilities) {
+  if (capabilities === void 0) return catalog;
+  const supported = validateUiCapabilities(capabilities).components;
+  return defineCatalog(catalog.components.filter((component) => supported.some((entry) => entry.name === component.name && entry.version === (component.version ?? 1))), {
+    jsonSchemaValidator: catalog.validator
+  });
+}
+__name(negotiateCatalog, "negotiateCatalog");
+async function prepareUiEmission(catalog, capabilities, component, props, version) {
+  const drawable = negotiateCatalog(catalog, capabilities);
+  if (component === GENUI_TREE_COMPONENT) {
+    if (version !== void 0 && version !== 1) throw new Error("Invalid UI tree version");
+    const validated2 = await validateTree(catalog, props.root);
+    if (!validated2.ok) throw new Error(`Invalid UI tree: ${formatIssues(validated2.issues)}`);
+    const supported = /* @__PURE__ */ __name((node) => drawable.has(node.type) && (node.children ?? []).every(supported), "supported");
+    const versions = /* @__PURE__ */ new Map();
+    const collectVersions = /* @__PURE__ */ __name((node) => {
+      versions.set(node.type, catalog.get(node.type)?.version ?? 1);
+      for (const child of node.children ?? []) collectVersions(child);
+    }, "collectVersions");
+    collectVersions(validated2.value);
+    return supported(validated2.value) ? {
+      kind: "ui",
+      component,
+      props: {
+        root: validated2.value
+      },
+      version: 1,
+      fallbackText: treeToText(catalog, validated2.value),
+      componentVersions: Object.fromEntries(versions)
+    } : {
+      kind: "text",
+      text: treeToText(catalog, validated2.value)
+    };
+  }
+  const definition = catalog.get(component);
+  if (definition === void 0) throw new Error(`Unknown UI component "${component}"`);
+  const currentVersion = definition.version ?? 1;
+  if (version !== void 0 && version !== currentVersion) throw new Error(`Invalid UI component version for "${component}"`);
+  const validated = await catalog.validate(component, props);
+  if (!validated.ok) throw new Error(`Invalid UI props: ${formatIssues(validated.issues)}`);
+  return drawable.has(component) ? {
+    kind: "ui",
+    component,
+    props: validated.value,
+    version: currentVersion,
+    fallbackText: componentToText(catalog, component, validated.value)
+  } : {
+    kind: "text",
+    text: componentToText(catalog, component, validated.value)
+  };
+}
+__name(prepareUiEmission, "prepareUiEmission");
+
+// src/action-proposal-transitions.ts
+function checkTime(value) {
+  if (!Number.isSafeInteger(value)) throw new RangeError("Action proposal timestamps must be safe integer milliseconds");
+}
+__name(checkTime, "checkTime");
+function checkString(value) {
+  if (typeof value !== "string" || value.length === 0) throw new TypeError("Action proposal identifiers must be nonempty strings");
+}
+__name(checkString, "checkString");
+function validateActionProposalCreation(input) {
+  const allowed = [
+    "id",
+    "tenantRef",
+    "actorRef",
+    "threadId",
+    "originRunId",
+    "originMessageId",
+    "originToolCallId",
+    "toolName",
+    "input",
+    "preparationInput",
+    "executionContext",
+    "confirmation",
+    "approver",
+    "expiresAt",
+    "idempotencyKey",
+    "replacementKey"
+  ];
+  if (Object.keys(input).some((key) => !allowed.includes(key))) throw new TypeError("Unknown action proposal creation field");
+  for (const key of [
+    "id",
+    "actorRef",
+    "threadId",
+    "originRunId",
+    "originMessageId",
+    "originToolCallId",
+    "toolName",
+    "approver",
+    "idempotencyKey"
+  ]) checkString(input[key]);
+  if (input.tenantRef !== null && typeof input.tenantRef !== "string") throw new TypeError("tenantRef must be an explicit string or null");
+  for (const value of [
+    input.id,
+    input.actorRef,
+    input.threadId,
+    input.tenantRef
+  ]) {
+    if (value !== null && value.length > 255) throw new RangeError("Action proposal id and scope must fit 255 UTF-16 code units");
+  }
+  if (input.replacementKey !== void 0) {
+    checkString(input.replacementKey);
+    if (input.replacementKey.length > 255) throw new RangeError("replacementKey must fit 255 UTF-16 code units");
+  }
+  if (Object.hasOwn(input, "executionContext")) {
+    const context = input.executionContext;
+    if (context === null || typeof context !== "object" || Array.isArray(context)) throw new TypeError("executionContext must be a JSON object");
+    const allowedContext = [
+      "agentName",
+      "persona",
+      "requestId",
+      "pageContext",
+      "uiCapabilities"
+    ];
+    if (Object.keys(context).some((key) => !allowedContext.includes(key))) throw new TypeError("Unknown execution context field");
+    checkString(context.requestId);
+    if (Object.hasOwn(context, "uiCapabilities")) validateUiCapabilities(context.uiCapabilities);
+    if (Object.hasOwn(context, "agentName")) checkString(context.agentName);
+    if (Object.hasOwn(context, "persona")) checkString(context.persona);
+    if (Object.hasOwn(context, "pageContext")) {
+      const page = context.pageContext;
+      if (page === null || typeof page !== "object" || Array.isArray(page)) throw new TypeError("pageContext must be a JSON object");
+      if (Object.hasOwn(page, "kind") && typeof page.kind !== "string") throw new TypeError("pageContext.kind must be a string");
+    }
+  }
+  if (input.expiresAt !== null) checkTime(input.expiresAt);
+  checkString(input.confirmation?.title);
+  checkString(input.confirmation?.verb);
+  canonicalActionProposalJson(input);
+}
+__name(validateActionProposalCreation, "validateActionProposalCreation");
+function validateActionProposalListQuery(query = {}) {
+  const limit = query.limit === void 0 ? 100 : query.limit;
+  if (!Number.isInteger(limit) || limit < 1 || limit > 1e3) throw new RangeError("limit must be an integer from 1 to 1000");
+  if (query.decision !== void 0 && ![
+    "pending",
+    "approved",
+    "rejected",
+    "expired",
+    "superseded"
+  ].includes(query.decision)) throw new TypeError("Unsupported action proposal list decision");
+  if (query.after !== void 0) {
+    const after = query.after;
+    if (typeof after !== "object" || after === null || Array.isArray(after) || Object.keys(after).some((key) => key !== "createdAt" && key !== "id")) throw new TypeError("Invalid action proposal cursor");
+    checkTime(after.createdAt);
+    checkString(after.id);
+    if (after.id.length > 255) throw new TypeError("Action proposal cursor id is too long");
+  }
+  return limit;
+}
+__name(validateActionProposalListQuery, "validateActionProposalListQuery");
+function canonicalActionProposalJson(value) {
+  const ancestors = /* @__PURE__ */ new Set();
+  const sort = /* @__PURE__ */ __name((item) => {
+    if (item === null || typeof item === "string" || typeof item === "boolean") return item;
+    if (typeof item === "number" && Number.isFinite(item)) return item;
+    if (typeof item !== "object" || item === null || ancestors.has(item)) throw new TypeError("Action proposals require finite, acyclic JSON values");
+    const prototype = Object.getPrototypeOf(item);
+    if (!Array.isArray(item) && prototype !== Object.prototype && prototype !== null) throw new TypeError("Action proposals require plain JSON objects");
+    ancestors.add(item);
+    const sorted = Array.isArray(item) ? Array.from(item, sort) : Object.fromEntries(Object.keys(item).sort().map((key) => [
+      key,
+      sort(item[key])
+    ]));
+    ancestors.delete(item);
+    return sorted;
+  }, "sort");
+  return JSON.stringify(sort(value));
+}
+__name(canonicalActionProposalJson, "canonicalActionProposalJson");
+function snapshotActionProposal(value) {
+  return JSON.parse(canonicalActionProposalJson(value));
+}
+__name(snapshotActionProposal, "snapshotActionProposal");
+function actionProposalScopeMatches(row, scope) {
+  return row.tenantRef === scope.tenantRef && row.actorRef === scope.actorRef && row.threadId === scope.threadId;
+}
+__name(actionProposalScopeMatches, "actionProposalScopeMatches");
+function initialActionProposal(input, now) {
+  validateActionProposalCreation(input);
+  checkTime(now);
+  return snapshotActionProposal({
+    ...input,
+    decision: "pending",
+    decisionAudit: null,
+    execution: null,
+    createdAt: now,
+    updatedAt: now
+  });
+}
+__name(initialActionProposal, "initialActionProposal");
+function actionProposalCreationMatches(row, input) {
+  validateActionProposalCreation(input);
+  const { decision: _decision, decisionAudit: _audit, execution: _execution, createdAt: _created, updatedAt: _updated, supersededBy: _supersededBy, outcome: _outcome, outcomeDelivery: _delivery, ...original } = row;
+  return canonicalActionProposalJson(original) === canonicalActionProposalJson(input);
+}
+__name(actionProposalCreationMatches, "actionProposalCreationMatches");
+function result(status, proposal) {
+  return {
+    status,
+    proposal: snapshotActionProposal(proposal)
+  };
+}
+__name(result, "result");
+function transitionActionProposalDecision(row, command, now) {
+  checkTime(now);
+  if (![
+    "approved",
+    "rejected",
+    "expired"
+  ].includes(command.decision)) throw new TypeError("Unsupported action proposal decision");
+  checkString(command.actorRef);
+  checkString(command.via);
+  if (command.reason !== void 0 && typeof command.reason !== "string") throw new TypeError("reason must be a string");
+  if (command.remember !== void 0 && typeof command.remember !== "boolean") throw new TypeError("remember must be a boolean");
+  if (row.decision !== "pending") {
+    return result(row.decision === command.decision ? "unchanged" : row.decision === "expired" ? "expired" : "conflict", row);
+  }
+  const next = snapshotActionProposal(row);
+  if (row.expiresAt !== null && now >= row.expiresAt) {
+    next.decision = "expired";
+    next.decisionAudit = {
+      actorRef: "system",
+      via: "expiry",
+      at: now
+    };
+    next.updatedAt = now;
+    return result(command.decision === "expired" ? "applied" : "expired", attachActionProposalOutcome(next, now));
+  }
+  if (command.decision === "expired") return result("conflict", row);
+  const { decision, ...audit } = command;
+  next.decision = decision;
+  next.decisionAudit = {
+    actorRef: audit.actorRef,
+    via: audit.via,
+    at: now,
+    ...audit.reason === void 0 ? {} : {
+      reason: audit.reason
+    },
+    ...audit.remember === void 0 ? {} : {
+      remember: audit.remember
+    }
+  };
+  next.updatedAt = now;
+  if (decision === "approved") next.execution = {
+    status: "queued",
+    generation: 0,
+    lease: null
+  };
+  return result("applied", decision === "approved" ? next : attachActionProposalOutcome(next, now));
+}
+__name(transitionActionProposalDecision, "transitionActionProposalDecision");
+function checkLeaseMs(leaseMs, now) {
+  checkTime(now);
+  if (!Number.isSafeInteger(leaseMs) || leaseMs <= 0 || !Number.isSafeInteger(now + leaseMs)) throw new RangeError("leaseMs must be finite and positive");
+}
+__name(checkLeaseMs, "checkLeaseMs");
+function transitionActionProposalClaim(row, command, now, token) {
+  checkLeaseMs(command.leaseMs, now);
+  checkString(command.workerId);
+  checkString(token);
+  const execution = row.execution;
+  if (row.decision !== "approved" || !execution || execution.status !== "queued" && !(execution.status === "executing" && execution.lease && now >= execution.lease.expiresAt)) return result("conflict", row);
+  const next = snapshotActionProposal(row);
+  const generation = execution.generation + 1;
+  next.execution = {
+    status: "executing",
+    generation,
+    lease: {
+      token,
+      generation,
+      workerId: command.workerId,
+      expiresAt: now + command.leaseMs
+    }
+  };
+  next.updatedAt = now;
+  return result("applied", next);
+}
+__name(transitionActionProposalClaim, "transitionActionProposalClaim");
+function leaseStatus(row, command, now) {
+  checkTime(now);
+  checkString(command.token);
+  if (!Number.isSafeInteger(command.generation) || command.generation < 1) throw new RangeError("Invalid lease generation");
+  const work = row.execution;
+  if (row.decision !== "approved" || work?.status !== "executing" || !work.lease || work.generation !== command.generation || work.lease.generation !== command.generation || work.lease.token !== command.token) return "conflict";
+  return now >= work.lease.expiresAt ? "expired" : "valid";
+}
+__name(leaseStatus, "leaseStatus");
+function transitionActionProposalLease(row, command, now) {
+  checkLeaseMs(command.leaseMs, now);
+  const status = leaseStatus(row, command, now);
+  if (status !== "valid") return result(status, row);
+  const next = snapshotActionProposal(row);
+  if (next.execution?.lease) next.execution.lease.expiresAt = Math.max(next.execution.lease.expiresAt, now + command.leaseMs);
+  next.updatedAt = now;
+  return result("applied", next);
+}
+__name(transitionActionProposalLease, "transitionActionProposalLease");
+function transitionActionProposalSettlement(row, command, now) {
+  checkTime(now);
+  if (command.status !== "succeeded" && command.status !== "failed") throw new TypeError("Unsupported settlement status");
+  if (command.status === "succeeded" && command.error !== void 0 || command.status === "failed" && (typeof command.error !== "string" || command.result !== void 0)) throw new TypeError("Ambiguous action proposal settlement");
+  const status = leaseStatus(row, command, now);
+  if (status !== "valid") return result(status, row);
+  const next = snapshotActionProposal(row);
+  next.execution = command.status === "succeeded" ? {
+    status: "succeeded",
+    generation: command.generation,
+    lease: null,
+    ...command.result === void 0 ? {} : {
+      result: command.result
+    }
+  } : {
+    status: "failed",
+    generation: command.generation,
+    lease: null,
+    error: command.error
+  };
+  if (command.ui !== void 0) canonicalActionProposalJson(command.ui);
+  if (command.text !== void 0 && typeof command.text !== "string") throw new TypeError("Outcome text must be a string");
+  next.updatedAt = now;
+  return result("applied", attachActionProposalOutcome(next, now, command.ui, command.text));
+}
+__name(transitionActionProposalSettlement, "transitionActionProposalSettlement");
+function transitionActionProposalSupersession(row, replacement, command, now) {
+  checkTime(now);
+  checkString(command.replacementProposalId);
+  checkString(command.actorRef);
+  checkString(command.via);
+  if (replacement.id !== command.replacementProposalId || row.id === replacement.id || !actionProposalScopeMatches(row, replacement) || row.toolName !== replacement.toolName || !row.replacementKey || row.replacementKey !== replacement.replacementKey) return result("conflict", row);
+  if (row.decision === "superseded") return result(row.supersededBy === replacement.id ? "unchanged" : "conflict", row);
+  if (row.decision !== "pending") return result("conflict", row);
+  if (row.expiresAt !== null && now >= row.expiresAt) return {
+    ...transitionActionProposalDecision(row, {
+      decision: "expired",
+      actorRef: "system",
+      via: "expiry"
+    }, now),
+    status: "expired"
+  };
+  const next = snapshotActionProposal({
+    ...row,
+    decision: "superseded",
+    supersededBy: replacement.id,
+    decisionAudit: {
+      actorRef: command.actorRef,
+      via: command.via,
+      replacementProposalId: replacement.id,
+      at: now
+    },
+    updatedAt: now
+  });
+  return result("applied", attachActionProposalOutcome(next, now));
+}
+__name(transitionActionProposalSupersession, "transitionActionProposalSupersession");
+
 // src/tool-registry.ts
 var ToolForbiddenError = class extends Error {
   static {
@@ -2868,6 +4045,35 @@ var ToolInputInvalidError = class extends Error {
     this.name = "ToolInputInvalidError";
   }
 };
+var ToolPreflightDeniedError = class extends Error {
+  static {
+    __name(this, "ToolPreflightDeniedError");
+  }
+  toolName;
+  reason;
+  constructor(toolName, reason) {
+    super(reason), this.toolName = toolName, this.reason = reason;
+    this.name = "ToolPreflightDeniedError";
+  }
+};
+var ToolInputDriftError = class extends Error {
+  static {
+    __name(this, "ToolInputDriftError");
+  }
+  toolName;
+  constructor(toolName) {
+    super(`Tool "${toolName}" input differs from its trusted snapshot`), this.toolName = toolName;
+    this.name = "ToolInputDriftError";
+  }
+};
+function assertTrustedInput(name, value, approved) {
+  try {
+    if (canonicalActionProposalJson(value) === canonicalActionProposalJson(approved)) return;
+  } catch {
+  }
+  throw new ToolInputDriftError(name);
+}
+__name(assertTrustedInput, "assertTrustedInput");
 var ToolRegistry = class {
   static {
     __name(this, "ToolRegistry");
@@ -2915,11 +4121,12 @@ var ToolRegistry = class {
   */
   async definitionsFor(actor, policy, allowedTools, scope = {}) {
     const visible = await this.visibleEntries(actor, policy, allowedTools);
-    return Promise.all(visible.map(async ({ spec, handler }) => {
+    const definitions = await Promise.all(visible.map(async ({ spec, handler }) => {
       const override = handler.describe === void 0 ? void 0 : await handler.describe({
         actor,
         ...scope
       });
+      if (override?.available === false) return null;
       return {
         name: spec.name,
         kind: spec.kind,
@@ -2927,6 +4134,7 @@ var ToolRegistry = class {
         inputSchema: override?.inputSchema ?? spec.inputSchema
       };
     }));
+    return definitions.filter((definition) => definition !== null);
   }
   /**
   * The specs {@link definitionsFor} offers the model, whole — the same four gates (allow-list,
@@ -2952,6 +4160,40 @@ var ToolRegistry = class {
   * moved, neither of which went through `definitionsFor` again) and re-parses the input via Zod.
   */
   async invoke(name, input, ctx, policy, options = {}) {
+    const { entry, value, ctx: withEmit } = await this.validated(name, input, ctx, policy, options);
+    const trusted = Object.hasOwn(options, "approvedInput");
+    if (trusted) assertTrustedInput(name, value, options.approvedInput);
+    const executionInput = trusted ? snapshotActionProposal(value) : value;
+    const hookInput = trusted ? snapshotActionProposal(executionInput) : value;
+    const result2 = entry.spec.kind === "action" ? await entry.handler.preflight?.(hookInput, withEmit, {
+      phase: "execute"
+    }) : void 0;
+    if (trusted) assertTrustedInput(name, hookInput, executionInput);
+    if (result2?.status === "denied") throw new ToolPreflightDeniedError(name, result2.reason);
+    if (result2?.status === "completed") return result2.output;
+    return entry.handler.execute(executionInput, withEmit);
+  }
+  /** Authorize and validate without executing. The caller journals this result before approval. */
+  async prepare(name, input, ctx, policy, options = {}) {
+    return (await this.prepareValidated(name, input, ctx, policy, options)).preflight;
+  }
+  /** Expose the single schema parse; snapshotInput opts proposal callers into immutable JSON. */
+  async prepareValidated(name, input, ctx, policy, options = {}) {
+    const { entry, value, ctx: withEmit } = await this.validated(name, input, ctx, policy, options);
+    const normalized = options.snapshotInput === true ? snapshotActionProposal(value) : value;
+    const hookInput = options.snapshotInput === true ? snapshotActionProposal(normalized) : value;
+    const preflight = (entry.spec.kind === "action" ? await entry.handler.preflight?.(hookInput, withEmit, {
+      phase: "prepare"
+    }) : void 0) ?? {
+      status: "ready"
+    };
+    if (options.snapshotInput === true) assertTrustedInput(name, hookInput, normalized);
+    return {
+      input: normalized,
+      preflight
+    };
+  }
+  async validated(name, input, ctx, policy, options) {
     const entry = this.entries.get(name);
     if (entry === void 0) {
       throw new ToolNotFoundError(name);
@@ -2976,7 +4218,11 @@ var ToolRegistry = class {
       ...ctx,
       emitUi: createNoopEmitUi(ctx.requestId)
     };
-    return entry.handler.execute(validation.value, withEmit);
+    return {
+      entry,
+      value: validation.value,
+      ctx: withEmit
+    };
   }
 };
 var DefaultRolesPolicy = class {
@@ -3023,6 +4269,69 @@ __name(closeEmptyRoles, "closeEmptyRoles");
 var import_node_crypto = require("crypto");
 var import_nestjs_diagnostics2 = require("@dudousxd/nestjs-diagnostics");
 
+// src/action-proposal-approval.ts
+async function resolveActionProposalApproval(input) {
+  const policy = input.policy ?? new DefaultApprovalPolicy();
+  const requirement = await policy.requirementFor(input.tool, input.actor, input.thread);
+  if (!requirement.required) return {
+    mode: "auto"
+  };
+  const remembered = await input.store.rememberedApprovals?.(input.thread.threadId) ?? [];
+  if (remembered.includes(input.tool.name)) return {
+    mode: "remembered",
+    approver: requirement.approver
+  };
+  const roundedTtl = requirement.ttlMs !== void 0 && Number.isFinite(requirement.ttlMs) ? Math.floor(requirement.ttlMs) : 0;
+  if (roundedTtl <= 0) return {
+    mode: "ask",
+    approver: requirement.approver
+  };
+  const now = (input.clock ?? Date.now)();
+  if (!Number.isSafeInteger(now) || !Number.isSafeInteger(roundedTtl) || !Number.isSafeInteger(now + roundedTtl)) throw new RangeError("Invalid action approval deadline");
+  return {
+    mode: "ask",
+    approver: requirement.approver,
+    ttlMs: roundedTtl,
+    expiresAt: new Date(now + roundedTtl).toISOString()
+  };
+}
+__name(resolveActionProposalApproval, "resolveActionProposalApproval");
+
+// src/action-proposal-preparation.ts
+async function prepareActionProposal(registry, name, input, ctx, policy, options = {}) {
+  const preparationInput = snapshotActionProposal(input);
+  const prepared = await registry.prepareValidated(name, snapshotActionProposal(preparationInput), ctx, policy, {
+    ...options,
+    snapshotInput: true
+  });
+  let replacementKey;
+  const replacement = registry.spec(name)?.replacementKey;
+  if (prepared.preflight.status === "ready" && replacement !== void 0) {
+    replacementKey = typeof replacement === "string" ? replacement : await replacement(snapshotActionProposal(prepared.input), ctx);
+    if (replacementKey !== void 0 && (typeof replacementKey !== "string" || !replacementKey || replacementKey.length > 255)) throw new TypeError("replacementKey must be a nonempty string of at most 255 UTF-16 code units");
+  }
+  return {
+    ...replacementKey !== void 0 ? {
+      replacementKey
+    } : {},
+    preparationInput,
+    input: prepared.input,
+    // Completed results keep their normal handler contract; they never create a proposal.
+    preflight: prepared.preflight.status === "ready" ? snapshotActionProposal(prepared.preflight) : prepared.preflight
+  };
+}
+__name(prepareActionProposal, "prepareActionProposal");
+
+// src/action-proposal-receipt.ts
+function actionProposalReceipt(proposalId) {
+  return {
+    proposalId,
+    status: "pending",
+    executed: false
+  };
+}
+__name(actionProposalReceipt, "actionProposalReceipt");
+
 // src/diagnostics.ts
 var import_nestjs_diagnostics = require("@dudousxd/nestjs-diagnostics");
 function publishAgentRunStarted(payload) {
@@ -3096,7 +4405,57 @@ var AGENT_DIAGNOSTIC_EVENTS = [
 function agentDiagnosticKey(event) {
   return `agent:${event}`;
 }
-__name(agentDiagnosticKey, "agentDiagnosticKey");
+__name(agentDiagnosticKey, "agentDiagnosticKey");
+
+// src/negotiated-tool-ui.ts
+function createNegotiatedUiCollector(toolCallId, scope, resolveCatalog, write) {
+  const collector = createUiCollector(toolCallId, write);
+  const texts = /* @__PURE__ */ new Map();
+  let next = 0;
+  return {
+    components: collector.components,
+    text: /* @__PURE__ */ __name(() => [
+      ...texts.values()
+    ].join("\n"), "text"),
+    restart: /* @__PURE__ */ __name(() => {
+      next = 0;
+      texts.clear();
+      collector.restart();
+    }, "restart"),
+    emit: /* @__PURE__ */ __name(async (component, props, options = {}) => {
+      if (!resolveCatalog) {
+        if (scope.uiCapabilities !== void 0) throw new Error("UI capabilities require an authorized server catalog");
+        return collector.emit(component, props, options);
+      }
+      const capturedProps = snapshotActionProposal(props);
+      const capturedOptions = {
+        ...options
+      };
+      const catalog = await resolveCatalog(scope);
+      const prepared = await prepareUiEmission(catalog, scope.uiCapabilities, component, capturedProps, capturedOptions.version);
+      const id = capturedOptions.id ?? `${toolCallId}:ui:${next++}`;
+      if (prepared.kind === "text") {
+        texts.set(id, prepared.text);
+        await write?.({
+          kind: "text",
+          text: prepared.text
+        });
+        return {
+          id
+        };
+      }
+      return collector.emit(prepared.component, prepared.props, {
+        id,
+        version: prepared.version,
+        fallbackText: prepared.fallbackText,
+        ...prepared.componentVersions !== void 0 ? {
+          componentVersions: prepared.componentVersions
+        } : {}
+      });
+    }, "emit")
+  };
+}
+__name(createNegotiatedUiCollector, "createNegotiatedUiCollector");
 
 // src/tool-retry.ts
 function hasTransientShape(error) {
@@ -3123,6 +4482,7 @@ function hasTransientShape(error) {
 }
 __name(hasTransientShape, "hasTransientShape");
 function isTransientToolError(error) {
+  if (error instanceof ToolPreflightDeniedError) return false;
   if (hasTransientShape(error)) {
     return true;
   }
@@ -3165,7 +4525,7 @@ async function invokeWithTransientRetry(fn, setting, options) {
     try {
       return await fn();
     } catch (error) {
-      if (isControlFlowSignal(error) || options?.isControlFlowError?.(error) === true) {
+      if (error instanceof ToolPreflightDeniedError || isControlFlowSignal(error) || options?.isControlFlowError?.(error) === true) {
         throw error;
       }
       const attemptsRemain = attempt < attempts;
@@ -3345,6 +4705,9 @@ function promptContext(input, persona) {
     ...input.pageContext !== void 0 ? {
       pageContext: input.pageContext
     } : {},
+    ...input.uiCapabilities !== void 0 ? {
+      uiCapabilities: input.uiCapabilities
+    } : {},
     ...persona !== void 0 ? {
       persona: {
         id: persona.id,
@@ -3541,7 +4904,8 @@ async function loadSelectedHistory(deps, input, hooks) {
       messages: keep,
       dropped: deps.historyPolicy?.summarize === void 0 ? [] : drop,
       title: thread.title,
-      hasAssistantMessage: thread.hasAssistantMessage
+      hasAssistantMessage: thread.hasAssistantMessage,
+      actionApprovalMode: deps.actionApprovalMode ?? "blocking"
     };
   });
   return {
@@ -3705,10 +5069,10 @@ async function structureAnswer(schema, deps, input, hooks, messages, step) {
           modelId: turn.modelId
         } : {}
       };
-    }, (result) => ({
-      inputTokens: result.usage.inputTokens,
-      outputTokens: result.usage.outputTokens,
-      textLength: result.text.length
+    }, (result2) => ({
+      inputTokens: result2.usage.inputTokens,
+      outputTokens: result2.usage.outputTokens,
+      textLength: result2.text.length
     })));
     await hooks.step(`persist:usage:structured:${step}:${attempt}`, () => deps.store.recordUsage({
       threadId: input.threadId,
@@ -3738,13 +5102,16 @@ async function structureAnswer(schema, deps, input, hooks, messages, step) {
   throw new StructuredOutputError(issues, text, maxAttempts);
 }
 __name(structureAnswer, "structureAnswer");
-function stampToolKinds(result, deps) {
+function stampToolKinds(result2, deps) {
   return {
-    ...result,
-    toolCalls: result.toolCalls.map((call) => call.kind === void 0 ? {
-      ...call,
-      kind: declaredKind(deps, call.name)
-    } : call)
+    ...result2,
+    toolCalls: result2.toolCalls.map((call) => {
+      const { preflight: _untrusted, prepared: _untrustedPrepared, actionApproval: _untrustedApproval, ...trusted } = call;
+      return trusted.kind === void 0 ? {
+        ...trusted,
+        kind: declaredKind(deps, trusted.name)
+      } : trusted;
+    })
   };
 }
 __name(stampToolKinds, "stampToolKinds");
@@ -3807,6 +5174,9 @@ function toolContext(deps, input, hooks) {
     ...input.pageContext !== void 0 ? {
       pageContext: input.pageContext
     } : {},
+    ...input.uiCapabilities !== void 0 ? {
+      uiCapabilities: input.uiCapabilities
+    } : {},
     ...deps.host !== void 0 ? {
       host: deps.host
     } : {},
@@ -3882,16 +5252,16 @@ async function runIntake(intake, deps, input, hooks, writer, threadHasAssistant)
   }
   const messageId = asked.messageId;
   const reply = await awaitElicitation(hooks, request, toolContext(deps, input, hooks));
-  const result = settleElicitation(request, reply);
+  const result2 = settleElicitation(request, reply);
   await hooks.step("intake:answers", async () => {
     await deps.store.updateToolCall({
       toolCallId: request.id,
       // A skip is not an answer. Both leave the agent holding the same values, but only one of them
       // is evidence the user chose them, and a reader auditing what the agent was told has to be
       // able to tell those apart.
-      status: result.skipped ? "rejected" : "executed",
-      output: result,
-      ...result.skipped ? {
+      status: result2.skipped ? "rejected" : "executed",
+      output: result2,
+      ...result2.skipped ? {
         error: "skipped by the user"
       } : {},
       ...reply.answeredByRef !== void 0 ? {
@@ -3902,13 +5272,13 @@ async function runIntake(intake, deps, input, hooks, writer, threadHasAssistant)
       {
         id: request.id,
         name: ASK_TOOL_NAME,
-        output: result
+        output: result2
       }
     ]);
     await writer.write(encodeStreamEvent({
       kind: "tool-output",
       id: request.id,
-      output: result
+      output: result2
     }));
   });
   return {
@@ -3921,7 +5291,7 @@ async function runIntake(intake, deps, input, hooks, writer, threadHasAssistant)
       {
         id: request.id,
         name: ASK_TOOL_NAME,
-        output: result
+        output: result2
       }
     ]
   };
@@ -3967,16 +5337,140 @@ async function claimToolCall(turn, call) {
     const spec = deps.registry.spec(call.name);
     const kind = call.kind ?? declaredKind(deps, call.name);
     const awaitsHuman = kind === "action" || kind === "ask";
-    const approval = kind === "action" ? await claimApproval(turn, call, spec) : void 0;
-    const parks = kind === "ask" || approval?.mode === "ask";
+    const independentApproval = turn.actionApprovalMode === "independent" && kind === "action" ? hooks.dispatchLlm !== void 0 && call.actionApproval !== void 0 ? call.actionApproval : await resolveActionProposalApproval({
+      actor: input.actor,
+      store: deps.store,
+      tool: {
+        name: call.name,
+        kind: "action",
+        ...spec !== void 0 ? {
+          spec
+        } : {}
+      },
+      thread: {
+        threadId: input.threadId,
+        runId: hooks.runId,
+        ...input.agentName !== void 0 ? {
+          agentName: input.agentName
+        } : {}
+      },
+      ...deps.approvalPolicy !== void 0 ? {
+        policy: deps.approvalPolicy
+      } : {}
+    }) : void 0;
+    let preflight;
+    let prepared;
+    if (turn.actionApprovalMode === "independent" && call.prepared !== void 0 && hooks.dispatchLlm !== void 0) prepared = call.prepared;
+    if (kind === "action" && hooks.dispatchLlm !== void 0 && call.preflight !== void 0) {
+      preflight = call.preflight;
+    } else if (kind === "action" && hooks.dispatchLlm !== void 0 && spec === void 0) {
+      preflight = {
+        status: "ready"
+      };
+    } else if (kind === "action") {
+      try {
+        const allowedTools = turn.persona?.allowedTools === void 0 ? deps.toolAllowList : intersectAllowLists(deps.toolAllowList, turn.persona.allowedTools);
+        if (independentApproval?.mode === "ask") {
+          prepared = await prepareActionProposal(deps.registry, call.name, call.input, toolCallContext(toolContext(deps, input, hooks), call.id), deps.rolesPolicy, allowedTools === void 0 ? {} : {
+            allowedTools
+          });
+          preflight = prepared.preflight;
+        } else {
+          preflight = await deps.registry.prepare(call.name, call.input, toolCallContext(toolContext(deps, input, hooks), call.id), deps.rolesPolicy, allowedTools === void 0 ? {} : {
+            allowedTools
+          });
+        }
+      } catch (error) {
+        if (hooks.isControlFlowError?.(error) === true || isControlFlowSignal(error) || isReplayIntegrityError(error)) throw error;
+        preflight = {
+          status: "failed",
+          error: error instanceof Error ? error.message : String(error)
+        };
+      }
+    }
+    let confirmation = preflight?.status === "ready" ? preflight.confirmation : void 0;
+    const approval = kind === "action" && preflight?.status === "ready" ? independentApproval ?? await claimApproval(turn, call, spec) : void 0;
+    let proposalId;
+    if (turn.actionApprovalMode === "independent" && approval?.mode === "ask") {
+      if (!prepared) throw new Error("Independent action lacks trusted prepared input");
+      const proposalStore = deps.store;
+      if (typeof proposalStore.createActionProposal !== "function") throw new Error("Independent action proposal store unavailable");
+      proposalId = `proposal-${(0, import_node_crypto.createHash)("sha256").update(JSON.stringify([
+        hooks.runId,
+        call.id
+      ])).digest("hex")}`;
+      const display = confirmation ?? spec?.presentation?.confirm ?? {
+        title: `Allow ${call.name}?`,
+        verb: "Approve"
+      };
+      const fill = /* @__PURE__ */ __name((value) => value.replace(/\{([^}]+)\}/g, (_match, path) => {
+        let current = prepared?.input;
+        for (const part of path.split(".")) current = current !== null && typeof current === "object" ? current[part] : void 0;
+        return current === void 0 ? "" : String(current);
+      }), "fill");
+      const create = prepared.replacementKey === void 0 ? proposalStore.createActionProposal.bind(proposalStore) : (() => {
+        const store = proposalStore;
+        if (typeof store.createReplacingActionProposal !== "function") throw new Error("Independent replacement requires atomic supersession store");
+        return store.createReplacingActionProposal.bind(store);
+      })();
+      const created = await create({
+        ...prepared.replacementKey !== void 0 ? {
+          replacementKey: prepared.replacementKey
+        } : {},
+        id: proposalId,
+        tenantRef: input.actor.tenantRef ?? null,
+        actorRef: input.actor.id,
+        threadId: input.threadId,
+        originRunId: hooks.runId,
+        originMessageId: messageId,
+        originToolCallId: call.id,
+        toolName: call.name,
+        input: prepared.input,
+        preparationInput: prepared.preparationInput,
+        executionContext: {
+          requestId: hooks.runId,
+          ...input.agentName !== void 0 ? {
+            agentName: input.agentName
+          } : {},
+          ...input.persona !== void 0 ? {
+            persona: input.persona
+          } : {},
+          ...input.pageContext !== void 0 ? {
+            pageContext: input.pageContext
+          } : {},
+          ...input.uiCapabilities !== void 0 ? {
+            uiCapabilities: input.uiCapabilities
+          } : {}
+        },
+        confirmation: confirmation ?? {
+          title: fill(display.title),
+          verb: fill(display.verb),
+          ...display.detail !== void 0 ? {
+            detail: fill(display.detail)
+          } : {}
+        },
+        approver: approval.approver,
+        expiresAt: approval.expiresAt === void 0 ? null : Date.parse(approval.expiresAt),
+        idempotencyKey: toolCallContext(toolContext(deps, input, hooks), call.id).idempotencyKey
+      });
+      if (created.status === "conflict") throw new Error("Action proposal replay payload conflict");
+      confirmation = created.proposal?.confirmation ?? confirmation;
+    }
+    const parks = kind === "ask" || approval?.mode === "ask" && proposalId === void 0;
     await deps.store.recordToolCall({
       toolCallId: call.id,
       messageId,
       toolName: call.name,
       toolType: awaitsHuman ? "action" : "read",
       input: call.input,
-      status: parks ? "pending_approval" : "auto_executed",
+      status: proposalId !== void 0 ? "proposed" : parks ? "pending_approval" : "auto_executed",
+      ...proposalId !== void 0 ? {
+        proposalId
+      } : {},
       runId: hooks.runId,
+      ...confirmation !== void 0 ? {
+        confirmation
+      } : {},
       ...approval !== void 0 && approval.mode !== "auto" ? {
         approver: approval.approver
       } : {},
@@ -3988,7 +5482,16 @@ async function claimToolCall(turn, call) {
       await turn.writer.write(encodeStreamEvent({
         kind: "approval-requested",
         id: call.id,
+        ...proposalId !== void 0 ? {
+          target: {
+            kind: "proposal",
+            proposalId
+          }
+        } : {},
         approver: approval.approver,
+        ...confirmation !== void 0 ? {
+          confirmation
+        } : {},
         ...approval.expiresAt !== void 0 ? {
           expiresAt: approval.expiresAt
         } : {}
@@ -4011,6 +5514,12 @@ async function claimToolCall(turn, call) {
       } : {},
       ...approval !== void 0 ? {
         approval
+      } : {},
+      ...preflight !== void 0 ? {
+        preflight
+      } : {},
+      ...proposalId !== void 0 ? {
+        proposalId
       } : {}
     };
   });
@@ -4036,6 +5545,12 @@ async function claimToolCall(turn, call) {
     ...toolType === "action" && persisted?.approval !== void 0 ? {
       approval: persisted.approval
     } : {},
+    ...persisted?.preflight !== void 0 ? {
+      preflight: persisted.preflight
+    } : {},
+    ...persisted?.proposalId !== void 0 ? {
+      proposalId: persisted.proposalId
+    } : {},
     ctx: toolContext(deps, input, hooks)
   };
 }
@@ -4183,6 +5698,9 @@ function skillContext(input) {
     } : {},
     ...input.pageContext !== void 0 ? {
       pageContext: input.pageContext
+    } : {},
+    ...input.uiCapabilities !== void 0 ? {
+      uiCapabilities: input.uiCapabilities
     } : {}
   };
 }
@@ -4199,7 +5717,7 @@ async function invokeClaimedTool(turn, claimed) {
     if (claimed.toolType === "memory") {
       return await rememberIntoTurn(turn, claimed, startedAt);
     }
-    const invokeAllowList = turn.persona?.allowedTools === void 0 ? void 0 : intersectAllowLists(deps.toolAllowList, turn.persona.allowedTools);
+    const invokeAllowList = turn.persona?.allowedTools === void 0 ? deps.toolAllowList : intersectAllowLists(deps.toolAllowList, turn.persona.allowedTools);
     let raw;
     if (hooks.dispatchTool) {
       const stepCtx = {
@@ -4215,6 +5733,9 @@ async function invokeClaimedTool(turn, claimed) {
         } : {},
         ...input.pageContext !== void 0 ? {
           pageContext: input.pageContext
+        } : {},
+        ...input.uiCapabilities !== void 0 ? {
+          uiCapabilities: input.uiCapabilities
         } : {}
       };
       const envelope = {
@@ -4236,37 +5757,49 @@ async function invokeClaimedTool(turn, claimed) {
       raw = await hooks.dispatchTool(resolvedCall, envelope);
     } else {
       const invocation = hooks.step(`tool:${call.id}`, async () => {
-        const ui2 = createUiCollector(call.id, (event) => turn.writer.write(encodeStreamEvent(event)));
-        const output2 = await traceToolExecution(hooks.runId, {
-          toolCallId: call.id,
-          toolName: call.name,
-          toolType
-        }, () => invokeWithTransientRetry(() => {
-          ui2.restart();
-          return deps.registry.invoke(call.name, call.input, {
-            ...toolCallContext(ctx, call.id),
-            emitUi: ui2.emit
-          }, deps.rolesPolicy, invokeAllowList !== void 0 ? {
-            allowedTools: invokeAllowList
-          } : {});
-        }, deps.toolTransientRetry ?? {}, {
-          ...hooks.isControlFlowError !== void 0 ? {
-            isControlFlowError: hooks.isControlFlowError
-          } : {},
-          onRetry: /* @__PURE__ */ __name((attempt, retryError) => {
-            publishAgentToolRetry({
-              toolName: call.name,
-              toolCallId: call.id,
-              attempt,
-              message: retryError instanceof Error ? retryError.message : String(retryError)
-            });
-          }, "onRetry")
-        }));
-        return wrapToolStepOutput(output2, ui2.components());
+        const ui2 = createNegotiatedUiCollector(call.id, ctx, deps.resolveUiCatalog, (event) => turn.writer.write(encodeStreamEvent(event)));
+        let output2;
+        try {
+          output2 = await traceToolExecution(hooks.runId, {
+            toolCallId: call.id,
+            toolName: call.name,
+            toolType
+          }, () => invokeWithTransientRetry(() => {
+            ui2.restart();
+            return deps.registry.invoke(call.name, call.input, {
+              ...toolCallContext(ctx, call.id),
+              emitUi: ui2.emit
+            }, deps.rolesPolicy, invokeAllowList !== void 0 ? {
+              allowedTools: invokeAllowList
+            } : {});
+          }, deps.toolTransientRetry ?? {}, {
+            ...hooks.isControlFlowError !== void 0 ? {
+              isControlFlowError: hooks.isControlFlowError
+            } : {},
+            onRetry: /* @__PURE__ */ __name((attempt, retryError) => {
+              publishAgentToolRetry({
+                toolName: call.name,
+                toolCallId: call.id,
+                attempt,
+                message: retryError instanceof Error ? retryError.message : String(retryError)
+              });
+            }, "onRetry")
+          }));
+        } catch (error) {
+          if (error instanceof Error && error.name === "ToolPreflightDeniedError") return wrapToolPreflightDenied(error.message);
+          throw error;
+        }
+        return wrapToolStepOutput(output2, ui2.components(), ui2.text());
       });
       raw = deps.toolTimeoutMs !== void 0 ? await withToolTimeout(invocation, deps.toolTimeoutMs, call.name) : await invocation;
     }
-    const { output, ui } = unwrapToolStepOutput(raw);
+    const { output, ui, preflightDenied, text } = unwrapToolStepOutput(raw);
+    if (text) turn.toolText.set(call.id, text);
+    if (preflightDenied !== void 0) return {
+      status: "denied",
+      reason: preflightDenied,
+      executionMs: Date.now() - startedAt
+    };
     if (ui.length > 0) {
       turn.toolUi.set(call.id, ui);
     }
@@ -4282,6 +5815,13 @@ async function invokeClaimedTool(turn, claimed) {
     if (hooks.isControlFlowError?.(error) === true || isControlFlowSignal(error) || isReplayIntegrityError(error)) {
       throw error;
     }
+    if (error instanceof Error && error.name === "ToolPreflightDeniedError") {
+      return {
+        status: "denied",
+        reason: error.message,
+        executionMs: Date.now() - startedAt
+      };
+    }
     return {
       status: "failed",
       error: error instanceof Error ? error.message : String(error),
@@ -4323,6 +5863,27 @@ async function recordToolOutcome(turn, claimed, outcome, deciderRef, meta) {
       } : {}
     }));
   }, "settle");
+  if (outcome.status === "denied") {
+    await hooks.step(`persist:toolreject:${call.id}`, async () => {
+      await deps.store.updateToolCall({
+        toolCallId: call.id,
+        status: meta === void 0 ? "rejected" : "failed",
+        error: outcome.reason,
+        ...decided
+      });
+      await settle();
+    });
+    return {
+      id: call.id,
+      name: call.name,
+      output: {
+        rejected: true,
+        reason: outcome.reason
+      },
+      denied: true,
+      error: `This action was denied by its preflight check: ${outcome.reason}. The requested mutation did not run.`
+    };
+  }
   if (outcome.status === "failed") {
     await hooks.step(`persist:toolfail:${call.id}`, async () => {
       await deps.store.updateToolCall({
@@ -4463,12 +6024,12 @@ async function elicitToolCall(turn, claimed) {
     }));
   });
   const reply = await awaitElicitation(hooks, request, ctx);
-  const result = settleElicitation(request, reply);
-  await hooks.step(result.skipped ? `persist:toolreject:${call.id}` : `persist:toolexec:${call.id}`, () => deps.store.updateToolCall({
+  const result2 = settleElicitation(request, reply);
+  await hooks.step(result2.skipped ? `persist:toolreject:${call.id}` : `persist:toolexec:${call.id}`, () => deps.store.updateToolCall({
     toolCallId: call.id,
-    status: result.skipped ? "rejected" : "executed",
-    output: result,
-    ...result.skipped ? {
+    status: result2.skipped ? "rejected" : "executed",
+    output: result2,
+    ...result2.skipped ? {
       error: "skipped by the user"
     } : {},
     ...reply.answeredByRef !== void 0 ? {
@@ -4479,24 +6040,50 @@ async function elicitToolCall(turn, claimed) {
     runId: hooks.runId,
     toolName: call.name,
     toolType: "action",
-    status: result.skipped ? "rejected" : "executed"
+    status: result2.skipped ? "rejected" : "executed"
   });
   return {
     id: call.id,
     name: call.name,
-    output: result
+    output: result2
   };
 }
 __name(elicitToolCall, "elicitToolCall");
 async function runClaimedToolCall(turn, claimed) {
   const { deps, input, hooks } = turn;
   const { call, toolType, ctx } = claimed;
+  if (claimed.proposalId !== void 0) {
+    turn.halt.independentProposal = true;
+    return {
+      id: call.id,
+      name: call.name,
+      output: actionProposalReceipt(claimed.proposalId)
+    };
+  }
   if (toolType === "agent") {
     return delegateToolCall(turn, claimed);
   }
   if (toolType === "ask") {
     return elicitToolCall(turn, claimed);
   }
+  if (claimed.preflight !== void 0 && claimed.preflight.status !== "ready") {
+    const result2 = claimed.preflight;
+    if (result2.status === "completed" && claimed.terminal === true) turn.halt.terminal = true;
+    const outcome = result2.status === "completed" ? {
+      status: "executed",
+      output: result2.output,
+      executionMs: 0
+    } : result2.status === "denied" ? {
+      status: "denied",
+      reason: result2.reason,
+      executionMs: 0
+    } : {
+      status: "failed",
+      error: result2.error,
+      executionMs: 0
+    };
+    return recordToolOutcome(turn, claimed, outcome, input.actor.id);
+  }
   let deciderRef = input.actor.id;
   let meta;
   if (toolType === "action" && claimed.approval?.mode === "remembered") {
@@ -4621,30 +6208,30 @@ function expiryNarrative() {
   return "This action needed approval, and the approval request expired before anyone decided. Nothing ran and nothing changed. Do not run it again on your own; tell the person it was not approved in time and ask whether they still want it.";
 }
 __name(expiryNarrative, "expiryNarrative");
-function outputFrame(result) {
-  if (result.denied === true) {
-    const reason = refusalReason(result);
+function outputFrame(result2) {
+  if (result2.denied === true) {
+    const reason = refusalReason(result2);
     return {
       kind: "tool-output-denied",
-      id: result.id,
+      id: result2.id,
       ...reason !== void 0 ? {
         reason
       } : {}
     };
   }
-  return result.error !== void 0 ? {
+  return result2.error !== void 0 ? {
     kind: "tool-output-error",
-    id: result.id,
-    error: result.error
+    id: result2.id,
+    error: result2.error
   } : {
     kind: "tool-output",
-    id: result.id,
-    output: result.output
+    id: result2.id,
+    output: result2.output
   };
 }
 __name(outputFrame, "outputFrame");
-function refusalReason(result) {
-  const { output } = result;
+function refusalReason(result2) {
+  const { output } = result2;
   if (output !== null && typeof output === "object" && "reason" in output) {
     const reason = output.reason;
     return typeof reason === "string" && reason !== DEFAULT_REFUSAL_REASON ? reason : void 0;
@@ -4884,6 +6471,25 @@ ${block}`;
         messages: prompt.messages,
         actor: input.actor,
         threadId: input.threadId,
+        actionApprovalMode: history.actionApprovalMode ?? "blocking",
+        preflightContext: {
+          actor: input.actor,
+          threadId: input.threadId,
+          runId: hooks.runId,
+          requestId: hooks.runId,
+          ...input.agentName !== void 0 ? {
+            agentName: input.agentName
+          } : {},
+          ...input.persona !== void 0 ? {
+            persona: input.persona
+          } : {},
+          ...input.pageContext !== void 0 ? {
+            pageContext: input.pageContext
+          } : {},
+          ...input.uiCapabilities !== void 0 ? {
+            uiCapabilities: input.uiCapabilities
+          } : {}
+        },
         ...gated ? {
           bufferOutput: true
         } : {},
@@ -4900,6 +6506,9 @@ ${block}`;
           tools: withAskTool({
             tools: await deps.registry.definitionsFor(input.actor, deps.rolesPolicy, intersectAllowLists(deps.toolAllowList, persona?.allowedTools), {
               threadId: input.threadId,
+              ...input.uiCapabilities !== void 0 ? {
+                uiCapabilities: input.uiCapabilities
+              } : {},
               ...input.agentName !== void 0 ? {
                 agentName: input.agentName
               } : {}
@@ -4919,7 +6528,7 @@ ${block}`;
         }) : void 0;
         const buffer = gateMode === "whole" ? createFrameBuffer() : void 0;
         const frames = observeTurnFrames(incremental?.writer ?? buffer?.writer ?? writer);
-        const result = stampToolKinds(withTurnFrames(await traceLlmTurn(hooks.runId, i, () => deps.model.runTurn({
+        const result2 = stampToolKinds(withTurnFrames(await traceLlmTurn(hooks.runId, i, () => deps.model.runTurn({
           system: prompt.system,
           messages: prompt.messages,
           tools,
@@ -4929,15 +6538,15 @@ ${block}`;
           await incremental.settled();
           const refusal = incremental.rejection();
           return {
-            ...result,
+            ...result2,
             releasedText: incremental.released(),
             ...refusal !== void 0 ? {
               gateRejection: refusal
             } : {}
           };
         }
-        return buffer === void 0 ? result : {
-          ...result,
+        return buffer === void 0 ? result2 : {
+          ...result2,
           bufferedFrames: buffer.frames()
         };
       });
@@ -5031,12 +6640,12 @@ ${block}`;
           role: "assistant",
           content: turn.text
         }
-      ], count), (result) => ({
-        followUps: result.followUps.length,
-        inputTokens: result.usage.inputTokens,
-        outputTokens: result.usage.outputTokens,
-        ...result.modelId !== void 0 ? {
-          modelId: result.modelId
+      ], count), (result2) => ({
+        followUps: result2.followUps.length,
+        inputTokens: result2.usage.inputTokens,
+        outputTokens: result2.usage.outputTokens,
+        ...result2.modelId !== void 0 ? {
+          modelId: result2.modelId
         } : {}
       })));
       let suggestions = generated.followUps;
@@ -5147,7 +6756,7 @@ ${block}`;
     };
     modelMessages.push(assistantMessage);
     for (const entry of synthetic) {
-      const { call, result } = entry;
+      const { call, result: result2 } = entry;
       await hooks.step(`${entry.step}:${assistant.id}`, async () => {
         await deps.store.recordToolCall({
           toolCallId: call.id,
@@ -5161,7 +6770,7 @@ ${block}`;
         await deps.store.updateToolCall({
           toolCallId: call.id,
           status: "executed",
-          output: result.output
+          output: result2.output
         });
         await writer.write(encodeStreamEvent({
           kind: "tool-input-available",
@@ -5173,7 +6782,7 @@ ${block}`;
         await writer.write(encodeStreamEvent({
           kind: "tool-output",
           id: call.id,
-          output: result.output
+          output: result2.output
         }));
       });
     }
@@ -5202,9 +6811,11 @@ ${block}`;
       messageId: assistant.id,
       writer,
       toolUi: /* @__PURE__ */ new Map(),
+      toolText: /* @__PURE__ */ new Map(),
       halt: {
         terminal: false
       },
+      actionApprovalMode: history.actionApprovalMode ?? "blocking",
       ...skillOffer !== void 0 ? {
         skills: skillOffer
       } : {},
@@ -5237,17 +6848,35 @@ ${block}`;
       ...results,
       ...syntheticResults
     ];
+    const toolText = escapeUnsafeToolUiText(toolCallsWithKind.map((call) => turnCalls.toolText.get(call.id)).filter((text) => text !== void 0).join("\n"));
     assistantMessage.toolResults = settledResults;
     await hooks.step(`stream:tool-outputs:${i}`, async () => {
       await deps.store.setMessageToolResults(assistant.id, settledResults);
+      if (toolText) await deps.store.appendMessage({
+        threadId: input.threadId,
+        role: "assistant",
+        content: toolText,
+        runId: hooks.runId,
+        ...input.agentName !== void 0 ? {
+          agentName: input.agentName
+        } : {}
+      });
       const toolUi = toolCallsWithKind.flatMap((call) => turnCalls.toolUi.get(call.id) ?? []);
       if (toolUi.length > 0) {
         await deps.store.setMessageUi?.(assistant.id, mergeUi(turn.ui, toolUi));
       }
-      for (const result of results) {
-        await writer.write(encodeStreamEvent(outputFrame(result)));
+      for (const result2 of results) {
+        await writer.write(encodeStreamEvent(outputFrame(result2)));
       }
     });
+    if (toolText) {
+      modelMessages.push({
+        role: "assistant",
+        content: toolText
+      });
+      lastText += `
+${toolText}`;
+    }
     await hooks.step(`stream:step-finish:${i}`, async () => {
       await writer.write(encodeStreamEvent({
         kind: "step-finish",
@@ -5261,7 +6890,7 @@ ${block}`;
         } : {}
       }));
     });
-    if (turnCalls.halt.terminal) {
+    if (turnCalls.halt.terminal || turnCalls.halt.independentProposal) {
       break;
     }
   }
@@ -5317,8 +6946,152 @@ ${block}`;
 }
 __name(runAgentLoop, "runAgentLoop");
 
+// src/in-memory-action-proposal-store.ts
+var import_node_crypto2 = require("crypto");
+var InMemoryActionProposalStore = class {
+  static {
+    __name(this, "InMemoryActionProposalStore");
+  }
+  rows = /* @__PURE__ */ new Map();
+  clock;
+  constructor(options = {}) {
+    this.clock = options.clock ?? Date.now;
+  }
+  async createActionProposal(input) {
+    validateActionProposalCreation(input);
+    const row = this.rows.get(input.id);
+    if (row) {
+      if (!actionProposalScopeMatches(row, input)) return {
+        status: "conflict"
+      };
+      return {
+        status: actionProposalCreationMatches(row, input) ? "unchanged" : "conflict",
+        proposal: snapshotActionProposal(row)
+      };
+    }
+    const proposal = initialActionProposal(input, this.clock());
+    this.rows.set(input.id, proposal);
+    return {
+      status: "created",
+      proposal: snapshotActionProposal(proposal)
+    };
+  }
+  async getActionProposal(scope, id) {
+    const row = this.rows.get(id);
+    return row && actionProposalScopeMatches(row, scope) ? snapshotActionProposal(row) : null;
+  }
+  async listActionProposals(scope, query = {}) {
+    const limit = validateActionProposalListQuery(query);
+    return [
+      ...this.rows.values()
+    ].filter((row) => actionProposalScopeMatches(row, scope) && (query.decision === void 0 || row.decision === query.decision) && (query.after === void 0 || row.createdAt > query.after.createdAt || row.createdAt === query.after.createdAt && row.id > query.after.id)).sort((a, b) => a.createdAt - b.createdAt || (a.id < b.id ? -1 : a.id > b.id ? 1 : 0)).slice(0, limit).map(snapshotActionProposal);
+  }
+  mutate(scope, id, transition) {
+    const row = this.rows.get(id);
+    if (!row || !actionProposalScopeMatches(row, scope)) return {
+      status: "not_found"
+    };
+    const result2 = transition(row, this.clock());
+    if (result2.proposal) this.rows.set(id, snapshotActionProposal(result2.proposal));
+    return result2;
+  }
+  async decideActionProposal(scope, id, command) {
+    return this.mutate(scope, id, (row, now) => transitionActionProposalDecision(row, command, now));
+  }
+  async claimActionProposal(scope, id, command) {
+    return this.mutate(scope, id, (row, now) => transitionActionProposalClaim(row, command, now, (0, import_node_crypto2.randomUUID)()));
+  }
+  async extendActionProposalLease(scope, id, command) {
+    return this.mutate(scope, id, (row, now) => transitionActionProposalLease(row, command, now));
+  }
+  async settleActionProposal(scope, id, command) {
+    return this.mutate(scope, id, (row, now) => transitionActionProposalSettlement(row, command, now));
+  }
+  async claimNextActionProposal(command) {
+    const now = this.clock();
+    validateActionProposalWorkerClaim(command, now);
+    const candidates = [
+      ...this.rows.values()
+    ].filter((row) => row.decision === "approved" && (row.execution?.status === "queued" || row.execution?.status === "executing" && row.execution.lease !== null && now >= row.execution.lease.expiresAt)).sort((a, b) => a.createdAt - b.createdAt || (a.id < b.id ? -1 : a.id > b.id ? 1 : 0)).slice(0, 32);
+    for (const candidate of candidates) {
+      const claimed = await this.claimActionProposal(candidate, candidate.id, command);
+      if (claimed.status === "applied" && claimed.proposal) return claimed.proposal;
+    }
+    return null;
+  }
+  async expireActionProposals(command) {
+    const now = this.clock();
+    validateActionProposalExpiryBatch(command, now);
+    const candidates = [
+      ...this.rows.values()
+    ].filter((row) => row.decision === "pending" && row.expiresAt !== null && now >= row.expiresAt).sort((a, b) => a.createdAt - b.createdAt || (a.id < b.id ? -1 : a.id > b.id ? 1 : 0)).slice(0, command.limit);
+    let expired = 0;
+    for (const candidate of candidates) {
+      const result2 = await this.decideActionProposal(candidate, candidate.id, {
+        decision: "expired",
+        actorRef: "system",
+        via: "expiry"
+      });
+      if (result2.status === "applied") expired++;
+    }
+    return expired;
+  }
+  async claimNextActionProposalOutcome(command) {
+    const now = this.clock();
+    validateActionProposalWorkerClaim(command, now);
+    const candidates = [
+      ...this.rows.values()
+    ].filter((row) => row.outcomeDelivery?.status === "pending" && (!row.outcomeDelivery.lease || now >= row.outcomeDelivery.lease.expiresAt)).sort((a, b) => a.createdAt - b.createdAt || (a.id < b.id ? -1 : a.id > b.id ? 1 : 0)).slice(0, 32);
+    for (const candidate of candidates) {
+      const row = this.rows.get(candidate.id);
+      if (!row) continue;
+      const next = claimActionProposalOutcome(row, command, this.clock(), (0, import_node_crypto2.randomUUID)());
+      if (!next?.outcome || !next.outcomeDelivery?.lease) continue;
+      this.rows.set(next.id, next);
+      return {
+        outcome: snapshotActionProposal(next.outcome),
+        lease: {
+          outcomeId: next.outcome.id,
+          token: next.outcomeDelivery.lease.token,
+          generation: next.outcomeDelivery.generation
+        }
+      };
+    }
+    return null;
+  }
+  async createReplacingActionProposal(input) {
+    validateActionProposalCreation(input);
+    const existing = this.rows.get(input.id);
+    if (existing) return this.createActionProposal(input);
+    const proposal = initialActionProposal(input, this.clock());
+    const replacements = [];
+    if (input.replacementKey) for (const row of this.rows.values()) {
+      if (row.decision !== "pending" || !actionProposalScopeMatches(row, input) || row.toolName !== input.toolName || row.replacementKey !== input.replacementKey) continue;
+      const result2 = transitionActionProposalSupersession(row, proposal, {
+        replacementProposalId: proposal.id,
+        actorRef: input.actorRef,
+        via: "supersession"
+      }, this.clock());
+      if (result2.proposal) replacements.push(result2.proposal);
+    }
+    this.rows.set(proposal.id, proposal);
+    for (const row of replacements) this.rows.set(row.id, row);
+    return {
+      status: "created",
+      proposal: snapshotActionProposal(proposal)
+    };
+  }
+  async supersedeActionProposal(scope, id, command) {
+    const replacement = this.rows.get(command.replacementProposalId);
+    if (!replacement || !actionProposalScopeMatches(replacement, scope)) return {
+      status: "not_found"
+    };
+    return this.mutate(scope, id, (row, now) => transitionActionProposalSupersession(row, replacement, command, now));
+  }
+};
+
 // src/in-memory-store.ts
-var InMemoryAgentStore = class {
+var InMemoryAgentStore = class extends InMemoryActionProposalStore {
   static {
     __name(this, "InMemoryAgentStore");
   }
@@ -5341,6 +7114,7 @@ var InMemoryAgentStore = class {
     const row = {
       id,
       actorRef: input.actor.id,
+      tenantRef: input.actor.tenantRef ?? null,
       title: input.title ?? "New chat",
       transient: input.transient ?? false,
       createdAt: ts,
@@ -5376,8 +7150,12 @@ var InMemoryAgentStore = class {
       }
       const approval = toolCallApprovalFromRow({
         toolCallId: call.toolCallId,
+        ...call.proposalId !== void 0 ? {
+          proposalId: call.proposalId
+        } : {},
         status: call.status,
         approver: call.approver,
+        confirmation: call.confirmation,
         expiresAt: call.expiresAt,
         remember: call.remember,
         executedByRef: call.executedByRef,
@@ -5400,6 +7178,10 @@ var InMemoryAgentStore = class {
         names.add(call.toolName);
       }
     }
+    const thread = this.threads.get(threadId);
+    if (thread) {
+      for (const proposal of this.rows.values()) if (proposal.threadId === threadId && proposal.actorRef === thread.actorRef && proposal.tenantRef === thread.tenantRef && proposal.decisionAudit?.remember === true && (proposal.execution?.status === "succeeded" || proposal.execution?.status === "failed")) names.add(proposal.toolName);
+    }
     return [
       ...names
     ];
@@ -5440,6 +7222,7 @@ var InMemoryAgentStore = class {
     const row = {
       id,
       actorRef: source.actorRef,
+      tenantRef: source.tenantRef,
       title: source.title,
       transient: false,
       createdAt: ts,
@@ -5640,6 +7423,9 @@ var InMemoryAgentStore = class {
       ...input.pageContext !== void 0 ? {
         pageContext: input.pageContext
       } : {},
+      ...input.uiCapabilities !== void 0 ? {
+        uiCapabilities: input.uiCapabilities
+      } : {},
       ...input.interrupt === true ? {
         interrupt: true
       } : {},
@@ -5744,6 +7530,78 @@ var InMemoryAgentStore = class {
     }
     return void 0;
   }
+  async getThreadActionProposalScope(threadId) {
+    const row = this.threads.get(threadId);
+    return row ? {
+      threadId,
+      actorRef: row.actorRef,
+      tenantRef: row.tenantRef
+    } : null;
+  }
+  async admitActionProposalOutcome(command) {
+    const row = [
+      ...this.rows.values()
+    ].find((row2) => row2.outcome?.id === command.outcomeId);
+    if (!row?.outcome || !row.outcomeDelivery) return {
+      status: "not_found"
+    };
+    if (row.outcomeDelivery.status === "admitted") return {
+      status: "unchanged",
+      ...row.outcomeDelivery.messageId !== void 0 ? {
+        messageId: row.outcomeDelivery.messageId
+      } : {}
+    };
+    if (row.outcomeDelivery.status === "discarded") return {
+      status: "discarded"
+    };
+    if (!actionProposalOutcomeFenceValid(row, command, this.clock())) return {
+      status: "conflict"
+    };
+    const thread = this.threads.get(row.threadId);
+    if (!thread) {
+      this.rows.set(row.id, snapshotActionProposal({
+        ...row,
+        outcomeDelivery: {
+          ...row.outcomeDelivery,
+          status: "discarded",
+          lease: null
+        }
+      }));
+      return {
+        status: "discarded"
+      };
+    }
+    if (thread.actorRef !== row.actorRef || thread.tenantRef !== row.tenantRef) return {
+      status: "conflict"
+    };
+    if (thread.activeStreamId) return {
+      status: "busy"
+    };
+    const message = {
+      id: crypto.randomUUID(),
+      role: "assistant",
+      content: actionProposalOutcomeText(row.outcome),
+      createdAt: this.now(),
+      actionProposalOutcome: snapshotActionProposal(row.outcome),
+      ui: snapshotActionProposal(row.outcome.ui)
+    };
+    const next = snapshotActionProposal({
+      ...row,
+      outcomeDelivery: {
+        ...row.outcomeDelivery,
+        status: "admitted",
+        lease: null,
+        messageId: message.id
+      }
+    });
+    thread.messages.push(message);
+    thread.updatedAt = message.createdAt;
+    this.rows.set(row.id, next);
+    return {
+      status: "applied",
+      messageId: message.id
+    };
+  }
   async appendMessage(input) {
     const row = this.threads.get(input.threadId);
     if (row === void 0) {
@@ -5786,6 +7644,9 @@ var InMemoryAgentStore = class {
       } : {},
       ...input.ui !== void 0 ? {
         ui: input.ui
+      } : {},
+      ...input.actionProposalOutcome !== void 0 ? {
+        actionProposalOutcome: input.actionProposalOutcome
       } : {}
     };
     row.messages.push(message);
@@ -5877,6 +7738,9 @@ var InMemoryAgentStore = class {
   async recordToolCall(input) {
     this.toolCalls.set(input.toolCallId, {
       toolCallId: input.toolCallId,
+      ...input.proposalId !== void 0 ? {
+        proposalId: input.proposalId
+      } : {},
       messageId: input.messageId,
       threadId: this.threadIdForMessage(input.messageId) ?? "",
       toolName: input.toolName,
@@ -5890,6 +7754,9 @@ var InMemoryAgentStore = class {
       ...input.approver !== void 0 ? {
         approver: input.approver
       } : {},
+      ...input.confirmation !== void 0 ? {
+        confirmation: structuredClone(input.confirmation)
+      } : {},
       ...input.expiresAt !== void 0 ? {
         expiresAt: input.expiresAt
       } : {}
@@ -6198,7 +8065,7 @@ var InMemoryAgentStore = class {
 };
 
 // src/confirm-token.ts
-var import_node_crypto2 = require("crypto");
+var import_node_crypto3 = require("crypto");
 var DEFAULT_CONFIRM_TTL_MS = 15 * 60 * 1e3;
 function canonicalJson(value) {
   if (value === void 0) return "null";
@@ -6215,7 +8082,7 @@ function signature(subject, expiresAt, secret) {
   if (secret === "") {
     throw new Error("confirm token: the secret is empty");
   }
-  return (0, import_node_crypto2.createHmac)("sha256", secret).update(canonicalJson([
+  return (0, import_node_crypto3.createHmac)("sha256", secret).update(canonicalJson([
     "agent-confirm",
     subject.tool,
     subject.actorId,
@@ -6242,11 +8109,11 @@ function verifyConfirmToken(token, subject, options) {
   if (expiresAt === void 0 || expiresAt < (options.now ?? Date.now())) return false;
   const expected = Buffer.from(signature(subject, expiresAt, options.secret));
   const given = Buffer.from(token.slice(token.indexOf(".") + 1));
-  return expected.length === given.length && (0, import_node_crypto2.timingSafeEqual)(expected, given);
+  return expected.length === given.length && (0, import_node_crypto3.timingSafeEqual)(expected, given);
 }
 __name(verifyConfirmToken, "verifyConfirmToken");
 function hashConfirmToken(token) {
-  return (0, import_node_crypto2.createHash)("sha256").update(token).digest("hex");
+  return (0, import_node_crypto3.createHash)("sha256").update(token).digest("hex");
 }
 __name(hashConfirmToken, "hashConfirmToken");
 var InMemoryConfirmTokenStore = class {
@@ -6394,12 +8261,12 @@ function withConfirmFields(schema) {
           });
         }
         const { args, fields } = splitConfirm(value);
-        const result = await inner.validate(args);
-        if (result.issues !== void 0) {
+        const result2 = await inner.validate(args);
+        if (result2.issues !== void 0) {
           return {
             issues: [
               ...issues,
-              ...result.issues
+              ...result2.issues
             ]
           };
         }
@@ -6409,10 +8276,10 @@ function withConfirmFields(schema) {
           };
         }
         return {
-          value: isRecord(result.value) ? {
-            ...result.value,
+          value: isRecord(result2.value) ? {
+            ...result2.value,
             ...fields
-          } : result.value
+          } : result2.value
         };
       }, "validate"),
       jsonSchema: {
@@ -6744,6 +8611,309 @@ var SqlTokenStreamSink = class {
     });
   }
 };
+
+// src/action-proposal-text.ts
+function resolveTextActionProposalDecision(text, proposals) {
+  const command = parseTextActionProposalCommand(text);
+  if (command.status === "unmatched") return command;
+  const { decision, remember } = command;
+  const pending = proposals.filter((proposal) => proposal.decision === "pending");
+  const explicitId = command.proposalId;
+  if (explicitId !== void 0) {
+    if (!pending.some((proposal) => proposal.id === explicitId)) return {
+      status: "unmatched"
+    };
+    return {
+      status: "decision",
+      proposalId: explicitId,
+      decision,
+      remember
+    };
+  }
+  if (pending.length === 0) return {
+    status: "unmatched"
+  };
+  if (pending.length > 1) return {
+    status: "ambiguous",
+    proposalIds: pending.map(({ id }) => id)
+  };
+  const candidate = pending[0];
+  if (!candidate) return {
+    status: "unmatched"
+  };
+  return {
+    status: "decision",
+    proposalId: candidate.id,
+    decision,
+    remember
+  };
+}
+__name(resolveTextActionProposalDecision, "resolveTextActionProposalDecision");
+function parseTextActionProposalCommand(text) {
+  if (/[\r\n]/u.test(text)) return {
+    status: "unmatched"
+  };
+  const normalized = text.trim();
+  const match = /^(sim|confirmo|confirmar|aprovar|aprovo|cancelar|rejeitar|rejeito|não|nao)(?: (sempre nesta conversa))?(?: #([^\s]+?))?[.!]?$/iu.exec(normalized);
+  if (!match) return {
+    status: "unmatched"
+  };
+  const verb = match[1]?.toLocaleLowerCase("pt-BR");
+  if (verb === void 0) return {
+    status: "unmatched"
+  };
+  const decision = [
+    "cancelar",
+    "rejeitar",
+    "rejeito",
+    "n\xE3o",
+    "nao"
+  ].includes(verb) ? "rejected" : "approved";
+  const remember = match[2] !== void 0;
+  if (remember && decision !== "approved") return {
+    status: "unmatched"
+  };
+  return {
+    status: "command",
+    decision,
+    remember,
+    ...match[3] !== void 0 ? {
+      proposalId: match[3]
+    } : {}
+  };
+}
+__name(parseTextActionProposalCommand, "parseTextActionProposalCommand");
+
+// src/action-proposal-executor.ts
+var ActionProposalExecutor = class {
+  static {
+    __name(this, "ActionProposalExecutor");
+  }
+  options;
+  constructor(options) {
+    this.options = options;
+  }
+  async execute(proposal) {
+    let ui = createNegotiatedUiCollector(proposal.originToolCallId, {
+      actor: {
+        id: proposal.actorRef
+      },
+      threadId: proposal.threadId
+    });
+    try {
+      const actor = await this.options.resolver.resolve({
+        actorRef: proposal.actorRef,
+        tenantRef: proposal.tenantRef
+      });
+      if (!actor || actor.id !== proposal.actorRef || (actor.tenantRef ?? null) !== proposal.tenantRef) throw new Error("Action proposal requester no longer exists or scope changed");
+      const deps = await this.options.resolveExecution(proposal, actor);
+      if (deps.registry.spec(proposal.toolName)?.kind !== "action") throw new Error("Action proposal tool no longer exists as an action");
+      const context = proposal.executionContext;
+      ui = createNegotiatedUiCollector(proposal.originToolCallId, {
+        actor,
+        threadId: proposal.threadId,
+        ...context?.agentName !== void 0 ? {
+          agentName: context.agentName
+        } : {},
+        ...context?.uiCapabilities !== void 0 ? {
+          uiCapabilities: context.uiCapabilities
+        } : {}
+      }, deps.resolveUiCatalog);
+      const output = await deps.registry.invoke(proposal.toolName, snapshotActionProposal(Object.hasOwn(proposal, "preparationInput") ? proposal.preparationInput : proposal.input), {
+        actor,
+        threadId: proposal.threadId,
+        runId: proposal.originRunId,
+        requestId: context?.requestId ?? proposal.originRunId,
+        toolCallId: proposal.originToolCallId,
+        idempotencyKey: proposal.idempotencyKey,
+        ...context?.agentName !== void 0 ? {
+          agentName: context.agentName
+        } : {},
+        ...context?.persona !== void 0 ? {
+          persona: context.persona
+        } : {},
+        ...context?.pageContext !== void 0 ? {
+          pageContext: context.pageContext
+        } : {},
+        ...context?.uiCapabilities !== void 0 ? {
+          uiCapabilities: context.uiCapabilities
+        } : {},
+        ...deps.host !== void 0 ? {
+          host: deps.host
+        } : {},
+        emitUi: ui.emit
+      }, deps.rolesPolicy, {
+        approvedInput: proposal.input,
+        ...deps.allowedTools !== void 0 ? {
+          allowedTools: deps.allowedTools
+        } : {}
+      });
+      return snapshotActionProposal({
+        status: "succeeded",
+        ...output !== void 0 ? {
+          result: output
+        } : {},
+        ui: ui.components(),
+        ...ui.text() ? {
+          text: ui.text()
+        } : {}
+      });
+    } catch (error) {
+      return {
+        status: "failed",
+        error: error instanceof Error ? error.message : String(error),
+        ui: ui.components(),
+        ...ui.text() ? {
+          text: ui.text()
+        } : {}
+      };
+    }
+  }
+};
+
+// src/action-proposal-worker.ts
+var ActionProposalWorker = class {
+  static {
+    __name(this, "ActionProposalWorker");
+  }
+  options;
+  leaseMs;
+  pollIntervalMs;
+  maxConcurrency;
+  timer;
+  stopped = false;
+  renewals = /* @__PURE__ */ new Set();
+  active;
+  constructor(options) {
+    this.options = options;
+    this.leaseMs = options.leaseMs ?? 3e4;
+    this.pollIntervalMs = options.pollIntervalMs ?? 1e3;
+    this.maxConcurrency = options.maxConcurrency ?? 1;
+    for (const value of [
+      this.leaseMs,
+      this.pollIntervalMs,
+      this.maxConcurrency
+    ]) if (!Number.isSafeInteger(value) || value <= 0) throw new RangeError("Worker configuration must be positive safe integers");
+    if (this.pollIntervalMs >= this.leaseMs / 3) throw new RangeError("Worker poll interval must be below one third of lease");
+    if (!options.workerId) throw new TypeError("workerId is required");
+  }
+  start() {
+    if (this.timer !== void 0 || this.stopped) return;
+    const tick = /* @__PURE__ */ __name(async () => {
+      if (this.stopped) return;
+      try {
+        await this.runOnce();
+      } catch (error) {
+        this.options.onError?.(error);
+      }
+      if (!this.stopped) this.timer = setTimeout(tick, this.pollIntervalMs);
+    }, "tick");
+    this.timer = setTimeout(tick, 0);
+  }
+  async stop() {
+    this.stopped = true;
+    for (const timer of this.renewals) clearInterval(timer);
+    this.renewals.clear();
+    if (this.timer !== void 0) clearTimeout(this.timer);
+    await this.active;
+  }
+  runOnce() {
+    if (this.active) return this.active;
+    if (this.stopped) return Promise.resolve();
+    const task = this.tick();
+    this.active = task;
+    return task.finally(() => {
+      if (this.active === task) this.active = void 0;
+    });
+  }
+  async tick() {
+    await this.options.store.expireActionProposals({
+      limit: 100
+    });
+    const work = [];
+    for (let index = 0; index < this.maxConcurrency && !this.stopped; index++) {
+      const proposal = await this.options.store.claimNextActionProposal({
+        workerId: this.options.workerId,
+        leaseMs: this.leaseMs
+      });
+      if (!proposal) break;
+      work.push(this.execute(proposal));
+    }
+    await Promise.all(work);
+    for (let index = 0; index < 32 && !this.stopped; index++) {
+      const delivery = await this.options.store.claimNextActionProposalOutcome({
+        workerId: this.options.workerId,
+        leaseMs: this.leaseMs
+      });
+      if (!delivery) break;
+      await this.options.store.admitActionProposalOutcome(delivery.lease);
+    }
+  }
+  async execute(proposal) {
+    const lease = proposal.execution?.lease;
+    if (!lease) throw new Error("Claimed action lacks execution lease");
+    let fenced = true;
+    let renewing;
+    const renew = /* @__PURE__ */ __name(() => {
+      if (renewing || !fenced) return;
+      renewing = this.options.store.extendActionProposalLease(proposal, proposal.id, {
+        token: lease.token,
+        generation: lease.generation,
+        leaseMs: this.leaseMs
+      }).then((result2) => {
+        if (result2.status !== "applied") fenced = false;
+      }, (error) => {
+        fenced = false;
+        this.options.onError?.(error);
+      }).finally(() => {
+        renewing = void 0;
+      });
+    }, "renew");
+    const timer = setInterval(renew, this.leaseMs / 3);
+    this.renewals.add(timer);
+    try {
+      const result2 = await this.options.executor.execute(proposal);
+      clearInterval(timer);
+      await renewing;
+      if (!fenced) return;
+      const settled = await this.options.store.settleActionProposal(proposal, proposal.id, {
+        ...result2,
+        token: lease.token,
+        generation: lease.generation
+      });
+      if (settled.status === "applied" && settled.proposal) await this.options.onSettled?.(settled.proposal);
+    } finally {
+      clearInterval(timer);
+      this.renewals.delete(timer);
+      await renewing;
+    }
+  }
+};
+
+// src/action-proposal-capabilities.ts
+function assertIndependentActionCapabilities(store, resolver) {
+  const candidate = store;
+  if (!resolver || typeof resolver.resolve !== "function") throw new Error("Independent action mode requires a BackgroundActorResolver");
+  if (!isChatQueueStore(store) || candidate.actionProposalAdmissionSupported === false) throw new Error("Independent action mode requires transactional thread admission");
+  const required = [
+    "createActionProposal",
+    "getActionProposal",
+    "listActionProposals",
+    "decideActionProposal",
+    "claimActionProposal",
+    "extendActionProposalLease",
+    "settleActionProposal",
+    "claimNextActionProposal",
+    "expireActionProposals",
+    "getThreadActionProposalScope",
+    "claimNextActionProposalOutcome",
+    "admitActionProposalOutcome",
+    "createReplacingActionProposal",
+    "supersedeActionProposal"
+  ];
+  if (required.some((method) => typeof candidate[method] !== "function")) throw new Error("Independent action mode requires proposal, worker, outcome and admission capabilities on the conversation store");
+}
+__name(assertIndependentActionCapabilities, "assertIndependentActionCapabilities");
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   AGENT_ACTOR_DIRECTORY,
@@ -6778,6 +8948,8 @@ var SqlTokenStreamSink = class {
   APPROVAL_EXPIRED_REASON,
   ASK_TOOL_DESCRIPTION,
   ASK_TOOL_NAME,
+  ActionProposalExecutor,
+  ActionProposalWorker,
   AgentRegistry,
   AgentStreamError,
   CONFIRM_JSON_SCHEMA_PROPERTIES,
@@ -6798,6 +8970,7 @@ var SqlTokenStreamSink = class {
   DefaultRolesPolicy,
   ELICITATION_INPUT_TYPES,
   GLOBAL_SCOPE,
+  InMemoryActionProposalStore,
   InMemoryAgentStore,
   InMemoryConfirmTokenStore,
   MAX_ASK_QUESTIONS,
@@ -6821,15 +8994,25 @@ var SqlTokenStreamSink = class {
   THREAD_DETAIL_CONTENT_CHARS,
   ToolDisabledError,
   ToolForbiddenError,
+  ToolInputDriftError,
   ToolInputInvalidError,
   ToolNotFoundError,
+  ToolPreflightDeniedError,
   ToolRegistry,
   UNFINISHED_TOOL_CALL,
+  actionProposalCreationMatches,
+  actionProposalOutcomeFenceValid,
+  actionProposalOutcomeScope,
+  actionProposalOutcomeText,
+  actionProposalReceipt,
+  actionProposalScopeMatches,
   actorScope,
   agentDiagnosticKey,
   agentFailureCode,
   askInputSchema,
   askToolDefinition,
+  assertIndependentActionCapabilities,
+  attachActionProposalOutcome,
   bucketByActor,
   bucketByModel,
   bucketByThread,
@@ -6837,12 +9020,15 @@ var SqlTokenStreamSink = class {
   buildMemoryBlock,
   buildSkillsBlock,
   canActorUseTool,
+  canonicalActionProposalJson,
   canonicalJson,
+  claimActionProposalOutcome,
   closeEmptyRoles,
   compositeSkillProvider,
   confirmTokenExpiry,
   createFrameBuffer,
   createIncrementalGate,
+  createNegotiatedUiCollector,
   createNoopEmitUi,
   createUiCollector,
   danglingToolCallIds,
@@ -6855,6 +9041,7 @@ var SqlTokenStreamSink = class {
   detachedStarted,
   detachedUnsettled,
   encodeStreamEvent,
+  escapeUnsafeToolUiText,
   estimateCost,
   estimateMessageTokens,
   exhaustedWindow,
@@ -6869,6 +9056,7 @@ var SqlTokenStreamSink = class {
   gateFollowUps,
   gateTail,
   hashConfirmToken,
+  initialActionProposal,
   intersectAllowLists,
   invokeWithTransientRetry,
   isChatQueueStore,
@@ -6887,7 +9075,9 @@ var SqlTokenStreamSink = class {
   observeTurnFrames,
   offerMemories,
   offerSkills,
+  parseTextActionProposalCommand,
   personaCatalogEntry,
+  prepareActionProposal,
   publishAgentDelegated,
   publishAgentMemoryResolved,
   publishAgentMemoryWritten,
@@ -6913,12 +9103,14 @@ var SqlTokenStreamSink = class {
   rememberToolDefinition,
   renderElicitationAnswers,
   repairInstruction,
+  resolveActionProposalApproval,
   resolveElicitation,
   resolveGateLookback,
   resolveMemoryDigest,
   resolveOutputGateMode,
   resolvePersonaAlias,
   resolveSkillCatalog,
+  resolveTextActionProposalDecision,
   resolveToolTransientRetryNumbers,
   rollupThreadUsage,
   runAgentLoop,
@@ -6935,6 +9127,7 @@ var SqlTokenStreamSink = class {
   skillInputSchema,
   skillToolDefinition,
   skillWriteVerdict,
+  snapshotActionProposal,
   stampToolKinds,
   staticModelCatalog,
   staticSkillProvider,
@@ -6945,8 +9138,18 @@ var SqlTokenStreamSink = class {
   toolCallContext,
   traceLlmTurn,
   traceToolExecution,
+  transitionActionProposalClaim,
+  transitionActionProposalDecision,
+  transitionActionProposalLease,
+  transitionActionProposalSettlement,
+  transitionActionProposalSupersession,
   truncateDetailContent,
   unwrapToolStepOutput,
+  validateActionProposalCreation,
+  validateActionProposalDiscoveryIndexBatch,
+  validateActionProposalExpiryBatch,
+  validateActionProposalListQuery,
+  validateActionProposalWorkerClaim,
   validateElicitationAnswer,
   validateElicitationValue,
   validateStructured,
@@ -6959,6 +9162,7 @@ var SqlTokenStreamSink = class {
   withSkillTool,
   withToolTimeout,
   withTurnFrames,
+  wrapToolPreflightDenied,
   wrapToolStepOutput,
   writeMemory
 });