@dudousxd/nestjs-agent-core 0.39.0 → 0.41.0

package/dist/index.js

@@ -169,16 +169,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
     } : {}
   };
@@ -187,8 +187,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 = {
@@ -196,17 +197,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 {
@@ -255,6 +275,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);
@@ -289,6 +317,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 = "*";
@@ -496,31 +528,37 @@ async function mayDecideApproval(policy, actor, decision) {
   return defaultCanDecide(actor, decision);
 }
 __name(mayDecideApproval, "mayDecideApproval");
-function toolCallApprovalFromRow(row) {
-  if (row.approver === null || row.approver === void 0) {
+function toolCallApprovalFromRow(row2) {
+  if (row2.approver === null || row2.approver === void 0) {
     return null;
   }
-  const status = row.status === "pending_approval" ? "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 status = row2.status === "pending_approval" || row2.status === "proposed" ? "pending" : row2.status === "rejected" ? "rejected" : row2.status === "expired" ? "expired" : "approved";
+  const expiresAt = row2.expiresAt instanceof Date ? row2.expiresAt.toISOString() : typeof row2.expiresAt === "string" ? row2.expiresAt : void 0;
   const decided = status === "approved" || status === "rejected";
   return {
-    toolCallId: row.toolCallId,
-    approver: row.approver,
+    toolCallId: row2.toolCallId,
+    ...row2.proposalId != null ? {
+      proposalId: row2.proposalId
+    } : {},
+    approver: row2.approver,
+    ...row2.confirmation != null ? {
+      confirmation: row2.confirmation
+    } : {},
     status,
     ...expiresAt !== void 0 ? {
       expiresAt
     } : {},
-    ...row.remember === true ? {
+    ...row2.remember === true ? {
       remember: true
     } : {},
-    ...decided && typeof row.executedByRef === "string" ? {
-      decidedBy: row.executedByRef
+    ...decided && typeof row2.executedByRef === "string" ? {
+      decidedBy: row2.executedByRef
     } : {},
-    ...decided && typeof row.decidedVia === "string" ? {
-      decidedVia: row.decidedVia
+    ...decided && typeof row2.decidedVia === "string" ? {
+      decidedVia: row2.decidedVia
     } : {},
-    ...status === "rejected" && typeof row.error === "string" ? {
-      reason: row.error
+    ...status === "rejected" && typeof row2.error === "string" ? {
+      reason: row2.error
     } : {}
   };
 }
@@ -537,28 +575,28 @@ function estimateCost(usage, price) {
   return uncachedInputTokens / 1e6 * price.inputPricePer1m + cacheWriteTokens / 1e6 * (price.cacheWritePricePer1m ?? price.inputPricePer1m) + cacheReadTokens / 1e6 * (price.cacheReadPricePer1m ?? price.inputPricePer1m) + usage.outputTokens / 1e6 * price.outputPricePer1m;
 }
 __name(estimateCost, "estimateCost");
-function rowCost(row, prices) {
-  return row.costUsd ?? estimateCost(row, prices.get(row.modelId));
+function rowCost(row2, prices) {
+  return row2.costUsd ?? estimateCost(row2, prices.get(row2.modelId));
 }
 __name(rowCost, "rowCost");
 function bucketByModel(rows, prices) {
   const byModel = /* @__PURE__ */ new Map();
-  for (const row of rows) {
-    const bucket = byModel.get(row.modelId) ?? {
+  for (const row2 of rows) {
+    const bucket = byModel.get(row2.modelId) ?? {
       requests: 0,
       inputTokens: 0,
       outputTokens: 0,
       costUsd: 0
     };
     bucket.requests += 1;
-    bucket.inputTokens += row.inputTokens;
-    bucket.outputTokens += row.outputTokens;
-    bucket.costUsd += rowCost(row, prices);
-    byModel.set(row.modelId, bucket);
+    bucket.inputTokens += row2.inputTokens;
+    bucket.outputTokens += row2.outputTokens;
+    bucket.costUsd += rowCost(row2, prices);
+    byModel.set(row2.modelId, bucket);
   }
-  const result = [];
+  const result2 = [];
   for (const [modelId, bucket] of byModel) {
-    result.push({
+    result2.push({
       modelId,
       requests: bucket.requests,
       inputTokens: bucket.inputTokens,
@@ -566,28 +604,28 @@ 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) {
   const byActor = /* @__PURE__ */ new Map();
-  for (const row of rows) {
-    const bucket = byActor.get(row.actorRef) ?? {
+  for (const row2 of rows) {
+    const bucket = byActor.get(row2.actorRef) ?? {
       requests: 0,
       totalTokens: 0,
       costUsd: 0,
       threadIds: /* @__PURE__ */ new Set()
     };
     bucket.requests += 1;
-    bucket.totalTokens += row.inputTokens + row.outputTokens;
-    bucket.costUsd += rowCost(row, prices);
-    bucket.threadIds.add(row.threadId);
-    byActor.set(row.actorRef, bucket);
+    bucket.totalTokens += row2.inputTokens + row2.outputTokens;
+    bucket.costUsd += rowCost(row2, prices);
+    bucket.threadIds.add(row2.threadId);
+    byActor.set(row2.actorRef, bucket);
   }
-  const result = [];
+  const result2 = [];
   for (const [actorRef, bucket] of byActor) {
-    result.push({
+    result2.push({
       actorRef,
       requests: bucket.requests,
       totalTokens: bucket.totalTokens,
@@ -595,30 +633,30 @@ 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) {
   const byThread = /* @__PURE__ */ new Map();
-  for (const row of rows) {
-    const bucket = byThread.get(row.threadId) ?? {
+  for (const row2 of rows) {
+    const bucket = byThread.get(row2.threadId) ?? {
       requests: 0,
       totalTokens: 0,
       costUsd: 0
     };
     bucket.requests += 1;
-    bucket.totalTokens += row.inputTokens + row.outputTokens;
-    bucket.costUsd += rowCost(row, prices);
-    byThread.set(row.threadId, bucket);
+    bucket.totalTokens += row2.inputTokens + row2.outputTokens;
+    bucket.costUsd += rowCost(row2, prices);
+    byThread.set(row2.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 ?? "",
@@ -627,8 +665,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) {
@@ -639,37 +677,37 @@ function rollupThreadUsage(rows, prices) {
     totalTokens: 0,
     costUsd: 0
   };
-  for (const row of rows) {
+  for (const row2 of rows) {
     rollup.requests += 1;
-    rollup.inputTokens += row.inputTokens;
-    rollup.outputTokens += row.outputTokens;
-    rollup.totalTokens += row.inputTokens + row.outputTokens;
-    rollup.costUsd += rowCost(row, prices);
+    rollup.inputTokens += row2.inputTokens;
+    rollup.outputTokens += row2.outputTokens;
+    rollup.totalTokens += row2.inputTokens + row2.outputTokens;
+    rollup.costUsd += rowCost(row2, prices);
   }
   return rollup;
 }
 __name(rollupThreadUsage, "rollupThreadUsage");
 function bucketUsageTrend(rows, prices) {
   const byDay = /* @__PURE__ */ new Map();
-  for (const row of rows) {
-    const bucket = byDay.get(row.day) ?? {
+  for (const row2 of rows) {
+    const bucket = byDay.get(row2.day) ?? {
       totalTokens: 0,
       costUsd: 0
     };
-    bucket.totalTokens += row.inputTokens + row.outputTokens;
-    bucket.costUsd += rowCost(row, prices);
-    byDay.set(row.day, bucket);
+    bucket.totalTokens += row2.inputTokens + row2.outputTokens;
+    bucket.costUsd += rowCost(row2, prices);
+    byDay.set(row2.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) {
@@ -694,7 +732,7 @@ async function filterToolsByEnabled(entries) {
     entry,
     enabled: await isToolEnabled(entry.spec, entry.handler)
   })));
-  return checked.filter((row) => row.enabled).map((row) => row.entry);
+  return checked.filter((row2) => row2.enabled).map((row2) => row2.entry);
 }
 __name(filterToolsByEnabled, "filterToolsByEnabled");
 async function canActorUseTool(actor, handler) {
@@ -706,7 +744,7 @@ async function filterToolsByCanUse(entries, actor) {
     entry,
     allowed: await canActorUseTool(actor, entry.handler)
   })));
-  return checked.filter((row) => row.allowed).map((row) => row.entry);
+  return checked.filter((row2) => row2.allowed).map((row2) => row2.entry);
 }
 __name(filterToolsByCanUse, "filterToolsByCanUse");
 async function filterToolsByRole(tools, actor, policy) {
@@ -1113,13 +1151,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");
@@ -2298,12 +2336,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");
@@ -2346,7 +2384,7 @@ async function writeMemory({ config, digest, call, ctx, runId }) {
       error: verdict.reason
     };
   }
-  const record = await write({
+  const record2 = await write({
     key,
     text,
     scope,
@@ -2360,7 +2398,7 @@ async function writeMemory({ config, digest, call, ctx, runId }) {
   });
   return {
     ok: true,
-    record
+    record: record2
   };
 }
 __name(writeMemory, "writeMemory");
@@ -2412,7 +2450,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);
@@ -2480,7 +2518,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;
@@ -2588,6 +2626,1665 @@ 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(row2, now, ui = [], text) {
+  if (row2.outcome) return row2;
+  const execution = row2.execution;
+  const outcome = {
+    id: `${row2.id}:outcome:1`,
+    proposalId: row2.id,
+    outcomeVersion: 1,
+    tenantRef: row2.tenantRef,
+    actorRef: row2.actorRef,
+    threadId: row2.threadId,
+    originRunId: row2.originRunId,
+    originToolCallId: row2.originToolCallId,
+    toolName: row2.toolName,
+    decision: row2.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
+    } : row2.decisionAudit?.reason !== void 0 ? {
+      error: row2.decisionAudit.reason
+    } : {}
+  };
+  return snapshotActionProposal({
+    ...row2,
+    outcome,
+    outcomeDelivery: {
+      status: "pending",
+      generation: 0,
+      lease: null
+    }
+  });
+}
+__name(attachActionProposalOutcome, "attachActionProposalOutcome");
+function claimActionProposalOutcome(row2, command, now, token) {
+  validateActionProposalWorkerClaim(command, now);
+  const delivery = row2.outcomeDelivery;
+  if (!row2.outcome || !delivery || delivery.status !== "pending" || delivery.lease && now < delivery.lease.expiresAt) return null;
+  const generation = delivery.generation + 1;
+  return snapshotActionProposal({
+    ...row2,
+    outcomeDelivery: {
+      ...delivery,
+      generation,
+      lease: {
+        token,
+        generation,
+        workerId: command.workerId,
+        expiresAt: now + command.leaseMs
+      }
+    }
+  });
+}
+__name(claimActionProposalOutcome, "claimActionProposalOutcome");
+function actionProposalOutcomeFenceValid(row2, 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 = row2.outcomeDelivery;
+  return row2.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 s2 = schema;
+  if (typeof s2.$ref === "string") {
+    const target = resolveRef(root, s2.$ref);
+    if (target === void 0) {
+      issues.push({
+        path,
+        message: `references unknown schema ${s2.$ref}`
+      });
+      return;
+    }
+    check(target, value, path, root, issues, depth + 1);
+  }
+  if (s2.type !== void 0) {
+    const types = Array.isArray(s2.type) ? s2.type : [
+      s2.type
+    ];
+    if (!types.some((type) => matchesType(type, value))) {
+      issues.push({
+        path,
+        message: `must be ${types.join(" or ")}`
+      });
+      return;
+    }
+  }
+  if (Array.isArray(s2.enum) && !s2.enum.some((option) => deepEqual(option, value))) {
+    issues.push({
+      path,
+      message: `must be one of ${s2.enum.map((option) => JSON.stringify(option)).join(", ")}`
+    });
+  }
+  if ("const" in s2 && !deepEqual(s2.const, value)) {
+    issues.push({
+      path,
+      message: `must be ${JSON.stringify(s2.const)}`
+    });
+  }
+  if (typeof value === "string") {
+    if (typeof s2.minLength === "number" && value.length < s2.minLength) {
+      issues.push({
+        path,
+        message: `must be at least ${s2.minLength} characters`
+      });
+    }
+    if (typeof s2.maxLength === "number" && value.length > s2.maxLength) {
+      issues.push({
+        path,
+        message: `must be at most ${s2.maxLength} characters`
+      });
+    }
+    if (typeof s2.pattern === "string") {
+      let pattern;
+      try {
+        pattern = new RegExp(s2.pattern, "u");
+      } catch {
+        pattern = void 0;
+      }
+      if (pattern !== void 0 && !pattern.test(value)) {
+        issues.push({
+          path,
+          message: `must match ${s2.pattern}`
+        });
+      }
+    }
+  }
+  if (typeof value === "number") {
+    if (typeof s2.minimum === "number" && value < s2.minimum) {
+      issues.push({
+        path,
+        message: `must be >= ${s2.minimum}`
+      });
+    }
+    if (typeof s2.maximum === "number" && value > s2.maximum) {
+      issues.push({
+        path,
+        message: `must be <= ${s2.maximum}`
+      });
+    }
+  }
+  if (Array.isArray(value)) {
+    if (typeof s2.minItems === "number" && value.length < s2.minItems) {
+      issues.push({
+        path,
+        message: `must have at least ${s2.minItems} items`
+      });
+    }
+    if (typeof s2.maxItems === "number" && value.length > s2.maxItems) {
+      issues.push({
+        path,
+        message: `must have at most ${s2.maxItems} items`
+      });
+    }
+    if (s2.items !== void 0 && !Array.isArray(s2.items)) {
+      value.forEach((item, index) => {
+        check(s2.items, item, [
+          ...path,
+          index
+        ], root, issues, depth + 1);
+      });
+    }
+  }
+  if (matchesType("object", value)) {
+    const record2 = value;
+    const properties = typeof s2.properties === "object" && s2.properties !== null ? s2.properties : {};
+    if (Array.isArray(s2.required)) {
+      for (const key of s2.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 (s2.additionalProperties === false) {
+        issues.push({
+          path: [
+            ...path,
+            key
+          ],
+          message: "is not a known property"
+        });
+      } else if (typeof s2.additionalProperties === "object" && s2.additionalProperties !== null) {
+        check(s2.additionalProperties, entry, [
+          ...path,
+          key
+        ], root, issues, depth + 1);
+      }
+    }
+  }
+  if (Array.isArray(s2.allOf)) {
+    for (const sub of s2.allOf) check(sub, value, path, root, issues, depth + 1);
+  }
+  if (Array.isArray(s2.anyOf) || Array.isArray(s2.oneOf)) {
+    const options = Array.isArray(s2.anyOf) ? s2.anyOf : s2.oneOf;
+    const passing = options.filter((sub) => {
+      const nested = [];
+      check(sub, value, path, root, nested, depth + 1);
+      return nested.length === 0;
+    }).length;
+    if (Array.isArray(s2.anyOf) ? passing === 0 : passing !== 1) {
+      issues.push({
+        path,
+        message: Array.isArray(s2.anyOf) ? "does not match any allowed shape" : "must match exactly one allowed shape"
+      });
+    }
+  }
+  if (s2.not !== void 0) {
+    const nested = [];
+    check(s2.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.outputProps ?? 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.outputProps ?? definition.props, props, validator);
+    },
+    jsonSchemaFor(component) {
+      const definition = byName.get(component);
+      return definition === void 0 ? void 0 : toJsonSchema(definition.outputProps ?? 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 = {}, phase = "output") {
+  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 = phase === "input" ? await validateProps(definition.props, element.props ?? {}, catalog.validator) : 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(row2, scope) {
+  return row2.tenantRef === scope.tenantRef && row2.actorRef === scope.actorRef && row2.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(row2, input) {
+  validateActionProposalCreation(input);
+  const { decision: _decision, decisionAudit: _audit, execution: _execution, createdAt: _created, updatedAt: _updated, supersededBy: _supersededBy, outcome: _outcome, outcomeDelivery: _delivery, ...original } = row2;
+  return canonicalActionProposalJson(original) === canonicalActionProposalJson(input);
+}
+__name(actionProposalCreationMatches, "actionProposalCreationMatches");
+function result(status, proposal) {
+  return {
+    status,
+    proposal: snapshotActionProposal(proposal)
+  };
+}
+__name(result, "result");
+function transitionActionProposalDecision(row2, 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 (row2.decision !== "pending") {
+    return result(row2.decision === command.decision ? "unchanged" : row2.decision === "expired" ? "expired" : "conflict", row2);
+  }
+  const next = snapshotActionProposal(row2);
+  if (row2.expiresAt !== null && now >= row2.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", row2);
+  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(row2, command, now, token) {
+  checkLeaseMs(command.leaseMs, now);
+  checkString(command.workerId);
+  checkString(token);
+  const execution = row2.execution;
+  if (row2.decision !== "approved" || !execution || execution.status !== "queued" && !(execution.status === "executing" && execution.lease && now >= execution.lease.expiresAt)) return result("conflict", row2);
+  const next = snapshotActionProposal(row2);
+  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(row2, command, now) {
+  checkTime(now);
+  checkString(command.token);
+  if (!Number.isSafeInteger(command.generation) || command.generation < 1) throw new RangeError("Invalid lease generation");
+  const work = row2.execution;
+  if (row2.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(row2, command, now) {
+  checkLeaseMs(command.leaseMs, now);
+  const status = leaseStatus(row2, command, now);
+  if (status !== "valid") return result(status, row2);
+  const next = snapshotActionProposal(row2);
+  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(row2, 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(row2, command, now);
+  if (status !== "valid") return result(status, row2);
+  const next = snapshotActionProposal(row2);
+  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(row2, replacement, command, now) {
+  checkTime(now);
+  checkString(command.replacementProposalId);
+  checkString(command.actorRef);
+  checkString(command.via);
+  if (replacement.id !== command.replacementProposalId || row2.id === replacement.id || !actionProposalScopeMatches(row2, replacement) || row2.toolName !== replacement.toolName || !row2.replacementKey || row2.replacementKey !== replacement.replacementKey) return result("conflict", row2);
+  if (row2.decision === "superseded") return result(row2.supersededBy === replacement.id ? "unchanged" : "conflict", row2);
+  if (row2.decision !== "pending") return result("conflict", row2);
+  if (row2.expiresAt !== null && now >= row2.expiresAt) return {
+    ...transitionActionProposalDecision(row2, {
+      decision: "expired",
+      actorRef: "system",
+      via: "expiry"
+    }, now),
+    status: "expired"
+  };
+  const next = snapshotActionProposal({
+    ...row2,
+    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/genui/builtins.ts
+var str = /* @__PURE__ */ __name((description, extra = {}) => ({
+  type: "string",
+  ...description !== void 0 ? {
+    description
+  } : {},
+  ...extra
+}), "str");
+var obj = /* @__PURE__ */ __name((properties, required = []) => ({
+  type: "object",
+  properties,
+  required,
+  additionalProperties: false
+}), "obj");
+var arr = /* @__PURE__ */ __name((items, extra = {}) => ({
+  type: "array",
+  items,
+  ...extra
+}), "arr");
+var cell = {
+  type: [
+    "string",
+    "number",
+    "boolean",
+    "null"
+  ]
+};
+var row = {
+  type: "object",
+  additionalProperties: cell
+};
+var s = /* @__PURE__ */ __name((value) => value === null || value === void 0 ? "" : String(value), "s");
+var heading = /* @__PURE__ */ __name((props) => props.title ? `*${s(props.title)}*
+` : "", "heading");
+function textTable(columns, rows, max = 15) {
+  const shown = rows.slice(0, max);
+  const widths = columns.map((column) => Math.min(28, Math.max(column.label.length, ...shown.map((r) => s(r[column.key]).length))));
+  const format = /* @__PURE__ */ __name((values) => values.map((value, index) => value.slice(0, widths[index]).padEnd(widths[index] ?? 0)).join("  "), "format");
+  const lines = [
+    format(columns.map((column) => column.label)),
+    widths.map((width) => "-".repeat(width)).join("  "),
+    ...shown.map((r) => format(columns.map((column) => s(r[column.key]))))
+  ];
+  if (rows.length > max) lines.push(`\u2026 ${rows.length - max} more rows`);
+  return `\`\`\`
+${lines.join("\n")}
+\`\`\``;
+}
+__name(textTable, "textTable");
+function lineDiff(before, after) {
+  const a = before.split("\n");
+  const b = after.split("\n");
+  if (a.length * b.length > 25e4) {
+    return [
+      ...a.map((text) => ({
+        op: "del",
+        text
+      })),
+      ...b.map((text) => ({
+        op: "add",
+        text
+      }))
+    ];
+  }
+  const dp = Array.from({
+    length: a.length + 1
+  }, () => new Array(b.length + 1).fill(0));
+  const at = /* @__PURE__ */ __name((i2, j2) => dp[i2]?.[j2] ?? 0, "at");
+  for (let i2 = a.length - 1; i2 >= 0; i2--) {
+    for (let j2 = b.length - 1; j2 >= 0; j2--) {
+      dp[i2][j2] = a[i2] === b[j2] ? at(i2 + 1, j2 + 1) + 1 : Math.max(at(i2 + 1, j2), at(i2, j2 + 1));
+    }
+  }
+  const out = [];
+  let i = 0;
+  let j = 0;
+  while (i < a.length && j < b.length) {
+    if (a[i] === b[j]) {
+      out.push({
+        op: "same",
+        text: a[i]
+      });
+      i++;
+      j++;
+    } else if (at(i + 1, j) >= at(i, j + 1)) {
+      out.push({
+        op: "del",
+        text: a[i++]
+      });
+    } else {
+      out.push({
+        op: "add",
+        text: b[j++]
+      });
+    }
+  }
+  while (i < a.length) out.push({
+    op: "del",
+    text: a[i++]
+  });
+  while (j < b.length) out.push({
+    op: "add",
+    text: b[j++]
+  });
+  return out;
+}
+__name(lineDiff, "lineDiff");
+function bar(value, max, width = 20) {
+  const n = max > 0 ? Math.round(Math.abs(value) / max * width) : 0;
+  return "\u2588".repeat(n) || "\u258F";
+}
+__name(bar, "bar");
+var DataTable = defineComponent({
+  name: "DataTable",
+  title: "Data table",
+  description: "Tabular data (records with the same fields) as a sortable table. Prefer it over markdown tables for more than 3 rows.",
+  props: obj({
+    title: str("Short caption"),
+    columns: arr(obj({
+      key: str("Field name in each row"),
+      label: str("Column header"),
+      align: str(void 0, {
+        enum: [
+          "left",
+          "right",
+          "center"
+        ]
+      }),
+      format: str("How to format values", {
+        enum: [
+          "text",
+          "number",
+          "currency",
+          "percent",
+          "date",
+          "link"
+        ]
+      })
+    }, [
+      "key",
+      "label"
+    ]), {
+      minItems: 1,
+      maxItems: 12
+    }),
+    rows: arr(row, {
+      maxItems: 500
+    })
+  }, [
+    "columns",
+    "rows"
+  ]),
+  fallbackText: /* @__PURE__ */ __name((props) => `${heading(props)}${textTable(props.columns ?? [], props.rows ?? [])}`, "fallbackText")
+});
+var Chart = defineComponent({
+  name: "Chart",
+  title: "Chart",
+  description: "`bar` to compare categories, `line` for a trend over time. `data` is a list of points; `xKey` names the category/time field and each series names a numeric field.",
+  props: obj({
+    type: str("Chart type", {
+      enum: [
+        "bar",
+        "line"
+      ]
+    }),
+    title: str(),
+    xKey: str("Field of each point used for the x axis"),
+    series: arr(obj({
+      key: str("Numeric field"),
+      label: str()
+    }, [
+      "key"
+    ]), {
+      minItems: 1,
+      maxItems: 6
+    }),
+    data: arr(row, {
+      minItems: 1,
+      maxItems: 200
+    }),
+    unit: str("Unit shown after values, e.g. `KB` or `%`")
+  }, [
+    "type",
+    "xKey",
+    "series",
+    "data"
+  ]),
+  fallbackText: /* @__PURE__ */ __name((props) => {
+    const series = props.series ?? [];
+    const data = props.data ?? [];
+    const first = series[0]?.key ?? "";
+    const max = Math.max(0, ...data.map((point) => Math.abs(Number(point[first]) || 0)));
+    const unit = props.unit ? ` ${s(props.unit)}` : "";
+    const lines = data.slice(0, 20).map((point) => `${s(point[props.xKey]).slice(0, 18).padEnd(18)} ${bar(Number(point[first]) || 0, max)} ${s(point[first])}${unit}`);
+    return `${heading(props)}\`\`\`
+${lines.join("\n")}
+\`\`\``;
+  }, "fallbackText")
+});
+var KpiCards = defineComponent({
+  name: "KpiCards",
+  title: "KPI cards",
+  description: "A few key numbers (metrics, totals, counts) as cards.",
+  props: obj({
+    title: str(),
+    items: arr(obj({
+      label: str(),
+      value: {
+        type: [
+          "string",
+          "number"
+        ]
+      },
+      delta: str("Change, e.g. `+12%`"),
+      trend: str(void 0, {
+        enum: [
+          "up",
+          "down",
+          "flat"
+        ]
+      }),
+      hint: str()
+    }, [
+      "label",
+      "value"
+    ]), {
+      minItems: 1,
+      maxItems: 8
+    })
+  }, [
+    "items"
+  ]),
+  fallbackText: /* @__PURE__ */ __name((props) => `${heading(props)}${(props.items ?? []).map((item) => `\u2022 *${s(item.label)}:* ${s(item.value)}${item.delta ? ` (${s(item.delta)})` : ""}`).join("\n")}`, "fallbackText")
+});
+var SourceCards = defineComponent({
+  name: "SourceCards",
+  title: "Sources",
+  description: "The documents, pages or links an answer is based on, as cards.",
+  props: obj({
+    title: str(),
+    items: arr(obj({
+      title: str(),
+      url: str(),
+      snippet: str(),
+      source: str("e.g. Wiki, GitHub")
+    }, [
+      "title"
+    ]), {
+      minItems: 1,
+      maxItems: 12
+    })
+  }, [
+    "items"
+  ]),
+  fallbackText: /* @__PURE__ */ __name((props) => `${heading(props)}${(props.items ?? []).map((item) => `\u2022 ${item.url ? `<${s(item.url)}|${s(item.title)}>` : s(item.title)}${item.source ? ` \u2014 ${s(item.source)}` : ""}`).join("\n")}`, "fallbackText")
+});
+var Checklist = defineComponent({
+  name: "Checklist",
+  title: "Checklist",
+  description: "Steps or a to-do list with done/not-done state.",
+  props: obj({
+    title: str(),
+    items: arr(obj({
+      label: str(),
+      done: {
+        type: "boolean"
+      },
+      note: str()
+    }, [
+      "label"
+    ]), {
+      minItems: 1,
+      maxItems: 50
+    })
+  }, [
+    "items"
+  ]),
+  fallbackText: /* @__PURE__ */ __name((props) => `${heading(props)}${(props.items ?? []).map((item) => `${item.done ? "\u2611" : "\u2610"} ${s(item.label)}${item.note ? ` \u2014 _${s(item.note)}_` : ""}`).join("\n")}`, "fallbackText")
+});
+var Timeline = defineComponent({
+  name: "Timeline",
+  title: "Timeline",
+  description: "Events in chronological order (the history of a project, an incident, a deal).",
+  props: obj({
+    title: str(),
+    events: arr(obj({
+      date: str(),
+      title: str(),
+      description: str()
+    }, [
+      "title"
+    ]), {
+      minItems: 1,
+      maxItems: 50
+    })
+  }, [
+    "events"
+  ]),
+  fallbackText: /* @__PURE__ */ __name((props) => `${heading(props)}${(props.events ?? []).map((event) => `\u2022 ${event.date ? `*${s(event.date)}* ` : ""}${s(event.title)}${event.description ? ` \u2014 ${s(event.description)}` : ""}`).join("\n")}`, "fallbackText")
+});
+var CodeBlock = defineComponent({
+  name: "CodeBlock",
+  title: "Code",
+  description: "A code snippet or file excerpt with syntax highlighting.",
+  props: obj({
+    title: str(),
+    language: str(),
+    code: str()
+  }, [
+    "code"
+  ]),
+  fallbackText: /* @__PURE__ */ __name((props) => `${heading(props)}\`\`\`
+${s(props.code)}
+\`\`\``, "fallbackText")
+});
+var Diff = defineComponent({
+  name: "Diff",
+  title: "Diff",
+  description: "A before/after change to a text or code file, as a line diff.",
+  props: obj({
+    title: str(),
+    language: str(),
+    before: str(),
+    after: str()
+  }, [
+    "before",
+    "after"
+  ]),
+  fallbackText: /* @__PURE__ */ __name((props) => `${heading(props)}\`\`\`
+${lineDiff(s(props.before), s(props.after)).map((line) => `${line.op === "add" ? "+" : line.op === "del" ? "-" : " "} ${line.text}`).join("\n")}
+\`\`\``, "fallbackText")
+});
+var Callout = defineComponent({
+  name: "Callout",
+  title: "Callout",
+  description: "A short note, warning or success message, emphasized.",
+  props: obj({
+    tone: str(void 0, {
+      enum: [
+        "info",
+        "success",
+        "warning",
+        "danger"
+      ]
+    }),
+    title: str(),
+    text: str()
+  }, [
+    "text"
+  ]),
+  fallbackText: /* @__PURE__ */ __name((props) => `${props.tone === "warning" || props.tone === "danger" ? ":warning: " : ":information_source: "}${heading(props)}${s(props.text)}`, "fallbackText")
+});
+var Stack = defineComponent({
+  name: "Stack",
+  title: "Stack",
+  description: "Lays its children out vertically (or horizontally with direction=row).",
+  props: obj({
+    direction: str(void 0, {
+      enum: [
+        "column",
+        "row"
+      ]
+    }),
+    gap: {
+      type: "number"
+    }
+  }),
+  children: true,
+  fallbackText: /* @__PURE__ */ __name(() => "", "fallbackText")
+});
+var Card = defineComponent({
+  name: "Card",
+  title: "Card",
+  description: "A box with an optional title around its children.",
+  props: obj({
+    title: str(),
+    subtitle: str()
+  }),
+  children: true,
+  fallbackText: /* @__PURE__ */ __name((props) => props.title ? `*${s(props.title)}*${props.subtitle ? ` \u2014 ${s(props.subtitle)}` : ""}` : "", "fallbackText")
+});
+var Heading = defineComponent({
+  name: "Heading",
+  title: "Heading",
+  description: "A heading.",
+  props: obj({
+    text: str()
+  }, [
+    "text"
+  ]),
+  fallbackText: /* @__PURE__ */ __name((props) => `*${s(props.text)}*`, "fallbackText")
+});
+var Text = defineComponent({
+  name: "Text",
+  title: "Text",
+  description: "A paragraph of plain text (no markdown).",
+  props: obj({
+    text: str(),
+    muted: {
+      type: "boolean"
+    }
+  }, [
+    "text"
+  ]),
+  fallbackText: /* @__PURE__ */ __name((props) => s(props.text), "fallbackText")
+});
+var Badge = defineComponent({
+  name: "Badge",
+  title: "Badge",
+  description: "A small label.",
+  props: obj({
+    text: str(),
+    tone: str(void 0, {
+      enum: [
+        "neutral",
+        "brand",
+        "success",
+        "warning",
+        "danger"
+      ]
+    })
+  }, [
+    "text"
+  ]),
+  fallbackText: /* @__PURE__ */ __name((props) => `[${s(props.text)}]`, "fallbackText")
+});
+var Link = defineComponent({
+  name: "Link",
+  title: "Link",
+  description: "A link to an http(s) URL.",
+  props: obj({
+    text: str(),
+    url: str(void 0, {
+      pattern: "^https?://"
+    })
+  }, [
+    "text",
+    "url"
+  ]),
+  fallbackText: /* @__PURE__ */ __name((props) => `<${s(props.url)}|${s(props.text || props.url)}>`, "fallbackText")
+});
+var Image = defineComponent({
+  name: "Image",
+  title: "Image",
+  description: "An image from an https URL.",
+  props: obj({
+    url: str(void 0, {
+      pattern: "^https://"
+    }),
+    alt: str()
+  }, [
+    "url"
+  ]),
+  fallbackText: /* @__PURE__ */ __name((props) => s(props.url), "fallbackText")
+});
+
+// src/genui/registry.ts
+function snapshotComponentPresentation(value) {
+  const seen = /* @__PURE__ */ new Set();
+  const check2 = /* @__PURE__ */ __name((entry) => {
+    if (entry === null || typeof entry === "string" || typeof entry === "boolean") return;
+    if (typeof entry === "number" && Number.isFinite(entry)) return;
+    if (typeof entry !== "object" || entry === null) throw new TypeError("genui: presentation must contain only JSON values");
+    if (seen.has(entry)) throw new TypeError("genui: presentation must contain acyclic JSON values");
+    if (!Array.isArray(entry) && Object.getPrototypeOf(entry) !== Object.prototype && Object.getPrototypeOf(entry) !== null) throw new TypeError("genui: presentation must contain plain JSON objects");
+    seen.add(entry);
+    for (const item of Object.values(entry)) check2(item);
+    seen.delete(entry);
+  }, "check");
+  check2(value);
+  return JSON.parse(JSON.stringify(value));
+}
+__name(snapshotComponentPresentation, "snapshotComponentPresentation");
+function createComponent(definition, options = {}) {
+  defineComponent(definition);
+  const catalog = defineCatalog([
+    definition
+  ], options);
+  const factory = /* @__PURE__ */ __name(async (props) => {
+    const result2 = await validateProps(definition.props, props, catalog.validator);
+    if (!result2.ok) throw new Error(`genui: invalid ${definition.name} props: ${formatIssues(result2.issues)}`);
+    const normalized = snapshotComponentPresentation(result2.value);
+    if (typeof normalized !== "object" || normalized === null || Array.isArray(normalized)) throw new TypeError("genui: component props must be a JSON object");
+    const portable = await catalog.validate(definition.name, normalized);
+    if (!portable.ok || canonicalJson(snapshotComponentPresentation(portable.value)) !== canonicalJson(normalized)) {
+      throw new Error(`genui: ${definition.name} requires outputProps accepting stable normalized JSON props`);
+    }
+    return {
+      component: definition.name,
+      props: normalized,
+      version: definition.version ?? 1,
+      fallbackText: componentToText(catalog, definition.name, normalized)
+    };
+  }, "factory");
+  return Object.assign(factory, {
+    definition
+  });
+}
+__name(createComponent, "createComponent");
+var table = createComponent(DataTable);
+var chart = createComponent(Chart);
+function validatePresentationBatch(presentations) {
+  const batch = Array.isArray(presentations) ? presentations : [
+    presentations
+  ];
+  return batch.map((item) => {
+    const presentation = snapshotComponentPresentation(item);
+    if (typeof presentation !== "object" || presentation === null || typeof presentation.component !== "string" || !/^[A-Za-z][A-Za-z0-9]{0,63}$/.test(presentation.component) || !Number.isSafeInteger(presentation.version) || presentation.version <= 0 || typeof presentation.fallbackText !== "string" || typeof presentation.props !== "object" || presentation.props === null || Array.isArray(presentation.props)) {
+      throw new TypeError("genui: invalid component presentation");
+    }
+    return presentation;
+  });
+}
+__name(validatePresentationBatch, "validatePresentationBatch");
+function canonicalJson(value) {
+  if (Array.isArray(value)) return `[${value.map(canonicalJson).join(",")}]`;
+  if (typeof value === "object" && value !== null) {
+    const record2 = value;
+    return `{${Object.keys(record2).sort().map((key) => `${JSON.stringify(key)}:${canonicalJson(record2[key])}`).join(",")}}`;
+  }
+  return JSON.stringify(value);
+}
+__name(canonicalJson, "canonicalJson");
+
+// src/tool-presentations.ts
+async function emitToolPresentations(handler, output, ctx, toolName) {
+  if (handler.present === void 0) return;
+  try {
+    const result2 = await handler.present(output, ctx);
+    if (result2 === void 0) return;
+    const batch = validatePresentationBatch(result2);
+    for (const presentation of batch) {
+      await ctx.emitUi(presentation.component, presentation.props, {
+        version: presentation.version,
+        fallbackText: presentation.fallbackText
+      });
+    }
+  } catch (error) {
+    if (ctx.onPresentationError !== void 0) {
+      try {
+        await ctx.onPresentationError(error, {
+          toolName
+        });
+        return;
+      } catch (reportError) {
+        console.warn(`Tool "${toolName}" presentation error reporter failed`, reportError);
+      }
+    } else {
+      console.warn(`Tool "${toolName}" presentation failed after successful execution`, error);
+    }
+  }
+}
+__name(emitToolPresentations, "emitToolPresentations");
+
 // src/tool-registry.ts
 var ToolForbiddenError = class extends Error {
   static {
@@ -2630,6 +4327,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");
@@ -2641,6 +4367,15 @@ var ToolRegistry = class {
       handler
     });
   }
+  /** Whether a successful preflight shortcut has UI to journal. */
+  hasPresentation(name) {
+    return typeof this.entries.get(name)?.handler.present === "function";
+  }
+  /** Present an already authorized successful domain result without executing its action again. */
+  async presentOutput(name, output, ctx) {
+    const entry = this.entries.get(name);
+    if (entry !== void 0) await emitToolPresentations(entry.handler, output, ctx, name);
+  }
   has(name) {
     return this.entries.has(name);
   }
@@ -2677,11 +4412,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,
@@ -2689,6 +4425,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,
@@ -2714,6 +4451,41 @@ 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);
+    const output = result2?.status === "completed" ? result2.output : await entry.handler.execute(executionInput, withEmit);
+    await emitToolPresentations(entry.handler, output, withEmit, name);
+    return output;
+  }
+  /** 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);
@@ -2738,7 +4510,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 {
@@ -2753,6 +4529,7 @@ var DefaultRolesPolicy = class {
     this.emptyRoles = options.emptyRoles ?? "allow";
   }
   can(actor, tool) {
+    if (tool.ability !== void 0 && tool.roles === void 0) return false;
     const allowed = tool.roles ?? this.defaultRoles;
     if (allowed.length === 0) return this.emptyRoles === "allow";
     return (actor.roles ?? []).some((role) => allowed.includes(role));
@@ -2785,6 +4562,69 @@ __name(closeEmptyRoles, "closeEmptyRoles");
 import { createHash } from "crypto";
 import { trace } from "@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
 import { emit } from "@dudousxd/nestjs-diagnostics";
 function publishAgentRunStarted(payload) {
@@ -2839,7 +4679,8 @@ var AGENT_SPAN_EVENTS = [
   "llm.turn",
   "tool.execution",
   "retrieval",
-  "follow-ups"
+  "follow-ups",
+  "structured-output"
 ];
 var AGENT_DIAGNOSTIC_EVENTS = [
   "run.started",
@@ -2860,6 +4701,67 @@ function agentDiagnosticKey(event) {
 }
 __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) {
+        const declared = scope.uiCapabilities === void 0 || scope.uiCapabilities.components.some((entry) => entry.name === component && entry.version === (options.version ?? 1));
+        if (declared) return collector.emit(component, props, options);
+        const id2 = options.id ?? `${toolCallId}:ui:${next++}`;
+        if (options.fallbackText !== void 0 && options.fallbackText.length > 0) {
+          texts.set(id2, options.fallbackText);
+          await write?.({
+            kind: "text",
+            text: options.fallbackText
+          });
+        }
+        return {
+          id: id2
+        };
+      }
+      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) {
   if (typeof error !== "object" || error === null) {
@@ -2885,6 +4787,7 @@ function hasTransientShape(error) {
 }
 __name(hasTransientShape, "hasTransientShape");
 function isTransientToolError(error) {
+  if (error instanceof ToolPreflightDeniedError) return false;
   if (hasTransientShape(error)) {
     return true;
   }
@@ -2927,7 +4830,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;
@@ -3107,6 +5010,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,
@@ -3303,7 +5209,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 {
@@ -3467,10 +5374,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,
@@ -3500,13 +5407,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");
@@ -3569,6 +5479,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
     } : {},
@@ -3644,16 +5557,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 ? {
@@ -3664,13 +5577,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 {
@@ -3683,7 +5596,7 @@ async function runIntake(intake, deps, input, hooks, writer, threadHasAssistant)
       {
         id: request.id,
         name: ASK_TOOL_NAME,
-        output: result
+        output: result2
       }
     ]
   };
@@ -3729,16 +5642,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-${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
       } : {},
@@ -3750,7 +5787,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
         } : {}
@@ -3771,8 +5817,18 @@ async function claimToolCall(turn, call) {
       ...spec?.terminal === true ? {
         terminal: true
       } : {},
+      // Journal this extra checkpoint's opt-in; historical claims without it keep their sequence.
+      ...preflight?.status === "completed" && deps.registry.hasPresentation(call.name) ? {
+        presentCompletedPreflight: true
+      } : {},
       ...approval !== void 0 ? {
         approval
+      } : {},
+      ...preflight !== void 0 ? {
+        preflight
+      } : {},
+      ...proposalId !== void 0 ? {
+        proposalId
       } : {}
     };
   });
@@ -3795,9 +5851,18 @@ async function claimToolCall(turn, call) {
     ...persisted?.terminal === true ? {
       terminal: true
     } : {},
+    ...persisted?.presentCompletedPreflight === true ? {
+      presentCompletedPreflight: true
+    } : {},
     ...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)
   };
 }
@@ -3945,6 +6010,9 @@ function skillContext(input) {
     } : {},
     ...input.pageContext !== void 0 ? {
       pageContext: input.pageContext
+    } : {},
+    ...input.uiCapabilities !== void 0 ? {
+      uiCapabilities: input.uiCapabilities
     } : {}
   };
 }
@@ -3961,7 +6029,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 = {
@@ -3977,6 +6045,9 @@ async function invokeClaimedTool(turn, claimed) {
         } : {},
         ...input.pageContext !== void 0 ? {
           pageContext: input.pageContext
+        } : {},
+        ...input.uiCapabilities !== void 0 ? {
+          uiCapabilities: input.uiCapabilities
         } : {}
       };
       const envelope = {
@@ -3998,37 +6069,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);
     }
@@ -4044,6 +6127,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),
@@ -4085,6 +6175,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({
@@ -4225,12 +6336,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 ? {
@@ -4241,24 +6352,63 @@ 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.presentCompletedPreflight === true) {
+      const raw = await hooks.step(`present:${call.id}`, async () => {
+        const ui = createNegotiatedUiCollector(call.id, ctx, deps.resolveUiCatalog, (event) => turn.writer.write(encodeStreamEvent(event)));
+        await deps.registry.presentOutput(call.name, result2.output, {
+          ...toolCallContext(ctx, call.id),
+          emitUi: ui.emit
+        });
+        return wrapToolStepOutput(result2.output, ui.components(), ui.text());
+      });
+      const presented = unwrapToolStepOutput(raw);
+      if (presented.ui.length > 0) turn.toolUi.set(call.id, presented.ui);
+      if (presented.text) turn.toolText.set(call.id, presented.text);
+    }
+    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") {
@@ -4383,30 +6533,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;
@@ -4646,6 +6796,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
         } : {},
@@ -4662,6 +6831,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
               } : {}
@@ -4681,7 +6853,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,
@@ -4691,15 +6863,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()
         };
       });
@@ -4793,12 +6965,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;
@@ -4909,7 +7081,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,
@@ -4923,7 +7095,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",
@@ -4935,7 +7107,7 @@ ${block}`;
         await writer.write(encodeStreamEvent({
           kind: "tool-output",
           id: call.id,
-          output: result.output
+          output: result2.output
         }));
       });
     }
@@ -4964,9 +7136,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
       } : {},
@@ -4999,17 +7173,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",
@@ -5023,7 +7215,7 @@ ${block}`;
         } : {}
       }));
     });
-    if (turnCalls.halt.terminal) {
+    if (turnCalls.halt.terminal || turnCalls.halt.independentProposal) {
       break;
     }
   }
@@ -5079,8 +7271,152 @@ ${block}`;
 }
 __name(runAgentLoop, "runAgentLoop");
 
+// src/in-memory-action-proposal-store.ts
+import { randomUUID } from "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 row2 = this.rows.get(input.id);
+    if (row2) {
+      if (!actionProposalScopeMatches(row2, input)) return {
+        status: "conflict"
+      };
+      return {
+        status: actionProposalCreationMatches(row2, input) ? "unchanged" : "conflict",
+        proposal: snapshotActionProposal(row2)
+      };
+    }
+    const proposal = initialActionProposal(input, this.clock());
+    this.rows.set(input.id, proposal);
+    return {
+      status: "created",
+      proposal: snapshotActionProposal(proposal)
+    };
+  }
+  async getActionProposal(scope, id) {
+    const row2 = this.rows.get(id);
+    return row2 && actionProposalScopeMatches(row2, scope) ? snapshotActionProposal(row2) : null;
+  }
+  async listActionProposals(scope, query = {}) {
+    const limit = validateActionProposalListQuery(query);
+    return [
+      ...this.rows.values()
+    ].filter((row2) => actionProposalScopeMatches(row2, scope) && (query.decision === void 0 || row2.decision === query.decision) && (query.after === void 0 || row2.createdAt > query.after.createdAt || row2.createdAt === query.after.createdAt && row2.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 row2 = this.rows.get(id);
+    if (!row2 || !actionProposalScopeMatches(row2, scope)) return {
+      status: "not_found"
+    };
+    const result2 = transition(row2, this.clock());
+    if (result2.proposal) this.rows.set(id, snapshotActionProposal(result2.proposal));
+    return result2;
+  }
+  async decideActionProposal(scope, id, command) {
+    return this.mutate(scope, id, (row2, now) => transitionActionProposalDecision(row2, command, now));
+  }
+  async claimActionProposal(scope, id, command) {
+    return this.mutate(scope, id, (row2, now) => transitionActionProposalClaim(row2, command, now, randomUUID()));
+  }
+  async extendActionProposalLease(scope, id, command) {
+    return this.mutate(scope, id, (row2, now) => transitionActionProposalLease(row2, command, now));
+  }
+  async settleActionProposal(scope, id, command) {
+    return this.mutate(scope, id, (row2, now) => transitionActionProposalSettlement(row2, command, now));
+  }
+  async claimNextActionProposal(command) {
+    const now = this.clock();
+    validateActionProposalWorkerClaim(command, now);
+    const candidates = [
+      ...this.rows.values()
+    ].filter((row2) => row2.decision === "approved" && (row2.execution?.status === "queued" || row2.execution?.status === "executing" && row2.execution.lease !== null && now >= row2.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((row2) => row2.decision === "pending" && row2.expiresAt !== null && now >= row2.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((row2) => row2.outcomeDelivery?.status === "pending" && (!row2.outcomeDelivery.lease || now >= row2.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 row2 = this.rows.get(candidate.id);
+      if (!row2) continue;
+      const next = claimActionProposalOutcome(row2, command, this.clock(), 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 row2 of this.rows.values()) {
+      if (row2.decision !== "pending" || !actionProposalScopeMatches(row2, input) || row2.toolName !== input.toolName || row2.replacementKey !== input.replacementKey) continue;
+      const result2 = transitionActionProposalSupersession(row2, 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 row2 of replacements) this.rows.set(row2.id, row2);
+    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, (row2, now) => transitionActionProposalSupersession(row2, replacement, command, now));
+  }
+};
+
 // src/in-memory-store.ts
-var InMemoryAgentStore = class {
+var InMemoryAgentStore = class extends InMemoryActionProposalStore {
   static {
     __name(this, "InMemoryAgentStore");
   }
@@ -5100,9 +7436,10 @@ var InMemoryAgentStore = class {
       throw new Error(`thread ${id} already exists`);
     }
     const ts = this.now();
-    const row = {
+    const row2 = {
       id,
       actorRef: input.actor.id,
+      tenantRef: input.actor.tenantRef ?? null,
       title: input.title ?? "New chat",
       transient: input.transient ?? false,
       createdAt: ts,
@@ -5112,20 +7449,20 @@ var InMemoryAgentStore = class {
         persona: input.persona
       } : {}
     };
-    this.threads.set(id, row);
-    return this.toSummary(row);
+    this.threads.set(id, row2);
+    return this.toSummary(row2);
   }
   async getThread(threadId) {
-    const row = this.threads.get(threadId);
-    if (row === void 0) {
+    const row2 = this.threads.get(threadId);
+    if (row2 === void 0) {
       return null;
     }
     return {
-      ...this.toSummary(row),
-      messages: row.messages.map((message) => this.withApprovals(message)),
+      ...this.toSummary(row2),
+      messages: row2.messages.map((message) => this.withApprovals(message)),
       // The run streaming right now — the one field the read-model reports it under.
-      ...row.activeStreamId !== void 0 ? {
-        activeRunId: row.activeStreamId
+      ...row2.activeStreamId !== void 0 ? {
+        activeRunId: row2.activeStreamId
       } : {}
     };
   }
@@ -5138,8 +7475,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,
@@ -5162,6 +7503,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
     ];
@@ -5183,7 +7528,7 @@ var InMemoryAgentStore = class {
   async listThreads(actorRef, limit = 50) {
     return [
       ...this.threads.values()
-    ].filter((row) => row.actorRef === actorRef && !row.transient).sort((a, b) => b.updatedAt.localeCompare(a.updatedAt)).slice(0, limit).map((row) => this.toSummary(row));
+    ].filter((row2) => row2.actorRef === actorRef && !row2.transient).sort((a, b) => b.updatedAt.localeCompare(a.updatedAt)).slice(0, limit).map((row2) => this.toSummary(row2));
   }
   async softDeleteThread(threadId) {
     this.threads.delete(threadId);
@@ -5199,9 +7544,10 @@ var InMemoryAgentStore = class {
     ];
     const id = crypto.randomUUID();
     const ts = this.now();
-    const row = {
+    const row2 = {
       id,
       actorRef: source.actorRef,
+      tenantRef: source.tenantRef,
       title: source.title,
       transient: false,
       createdAt: ts,
@@ -5220,8 +7566,8 @@ var InMemoryAgentStore = class {
         persona: source.persona
       } : {}
     };
-    this.threads.set(id, row);
-    return this.toSummary(row);
+    this.threads.set(id, row2);
+    return this.toSummary(row2);
   }
   async ownerOfThread(threadId) {
     return this.threads.get(threadId)?.actorRef ?? null;
@@ -5241,38 +7587,38 @@ var InMemoryAgentStore = class {
     return call.runId ?? this.threads.get(call.threadId)?.activeStreamId ?? null;
   }
   async ownerOfActiveStream(runId) {
-    for (const row of this.threads.values()) {
-      if (row.activeStreamId === runId) {
-        return row.actorRef;
+    for (const row2 of this.threads.values()) {
+      if (row2.activeStreamId === runId) {
+        return row2.actorRef;
       }
     }
     return null;
   }
   async setTitle(threadId, title) {
-    const row = this.threads.get(threadId);
-    if (row !== void 0) {
-      row.title = title;
-      row.updatedAt = this.now();
+    const row2 = this.threads.get(threadId);
+    if (row2 !== void 0) {
+      row2.title = title;
+      row2.updatedAt = this.now();
     }
   }
   async updateThread(threadId, patch) {
-    const row = this.threads.get(threadId);
-    if (row === void 0) {
+    const row2 = this.threads.get(threadId);
+    if (row2 === void 0) {
       return;
     }
     if (patch.title !== void 0) {
-      row.title = patch.title;
+      row2.title = patch.title;
     }
     if (patch.defaultAgent !== void 0) {
-      row.defaultAgent = patch.defaultAgent;
+      row2.defaultAgent = patch.defaultAgent;
     }
     if (patch.model !== void 0) {
-      row.model = patch.model;
+      row2.model = patch.model;
     }
     if (patch.persona !== void 0) {
-      row.persona = patch.persona;
+      row2.persona = patch.persona;
     }
-    row.updatedAt = this.now();
+    row2.updatedAt = this.now();
   }
   async activeRunForThread(threadId) {
     return this.threads.get(threadId)?.activeStreamId ?? null;
@@ -5320,64 +7666,64 @@ var InMemoryAgentStore = class {
   }
   /** Settle a run's outcome. A no-op when the run is unknown (mirrors `setTitle`/`updateThread`). */
   async recordRunEnd(end) {
-    const row = this.runs.get(end.runId);
-    if (row === void 0) {
+    const row2 = this.runs.get(end.runId);
+    if (row2 === void 0) {
       return;
     }
-    row.status = end.status;
-    row.settledAt = this.now();
+    row2.status = end.status;
+    row2.settledAt = this.now();
     if (end.durationMs !== void 0) {
-      row.durationMs = end.durationMs;
+      row2.durationMs = end.durationMs;
     }
     if (end.errorCode !== void 0) {
-      row.errorCode = end.errorCode;
+      row2.errorCode = end.errorCode;
     }
     if (end.errorMessage !== void 0) {
-      row.errorMessage = end.errorMessage;
+      row2.errorMessage = end.errorMessage;
     }
   }
   /** Bump the run's llm-step retry counter. */
   async bumpRunRetries(runId) {
-    const row = this.runs.get(runId);
-    if (row !== void 0) {
-      row.retries += 1;
+    const row2 = this.runs.get(runId);
+    if (row2 !== void 0) {
+      row2.retries += 1;
     }
   }
   async promoteThread(threadId) {
-    const row = this.threads.get(threadId);
-    if (row?.transient) {
-      row.transient = false;
-      row.updatedAt = this.now();
+    const row2 = this.threads.get(threadId);
+    if (row2?.transient) {
+      row2.transient = false;
+      row2.updatedAt = this.now();
     }
   }
   async setActiveStream(threadId, runId) {
-    const row = this.threads.get(threadId);
-    if (row !== void 0) {
+    const row2 = this.threads.get(threadId);
+    if (row2 !== void 0) {
       if (runId === null) {
-        delete row.activeStreamId;
+        delete row2.activeStreamId;
       } else {
-        row.activeStreamId = runId;
+        row2.activeStreamId = runId;
       }
     }
   }
   async claimActiveStream(threadId, runId, options = {}) {
-    const row = this.threads.get(threadId);
-    if (row === void 0) {
+    const row2 = this.threads.get(threadId);
+    if (row2 === void 0) {
       return false;
     }
-    const holder = row.activeStreamId;
+    const holder = row2.activeStreamId;
     if (holder !== void 0 && holder !== runId && holder !== options.replacing) {
       return false;
     }
-    row.activeStreamId = runId;
+    row2.activeStreamId = runId;
     return true;
   }
   async releaseActiveStream(threadId, runId) {
-    const row = this.threads.get(threadId);
-    if (row?.activeStreamId !== runId) {
+    const row2 = this.threads.get(threadId);
+    if (row2?.activeStreamId !== runId) {
       return false;
     }
-    delete row.activeStreamId;
+    delete row2.activeStreamId;
     return true;
   }
   async enqueueMessage(input) {
@@ -5402,6 +7748,9 @@ var InMemoryAgentStore = class {
       ...input.pageContext !== void 0 ? {
         pageContext: input.pageContext
       } : {},
+      ...input.uiCapabilities !== void 0 ? {
+        uiCapabilities: input.uiCapabilities
+      } : {},
       ...input.interrupt === true ? {
         interrupt: true
       } : {},
@@ -5506,9 +7855,81 @@ var InMemoryAgentStore = class {
     }
     return void 0;
   }
+  async getThreadActionProposalScope(threadId) {
+    const row2 = this.threads.get(threadId);
+    return row2 ? {
+      threadId,
+      actorRef: row2.actorRef,
+      tenantRef: row2.tenantRef
+    } : null;
+  }
+  async admitActionProposalOutcome(command) {
+    const row2 = [
+      ...this.rows.values()
+    ].find((row3) => row3.outcome?.id === command.outcomeId);
+    if (!row2?.outcome || !row2.outcomeDelivery) return {
+      status: "not_found"
+    };
+    if (row2.outcomeDelivery.status === "admitted") return {
+      status: "unchanged",
+      ...row2.outcomeDelivery.messageId !== void 0 ? {
+        messageId: row2.outcomeDelivery.messageId
+      } : {}
+    };
+    if (row2.outcomeDelivery.status === "discarded") return {
+      status: "discarded"
+    };
+    if (!actionProposalOutcomeFenceValid(row2, command, this.clock())) return {
+      status: "conflict"
+    };
+    const thread = this.threads.get(row2.threadId);
+    if (!thread) {
+      this.rows.set(row2.id, snapshotActionProposal({
+        ...row2,
+        outcomeDelivery: {
+          ...row2.outcomeDelivery,
+          status: "discarded",
+          lease: null
+        }
+      }));
+      return {
+        status: "discarded"
+      };
+    }
+    if (thread.actorRef !== row2.actorRef || thread.tenantRef !== row2.tenantRef) return {
+      status: "conflict"
+    };
+    if (thread.activeStreamId) return {
+      status: "busy"
+    };
+    const message = {
+      id: crypto.randomUUID(),
+      role: "assistant",
+      content: actionProposalOutcomeText(row2.outcome),
+      createdAt: this.now(),
+      actionProposalOutcome: snapshotActionProposal(row2.outcome),
+      ui: snapshotActionProposal(row2.outcome.ui)
+    };
+    const next = snapshotActionProposal({
+      ...row2,
+      outcomeDelivery: {
+        ...row2.outcomeDelivery,
+        status: "admitted",
+        lease: null,
+        messageId: message.id
+      }
+    });
+    thread.messages.push(message);
+    thread.updatedAt = message.createdAt;
+    this.rows.set(row2.id, next);
+    return {
+      status: "applied",
+      messageId: message.id
+    };
+  }
   async appendMessage(input) {
-    const row = this.threads.get(input.threadId);
-    if (row === void 0) {
+    const row2 = this.threads.get(input.threadId);
+    if (row2 === void 0) {
       throw new Error(`thread ${input.threadId} not found`);
     }
     const message = {
@@ -5548,15 +7969,18 @@ var InMemoryAgentStore = class {
       } : {},
       ...input.ui !== void 0 ? {
         ui: input.ui
+      } : {},
+      ...input.actionProposalOutcome !== void 0 ? {
+        actionProposalOutcome: input.actionProposalOutcome
       } : {}
     };
-    row.messages.push(message);
-    row.updatedAt = message.createdAt;
+    row2.messages.push(message);
+    row2.updatedAt = message.createdAt;
     return message;
   }
   async setMessageToolResults(messageId, results) {
-    for (const row of this.threads.values()) {
-      const message = row.messages.find((candidate) => candidate.id === messageId);
+    for (const row2 of this.threads.values()) {
+      const message = row2.messages.find((candidate) => candidate.id === messageId);
       if (message !== void 0) {
         message.toolResults = results;
         return;
@@ -5564,12 +7988,12 @@ var InMemoryAgentStore = class {
     }
   }
   async setMessageUi(messageId, ui) {
-    for (const row of this.threads.values()) {
-      const index = row.messages.findIndex((candidate) => candidate.id === messageId);
-      const message = row.messages[index];
+    for (const row2 of this.threads.values()) {
+      const index = row2.messages.findIndex((candidate) => candidate.id === messageId);
+      const message = row2.messages[index];
       if (message !== void 0) {
         const { ui: _previous, ...rest } = message;
-        row.messages[index] = ui.length > 0 ? {
+        row2.messages[index] = ui.length > 0 ? {
           ...rest,
           ui
         } : rest;
@@ -5581,12 +8005,12 @@ var InMemoryAgentStore = class {
     return this.threadIdForMessage(messageId) ?? null;
   }
   async setMessageFeedback(messageId, feedback) {
-    for (const row of this.threads.values()) {
-      const index = row.messages.findIndex((candidate) => candidate.id === messageId);
-      const message = row.messages[index];
+    for (const row2 of this.threads.values()) {
+      const index = row2.messages.findIndex((candidate) => candidate.id === messageId);
+      const message = row2.messages[index];
       if (message !== void 0) {
         const { feedback: _previous, ...rest } = message;
-        row.messages[index] = feedback !== null ? {
+        row2.messages[index] = feedback !== null ? {
           ...rest,
           feedback
         } : rest;
@@ -5595,13 +8019,13 @@ var InMemoryAgentStore = class {
     }
   }
   async truncateFrom(threadId, messageId) {
-    const row = this.threads.get(threadId);
-    if (row === void 0) {
+    const row2 = this.threads.get(threadId);
+    if (row2 === void 0) {
       return;
     }
-    const cutoff = row.messages.findIndex((message) => message.id === messageId);
+    const cutoff = row2.messages.findIndex((message) => message.id === messageId);
     if (cutoff >= 0) {
-      row.messages = row.messages.slice(0, cutoff);
+      row2.messages = row2.messages.slice(0, cutoff);
     }
   }
   /**
@@ -5639,6 +8063,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,
@@ -5652,6 +8079,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
       } : {}
@@ -5660,16 +8090,16 @@ var InMemoryAgentStore = class {
   async toolCallOutcomes(toolCallIds) {
     const outcomes = [];
     for (const id of toolCallIds) {
-      const row = this.toolCalls.get(id);
-      if (row !== void 0) {
+      const row2 = this.toolCalls.get(id);
+      if (row2 !== void 0) {
         outcomes.push({
           id,
-          status: row.status,
-          ...row.output !== void 0 ? {
-            output: row.output
+          status: row2.status,
+          ...row2.output !== void 0 ? {
+            output: row2.output
           } : {},
-          ...row.error !== void 0 ? {
-            error: row.error
+          ...row2.error !== void 0 ? {
+            error: row2.error
           } : {}
         });
       }
@@ -5678,38 +8108,38 @@ var InMemoryAgentStore = class {
   }
   async failUnsettledToolCalls(runId, error) {
     let settled = 0;
-    for (const row of this.toolCalls.values()) {
-      if (row.runId === runId && row.status === "pending_approval") {
-        row.status = "failed";
-        row.error = error;
+    for (const row2 of this.toolCalls.values()) {
+      if (row2.runId === runId && row2.status === "pending_approval") {
+        row2.status = "failed";
+        row2.error = error;
         settled += 1;
       }
     }
     return settled;
   }
   async updateToolCall(input) {
-    const row = this.toolCalls.get(input.toolCallId);
-    if (row === void 0) {
+    const row2 = this.toolCalls.get(input.toolCallId);
+    if (row2 === void 0) {
       return;
     }
-    row.status = input.status;
+    row2.status = input.status;
     if (input.output !== void 0) {
-      row.output = input.output;
+      row2.output = input.output;
     }
     if (input.error !== void 0) {
-      row.error = input.error;
+      row2.error = input.error;
     }
     if (input.executionMs !== void 0) {
-      row.executionMs = input.executionMs;
+      row2.executionMs = input.executionMs;
     }
     if (input.executedByRef !== void 0) {
-      row.executedByRef = input.executedByRef;
+      row2.executedByRef = input.executedByRef;
     }
     if (input.remember !== void 0) {
-      row.remember = input.remember;
+      row2.remember = input.remember;
     }
     if (input.decidedVia !== void 0) {
-      row.decidedVia = input.decidedVia;
+      row2.decidedVia = input.decidedVia;
     }
   }
   async recordUsage(input) {
@@ -5737,9 +8167,9 @@ var InMemoryAgentStore = class {
     return this.usageBetween(actorRef, day, day);
   }
   async usageBetween(actorRef, fromDay, toDay) {
-    const rows = this.usage.filter((row) => row.actorRef === actorRef && row.day >= fromDay && row.day <= toDay);
-    const usedTokens = rows.reduce((sum, row) => sum + row.inputTokens + row.outputTokens, 0);
-    const costUsd = rows.reduce((sum, row) => sum + (row.costUsd ?? 0), 0);
+    const rows = this.usage.filter((row2) => row2.actorRef === actorRef && row2.day >= fromDay && row2.day <= toDay);
+    const usedTokens = rows.reduce((sum, row2) => sum + row2.inputTokens + row2.outputTokens, 0);
+    const costUsd = rows.reduce((sum, row2) => sum + (row2.costUsd ?? 0), 0);
     return {
       usedTokens,
       costUsd
@@ -5747,30 +8177,30 @@ var InMemoryAgentStore = class {
   }
   /** Test helper: read the recorded usage rows (modelId + token totals). */
   usageRows() {
-    return this.usage.map((row) => ({
-      actorRef: row.actorRef,
-      tokens: row.inputTokens + row.outputTokens,
-      modelId: row.modelId
+    return this.usage.map((row2) => ({
+      actorRef: row2.actorRef,
+      tokens: row2.inputTokens + row2.outputTokens,
+      modelId: row2.modelId
     }));
   }
   /** Governance read-model feed: recorded usage rows with the input/output split + thread/day. */
   governanceUsage() {
-    return this.usage.map((row) => ({
-      actorRef: row.actorRef,
-      threadId: row.threadId,
-      modelId: row.modelId,
-      inputTokens: row.inputTokens,
-      outputTokens: row.outputTokens,
-      day: row.day,
-      createdAt: row.createdAt,
-      ...row.cacheWriteTokens !== void 0 ? {
-        cacheWriteTokens: row.cacheWriteTokens
+    return this.usage.map((row2) => ({
+      actorRef: row2.actorRef,
+      threadId: row2.threadId,
+      modelId: row2.modelId,
+      inputTokens: row2.inputTokens,
+      outputTokens: row2.outputTokens,
+      day: row2.day,
+      createdAt: row2.createdAt,
+      ...row2.cacheWriteTokens !== void 0 ? {
+        cacheWriteTokens: row2.cacheWriteTokens
       } : {},
-      ...row.cacheReadTokens !== void 0 ? {
-        cacheReadTokens: row.cacheReadTokens
+      ...row2.cacheReadTokens !== void 0 ? {
+        cacheReadTokens: row2.cacheReadTokens
       } : {},
-      ...row.costUsd !== void 0 ? {
-        costUsd: row.costUsd
+      ...row2.costUsd !== void 0 ? {
+        costUsd: row2.costUsd
       } : {}
     }));
   }
@@ -5778,22 +8208,22 @@ var InMemoryAgentStore = class {
   governanceToolCalls() {
     return [
       ...this.toolCalls.values()
-    ].map((row) => ({
-      toolCallId: row.toolCallId,
-      toolName: row.toolName,
-      toolType: row.toolType,
-      status: row.status,
-      threadId: row.threadId,
-      messageId: row.messageId,
-      createdAt: row.createdAt,
-      ...row.executionMs !== void 0 ? {
-        executionMs: row.executionMs
+    ].map((row2) => ({
+      toolCallId: row2.toolCallId,
+      toolName: row2.toolName,
+      toolType: row2.toolType,
+      status: row2.status,
+      threadId: row2.threadId,
+      messageId: row2.messageId,
+      createdAt: row2.createdAt,
+      ...row2.executionMs !== void 0 ? {
+        executionMs: row2.executionMs
       } : {},
-      ...row.error !== void 0 ? {
-        error: row.error
+      ...row2.error !== void 0 ? {
+        error: row2.error
       } : {},
-      ...row.runId !== void 0 ? {
-        runId: row.runId
+      ...row2.runId !== void 0 ? {
+        runId: row2.runId
       } : {}
     }));
   }
@@ -5853,51 +8283,51 @@ var InMemoryAgentStore = class {
   governanceThreads() {
     return [
       ...this.threads.values()
-    ].map((row) => ({
-      threadId: row.id,
-      title: row.title,
-      actorRef: row.actorRef,
-      messageCount: row.messages.length,
-      updatedAt: row.updatedAt
+    ].map((row2) => ({
+      threadId: row2.id,
+      title: row2.title,
+      actorRef: row2.actorRef,
+      messageCount: row2.messages.length,
+      updatedAt: row2.updatedAt
     }));
   }
   /** Governance read-model feed: recorded run outcomes (the reliability surfaces). */
   governanceRuns() {
     return [
       ...this.runs.values()
-    ].map((row) => ({
-      runId: row.runId,
-      threadId: row.threadId,
-      actorRef: row.actorRef,
-      status: row.status,
-      retries: row.retries,
-      startedAt: row.startedAt,
-      ...row.agentName !== void 0 ? {
-        agentName: row.agentName
+    ].map((row2) => ({
+      runId: row2.runId,
+      threadId: row2.threadId,
+      actorRef: row2.actorRef,
+      status: row2.status,
+      retries: row2.retries,
+      startedAt: row2.startedAt,
+      ...row2.agentName !== void 0 ? {
+        agentName: row2.agentName
       } : {},
-      ...row.parentRunId !== void 0 ? {
-        parentRunId: row.parentRunId
+      ...row2.parentRunId !== void 0 ? {
+        parentRunId: row2.parentRunId
       } : {},
-      ...row.durationMs !== void 0 ? {
-        durationMs: row.durationMs
+      ...row2.durationMs !== void 0 ? {
+        durationMs: row2.durationMs
       } : {},
-      ...row.errorCode !== void 0 ? {
-        errorCode: row.errorCode
+      ...row2.errorCode !== void 0 ? {
+        errorCode: row2.errorCode
       } : {},
-      ...row.errorMessage !== void 0 ? {
-        errorMessage: row.errorMessage
+      ...row2.errorMessage !== void 0 ? {
+        errorMessage: row2.errorMessage
       } : {},
-      ...row.settledAt !== void 0 ? {
-        settledAt: row.settledAt
+      ...row2.settledAt !== void 0 ? {
+        settledAt: row2.settledAt
       } : {},
-      ...row.promptHash !== void 0 ? {
-        promptHash: row.promptHash
+      ...row2.promptHash !== void 0 ? {
+        promptHash: row2.promptHash
       } : {}
     }));
   }
   threadIdForMessage(messageId) {
-    for (const [threadId, row] of this.threads) {
-      if (row.messages.some((message) => message.id === messageId)) {
+    for (const [threadId, row2] of this.threads) {
+      if (row2.messages.some((message) => message.id === messageId)) {
         return threadId;
       }
     }
@@ -5907,54 +8337,54 @@ var InMemoryAgentStore = class {
   toolCallRows() {
     return [
       ...this.toolCalls.values()
-    ].map((row) => ({
-      toolCallId: row.toolCallId,
-      toolName: row.toolName,
-      toolType: row.toolType,
-      status: row.status,
-      input: row.input,
-      ...row.output !== void 0 ? {
-        output: row.output
+    ].map((row2) => ({
+      toolCallId: row2.toolCallId,
+      toolName: row2.toolName,
+      toolType: row2.toolType,
+      status: row2.status,
+      input: row2.input,
+      ...row2.output !== void 0 ? {
+        output: row2.output
       } : {},
-      ...row.error !== void 0 ? {
-        error: row.error
+      ...row2.error !== void 0 ? {
+        error: row2.error
       } : {},
-      ...row.runId !== void 0 ? {
-        runId: row.runId
+      ...row2.runId !== void 0 ? {
+        runId: row2.runId
       } : {},
-      ...row.executedByRef !== void 0 ? {
-        executedByRef: row.executedByRef
+      ...row2.executedByRef !== void 0 ? {
+        executedByRef: row2.executedByRef
       } : {},
-      ...row.approver !== void 0 ? {
-        approver: row.approver
+      ...row2.approver !== void 0 ? {
+        approver: row2.approver
       } : {},
-      ...row.expiresAt !== void 0 ? {
-        expiresAt: row.expiresAt
+      ...row2.expiresAt !== void 0 ? {
+        expiresAt: row2.expiresAt
       } : {},
-      ...row.remember !== void 0 ? {
-        remember: row.remember
+      ...row2.remember !== void 0 ? {
+        remember: row2.remember
       } : {},
-      ...row.decidedVia !== void 0 ? {
-        decidedVia: row.decidedVia
+      ...row2.decidedVia !== void 0 ? {
+        decidedVia: row2.decidedVia
       } : {}
     }));
   }
-  toSummary(row) {
-    const last = row.messages[row.messages.length - 1];
+  toSummary(row2) {
+    const last = row2.messages[row2.messages.length - 1];
     return {
-      id: row.id,
-      title: row.title,
-      transient: row.transient,
-      createdAt: row.createdAt,
-      updatedAt: row.updatedAt,
+      id: row2.id,
+      title: row2.title,
+      transient: row2.transient,
+      createdAt: row2.createdAt,
+      updatedAt: row2.updatedAt,
       ...last !== void 0 ? {
         lastMessagePreview: last.content.slice(0, 120)
       } : {},
-      defaultAgent: row.defaultAgent ?? null,
-      ...row.model != null ? {
-        model: row.model
+      defaultAgent: row2.defaultAgent ?? null,
+      ...row2.model != null ? {
+        model: row2.model
       } : {},
-      persona: row.persona ?? null
+      persona: row2.persona ?? null
     };
   }
 };
@@ -5962,22 +8392,22 @@ var InMemoryAgentStore = class {
 // src/confirm-token.ts
 import { createHash as createHash2, createHmac, timingSafeEqual } from "crypto";
 var DEFAULT_CONFIRM_TTL_MS = 15 * 60 * 1e3;
-function canonicalJson(value) {
+function canonicalJson2(value) {
   if (value === void 0) return "null";
   if (value === null || typeof value !== "object") return JSON.stringify(value) ?? "null";
-  if (Array.isArray(value)) return `[${value.map(canonicalJson).join(",")}]`;
+  if (Array.isArray(value)) return `[${value.map(canonicalJson2).join(",")}]`;
   if (typeof value.toJSON === "function") {
-    return canonicalJson(value.toJSON());
+    return canonicalJson2(value.toJSON());
   }
   const entries = Object.entries(value).filter(([, entry]) => entry !== void 0).sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0);
-  return `{${entries.map(([key, entry]) => `${JSON.stringify(key)}:${canonicalJson(entry)}`).join(",")}}`;
+  return `{${entries.map(([key, entry]) => `${JSON.stringify(key)}:${canonicalJson2(entry)}`).join(",")}}`;
 }
-__name(canonicalJson, "canonicalJson");
+__name(canonicalJson2, "canonicalJson");
 function signature(subject, expiresAt, secret) {
   if (secret === "") {
     throw new Error("confirm token: the secret is empty");
   }
-  return createHmac("sha256", secret).update(canonicalJson([
+  return createHmac("sha256", secret).update(canonicalJson2([
     "agent-confirm",
     subject.tool,
     subject.actorId,
@@ -6156,12 +8586,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
             ]
           };
         }
@@ -6171,10 +8601,10 @@ function withConfirmFields(schema) {
           };
         }
         return {
-          value: isRecord(result.value) ? {
-            ...result.value,
+          value: isRecord(result2.value) ? {
+            ...result2.value,
             ...fields
-          } : result.value
+          } : result2.value
         };
       }, "validate"),
       jsonSchema: {
@@ -6305,8 +8735,8 @@ var SqlTokenStreamSink = class {
   autoPurge;
   writes = /* @__PURE__ */ new Map();
   lastAutoPurge = 0;
-  constructor(table, options = {}) {
-    this.table = table;
+  constructor(table2, options = {}) {
+    this.table = table2;
     this.pollIntervalMs = Math.max(1, options.pollIntervalMs ?? DEFAULT_POLL_INTERVAL_MS);
     this.idlePollIntervalMs = Math.max(this.pollIntervalMs, options.idlePollIntervalMs ?? DEFAULT_IDLE_POLL_INTERVAL_MS);
     this.flushMs = Math.max(0, options.flushMs ?? DEFAULT_FLUSH_MS);
@@ -6448,15 +8878,15 @@ var SqlTokenStreamSink = class {
     let quietSince = Date.now();
     while (true) {
       const rows = await this.table.read(runId, cursor, READ_PAGE);
-      for (const row of rows) {
-        cursor = row.seq;
-        if (row.frame === null) {
-          if (row.error !== null) {
-            throw new AgentStreamError(JSON.parse(row.error));
+      for (const row2 of rows) {
+        cursor = row2.seq;
+        if (row2.frame === null) {
+          if (row2.error !== null) {
+            throw new AgentStreamError(JSON.parse(row2.error));
           }
           return;
         }
-        yield encoder2.encode(row.frame);
+        yield encoder2.encode(row2.frame);
       }
       if (rows.length > 0) {
         quietSince = Date.now();
@@ -6506,6 +8936,436 @@ var SqlTokenStreamSink = class {
     });
   }
 };
+
+// src/action-proposal-text.ts
+function resolveTextActionProposalDecision(text, proposals, vocabulary) {
+  const command = parseTextActionProposalCommand(text, vocabulary);
+  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");
+var DEFAULT_TEXT_ACTION_PROPOSAL_VOCABULARY = {
+  approve: [
+    "yes",
+    "confirm",
+    "approve",
+    "approved",
+    "ok"
+  ],
+  reject: [
+    "no",
+    "cancel",
+    "reject",
+    "deny"
+  ],
+  remember: [
+    "always in this conversation"
+  ]
+};
+var DEFAULT_TEXT_ACTION_PROPOSAL_REPLIES = {
+  approved: "Proposal approved and queued to run.",
+  rejected: "Proposal rejected; nothing was run.",
+  expired: "The proposal expired; nothing was run.",
+  unchanged: "This proposal could not be changed; refresh the list to see where it stands.",
+  ambiguous: /* @__PURE__ */ __name((ids) => `Which proposal? Reply confirm #ID or cancel #ID: ${ids.join(", ")}`, "ambiguous"),
+  tooMany: "There are several proposals. Confirm or reject one with an explicit #ID."
+};
+function textActionProposalReply(result2, decision, replies = DEFAULT_TEXT_ACTION_PROPOSAL_REPLIES) {
+  return result2.status === "expired" || result2.proposal?.decision === "expired" ? replies.expired : result2.status === "applied" || result2.status === "unchanged" ? decision === "approved" ? replies.approved : replies.rejected : replies.unchanged;
+}
+__name(textActionProposalReply, "textActionProposalReply");
+var escapeRegExp = /* @__PURE__ */ __name((word) => word.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"), "escapeRegExp");
+var alternatives = /* @__PURE__ */ __name((words) => words.map((word) => word.trim()).filter((word) => word.length > 0).map((word) => escapeRegExp(word).replace(/\s+/g, "\\s+")).join("|"), "alternatives");
+var fold = /* @__PURE__ */ __name((word) => word.trim().toLowerCase(), "fold");
+function parseTextActionProposalCommand(text, vocabulary = DEFAULT_TEXT_ACTION_PROPOSAL_VOCABULARY) {
+  if (/[\r\n]/u.test(text)) return {
+    status: "unmatched"
+  };
+  const verbs = alternatives([
+    ...vocabulary.approve,
+    ...vocabulary.reject
+  ]);
+  if (verbs.length === 0) return {
+    status: "unmatched"
+  };
+  const remember = alternatives(vocabulary.remember);
+  const match = new RegExp(`^(${verbs})${remember.length > 0 ? `(?: (${remember}))?` : "()"}(?: #([^\\s]+?))?[.!]?$`, "iu").exec(text.trim());
+  if (!match) return {
+    status: "unmatched"
+  };
+  const verb = match[1] === void 0 ? void 0 : fold(match[1]);
+  if (verb === void 0) return {
+    status: "unmatched"
+  };
+  const decision = vocabulary.reject.some((word) => fold(word) === verb) ? "rejected" : "approved";
+  const remembers = match[2] !== void 0 && match[2] !== "";
+  if (remembers && decision !== "approved") return {
+    status: "unmatched"
+  };
+  return {
+    status: "command",
+    decision,
+    remember: remembers,
+    ...match[3] !== void 0 ? {
+      proposalId: match[3]
+    } : {}
+  };
+}
+__name(parseTextActionProposalCommand, "parseTextActionProposalCommand");
+var ptBrActionProposalText = {
+  vocabulary: {
+    approve: [
+      "sim",
+      "confirmo",
+      "confirmar",
+      "aprovar",
+      "aprovo",
+      "pode",
+      ...DEFAULT_TEXT_ACTION_PROPOSAL_VOCABULARY.approve
+    ],
+    reject: [
+      "n\xE3o",
+      "nao",
+      "cancelar",
+      "cancela",
+      "rejeitar",
+      "rejeito",
+      ...DEFAULT_TEXT_ACTION_PROPOSAL_VOCABULARY.reject
+    ],
+    remember: [
+      "sempre nesta conversa",
+      ...DEFAULT_TEXT_ACTION_PROPOSAL_VOCABULARY.remember
+    ]
+  },
+  replies: {
+    approved: "Proposta aprovada e enfileirada para execu\xE7\xE3o.",
+    rejected: "Proposta rejeitada; nenhuma a\xE7\xE3o foi executada.",
+    expired: "A proposta expirou; nenhuma a\xE7\xE3o foi executada.",
+    unchanged: "N\xE3o foi poss\xEDvel alterar esta proposta; atualize a lista para consultar seu estado.",
+    ambiguous: /* @__PURE__ */ __name((ids) => `Qual proposta? Responda confirmar #ID ou cancelar #ID: ${ids.join(", ")}`, "ambiguous"),
+    tooMany: "H\xE1 v\xE1rias propostas. Confirme ou rejeite usando #ID expl\xEDcito."
+  }
+};
+
+// src/action-proposal-view.ts
+function toActionProposalView(proposal) {
+  const { execution, outcomeDelivery, idempotencyKey: _idempotencyKey, preparationInput: _preparationInput, executionContext: _executionContext, ...rest } = proposal;
+  return {
+    ...rest,
+    execution: execution === null ? null : withoutLease(execution),
+    ...outcomeDelivery !== void 0 ? {
+      outcomeDelivery: withoutLease(outcomeDelivery)
+    } : {}
+  };
+}
+__name(toActionProposalView, "toActionProposalView");
+function toActionProposalMutationView(result2) {
+  const { proposal, ...rest } = result2;
+  return {
+    ...rest,
+    ...proposal !== void 0 ? {
+      proposal: toActionProposalView(proposal)
+    } : {}
+  };
+}
+__name(toActionProposalMutationView, "toActionProposalMutationView");
+function withoutLease(value) {
+  const { lease: _lease, ...rest } = value;
+  return rest;
+}
+__name(withoutLease, "withoutLease");
+
+// 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");
+
+// src/functional-tool.ts
+function createFunctionalTool(definition) {
+  const { input, execute, present, preflight, isEnabled, canUse, describe, kind, ...metadata } = definition;
+  return {
+    spec: {
+      ...metadata,
+      kind: kind ?? "read",
+      inputSchema: input
+    },
+    handler: {
+      execute: execute.bind(definition),
+      ...present === void 0 ? {} : {
+        present: present.bind(definition)
+      },
+      ...preflight === void 0 ? {} : {
+        preflight: preflight.bind(definition)
+      },
+      ...isEnabled === void 0 ? {} : {
+        isEnabled: isEnabled.bind(definition)
+      },
+      ...canUse === void 0 ? {} : {
+        canUse: canUse.bind(definition)
+      },
+      ...describe === void 0 ? {} : {
+        describe: describe.bind(definition)
+      }
+    }
+  };
+}
+__name(createFunctionalTool, "createFunctionalTool");
 export {
   AGENT_ACTOR_DIRECTORY,
   AGENT_ACTOR_RESOLVER,
@@ -6539,6 +9399,8 @@ export {
   APPROVAL_EXPIRED_REASON,
   ASK_TOOL_DESCRIPTION,
   ASK_TOOL_NAME,
+  ActionProposalExecutor,
+  ActionProposalWorker,
   AgentRegistry,
   AgentStreamError,
   CONFIRM_JSON_SCHEMA_PROPERTIES,
@@ -6553,12 +9415,15 @@ export {
   DEFAULT_MAX_SKILLS,
   DEFAULT_REFUSAL_REASON,
   DEFAULT_STRUCTURED_OUTPUT_INSTRUCTION,
+  DEFAULT_TEXT_ACTION_PROPOSAL_REPLIES,
+  DEFAULT_TEXT_ACTION_PROPOSAL_VOCABULARY,
   DEFAULT_TOOL_TRANSIENT_RETRY_ATTEMPTS,
   DEFAULT_TOOL_TRANSIENT_RETRY_BACKOFF_MS,
   DefaultApprovalPolicy,
   DefaultRolesPolicy,
   ELICITATION_INPUT_TYPES,
   GLOBAL_SCOPE,
+  InMemoryActionProposalStore,
   InMemoryAgentStore,
   InMemoryConfirmTokenStore,
   MAX_ASK_QUESTIONS,
@@ -6582,15 +9447,25 @@ export {
   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,
@@ -6598,12 +9473,16 @@ export {
   buildMemoryBlock,
   buildSkillsBlock,
   canActorUseTool,
-  canonicalJson,
+  canonicalActionProposalJson,
+  canonicalJson2 as canonicalJson,
+  claimActionProposalOutcome,
   closeEmptyRoles,
   compositeSkillProvider,
   confirmTokenExpiry,
   createFrameBuffer,
+  createFunctionalTool,
   createIncrementalGate,
+  createNegotiatedUiCollector,
   createNoopEmitUi,
   createUiCollector,
   danglingToolCallIds,
@@ -6615,7 +9494,9 @@ export {
   detachedDelivered,
   detachedStarted,
   detachedUnsettled,
+  emitToolPresentations,
   encodeStreamEvent,
+  escapeUnsafeToolUiText,
   estimateCost,
   estimateMessageTokens,
   exhaustedWindow,
@@ -6630,6 +9511,7 @@ export {
   gateFollowUps,
   gateTail,
   hashConfirmToken,
+  initialActionProposal,
   intersectAllowLists,
   invokeWithTransientRetry,
   isChatQueueStore,
@@ -6648,7 +9530,10 @@ export {
   observeTurnFrames,
   offerMemories,
   offerSkills,
+  parseTextActionProposalCommand,
   personaCatalogEntry,
+  prepareActionProposal,
+  ptBrActionProposalText,
   publishAgentDelegated,
   publishAgentMemoryResolved,
   publishAgentMemoryWritten,
@@ -6674,12 +9559,14 @@ export {
   rememberToolDefinition,
   renderElicitationAnswers,
   repairInstruction,
+  resolveActionProposalApproval,
   resolveElicitation,
   resolveGateLookback,
   resolveMemoryDigest,
   resolveOutputGateMode,
   resolvePersonaAlias,
   resolveSkillCatalog,
+  resolveTextActionProposalDecision,
   resolveToolTransientRetryNumbers,
   rollupThreadUsage,
   runAgentLoop,
@@ -6696,18 +9583,32 @@ export {
   skillInputSchema,
   skillToolDefinition,
   skillWriteVerdict,
+  snapshotActionProposal,
   stampToolKinds,
   staticModelCatalog,
   staticSkillProvider,
   streamFailure,
   summarizeWithModel,
   tenantScope,
+  textActionProposalReply,
+  toActionProposalMutationView,
+  toActionProposalView,
   toolCallApprovalFromRow,
   toolCallContext,
   traceLlmTurn,
   traceToolExecution,
+  transitionActionProposalClaim,
+  transitionActionProposalDecision,
+  transitionActionProposalLease,
+  transitionActionProposalSettlement,
+  transitionActionProposalSupersession,
   truncateDetailContent,
   unwrapToolStepOutput,
+  validateActionProposalCreation,
+  validateActionProposalDiscoveryIndexBatch,
+  validateActionProposalExpiryBatch,
+  validateActionProposalListQuery,
+  validateActionProposalWorkerClaim,
   validateElicitationAnswer,
   validateElicitationValue,
   validateStructured,
@@ -6720,6 +9621,7 @@ export {
   withSkillTool,
   withToolTimeout,
   withTurnFrames,
+  wrapToolPreflightDenied,
   wrapToolStepOutput,
   writeMemory
 };