@beyondwork/docx-react-component 1.0.120 → 1.0.121

package/dist/{chunk-FIGWJ43K.js → chunk-IT2DK3A7.js}

@@ -17,18 +17,18 @@ import {
   resolveScopeRange,
   scopeSpecificity,
   searchDocument
-} from "./chunk-MPYYBRVN.js";
+} from "./chunk-PCXTMEGY.js";
 import {
   BROADCAST_COMMAND_TYPES,
   COMMAND_EVENT_SCHEMA_VERSION,
   LOCAL_ONLY_COMMAND_TYPES,
   getRemoteCursorStates
-} from "./chunk-XC56YLIS.js";
+} from "./chunk-C2LWJ4CZ.js";
 import {
   buildPageAnchorElementId,
   createUiApi,
   emitUxResponse
-} from "./chunk-VCL5MJMZ.js";
+} from "./chunk-GON2DNTE.js";
 import {
   DEFAULT_PX_PER_TWIP,
   DEFAULT_REGISTRY_ENTRIES,
@@ -36,23 +36,23 @@ import {
   LAYCACHE_SCHEMA_VERSION,
   LAYOUT_ENGINE_VERSION,
   createScopeTagRegistry
-} from "./chunk-TMQGWF7R.js";
+} from "./chunk-G3B2OBCZ.js";
 import {
   chartModelStore,
   createFormattingContext
-} from "./chunk-AUQDC5BD.js";
+} from "./chunk-3TUQCHYT.js";
 import {
   deriveDocumentStats
-} from "./chunk-FLNQY74K.js";
+} from "./chunk-OYGMRRR7.js";
 import {
   DocxSession
-} from "./chunk-BM5NSDII.js";
+} from "./chunk-S4ANOS2M.js";
 import {
   WORKFLOW_PAYLOAD_PART_PATH,
   buildEditorStateXml,
   parseEditorStateXml,
   parseWorkflowPayloadEnvelopeFromPackage
-} from "./chunk-KCHEAX4Z.js";
+} from "./chunk-EMDH4IQN.js";
 import {
   EMU_PER_PX,
   GRADIENT_STOP_UNITS,
@@ -61,7 +61,7 @@ import {
   createHeaderFooterStoryKey,
   createNoteStoryKey,
   validateEditableTargetRef
-} from "./chunk-AQA7OZ2R.js";
+} from "./chunk-TFSXOIAI.js";
 import {
   readOpcPackage
 } from "./chunk-OL2UEHRP.js";
@@ -1894,6 +1894,7 @@ function toV3PageLocalStory(story, frame) {
     variant: story.variant,
     relationshipId: story.relationshipId,
     ...story.sectionIndex !== void 0 ? { sectionIndex: story.sectionIndex } : {},
+    previewText: story.previewText,
     resolvedFields: story.resolvedFields.map(toV3PageLocalStoryField),
     anchoredObjects: story.anchoredObjects.map(toV3PageLocalStoryObject),
     measuredFrameHeightTwips: story.measuredFrameHeightTwips,
@@ -3819,19 +3820,24 @@ function getRuntimeTableSelectionDescriptor(snapshot) {
   const tableBlockIndex = tableDepth > 1 ? -1 : anchor.tableBlockIndex;
   const spansMultipleCells = anchor.rowIndex !== head.rowIndex || anchor.columnIndex !== head.columnIndex || !snapshot.selection.isCollapsed;
   const hasEditableTableTarget = target !== void 0 && tableBlockPath !== void 0;
+  const nonEditableReason = anchor.nonEditableReason ?? head.nonEditableReason;
+  const editability = nonEditableReason !== void 0 || tableDepth > 1 && !hasEditableTableTarget ? "non-editable" : "editable";
   const descriptor = {
-    editability: tableDepth > 1 && !hasEditableTableTarget ? "non-editable" : "editable",
-    ...tableDepth > 1 && !hasEditableTableTarget ? {
+    editability,
+    ...nonEditableReason !== void 0 ? {
+      nonEditableReason,
+      message: nonEditableReason === "vertical-merge-continuation-not-editable" ? "Vertical-merge continuation cells are synthetic layout cells; edit the visible restart cell instead." : "Nested table selection descriptors require a validated editable target path."
+    } : tableDepth > 1 && !hasEditableTableTarget ? {
       nonEditableReason: "nested-table-not-editable",
       message: "Nested table selection descriptors require a validated editable target path."
     } : {},
     tableDepth,
-    ...target ? { storyKey: target.storyKey } : {},
+    ...editability === "editable" && target ? { storyKey: target.storyKey } : {},
     ...tableBlockPath ? {
       tableBlockPath,
-      tableKey: `${target?.storyKey ?? "unknown"}:${tableBlockPath}`
+      tableKey: `${editability === "editable" ? target?.storyKey ?? "unknown" : "unknown"}:${tableBlockPath}`
     } : {},
-    ...target ? {
+    ...editability === "editable" && target ? {
       editableTarget: {
         targetKey: target.targetKey,
         kind: target.kind,
@@ -3884,7 +3890,8 @@ function findCellHit(blocks, position, tableDepth) {
             columnIndex: currentColumn,
             colspan: Math.max(1, cell.colspan),
             rowspan: Math.max(1, cell.rowspan),
-            ...editableTarget ? { editableTarget } : {}
+            ...editableTarget && validTableEditableTarget(editableTarget) ? { editableTarget } : {},
+            ...cell.verticalMerge === "continue" || editableTarget?.posture.blockers.includes("synthetic-layout-cell") ? { nonEditableReason: "vertical-merge-continuation-not-editable" } : {}
           };
         }
       }
@@ -4015,21 +4022,6 @@ function copyEnvelope(envelope) {
     ...envelope.sourceIdentity ? { sourceIdentity: { ...envelope.sourceIdentity } } : {}
   };
 }
-var UNAVAILABLE_COVERAGE = {
-  status: "unavailable",
-  pageCount: 0,
-  pageMaterialization: { paginated: 0, unpaginated: 0 },
-  regionCount: 0,
-  sliceCount: 0,
-  lineCount: 0,
-  anchorCount: 0,
-  hitTargetCount: 0,
-  semanticEntryCount: 0,
-  editableTargetCount: 0,
-  replacementEnvelopeCount: 0,
-  objectHandleCount: 0,
-  precision: { exact: 0, "within-tolerance": 0, heuristic: 0 }
-};
 function copyLayoutDivergence(divergence) {
   return {
     divergenceId: divergence.divergenceId,
@@ -4056,16 +4048,6 @@ function copyGraphOracleReference(reference) {
   };
 }
 function projectLayoutEvidence(runtime, pageIds) {
-  if (typeof runtime.layout?.getPageCount !== "function") {
-    return {
-      status: "unavailable",
-      pageCount: 0,
-      pageIds: [],
-      pagesWithDivergences: [],
-      divergenceIds: [],
-      divergences: []
-    };
-  }
   const pageCount = runtime.layout.getPageCount();
   const selectedPageIds = pageIds ? new Set(pageIds) : null;
   const pageIdOut = [];
@@ -4199,26 +4181,14 @@ function projectOracleEvidence(runtime, options, input) {
 }
 function projectDocumentPe2Evidence(runtime, options) {
   const layout = projectLayoutEvidence(runtime);
-  const geometry = runtime.geometry ? copyCoverage(runtime.geometry.getGeometryCoverage()) : UNAVAILABLE_COVERAGE;
   return {
-    geometry,
+    geometry: copyCoverage(runtime.geometry.getGeometryCoverage()),
     layout,
     oracle: projectOracleEvidence(runtime, options, { pageIds: layout.pageIds })
   };
 }
 function projectScopePe2Evidence(runtime, handle, options) {
   const { scopeId } = handle;
-  if (!runtime.geometry) {
-    const layout2 = projectLayoutEvidence(runtime, []);
-    return {
-      geometry: {
-        coverage: UNAVAILABLE_COVERAGE,
-        reason: "geometry-index-unavailable"
-      },
-      layout: layout2,
-      oracle: projectOracleEvidence(runtime, options, { scopeId, pageIds: layout2.pageIds })
-    };
-  }
   const coverage = copyCoverage(runtime.geometry.getGeometryCoverage());
   const index = runtime.geometry.getGeometryIndex();
   if (!index) {
@@ -4651,17 +4621,19 @@ function capabilityBlockerDetailFor(code) {
 }
 function readbackBlockerDetailFor(code) {
   const unchangedPrefix = "apply-readback-unchanged:";
+  const mismatchPrefix = "apply-readback-mismatch:";
   const unresolvablePrefix = "apply-readback-unresolvable:";
   const isUnchanged = code.startsWith(unchangedPrefix);
+  const isMismatch = code.startsWith(mismatchPrefix);
   const isUnresolvable = code.startsWith(unresolvablePrefix);
-  if (!isUnchanged && !isUnresolvable) return null;
-  const scopeId = isUnchanged ? code.slice(unchangedPrefix.length) : code.slice(unresolvablePrefix.length);
+  if (!isUnchanged && !isMismatch && !isUnresolvable) return null;
+  const scopeId = isUnchanged ? code.slice(unchangedPrefix.length) : isMismatch ? code.slice(mismatchPrefix.length) : code.slice(unresolvablePrefix.length);
   return {
     code,
     category: "capability-prerequisite",
     scopeKind: "scope",
-    message: isUnchanged ? `Runtime dispatch completed, but authoritative readback showed target scope ${scopeId} content was unchanged.` : `Runtime dispatch completed, but target scope ${scopeId} could not be re-resolved for authoritative readback.`,
-    nextStep: isUnchanged ? "Treat this as a hard refusal for content mutation. Attach an explanation or issue, and wait for an L08 mutation/readback route before surfacing warn-and-proceed." : "Re-resolve the target with ai.resolveReference or ai.queryScopeAtPosition, then retry only with the returned handle's scopeId; otherwise attach an explanation or issue."
+    message: isUnchanged ? `Runtime dispatch completed, but authoritative readback showed target scope ${scopeId} content was unchanged.` : isMismatch ? `Runtime dispatch completed, but authoritative readback did not match the requested replacement for target scope ${scopeId}.` : `Runtime dispatch completed, but target scope ${scopeId} could not be re-resolved for authoritative readback.`,
+    nextStep: isUnchanged ? "Treat this as a hard refusal for content mutation. Attach an explanation or issue, and wait for an L08 mutation/readback route before surfacing warn-and-proceed." : isMismatch ? "Treat this as a hard refusal for content mutation. Re-resolve the target and retry only after the replacement path has a proven mutation/readback route." : "Re-resolve the target with ai.resolveReference or ai.queryScopeAtPosition, then retry only with the returned handle's scopeId; otherwise attach an explanation or issue."
   };
 }
 function projectBlockerDetails(blockers) {
@@ -4722,6 +4694,15 @@ function createReplacementFamily(runtime) {
           warnings: Object.freeze([TEXTBOX_TARGET_AVAILABLE_WARNING])
         };
       }
+      const generatedOrLinkedBlockers = generatedOrLinkedReplacementBlockers(bundle, operation);
+      if (generatedOrLinkedBlockers.length > 0) {
+        return {
+          proposalId,
+          safe: false,
+          posture: "hard-refusal",
+          blockers: generatedOrLinkedBlockers
+        };
+      }
       const proposedContent = typeof input.proposedText === "string" ? { kind: "text", text: input.proposedText } : { kind: "text", text: "" };
       const verdict = composeScopeValidation({
         scope: compiled.scope,
@@ -4831,6 +4812,15 @@ function createReplacementFamily(runtime) {
     }
   };
 }
+function generatedOrLinkedReplacementBlockers(bundle, operation) {
+  if (!bundle || operation !== "replace") return Object.freeze([]);
+  const blockers = bundle.evidence.capabilities?.canReplaceText.blockers ?? [];
+  return Object.freeze(
+    blockers.filter(
+      (blocker2) => blocker2 === "field-generated-text" || blocker2.startsWith("link-bookmark:")
+    )
+  );
+}
 
 // src/api/v3/ai/_metadata-audit.ts
 function snapshotDocumentHash(runtime) {
@@ -5658,7 +5648,7 @@ function createTableActionFamily(runtime) {
       );
       const surface = runtime.getRenderSnapshot().surface?.blocks ?? [];
       const currentTargets = collectEditableTargetRefs(runtime.getCanonicalDocument()).filter(
-        (target) => target.table && target.storyKey === "main" && supportedTableKeys.has(target.table.tableKey) && isResolvableCurrentTableActionTarget(runtime, surface, target)
+        (target) => target.table && supportedTableKeys.has(target.table.tableKey) && isResolvableCurrentTableActionTarget(runtime, surface, target)
       );
       const seed = documentSeed(runtime);
       const byActionHandle = /* @__PURE__ */ new Map();
@@ -5710,18 +5700,19 @@ function createTableActionFamily(runtime) {
       if (warning) {
         return blockedResult(input, proposalId, warning);
       }
-      const targetBlocker = validateTableTarget(target, input.operation.kind);
+      const targetBlocker = validateTableTarget(target, input.operation);
       if (targetBlocker) {
         return blockedResult(input, proposalId, targetBlocker);
       }
       if (isTableTextOperation(input.operation)) {
         const textContent = tableTextContent(input.operation);
-        if (textContent === null) {
+        const fragmentContent = tableStructuredFragment(input.operation);
+        if (textContent === null && fragmentContent === null) {
           return blockedResult(input, proposalId, {
             code: `table-action-text-content-required:${input.operation.kind}`,
             category: "unsupported-operation",
-            message: "Paste/drop table text actions require plain text content.",
-            nextStep: 'Retry with operation.content.kind="text" and a string text value; structured cell payloads are refused.',
+            message: "Paste/drop table text actions require plain text or a canonical document fragment.",
+            nextStep: 'Retry with operation.content.kind="text" and a string text value, or operation.content.kind="structured" with a CanonicalDocumentFragment payload.',
             actionHandle: input.actionHandle,
             operation: input.operation.kind,
             operationScope: target.table?.operationScope
@@ -5745,12 +5736,21 @@ function createTableActionFamily(runtime) {
           });
         }
         const before2 = runtime.getCanonicalDocument();
-        runtime.dispatch({
-          type: "table.apply-text",
-          operation: { type: "replace-text", text: textContent },
-          editableTarget: target,
-          origin: { source: "api", timestamp: nowUtc }
-        });
+        if (fragmentContent) {
+          runtime.dispatch({
+            type: "fragment.insert",
+            fragment: fragmentContent,
+            editableTarget: target,
+            origin: { source: "api", timestamp: nowUtc }
+          });
+        } else {
+          runtime.dispatch({
+            type: "table.apply-text",
+            operation: { type: "replace-text", text: textContent ?? "" },
+            editableTarget: target,
+            origin: { source: "api", timestamp: nowUtc }
+          });
+        }
         const changed2 = runtime.getCanonicalDocument() !== before2;
         const afterReadback = tableTextReadback(readEditableTargetText(runtime.getCanonicalDocument(), target));
         return {
@@ -5760,7 +5760,7 @@ function createTableActionFamily(runtime) {
           actionHandle: input.actionHandle,
           operation: input.operation.kind,
           commandReference: {
-            command: "table.apply-text",
+            command: fragmentContent ? "fragment.insert" : "table.apply-text",
             actorId: input.actorId ?? "v3-ai-api",
             origin: input.origin ?? "agent",
             emittedAtUtc: nowUtc
@@ -5775,14 +5775,15 @@ function createTableActionFamily(runtime) {
       }
       const resolution = resolveEditableTableStructureTarget({
         document: runtime.getCanonicalDocument(),
-        target
+        target,
+        selectionDescriptor: operationSelectionDescriptor(input.operation)
       });
       if (resolution.kind === "rejected") {
         return blockedResult(input, proposalId, {
           code: resolution.blockedReason.code,
           category: "blocked-target",
           message: resolution.blockedReason.message,
-          nextStep: "Use a supported top-level table-structure target from ai.listTableActions; nested, SDT, secondary-story, stale, or workflow-blocked targets remain refused.",
+          nextStep: "Use a supported table-structure target from ai.listTableActions; nested, SDT, stale, wrong-story, or workflow-blocked targets remain refused.",
           actionHandle: input.actionHandle,
           operation: input.operation.kind,
           operationScope: target.table?.operationScope
@@ -5831,10 +5832,10 @@ function isSupportedTableActionEvidence(entry) {
   return isSupportedTableStructureEvidence(entry) || isSupportedTableTextEvidence(entry);
 }
 function isSupportedTableStructureEvidence(entry) {
-  return entry.commandFamily === "table-structure" && entry.runtimeCommand.status === "supported" && entry.runtimeCommand.intents.includes("table-structure-action") && Boolean(entry.table) && entry.storyKey === "main" && entry.table?.operationScope !== "text";
+  return entry.commandFamily === "table-structure" && entry.runtimeCommand.status === "supported" && entry.runtimeCommand.intents.includes("table-structure-action") && Boolean(entry.table) && entry.table?.operationScope !== "text";
 }
 function isSupportedTableTextEvidence(entry) {
-  return entry.commandFamily === "text-leaf" && entry.runtimeCommand.status === "supported" && Boolean(entry.table) && entry.storyKey === "main" && entry.table?.operationScope === "text";
+  return entry.commandFamily === "text-leaf" && entry.runtimeCommand.status === "supported" && Boolean(entry.table) && entry.table?.operationScope === "text";
 }
 function projectTableActionDescriptor(document, seed, entry) {
   if (!isSupportedTableActionEvidence(entry) || !entry.table) {
@@ -5876,7 +5877,8 @@ function projectCurrentTableTarget(document, seed, target) {
     reason: table.operationScope === "text" ? "l07:table-text-target-supported" : "l07:table-structure-target-supported"
   };
 }
-function validateTableTarget(target, operation) {
+function validateTableTarget(target, operationInput) {
+  const operation = operationInput.kind;
   if (operation === "paste-cell-content" || operation === "drop-cell-content") {
     if (target.commandFamily !== "text-leaf" || target.table?.operationScope !== "text") {
       return {
@@ -5912,6 +5914,9 @@ function validateTableTarget(target, operation) {
   }
   const supported = operationsForScope(target.table.operationScope);
   if (!supported.includes(operation)) {
+    if (operation === "merge-cells" && target.table.operationScope === "cell" && operationSelectionDescriptor(operationInput) !== null) {
+      return null;
+    }
     const callable = callableOperationsForScope(target.table.operationScope);
     if (callable.includes(operation)) return null;
     return {
@@ -5926,18 +5931,7 @@ function validateTableTarget(target, operation) {
   return null;
 }
 function tableActionWarning(input, target) {
-  if ((input.operation.kind === "paste-cell-content" || input.operation.kind === "drop-cell-content") && input.operation.content?.kind === "structured") {
-    return {
-      code: `table-action-unsupported:structured-cell-content:${input.operation.kind}`,
-      category: "unsupported-operation",
-      message: "Structured paste/drop payloads are not accepted for command-native table text actions.",
-      nextStep: "Retry with plain text content, or use a product paste path that can produce a validated fragment command.",
-      actionHandle: input.actionHandle,
-      operation: input.operation.kind,
-      operationScope: target.table?.operationScope
-    };
-  }
-  if (input.operation.kind === "merge-cells" && target.table?.operationScope === "cell") {
+  if (input.operation.kind === "merge-cells" && target.table?.operationScope === "cell" && operationSelectionDescriptor(input.operation) === null) {
     return {
       code: "table-action-unsupported:merge-cells:single-cell-target",
       category: "unsupported-operation",
@@ -5955,7 +5949,7 @@ function callableOperationsForScope(scope) {
     case "text":
       return TEXT_TRANSFER_OPERATIONS;
     case "cell":
-      return CELL_STRUCTURE_OPERATIONS;
+      return [...CELL_STRUCTURE_OPERATIONS, "merge-cells"];
     default:
       return operationsForScope(scope);
   }
@@ -5980,7 +5974,7 @@ function resolveTableActionHandle(runtime, seed, actionHandle) {
   const document = runtime.getCanonicalDocument();
   const surface = runtime.getRenderSnapshot().surface?.blocks ?? [];
   const targets = collectEditableTargetRefs(document).filter(
-    (target) => target.table && target.storyKey === "main" && callableOperationsForScope(target.table.operationScope).length > 0 && isResolvableCurrentTableActionTarget(runtime, surface, target)
+    (target) => target.table && callableOperationsForScope(target.table.operationScope).length > 0 && isResolvableCurrentTableActionTarget(runtime, surface, target)
   );
   return targets.find((target) => {
     return tableActionHandle(seed, target.targetKey) === actionHandle;
@@ -6013,7 +6007,7 @@ function hashOpaque(input) {
   return (h >>> 0).toString(36).padStart(7, "0");
 }
 function toTableStructureOperation(operation) {
-  const { kind, ...rest } = operation;
+  const { kind, selectionDescriptor: _selectionDescriptor, ...rest } = operation;
   return {
     ...rest,
     type: kind
@@ -6025,6 +6019,19 @@ function isTableTextOperation(operation) {
 function tableTextContent(operation) {
   return operation.content?.kind === "text" ? operation.content.text : null;
 }
+function tableStructuredFragment(operation) {
+  if (operation.content?.kind !== "structured") return null;
+  return isCanonicalDocumentFragment(operation.content.value) ? operation.content.value : null;
+}
+function isCanonicalDocumentFragment(value) {
+  return Boolean(
+    value && typeof value === "object" && Array.isArray(value.blocks)
+  );
+}
+function operationSelectionDescriptor(operation) {
+  const descriptor = operation.selectionDescriptor;
+  return descriptor ?? null;
+}
 function tableActionTargetReadback(actionHandle, target) {
   return {
     actionHandle,
@@ -6132,6 +6139,1791 @@ function documentSeed(runtime) {
   return state.documentId ?? "document";
 }
 
+// src/api/v3/ai/actions.ts
+function actionMethodMetadata(method, readOrMutate, auditCategory, contextPromptShape, uxIntent) {
+  return {
+    name: `ai.actions.${method}`,
+    status: "live-with-adapter",
+    sourceLayer: "ai",
+    liveEvidence: {
+      runnerTest: "test/api/v3/ai/ai-actions-category.test.ts",
+      commit: "refactor-09-ai-actions-category"
+    },
+    uxIntent,
+    agentMetadata: {
+      readOrMutate,
+      boundedScope: "scope",
+      auditCategory,
+      contextPromptShape
+    },
+    stateClass: "A-canonical",
+    persistsTo: "canonical",
+    ...readOrMutate === "mutate" ? { broadcastsVia: "crdt" } : {},
+    rwdReference: `\xA7AI API \xA7 ai.actions.${method}`
+  };
+}
+var discoverMetadata = actionMethodMetadata(
+  "discover",
+  "read",
+  "actions-discover",
+  "Read supported simple action methods, policy vocabulary, and optional target capability posture.",
+  { uiVisible: false, expectsUxResponse: "none" }
+);
+var locateMetadata = actionMethodMetadata(
+  "locate",
+  "read",
+  "actions-locate",
+  "Find the first scope/table-text target by query; returns ScopeHandle or opaque table actionHandle, never offsets.",
+  { uiVisible: false, expectsUxResponse: "none" }
+);
+var locateAllMetadata = actionMethodMetadata(
+  "locateAll",
+  "read",
+  "actions-locate",
+  "Find scope/table-text targets by query; table text matches include readback {text,isEmpty}.",
+  { uiVisible: false, expectsUxResponse: "none" }
+);
+var rewriteMetadata = actionMethodMetadata(
+  "rewrite",
+  "mutate",
+  "actions-rewrite",
+  "Rewrite one target through applyReplacementScope or table actionHandle/table.apply-text.",
+  {
+    uiVisible: true,
+    expectsUxResponse: "inline-change",
+    expectedDelta: "target text changes"
+  }
+);
+var rewriteAllMetadata = actionMethodMetadata(
+  "rewriteAll",
+  "mutate",
+  "actions-rewrite",
+  "Rewrite every locateAll match up to the supplied limit through the same scope/table text routes as rewrite.",
+  {
+    uiVisible: true,
+    expectsUxResponse: "inline-change",
+    expectedDelta: "matched target text changes"
+  }
+);
+var insertTextMetadata = actionMethodMetadata(
+  "insertText",
+  "mutate",
+  "actions-insert-text",
+  "Insert text before or after a semantic scope through the scoped replacement path.",
+  {
+    uiVisible: true,
+    expectsUxResponse: "inline-change",
+    expectedDelta: "adjacent text is inserted"
+  }
+);
+var flagMetadata = actionMethodMetadata(
+  "flag",
+  "mutate",
+  "actions-flag",
+  "Create one durable AI issue flag on a semantic scope.",
+  {
+    uiVisible: true,
+    expectsUxResponse: "warning-added",
+    expectedDelta: "issue rail shows a new issue card"
+  }
+);
+var flagManyMetadata = actionMethodMetadata(
+  "flagMany",
+  "mutate",
+  "actions-flag",
+  "Create durable AI issue flags on locateAll scope matches.",
+  {
+    uiVisible: true,
+    expectsUxResponse: "warning-added",
+    expectedDelta: "issue rail shows new issue cards"
+  }
+);
+var markMetadata = actionMethodMetadata(
+  "mark",
+  "mutate",
+  "actions-mark",
+  "Apply a scoped formatting action through applyScopeAction.",
+  {
+    uiVisible: true,
+    expectsUxResponse: "inline-change",
+    expectedDelta: "target formatting changes"
+  }
+);
+var briefMetadata = actionMethodMetadata(
+  "brief",
+  "read",
+  "actions-brief",
+  "Read a compact document or target summary without invoking a model provider.",
+  { uiVisible: false, expectsUxResponse: "none" }
+);
+var fieldRefreshMetadata = actionMethodMetadata(
+  "fieldRefresh",
+  "mutate",
+  "actions-generated-content",
+  "Refresh a supported generated field target through the modeled runtime field command.",
+  {
+    uiVisible: true,
+    expectsUxResponse: "inline-change",
+    expectedDelta: "generated field result refreshes"
+  }
+);
+var tocRefreshMetadata = actionMethodMetadata(
+  "tocRefresh",
+  "mutate",
+  "actions-generated-content",
+  "Refresh a supported table-of-contents target through the modeled runtime TOC command.",
+  {
+    uiVisible: true,
+    expectsUxResponse: "inline-change",
+    expectedDelta: "table-of-contents result refreshes"
+  }
+);
+var bookmarkEditMetadata = actionMethodMetadata(
+  "bookmarkEdit",
+  "mutate",
+  "actions-link-bookmark",
+  "Edit a supported bookmark content range through the modeled runtime bookmark command.",
+  {
+    uiVisible: true,
+    expectsUxResponse: "inline-change",
+    expectedDelta: "bookmark content changes"
+  }
+);
+var hyperlinkDestinationEditMetadata = actionMethodMetadata(
+  "hyperlinkDestinationEdit",
+  "mutate",
+  "actions-link-bookmark",
+  "Update a supported hyperlink destination through the modeled runtime hyperlink command.",
+  {
+    uiVisible: true,
+    expectsUxResponse: "inline-change",
+    expectedDelta: "hyperlink destination changes"
+  }
+);
+var listOperationMetadata = actionMethodMetadata(
+  "listOperation",
+  "mutate",
+  "actions-list-operation",
+  "Apply list toggle, indent, outdent, restart, or continue-numbering commands to paragraph-like scope handles.",
+  {
+    uiVisible: true,
+    expectsUxResponse: "inline-change",
+    expectedDelta: "list structure changes"
+  }
+);
+var tableFragmentMetadata = actionMethodMetadata(
+  "tableFragment",
+  "mutate",
+  "actions-table-fragment",
+  "Apply structured table paste/drop through an opaque table actionHandle.",
+  {
+    uiVisible: true,
+    expectsUxResponse: "inline-change",
+    expectedDelta: "table cell fragment content changes"
+  }
+);
+var tableSelectionMetadata = actionMethodMetadata(
+  "tableSelection",
+  "mutate",
+  "actions-table-selection",
+  "Apply table merge/split selection operations through an opaque table actionHandle.",
+  {
+    uiVisible: true,
+    expectsUxResponse: "inline-change",
+    expectedDelta: "table cell selection structure changes"
+  }
+);
+var runPlanMetadata = actionMethodMetadata(
+  "runPlan",
+  "mutate",
+  "actions-run-plan",
+  "Validate or apply a host-generated structured plan by dispatching exact steps through existing action primitives; no free-form instruction interpretation.",
+  {
+    uiVisible: true,
+    expectsUxResponse: "inline-change",
+    expectedDelta: "planned step mutations are applied when mode is apply"
+  }
+);
+var ACTION_METHODS = Object.freeze([
+  "discover",
+  "locate",
+  "locateAll",
+  "rewrite",
+  "rewriteAll",
+  "insertText",
+  "flag",
+  "flagMany",
+  "mark",
+  "brief",
+  "fieldRefresh",
+  "tocRefresh",
+  "bookmarkEdit",
+  "hyperlinkDestinationEdit",
+  "listOperation",
+  "tableFragment",
+  "tableSelection",
+  "runPlan"
+]);
+var DEFAULT_LOCATE_LIMIT = 20;
+var DEFAULT_REWRITE_ALL_LIMIT = 10;
+var DEFAULT_TABLE_TEXT_SCOPE_LIMIT = 3;
+var DEFAULT_PLAN_STEP_LIMIT = 20;
+function createActionsFamily(runtime) {
+  const category = {
+    discover(input) {
+      const policies = createPolicyFamily(runtime).listAIActions();
+      if (!input?.target) {
+        return {
+          status: "supported",
+          methods: ACTION_METHODS,
+          policyActions: policies
+        };
+      }
+      const resolved = resolveTarget(runtime, input.target);
+      if (!resolved.ok) {
+        return {
+          status: "blocked",
+          methods: ACTION_METHODS,
+          policyActions: policies,
+          blockers: resolved.blockers,
+          blockerDetails: resolved.blockerDetails
+        };
+      }
+      return {
+        status: "supported",
+        methods: ACTION_METHODS,
+        policyActions: policies,
+        target: summarizeTarget(resolved.target)
+      };
+    },
+    locate(input) {
+      const all = locateAll(runtime, { ...input, limit: input.limit ?? 1 });
+      return {
+        status: all.status,
+        matches: all.matches.slice(0, 1),
+        ...all.blockers ? { blockers: all.blockers } : {},
+        ...all.blockerDetails ? { blockerDetails: all.blockerDetails } : {}
+      };
+    },
+    locateAll(input) {
+      return locateAll(runtime, input);
+    },
+    rewrite(input) {
+      if (input.text === void 0) {
+        return blockedApply(
+          "actions:rewrite:text-required",
+          "input",
+          "Rewrite actions require a text value.",
+          "Retry with a text string."
+        );
+      }
+      const resolved = resolveTarget(runtime, input.target);
+      if (!resolved.ok) return blockedApplyFromResolution(resolved);
+      return applyRewrite(runtime, resolved.target, input);
+    },
+    rewriteAll(input) {
+      const located = locateAll(runtime, {
+        query: input.query,
+        kind: input.kind,
+        matchCase: input.matchCase,
+        limit: input.limit ?? DEFAULT_REWRITE_ALL_LIMIT,
+        includeTableText: input.includeTableText,
+        tableTextScopeLimit: input.tableTextScopeLimit
+      });
+      if (located.status !== "found") {
+        return blockedApply(
+          located.blockers?.[0] ?? `actions:locate:not-found:${input.query}`,
+          located.status === "blocked" ? "input" : "unresolved-target",
+          located.status === "blocked" ? "The locate request was blocked." : "No scope or table text action matched the query.",
+          "Call ai.actions.locateAll with a broader query, then retry with a returned handle or actionHandle.",
+          located.blockerDetails
+        );
+      }
+      const results = located.matches.map((match) => {
+        const target = match.actionHandle ? { actionHandle: match.actionHandle } : match.handle ? { handle: match.handle } : null;
+        if (!target) {
+          return blockedApply(
+            "actions:rewrite-all:match-without-target",
+            "blocked",
+            "A locate match did not carry a callable target.",
+            "Refresh the locate result and retry."
+          );
+        }
+        const resolved = resolveTarget(runtime, target);
+        if (!resolved.ok) return blockedApplyFromResolution(resolved);
+        return applyRewrite(runtime, resolved.target, input);
+      });
+      const applied = results.filter((result) => result.applied);
+      return {
+        status: applied.length === results.length ? "applied" : applied.length > 0 ? "partial" : "blocked",
+        applied: applied.length > 0,
+        changed: results.some((result) => result.changed),
+        results: Object.freeze(results)
+      };
+    },
+    insertText(input) {
+      const resolved = resolveTarget(runtime, input.target);
+      if (!resolved.ok) return blockedApplyFromResolution(resolved);
+      if (resolved.target.kind !== "scope") {
+        return blockedApply(
+          "actions:insert-text:table-text-adjacent-unsupported",
+          "unsupported",
+          "Adjacent text insertion is not supported for table text action handles.",
+          "Use ai.actions.rewrite with a table text actionHandle when replacing the cell text is acceptable."
+        );
+      }
+      const result = createReplacementFamily(runtime).applyReplacementScope({
+        targetScopeId: resolved.target.handle.scopeId,
+        operation: input.position === "before" ? "insert-before" : "insert-after",
+        proposedText: input.text,
+        ...input.actionId ? { actionId: input.actionId } : {},
+        ...input.reason ? { reason: input.reason } : {},
+        ...input.preserve ? { preserve: input.preserve } : {},
+        ...input.actorId ? { actorId: input.actorId } : {},
+        ...input.origin ? { origin: input.origin } : {},
+        ...input.proposalId ? { proposalId: input.proposalId } : {}
+      });
+      return projectApplyResult(result, resolved.target);
+    },
+    flag(input) {
+      const resolved = resolveTarget(runtime, input.target);
+      if (!resolved.ok) return blockedApplyFromResolution(resolved);
+      if (resolved.target.kind !== "scope") {
+        return blockedApply(
+          "actions:flag:table-text-handle-unsupported",
+          "unsupported",
+          "Issue flags attach to semantic scopes, not table text action handles.",
+          "Use the owning table or paragraph scope handle when creating an issue flag."
+        );
+      }
+      const result = createAttachFamily(runtime).createIssue({
+        scopeId: resolved.target.handle.scopeId,
+        summary: input.summary,
+        ...input.severity ? { severity: input.severity } : {},
+        ...input.actorId ? { actorId: input.actorId } : {},
+        ...input.origin ? { origin: input.origin } : {}
+      });
+      return {
+        status: result.created ? "applied" : "blocked",
+        applied: result.created,
+        changed: result.created,
+        target: summarizeTarget(resolved.target),
+        proposalId: result.issueId,
+        ...result.reason ? { blockers: Object.freeze([result.reason]) } : {},
+        ...result.reason ? {
+          blockerDetails: Object.freeze([
+            blocker(
+              result.reason,
+              "unresolved-target",
+              "The issue flag target could not be resolved.",
+              "Refresh the scope handle and retry."
+            )
+          ])
+        } : {},
+        ...result.auditReference ? { auditReference: result.auditReference } : {}
+      };
+    },
+    flagMany(input) {
+      const located = locateAll(runtime, input);
+      if (located.status !== "found") {
+        return blockedApply(
+          located.blockers?.[0] ?? `actions:locate:not-found:${input.query}`,
+          located.status === "blocked" ? "input" : "unresolved-target",
+          "No scope matched the flag query.",
+          "Call ai.actions.locateAll with a broader query, then retry with a returned handle.",
+          located.blockerDetails
+        );
+      }
+      const results = located.matches.map((match) => {
+        if (!match.handle) {
+          return blockedApply(
+            "actions:flag-many:table-text-handle-unsupported",
+            "unsupported",
+            "Issue flags attach to semantic scopes, not table text action handles.",
+            "Use a semantic scope handle for issue flags."
+          );
+        }
+        const resolved = resolveTarget(runtime, { handle: match.handle });
+        if (!resolved.ok) return blockedApplyFromResolution(resolved);
+        const result = createAttachFamily(runtime).createIssue({
+          scopeId: match.handle.scopeId,
+          summary: input.summary,
+          ...input.severity ? { severity: input.severity } : {},
+          ...input.actorId ? { actorId: input.actorId } : {},
+          ...input.origin ? { origin: input.origin } : {}
+        });
+        return {
+          status: result.created ? "applied" : "blocked",
+          applied: result.created,
+          changed: result.created,
+          target: summarizeTarget(resolved.target),
+          proposalId: result.issueId,
+          ...result.auditReference ? { auditReference: result.auditReference } : {}
+        };
+      });
+      const applied = results.filter((result) => result.applied);
+      return {
+        status: applied.length === results.length ? "applied" : applied.length > 0 ? "partial" : "blocked",
+        applied: applied.length > 0,
+        changed: results.some((result) => result.changed),
+        results: Object.freeze(results)
+      };
+    },
+    mark(input) {
+      const resolved = resolveTarget(runtime, input.target);
+      if (!resolved.ok) return blockedApplyFromResolution(resolved);
+      if (resolved.target.kind !== "scope") {
+        return blockedApply(
+          "actions:mark:table-text-handle-unsupported",
+          "unsupported",
+          "Mark actions apply to semantic scopes, not table text action handles.",
+          "Use a semantic scope handle for formatting marks."
+        );
+      }
+      const result = createReplacementFamily(runtime).applyScopeAction({
+        targetScopeId: resolved.target.handle.scopeId,
+        action: input.action,
+        ...input.actionId ? { actionId: input.actionId } : {},
+        ...input.reason ? { reason: input.reason } : {},
+        ...input.actorId ? { actorId: input.actorId } : {},
+        ...input.origin ? { origin: input.origin } : {},
+        ...input.proposalId ? { proposalId: input.proposalId } : {}
+      });
+      return projectApplyResult(result, resolved.target);
+    },
+    brief(input) {
+      if (!input?.target) {
+        return {
+          status: "read",
+          document: createInspectFamily(runtime).inspectDocument()
+        };
+      }
+      const resolved = resolveTarget(runtime, input.target);
+      if (!resolved.ok) {
+        return {
+          status: "blocked",
+          blockers: resolved.blockers,
+          blockerDetails: resolved.blockerDetails
+        };
+      }
+      if (resolved.target.kind === "table-text") {
+        const readback = resolved.target.action.readback;
+        return {
+          status: "read",
+          target: summarizeTarget(resolved.target),
+          ...readback ? { text: readback.text, excerpt: excerpt(readback.text) } : {}
+        };
+      }
+      const text = resolved.target.scope.content.text;
+      return {
+        status: "read",
+        target: summarizeTarget(resolved.target),
+        text,
+        excerpt: resolved.target.scope.content.excerpt ?? excerpt(text)
+      };
+    },
+    fieldRefresh(input) {
+      return applyModeledCommand(
+        runtime,
+        input.target,
+        "fieldRefresh",
+        {
+          type: "field.refresh",
+          options: { supportedOnly: input.supportedOnly ?? true },
+          origin: actionOrigin(runtime, input)
+        },
+        input
+      );
+    },
+    tocRefresh(input) {
+      return applyModeledCommand(
+        runtime,
+        input.target,
+        "tocRefresh",
+        {
+          type: "toc.refresh",
+          options: {
+            ...input.tocId ? { tocId: input.tocId } : {},
+            ...input.mode ? { mode: input.mode } : {},
+            ...input.maxLevel !== void 0 ? { maxLevel: input.maxLevel } : {}
+          },
+          origin: actionOrigin(runtime, input)
+        },
+        input
+      );
+    },
+    bookmarkEdit(input) {
+      if (input.text === void 0) {
+        return blockedApply(
+          "actions:bookmark-edit:text-required",
+          "input",
+          "Bookmark content edit actions require a text value.",
+          "Retry with a text string."
+        );
+      }
+      return applyModeledCommand(
+        runtime,
+        input.target,
+        "bookmarkEdit",
+        {
+          type: "bookmark.edit-content",
+          text: input.text,
+          origin: actionOrigin(runtime, input)
+        },
+        input
+      );
+    },
+    hyperlinkDestinationEdit(input) {
+      if (!input.href) {
+        return blockedApply(
+          "actions:hyperlink-destination-edit:href-required",
+          "input",
+          "Hyperlink destination edit actions require a non-empty href.",
+          "Retry with an href string."
+        );
+      }
+      return applyModeledCommand(
+        runtime,
+        input.target,
+        "hyperlinkDestinationEdit",
+        {
+          type: "hyperlink.update-destination",
+          href: input.href,
+          origin: actionOrigin(runtime, input)
+        },
+        input
+      );
+    },
+    listOperation(input) {
+      return applyListOperation(runtime, input);
+    },
+    tableFragment(input) {
+      const result = createTableActionFamily(runtime).applyTableAction(input);
+      return projectTableApplyResult(result);
+    },
+    tableSelection(input) {
+      const result = createTableActionFamily(runtime).applyTableAction(input);
+      return projectTableApplyResult(result);
+    },
+    runPlan(input) {
+      return runPlan(runtime, input);
+    }
+  };
+  const family = {
+    actions() {
+      return Object.freeze(category);
+    }
+  };
+  return { actions: family.actions() };
+}
+function runPlan(runtime, input) {
+  const mode = input.mode ?? "preview";
+  const maxSteps = Math.max(0, input.maxSteps ?? DEFAULT_PLAN_STEP_LIMIT);
+  if (!Array.isArray(input.steps) || input.steps.length === 0) {
+    return blockedPlan(
+      mode,
+      "actions:plan:empty",
+      "input",
+      "Run plan requires at least one structured step.",
+      "Have the host generate explicit steps with exact scope handles or opaque action handles."
+    );
+  }
+  if (input.steps.length > maxSteps) {
+    return blockedPlan(
+      mode,
+      `actions:plan:too-many-steps:${input.steps.length}`,
+      "input",
+      `Run plan received ${input.steps.length} steps, exceeding the limit of ${maxSteps}.`,
+      "Split the host-generated plan into smaller calls and retry."
+    );
+  }
+  const stopOnBlocker = input.stopOnBlocker ?? true;
+  const results = [];
+  for (const step of input.steps) {
+    const result = runPlanStep(runtime, mode, step, input);
+    results.push(result);
+    if (stopOnBlocker && (result.status === "blocked" || result.status === "unsupported")) {
+      break;
+    }
+  }
+  return summarizePlanResult(mode, results);
+}
+function runPlanStep(runtime, mode, step, plan) {
+  if (!step.id) {
+    return blockedPlanStep(
+      "unknown-step",
+      step.kind,
+      "actions:plan:step-id-required",
+      "input",
+      "Every plan step requires a stable id supplied by the host.",
+      "Regenerate the plan with stable per-step ids."
+    );
+  }
+  if (step.kind === "tableAction" || step.kind === "tableFragment" || step.kind === "tableSelection") {
+    return runPlanTableActionStep(runtime, mode, step, plan);
+  }
+  const before = step.target ? readPlanTarget(runtime, step.target) : readDocumentPlanTarget(runtime);
+  if (!before.ok) {
+    return blockedPlanStepFromDetails(step.id, step.kind, before.blockerDetails);
+  }
+  const precondition = checkPlanPreconditions(step, before.readback);
+  if (precondition) {
+    return blockedPlanStepFromDetails(step.id, step.kind, [precondition], {
+      target: before.target,
+      beforeReadback: before.readback,
+      tableAction: before.tableAction
+    });
+  }
+  if (step.kind === "brief") {
+    return {
+      id: step.id,
+      kind: step.kind,
+      status: "read",
+      applied: false,
+      changed: false,
+      ...before.target ? { target: before.target } : {},
+      ...before.tableAction ? { tableAction: before.tableAction } : {},
+      ...before.readback ? { beforeReadback: before.readback } : {}
+    };
+  }
+  const capabilityBlocker = checkPlanStepCapability(runtime, step, before);
+  if (capabilityBlocker) {
+    return blockedPlanStepFromDetails(step.id, step.kind, [capabilityBlocker], {
+      target: before.target,
+      beforeReadback: before.readback,
+      tableAction: before.tableAction
+    });
+  }
+  if (mode === "preview") {
+    return {
+      id: step.id,
+      kind: step.kind,
+      status: "planned",
+      applied: false,
+      changed: false,
+      ...before.target ? { target: before.target } : {},
+      ...before.tableAction ? { tableAction: before.tableAction } : {},
+      ...before.readback ? { beforeReadback: before.readback } : {}
+    };
+  }
+  const applied = applyPlanStep(runtime, step, plan);
+  const after = step.kind === "flag" ? before : step.target ? readPlanTarget(runtime, step.target) : before;
+  return {
+    id: step.id,
+    kind: step.kind,
+    status: applied.status === "unsupported" ? "unsupported" : applied.applied ? "applied" : "blocked",
+    applied: applied.applied,
+    changed: applied.changed,
+    ...applied.target ?? before.target ? { target: applied.target ?? before.target } : {},
+    ...before.tableAction ? { tableAction: before.tableAction } : {},
+    ...before.readback ? { beforeReadback: before.readback } : {},
+    ...after.ok && after.readback ? { afterReadback: after.readback } : {},
+    ...applied.proposalId ? { proposalId: applied.proposalId } : {},
+    ...applied.posture ? { posture: applied.posture } : {},
+    ...applied.blockers ? { blockers: applied.blockers } : {},
+    ...applied.blockerDetails ? { blockerDetails: applied.blockerDetails } : {},
+    ...applied.auditReference ? { auditReference: applied.auditReference } : {},
+    ...applied.commandReference ? { commandReference: applied.commandReference } : {}
+  };
+}
+function runPlanTableActionStep(runtime, mode, step, plan) {
+  const before = readPlanTableAction(runtime, step.actionHandle);
+  if (!before.ok) {
+    return blockedPlanStepFromDetails(step.id, step.kind, before.blockerDetails);
+  }
+  const tableAction = before.tableAction;
+  if (!tableAction) {
+    return blockedPlanStep(
+      step.id,
+      step.kind,
+      `actions:plan:action-handle-not-found:${step.actionHandle}`,
+      "unresolved-target",
+      "No current table action matches the supplied opaque actionHandle.",
+      "Have the host re-list table actions and regenerate the plan with a fresh actionHandle."
+    );
+  }
+  const precondition = checkPlanPreconditions(step, before.readback);
+  if (precondition) {
+    return blockedPlanStepFromDetails(step.id, step.kind, [precondition], {
+      beforeReadback: before.readback,
+      tableAction
+    });
+  }
+  const operationKind = step.operation?.kind;
+  const operationFamilyBlocker = tablePlanOperationFamilyBlocker(step.kind, operationKind);
+  if (operationFamilyBlocker) {
+    return blockedPlanStepFromDetails(step.id, step.kind, [operationFamilyBlocker], {
+      beforeReadback: before.readback,
+      tableAction
+    });
+  }
+  if (!operationKind || !tableAction.callableOperations.includes(operationKind)) {
+    return blockedPlanStepFromDetails(
+      step.id,
+      step.kind,
+      [
+        blocker(
+          `actions:plan:table-operation-unsupported:${step.id}`,
+          "unsupported",
+          "The table action handle does not advertise the requested operation as callable.",
+          "Have the host re-list table actions and choose an operation from callableOperations."
+        )
+      ],
+      {
+        beforeReadback: before.readback,
+        tableAction
+      }
+    );
+  }
+  if (mode === "preview") {
+    return {
+      id: step.id,
+      kind: step.kind,
+      status: "planned",
+      applied: false,
+      changed: false,
+      tableAction,
+      ...before.readback ? { beforeReadback: before.readback } : {}
+    };
+  }
+  const result = createTableActionFamily(runtime).applyTableAction({
+    actionHandle: step.actionHandle,
+    operation: step.operation,
+    ...step.scopeId ? { scopeId: step.scopeId } : {},
+    actorId: step.actorId ?? plan.actorId,
+    origin: step.origin ?? plan.origin,
+    ...step.proposalId ? { proposalId: step.proposalId } : {}
+  });
+  const after = readPlanTableAction(runtime, step.actionHandle);
+  return {
+    id: step.id,
+    kind: step.kind,
+    status: result.applied ? "applied" : "blocked",
+    applied: result.applied,
+    changed: result.changed,
+    tableAction,
+    ...before.readback ? { beforeReadback: before.readback } : {},
+    ...result.afterReadback ? { afterReadback: tableReadbackToPlanReadback(result.afterReadback) } : after.ok && after.readback ? { afterReadback: after.readback } : {},
+    proposalId: result.proposalId,
+    ...result.posture ? { posture: result.posture } : {},
+    ...result.blockers ? { blockers: result.blockers } : {},
+    ...result.blockerDetails ? {
+      blockerDetails: Object.freeze(
+        result.blockerDetails.map(
+          (detail) => blocker(detail.code, "blocked", detail.message, detail.nextStep)
+        )
+      )
+    } : {},
+    ...result.commandReference ? { commandReference: result.commandReference } : {}
+  };
+}
+function locateAll(runtime, input) {
+  if (!input.query) {
+    const detail = blocker(
+      "actions:locate:query-required",
+      "input",
+      "Locate actions require a non-empty query.",
+      "Retry with a non-empty query string."
+    );
+    return {
+      status: "blocked",
+      matches: Object.freeze([]),
+      blockers: Object.freeze([detail.code]),
+      blockerDetails: Object.freeze([detail])
+    };
+  }
+  const compiler = createScopeCompilerService(runtime);
+  const limit = Math.max(0, input.limit ?? DEFAULT_LOCATE_LIMIT);
+  const matches = [];
+  const scopes = compiler.compileAllScopes();
+  const shouldScanTableText = input.includeTableText === true || input.includeTableText !== false && input.kind !== void 0 && isTableFamilyScope(input.kind);
+  for (const scope of scopes) {
+    if (matches.length >= limit) break;
+    if (input.kind && scope.kind !== input.kind) continue;
+    if (isTableFamilyScope(scope.kind)) continue;
+    const text = scope.content.text;
+    if (!textMatches(text, input.query, input.matchCase)) continue;
+    matches.push({
+      kind: scope.kind,
+      text,
+      excerpt: scope.content.excerpt ?? excerpt(text),
+      handle: scope.handle,
+      isEmpty: text.trim().length === 0
+    });
+  }
+  if (matches.length < limit && shouldScanTableText) {
+    const tableTextScopeLimit = Math.max(
+      0,
+      input.tableTextScopeLimit ?? DEFAULT_TABLE_TEXT_SCOPE_LIMIT
+    );
+    let tableScopesScanned = 0;
+    for (const scope of scopes) {
+      if (matches.length >= limit || tableScopesScanned >= tableTextScopeLimit) break;
+      if (scope.kind !== "table") continue;
+      tableScopesScanned += 1;
+      for (const action of tableTextActionsForScope(runtime, scope.handle)) {
+        if (matches.length >= limit) break;
+        const readback = action.readback;
+        if (!readback || !textMatches(readback.text, input.query, input.matchCase)) continue;
+        matches.push({
+          kind: "table-text",
+          text: readback.text,
+          excerpt: excerpt(readback.text),
+          actionHandle: action.actionHandle,
+          readback,
+          isEmpty: readback.isEmpty
+        });
+      }
+    }
+  }
+  return {
+    status: matches.length > 0 ? "found" : "not-found",
+    matches: Object.freeze(matches),
+    ...matches.length === 0 ? { blockers: Object.freeze([`actions:locate:not-found:${input.query}`]) } : {}
+  };
+}
+function resolveTarget(runtime, target) {
+  if ("actionHandle" in target) {
+    const action = findTableAction(runtime, target.actionHandle);
+    if (!action) {
+      return blockedResolution(
+        `actions:target:action-handle-not-found:${target.actionHandle}`,
+        "unresolved-target",
+        "No current table text action matches the supplied actionHandle.",
+        "Call ai.actions.locateAll or ai.listTableActions again and retry with a fresh actionHandle."
+      );
+    }
+    if (action.family !== "table-text") {
+      return blockedResolution(
+        `actions:target:action-handle-not-text:${target.actionHandle}`,
+        "unsupported",
+        "This actionHandle is not a table text action.",
+        "Use table structure handles with ai.applyTableAction, or use a table text actionHandle for rewrite."
+      );
+    }
+    return { ok: true, target: { kind: "table-text", action } };
+  }
+  if ("handle" in target) {
+    const compiled = createScopeCompilerService(runtime).compileScopeById(target.handle.scopeId);
+    if (!compiled) {
+      return blockedResolution(
+        `actions:target:scope-not-resolvable:${target.handle.scopeId}`,
+        "unresolved-target",
+        "The target scope no longer resolves in the current document.",
+        "Refresh the scope handle with ai.actions.locateAll or ai.resolveReference, then retry."
+      );
+    }
+    return { ok: true, target: { kind: "scope", scope: compiled.scope, handle: compiled.scope.handle } };
+  }
+  const located = locateAll(runtime, {
+    query: target.query,
+    kind: target.kind,
+    matchCase: target.matchCase,
+    includeTableText: target.includeTableText,
+    tableTextScopeLimit: target.tableTextScopeLimit,
+    limit: 2
+  });
+  if (located.status !== "found") {
+    return blockedResolution(
+      located.blockers?.[0] ?? `actions:target:not-found:${target.query}`,
+      located.status === "blocked" ? "input" : "unresolved-target",
+      located.status === "blocked" ? "The target query was blocked." : "No unique target matched the query.",
+      "Call ai.actions.locateAll and retry with a returned handle or actionHandle.",
+      located.blockerDetails
+    );
+  }
+  if (located.matches.length > 1) {
+    return blockedResolution(
+      `actions:target:ambiguous:${target.query}`,
+      "ambiguous-target",
+      "The query matched more than one target.",
+      "Call ai.actions.locateAll and retry with the exact returned handle or actionHandle."
+    );
+  }
+  const [match] = located.matches;
+  if (!match) {
+    return blockedResolution(
+      `actions:target:not-found:${target.query}`,
+      "unresolved-target",
+      "No target matched the query.",
+      "Call ai.actions.locateAll with a broader query."
+    );
+  }
+  if (match.actionHandle) return resolveTarget(runtime, { actionHandle: match.actionHandle });
+  if (match.handle) return resolveTarget(runtime, { handle: match.handle });
+  return blockedResolution(
+    `actions:target:not-callable:${target.query}`,
+    "blocked",
+    "The locate match did not carry a callable target.",
+    "Refresh the locate result and retry."
+  );
+}
+function applyRewrite(runtime, target, input) {
+  if (target.kind === "table-text") {
+    const result2 = createTableActionFamily(runtime).applyTableAction({
+      actionHandle: target.action.actionHandle,
+      operation: { kind: "paste-cell-content", content: { kind: "text", text: input.text } },
+      actorId: input.actorId,
+      origin: input.origin,
+      proposalId: input.proposalId ?? mockId(runtime.getSessionState().documentId, `actions-rewrite-${target.action.actionHandle}`)
+    });
+    return {
+      status: result2.applied ? "applied" : "blocked",
+      applied: result2.applied,
+      changed: result2.changed,
+      target: summarizeTarget(target),
+      proposalId: result2.proposalId,
+      posture: result2.posture,
+      ...result2.blockers ? { blockers: result2.blockers } : {},
+      ...result2.blockerDetails ? {
+        blockerDetails: Object.freeze(
+          result2.blockerDetails.map(
+            (detail) => blocker(detail.code, "blocked", detail.message, detail.nextStep)
+          )
+        )
+      } : {},
+      ...result2.commandReference ? { commandReference: result2.commandReference } : {},
+      ...result2.afterReadback ? { afterReadback: result2.afterReadback } : {}
+    };
+  }
+  const beforeText = target.scope.content.text;
+  const result = createReplacementFamily(runtime).applyReplacementScope({
+    targetScopeId: target.handle.scopeId,
+    operation: "replace",
+    proposedText: input.text,
+    ...input.actionId ? { actionId: input.actionId } : {},
+    ...input.reason ? { reason: input.reason } : {},
+    ...input.preserve ? { preserve: input.preserve } : {},
+    ...input.actorId ? { actorId: input.actorId } : {},
+    ...input.origin ? { origin: input.origin } : {},
+    ...input.proposalId ? { proposalId: input.proposalId } : {}
+  });
+  return projectRewriteScopeResult(runtime, result, target, beforeText, input.text);
+}
+function projectApplyResult(result, target) {
+  return {
+    status: result.applied ? "applied" : "blocked",
+    applied: result.applied,
+    changed: result.applied,
+    target: summarizeTarget(target),
+    proposalId: result.proposalId,
+    ...result.posture ? { posture: result.posture } : {},
+    ...result.blockers ? { blockers: result.blockers } : {},
+    ...result.blockerDetails ? {
+      blockerDetails: Object.freeze(
+        result.blockerDetails.map(
+          (detail) => blocker(detail.code, "blocked", detail.message, detail.nextStep)
+        )
+      )
+    } : {},
+    ...result.auditReference ? { auditReference: result.auditReference } : {}
+  };
+}
+function projectRewriteScopeResult(runtime, result, target, beforeText, proposedText) {
+  if (!result.applied) return projectApplyResult(result, target);
+  const compiledAfter = createScopeCompilerService(runtime).compileScopeById(
+    target.handle.scopeId
+  );
+  if (!compiledAfter) {
+    return blockedRewriteReadback(
+      result,
+      target,
+      `actions:rewrite:authoritative-readback-unresolvable:${target.handle.scopeId}`,
+      "The replacement primitive reported success, but the target scope could not be re-read afterwards.",
+      "Treat the mutation as untrusted. Re-locate the target and retry only after the scope resolves, or create an issue flag instead."
+    );
+  }
+  const afterText = compiledAfter.scope.content.text;
+  const changed = afterText !== beforeText;
+  const expectedPresent = proposedText.length === 0 ? afterText.length === 0 : afterText.includes(proposedText);
+  if (!changed) {
+    return blockedRewriteReadback(
+      result,
+      { ...target, scope: compiledAfter.scope, handle: compiledAfter.scope.handle },
+      `actions:rewrite:authoritative-readback-unchanged:${target.handle.scopeId}`,
+      "The replacement primitive reported success, but authoritative scope readback showed unchanged text.",
+      "Treat the mutation as not applied. Retry with a narrower scope or create an issue flag; do not claim the replacement succeeded."
+    );
+  }
+  if (!expectedPresent) {
+    return blockedRewriteReadback(
+      result,
+      { ...target, scope: compiledAfter.scope, handle: compiledAfter.scope.handle },
+      `actions:rewrite:authoritative-readback-mismatch:${target.handle.scopeId}`,
+      "The replacement primitive reported success, but authoritative scope readback did not contain the proposed text.",
+      "Treat the mutation as suspect. Re-read the target, inspect the exported package when available, and retry only with a verified target."
+    );
+  }
+  return {
+    status: "applied",
+    applied: true,
+    changed: true,
+    target: summarizeTarget({
+      ...target,
+      scope: compiledAfter.scope,
+      handle: compiledAfter.scope.handle
+    }),
+    proposalId: result.proposalId,
+    ...result.posture ? { posture: result.posture } : {},
+    ...result.auditReference ? { auditReference: result.auditReference } : {}
+  };
+}
+function blockedRewriteReadback(result, target, code, message, nextStep) {
+  const detail = blocker(code, "blocked", message, nextStep);
+  return {
+    status: "blocked",
+    applied: false,
+    changed: false,
+    target: summarizeTarget(target),
+    proposalId: result.proposalId,
+    posture: "suspect-readback",
+    blockers: Object.freeze([detail.code]),
+    blockerDetails: Object.freeze([detail]),
+    ...result.auditReference ? { auditReference: result.auditReference } : {}
+  };
+}
+function summarizeTarget(target) {
+  if (target.kind === "table-text") {
+    return {
+      kind: "table-text",
+      actionHandle: target.action.actionHandle,
+      ...target.action.readback ? { readback: target.action.readback } : {},
+      canRewriteText: true,
+      canInsertAdjacentText: false,
+      canFlag: false,
+      canMark: false
+    };
+  }
+  return {
+    kind: target.scope.kind,
+    handle: target.handle,
+    canRewriteText: canRewriteScopeText(target.scope),
+    canInsertAdjacentText: canRewriteScopeText(target.scope),
+    canFlag: true,
+    canMark: canMarkScope(target.scope)
+  };
+}
+function tableTextActionsForScope(runtime, handle) {
+  const result = createTableActionFamily(runtime).listTableActions({
+    handle,
+    nowUtc: currentAuditTimestamp(runtime)
+  });
+  return result.actions.filter((action) => action.family === "table-text");
+}
+function findTableAction(runtime, actionHandle) {
+  const action = findAnyTableAction(runtime, actionHandle);
+  return action?.family === "table-text" ? action : null;
+}
+function findAnyTableAction(runtime, actionHandle) {
+  const compiler = createScopeCompilerService(runtime);
+  for (const scope of compiler.compileAllScopes()) {
+    if (scope.kind !== "table") continue;
+    const result = createTableActionFamily(runtime).listTableActions({
+      handle: scope.handle,
+      nowUtc: currentAuditTimestamp(runtime)
+    });
+    const action = result.actions.find(
+      (candidate) => candidate.actionHandle === actionHandle
+    );
+    if (action) return action;
+  }
+  return null;
+}
+function readDocumentPlanTarget(runtime) {
+  const document = createInspectFamily(runtime).inspectDocument();
+  return {
+    ok: true,
+    readback: {
+      text: document.semanticSummary,
+      excerpt: document.semanticSummary,
+      isEmpty: document.semanticSummary.trim().length === 0
+    }
+  };
+}
+function readPlanTarget(runtime, target) {
+  if ("handle" in target) {
+    const compiled = createScopeCompilerService(runtime).compileScopeById(target.handle.scopeId);
+    if (!compiled) {
+      return {
+        ok: false,
+        blockerDetails: Object.freeze([
+          blocker(
+            `actions:plan:target-not-resolvable:${target.handle.scopeId}`,
+            "unresolved-target",
+            "The plan step scope handle no longer resolves.",
+            "Have the host re-locate the target and regenerate the plan with a fresh handle."
+          )
+        ])
+      };
+    }
+    const text = compiled.scope.content.text;
+    const resolved = {
+      kind: "scope",
+      scope: compiled.scope,
+      handle: compiled.scope.handle
+    };
+    return {
+      ok: true,
+      target: summarizeTarget(resolved),
+      readback: {
+        text,
+        excerpt: compiled.scope.content.excerpt ?? excerpt(text),
+        isEmpty: text.trim().length === 0
+      }
+    };
+  }
+  if (!("actionHandle" in target) || typeof target.actionHandle !== "string") {
+    return {
+      ok: false,
+      blockerDetails: Object.freeze([
+        blocker(
+          "actions:plan:exact-target-required",
+          "input",
+          "Plan steps accept only exact ScopeHandle or opaque actionHandle targets.",
+          "Have the host resolve queries before calling runPlan and pass only returned handles."
+        )
+      ])
+    };
+  }
+  return readPlanTableAction(runtime, target.actionHandle);
+}
+function readPlanTableAction(runtime, actionHandle) {
+  const action = findAnyTableAction(runtime, actionHandle);
+  if (!action) {
+    return {
+      ok: false,
+      blockerDetails: Object.freeze([
+        blocker(
+          `actions:plan:action-handle-not-found:${actionHandle}`,
+          "unresolved-target",
+          "No current table action matches the supplied opaque actionHandle.",
+          "Have the host call ai.listTableActions or ai.actions.locateAll again and regenerate the plan with a fresh actionHandle."
+        )
+      ])
+    };
+  }
+  return {
+    ok: true,
+    tableAction: action,
+    ...action.family === "table-text" ? { target: summarizeTarget({ kind: "table-text", action }) } : {},
+    ...action.readback ? { readback: tableReadbackToPlanReadback(action.readback) } : {}
+  };
+}
+function tableReadbackToPlanReadback(readback) {
+  return {
+    text: readback.text,
+    excerpt: excerpt(readback.text),
+    isEmpty: readback.isEmpty
+  };
+}
+function checkPlanPreconditions(step, readback) {
+  const preconditions = step.preconditions;
+  if (!preconditions) return null;
+  if (preconditions.expectedBeforeTextIncludes !== void 0 && !readback?.text?.includes(preconditions.expectedBeforeTextIncludes)) {
+    return blocker(
+      `actions:plan:precondition-text-mismatch:${step.id}`,
+      "blocked",
+      "The target readback did not contain the host-provided expected text before the step.",
+      "Re-read the target and regenerate the plan from current document state."
+    );
+  }
+  if (preconditions.expectedBeforeIsEmpty !== void 0 && readback?.isEmpty !== preconditions.expectedBeforeIsEmpty) {
+    return blocker(
+      `actions:plan:precondition-empty-mismatch:${step.id}`,
+      "blocked",
+      "The target empty/non-empty state no longer matches the host-provided precondition.",
+      "Re-read the target and regenerate the plan from current document state."
+    );
+  }
+  return null;
+}
+function checkPlanStepCapability(runtime, step, before) {
+  const target = before.target;
+  if (!target) {
+    return blocker(
+      `actions:plan:target-required:${step.id}`,
+      "input",
+      "The plan step requires an exact target handle.",
+      "Regenerate the plan with a ScopeHandle or opaque actionHandle returned by L09."
+    );
+  }
+  if (step.kind === "rewrite" && !target.canRewriteText) {
+    return blocker(
+      `actions:plan:target-not-rewriteable:${step.id}`,
+      "unsupported",
+      "The target capability posture does not allow text rewrite.",
+      "Use a supported text target, table text actionHandle, or create an issue flag instead."
+    );
+  }
+  if (step.kind === "insertText" && !target.canInsertAdjacentText) {
+    return blocker(
+      `actions:plan:target-not-insertable:${step.id}`,
+      "unsupported",
+      "The target capability posture does not allow adjacent text insertion.",
+      "Use a supported semantic scope or choose rewrite/flag instead."
+    );
+  }
+  if (step.kind === "flag" && !target.canFlag) {
+    return blocker(
+      `actions:plan:target-not-flaggable:${step.id}`,
+      "unsupported",
+      "The target capability posture does not allow issue flags.",
+      "Use the owning semantic scope handle for issue flags."
+    );
+  }
+  if (step.kind === "mark" && !target.canMark) {
+    return blocker(
+      `actions:plan:target-not-markable:${step.id}`,
+      "unsupported",
+      "The target capability posture does not allow formatting marks.",
+      "Use a supported semantic scope or create an issue flag instead."
+    );
+  }
+  if (step.kind === "fieldRefresh" || step.kind === "tocRefresh" || step.kind === "bookmarkEdit" || step.kind === "hyperlinkDestinationEdit") {
+    const resolved = resolveScopeExactTarget(runtime, step.target, step.kind);
+    if (!resolved.ok) return resolved.blockerDetails[0] ?? null;
+    const targetRef = resolveModeledEditableTarget(runtime, resolved.target, step.kind);
+    if (!targetRef.ok) return targetRef.blockerDetails[0] ?? null;
+    return null;
+  }
+  if (step.kind === "listOperation") {
+    const resolved = resolveScopeExactTarget(runtime, step.target, step.kind);
+    if (!resolved.ok) return resolved.blockerDetails[0] ?? null;
+    const scope = resolved.target.scope;
+    if (scope.kind !== "list-item" && scope.kind !== "paragraph" && scope.kind !== "heading") {
+      return blocker(
+        `actions:list-operation:target-kind-unsupported:${scope.kind}`,
+        "unsupported",
+        "List operations require a paragraph-like scope handle.",
+        "Use ai.actions.locateAll or ai.listScopes to select a paragraph, heading, or list-item handle."
+      );
+    }
+    if (paragraphIndexFromHandle(scope.handle) === null) {
+      return blockerWithOwner(
+        `actions:list-operation:paragraph-index-unresolved:${scope.handle.scopeId}`,
+        "blocked",
+        "The list operation target did not resolve to a current paragraph index.",
+        "Refresh the scope handle and retry; route persistent failures to L08 scope resolution.",
+        "L08 semantic scope compiler"
+      );
+    }
+    return null;
+  }
+  return null;
+}
+function applyPlanStep(runtime, step, plan) {
+  switch (step.kind) {
+    case "rewrite":
+      return createActionsFamily(runtime).actions.rewrite({
+        target: step.target,
+        text: step.text,
+        ...step.actionId ? { actionId: step.actionId } : {},
+        ...step.reason ? { reason: step.reason } : {},
+        ...step.preserve ? { preserve: step.preserve } : {},
+        actorId: step.actorId ?? plan.actorId,
+        origin: step.origin ?? plan.origin,
+        ...step.proposalId ? { proposalId: step.proposalId } : {}
+      });
+    case "insertText":
+      return createActionsFamily(runtime).actions.insertText({
+        target: step.target,
+        position: step.position,
+        text: step.text,
+        ...step.actionId ? { actionId: step.actionId } : {},
+        ...step.reason ? { reason: step.reason } : {},
+        ...step.preserve ? { preserve: step.preserve } : {},
+        actorId: step.actorId ?? plan.actorId,
+        origin: step.origin ?? plan.origin,
+        ...step.proposalId ? { proposalId: step.proposalId } : {}
+      });
+    case "flag":
+      return createActionsFamily(runtime).actions.flag({
+        target: step.target,
+        summary: step.summary,
+        ...step.severity ? { severity: step.severity } : {},
+        actorId: step.actorId ?? plan.actorId,
+        origin: step.origin ?? plan.origin
+      });
+    case "mark":
+      return createActionsFamily(runtime).actions.mark({
+        target: step.target,
+        action: step.action,
+        ...step.actionId ? { actionId: step.actionId } : {},
+        ...step.reason ? { reason: step.reason } : {},
+        actorId: step.actorId ?? plan.actorId,
+        origin: step.origin ?? plan.origin,
+        ...step.proposalId ? { proposalId: step.proposalId } : {}
+      });
+    case "fieldRefresh":
+      return createActionsFamily(runtime).actions.fieldRefresh({
+        target: step.target,
+        supportedOnly: step.supportedOnly,
+        actorId: step.actorId ?? plan.actorId,
+        origin: step.origin ?? plan.origin
+      });
+    case "tocRefresh":
+      return createActionsFamily(runtime).actions.tocRefresh({
+        target: step.target,
+        ...step.tocId ? { tocId: step.tocId } : {},
+        ...step.mode ? { mode: step.mode } : {},
+        ...step.maxLevel !== void 0 ? { maxLevel: step.maxLevel } : {},
+        actorId: step.actorId ?? plan.actorId,
+        origin: step.origin ?? plan.origin
+      });
+    case "bookmarkEdit":
+      return createActionsFamily(runtime).actions.bookmarkEdit({
+        target: step.target,
+        text: step.text,
+        actorId: step.actorId ?? plan.actorId,
+        origin: step.origin ?? plan.origin
+      });
+    case "hyperlinkDestinationEdit":
+      return createActionsFamily(runtime).actions.hyperlinkDestinationEdit({
+        target: step.target,
+        href: step.href,
+        actorId: step.actorId ?? plan.actorId,
+        origin: step.origin ?? plan.origin
+      });
+    case "listOperation":
+      return createActionsFamily(runtime).actions.listOperation({
+        target: step.target,
+        operation: step.operation,
+        actorId: step.actorId ?? plan.actorId,
+        origin: step.origin ?? plan.origin
+      });
+  }
+}
+function applyModeledCommand(runtime, targetInput, kind, commandInput, reference) {
+  const resolvedScope = resolveScopeExactTarget(runtime, targetInput, kind);
+  if (!resolvedScope.ok) return blockedApplyFromResolution(resolvedScope);
+  const targetRef = resolveModeledEditableTarget(runtime, resolvedScope.target, kind);
+  if (!targetRef.ok) {
+    return blockedApplyFromResolution(targetRef);
+  }
+  const before = runtime.getCanonicalDocument();
+  const command = {
+    ...commandInput,
+    editableTarget: targetRef.targetRef
+  };
+  runtime.dispatch(command);
+  const after = runtime.getCanonicalDocument();
+  const changed = after !== before;
+  if (!changed) {
+    return blockedApply(
+      `actions:${actionSlug(kind)}:runtime-noop:${resolvedScope.target.handle.scopeId}`,
+      "blocked",
+      "The modeled runtime command was accepted but produced no document change.",
+      `Route to ${ownerRouteForModeledAction(kind)} with the target handle and command family evidence; do not report this as a successful warning path.`,
+      [
+        blockerWithOwner(
+          `actions:${actionSlug(kind)}:runtime-noop:${resolvedScope.target.handle.scopeId}`,
+          "blocked",
+          "The modeled runtime command was accepted but produced no document change.",
+          `Route to ${ownerRouteForModeledAction(kind)} with the target handle and command family evidence; do not report this as a successful warning path.`,
+          ownerRouteForModeledAction(kind)
+        )
+      ]
+    );
+  }
+  const compiledAfter = createScopeCompilerService(runtime).compileScopeById(
+    resolvedScope.target.handle.scopeId
+  );
+  const summarizedTarget = compiledAfter ? summarizeTarget({
+    kind: "scope",
+    scope: compiledAfter.scope,
+    handle: compiledAfter.scope.handle
+  }) : summarizeTarget(resolvedScope.target);
+  return {
+    status: "applied",
+    applied: true,
+    changed: true,
+    target: summarizedTarget,
+    commandReference: {
+      command: command.type,
+      actorId: reference?.actorId ?? commandActorId(commandInput.origin),
+      origin: reference?.origin ?? commandOriginKind(commandInput.origin),
+      emittedAtUtc: commandInput.origin?.timestamp ?? currentAuditTimestamp(runtime)
+    }
+  };
+}
+function applyListOperation(runtime, input) {
+  const resolvedScope = resolveScopeExactTarget(runtime, input.target, "listOperation");
+  if (!resolvedScope.ok) return blockedApplyFromResolution(resolvedScope);
+  const scope = resolvedScope.target.scope;
+  if (scope.kind !== "list-item" && scope.kind !== "paragraph" && scope.kind !== "heading") {
+    return blockedApply(
+      `actions:list-operation:target-kind-unsupported:${scope.kind}`,
+      "unsupported",
+      "List operations require a paragraph-like scope handle.",
+      "Use ai.actions.locateAll or ai.listScopes to select a paragraph, heading, or list-item handle."
+    );
+  }
+  const paragraphIndex = paragraphIndexFromHandle(scope.handle);
+  if (paragraphIndex === null) {
+    return blockedApply(
+      `actions:list-operation:paragraph-index-unresolved:${scope.handle.scopeId}`,
+      "blocked",
+      "The list operation target did not resolve to a current paragraph index.",
+      "Refresh the scope handle and retry; route persistent failures to L08 scope resolution.",
+      [
+        blockerWithOwner(
+          `actions:list-operation:paragraph-index-unresolved:${scope.handle.scopeId}`,
+          "blocked",
+          "The list operation target did not resolve to a current paragraph index.",
+          "Refresh the scope handle and retry; route persistent failures to L08 scope resolution.",
+          "L08 semantic scope compiler"
+        )
+      ]
+    );
+  }
+  const command = listCommandForOperation(input.operation, paragraphIndex, actionOrigin(runtime, input));
+  const before = runtime.getCanonicalDocument();
+  runtime.dispatch(command);
+  const changed = runtime.getCanonicalDocument() !== before;
+  if (!changed) {
+    return blockedApply(
+      `actions:list-operation:runtime-noop:${scope.handle.scopeId}`,
+      "blocked",
+      "The list runtime command produced no document change for the selected scope.",
+      "Select a list-compatible paragraph and retry, or route to L03/L07 list command support with the scope handle.",
+      [
+        blockerWithOwner(
+          `actions:list-operation:runtime-noop:${scope.handle.scopeId}`,
+          "blocked",
+          "The list runtime command produced no document change for the selected scope.",
+          "Select a list-compatible paragraph and retry, or route to L03/L07 list command support with the scope handle.",
+          "L03 numbering/list semantics and L07 runtime list commands"
+        )
+      ]
+    );
+  }
+  const compiledAfter = createScopeCompilerService(runtime).compileScopeById(scope.handle.scopeId);
+  return {
+    status: "applied",
+    applied: true,
+    changed: true,
+    target: compiledAfter ? summarizeTarget({ kind: "scope", scope: compiledAfter.scope, handle: compiledAfter.scope.handle }) : summarizeTarget(resolvedScope.target),
+    commandReference: {
+      command: command.type,
+      actorId: input.actorId ?? "v3-ai-api",
+      origin: input.origin ?? "agent",
+      emittedAtUtc: command.origin?.timestamp ?? currentAuditTimestamp(runtime)
+    }
+  };
+}
+function projectTableApplyResult(result) {
+  return {
+    status: result.applied ? "applied" : "blocked",
+    applied: result.applied,
+    changed: result.changed,
+    proposalId: result.proposalId,
+    posture: result.posture,
+    ...result.blockers ? { blockers: result.blockers } : {},
+    ...result.blockerDetails ? {
+      blockerDetails: Object.freeze(
+        result.blockerDetails.map(
+          (detail) => blocker(detail.code, "blocked", detail.message, detail.nextStep)
+        )
+      )
+    } : {},
+    ...result.commandReference ? { commandReference: result.commandReference } : {},
+    ...result.afterReadback ? { afterReadback: result.afterReadback } : {}
+  };
+}
+function resolveScopeExactTarget(runtime, targetInput, feature) {
+  if ("actionHandle" in targetInput) {
+    return blockedScopeResolution(
+      `actions:${actionSlug(feature)}:scope-handle-required`,
+      "unsupported",
+      `${feature} requires a semantic scope handle, not a table actionHandle.`,
+      "Use scope handles for generated-content, link/bookmark, and list actions; use table actionHandles only for table actions."
+    );
+  }
+  const resolved = resolveTarget(runtime, { handle: targetInput.handle });
+  if (!resolved.ok) return resolved;
+  if (resolved.target.kind !== "scope") {
+    return blockedScopeResolution(
+      `actions:${actionSlug(feature)}:scope-target-required`,
+      "unsupported",
+      `${feature} requires a semantic scope handle.`,
+      "Refresh the target through ai.actions.locateAll or ai.listScopes and retry with a ScopeHandle."
+    );
+  }
+  return { ok: true, target: resolved.target };
+}
+function resolveModeledEditableTarget(runtime, target, kind) {
+  const bundle = createScopeCompilerService(runtime).compileBundleById(
+    target.handle.scopeId,
+    currentAuditTimestamp(runtime)
+  );
+  const entries = bundle?.evidence.editableTargets?.entries ?? [];
+  const candidates = entries.filter((entry) => entry.runtimeCommand.status === "supported").filter((entry) => modeledEntryMatches(kind, entry)).sort((left, right) => modeledEntryRank(kind, left) - modeledEntryRank(kind, right));
+  if (candidates.length === 0) {
+    return blockedEditableResolution(
+      `actions:${actionSlug(kind)}:unsupported:${target.handle.scopeId}`,
+      "unsupported",
+      "The target scope does not expose a supported modeled command target for this action.",
+      `Route to ${ownerRouteForModeledAction(kind)} with the scope handle and editable-target evidence; do not fall back to raw refs or broad replacement.`,
+      [
+        blockerWithOwner(
+          `actions:${actionSlug(kind)}:unsupported:${target.handle.scopeId}`,
+          "unsupported",
+          "The target scope does not expose a supported modeled command target for this action.",
+          `Route to ${ownerRouteForModeledAction(kind)} with the scope handle and editable-target evidence; do not fall back to raw refs or broad replacement.`,
+          ownerRouteForModeledAction(kind)
+        )
+      ]
+    );
+  }
+  const [candidate] = candidates;
+  if (!candidate) {
+    return blockedEditableResolution(
+      `actions:${actionSlug(kind)}:unsupported:${target.handle.scopeId}`,
+      "unsupported",
+      "No supported target candidate was available.",
+      `Route to ${ownerRouteForModeledAction(kind)}.`
+    );
+  }
+  const currentTarget = collectEditableTargetRefs(runtime.getCanonicalDocument()).find((ref) => ref.targetKey === candidate.targetKey);
+  if (!currentTarget) {
+    return blockedEditableResolution(
+      `actions:${actionSlug(kind)}:target-not-current:${target.handle.scopeId}`,
+      "unresolved-target",
+      "The supported editable target evidence is stale in the current document.",
+      "Refresh the scope handle and action evidence before retrying."
+    );
+  }
+  return { ok: true, targetRef: currentTarget };
+}
+function modeledEntryMatches(kind, entry) {
+  switch (kind) {
+    case "fieldRefresh":
+      return entry.commandFamily === "field" && entry.runtimeCommand.intents.includes("field-update") && entry.kind !== "toc-region-refresh";
+    case "tocRefresh":
+      return entry.commandFamily === "field" && entry.runtimeCommand.intents.includes("toc-refresh");
+    case "bookmarkEdit":
+      return entry.commandFamily === "link-bookmark" && entry.kind === "bookmark-content-range" && entry.runtimeCommand.intents.includes("bookmark-update");
+    case "hyperlinkDestinationEdit":
+      return entry.commandFamily === "link-bookmark" && entry.kind === "hyperlink-destination" && entry.runtimeCommand.intents.includes("hyperlink-update");
+  }
+}
+function modeledEntryRank(kind, entry) {
+  if (kind === "fieldRefresh" && entry.kind === "field-region-refresh") return 0;
+  if (kind === "tocRefresh" && entry.kind === "toc-region-refresh") return 0;
+  return 1;
+}
+function tablePlanOperationFamilyBlocker(stepKind, operationKind) {
+  if (stepKind === "tableFragment") {
+    if (operationKind !== "paste-cell-content" && operationKind !== "drop-cell-content") {
+      return blocker(
+        "actions:plan:table-fragment-operation-required",
+        "unsupported",
+        "tableFragment plan steps require a paste-cell-content or drop-cell-content operation.",
+        "Use tableAction for general table operations, or supply a fragment paste/drop operation."
+      );
+    }
+  }
+  if (stepKind === "tableSelection" && operationKind !== "merge-cells" && operationKind !== "split-cell") {
+    return blocker(
+      "actions:plan:table-selection-operation-required",
+      "unsupported",
+      "tableSelection plan steps require a merge-cells or split-cell operation.",
+      "Use tableAction for other table operations, or supply a merge/split selection operation."
+    );
+  }
+  return null;
+}
+function listCommandForOperation(operation, paragraphIndex, origin) {
+  switch (operation.kind) {
+    case "toggle":
+      return {
+        type: "list.toggle",
+        kind: operation.listKind,
+        paragraphIndexes: [paragraphIndex],
+        origin
+      };
+    case "indent":
+      return { type: "list.indent", paragraphIndexes: [paragraphIndex], origin };
+    case "outdent":
+      return { type: "list.outdent", paragraphIndexes: [paragraphIndex], origin };
+    case "restart-numbering":
+      return {
+        type: "list.restart-numbering",
+        paragraphIndex,
+        ...operation.startAt !== void 0 ? { startAt: operation.startAt } : {},
+        origin
+      };
+    case "continue-numbering":
+      return { type: "list.continue-numbering", paragraphIndex, origin };
+  }
+}
+function paragraphIndexFromHandle(handle) {
+  const raw = handle.semanticPath[handle.semanticPath.length - 1];
+  if (raw === void 0) return null;
+  const index = Number(raw);
+  return Number.isSafeInteger(index) && index >= 0 ? index : null;
+}
+function actionOrigin(runtime, input) {
+  return { source: "api", timestamp: currentAuditTimestamp(runtime) };
+}
+function commandActorId(origin) {
+  return origin?.source === "api" ? "v3-ai-api" : "v3-ai-api";
+}
+function commandOriginKind(_origin) {
+  return "agent";
+}
+function actionSlug(feature) {
+  switch (feature) {
+    case "fieldRefresh":
+      return "field-refresh";
+    case "tocRefresh":
+      return "toc-refresh";
+    case "bookmarkEdit":
+      return "bookmark-edit";
+    case "hyperlinkDestinationEdit":
+      return "hyperlink-destination-edit";
+    case "listOperation":
+      return "list-operation";
+  }
+}
+function ownerRouteForModeledAction(kind) {
+  switch (kind) {
+    case "fieldRefresh":
+    case "tocRefresh":
+      return "L02 field identity, L03 generated-content semantics, L07 field refresh command";
+    case "bookmarkEdit":
+    case "hyperlinkDestinationEdit":
+      return "L02 link/bookmark identity and L07 modeled link/bookmark commands";
+  }
+}
+function isTableFamilyScope(kind) {
+  return kind === "table" || kind === "table-row" || kind === "table-cell";
+}
+function canRewriteScopeText(scope) {
+  return !isTableFamilyScope(scope.kind) && (scope.replaceability.level === "full" || scope.replaceability.level === "text-only");
+}
+function canMarkScope(scope) {
+  return !isTableFamilyScope(scope.kind) && scope.replaceability.level !== "blocked" && scope.replaceability.level !== "preserve-only";
+}
+function textMatches(text, query, matchCase) {
+  if (matchCase) return text.includes(query);
+  return text.toLocaleLowerCase().includes(query.toLocaleLowerCase());
+}
+function excerpt(text) {
+  const normalized = text.replace(/\s+/g, " ").trim();
+  return normalized.length <= 120 ? normalized : `${normalized.slice(0, 117)}...`;
+}
+function blocker(code, category, message, nextStep) {
+  return { code, category, message, nextStep };
+}
+function blockerWithOwner(code, category, message, nextStep, ownerRoute) {
+  return { code, category, message, nextStep, ownerRoute };
+}
+function blockedResolution(code, category, message, nextStep, existingDetails) {
+  const detail = existingDetails?.[0] ?? blocker(code, category, message, nextStep);
+  return {
+    ok: false,
+    blockers: Object.freeze([detail.code]),
+    blockerDetails: Object.freeze([detail])
+  };
+}
+function blockedScopeResolution(code, category, message, nextStep, existingDetails) {
+  const detail = existingDetails?.[0] ?? blocker(code, category, message, nextStep);
+  return {
+    ok: false,
+    blockers: Object.freeze([detail.code]),
+    blockerDetails: Object.freeze([detail])
+  };
+}
+function blockedEditableResolution(code, category, message, nextStep, existingDetails) {
+  const detail = existingDetails?.[0] ?? blocker(code, category, message, nextStep);
+  return {
+    ok: false,
+    blockers: Object.freeze([detail.code]),
+    blockerDetails: Object.freeze([detail])
+  };
+}
+function blockedApply(code, category, message, nextStep, existingDetails) {
+  const detail = existingDetails?.[0] ?? blocker(code, category, message, nextStep);
+  return {
+    status: category === "unsupported" ? "unsupported" : "blocked",
+    applied: false,
+    changed: false,
+    blockers: Object.freeze([detail.code]),
+    blockerDetails: Object.freeze([detail])
+  };
+}
+function blockedApplyFromResolution(resolution) {
+  const detail = resolution.blockerDetails[0];
+  return {
+    status: detail?.category === "unsupported" ? "unsupported" : "blocked",
+    applied: false,
+    changed: false,
+    blockers: resolution.blockers,
+    blockerDetails: resolution.blockerDetails
+  };
+}
+function blockedPlan(mode, code, category, message, nextStep) {
+  const detail = blocker(code, category, message, nextStep);
+  return {
+    status: "blocked",
+    mode,
+    applied: false,
+    changed: false,
+    steps: Object.freeze([]),
+    supportedMethods: ACTION_METHODS,
+    blockers: Object.freeze([detail.code]),
+    blockerDetails: Object.freeze([detail])
+  };
+}
+function blockedPlanStep(id, kind, code, category, message, nextStep) {
+  return blockedPlanStepFromDetails(id, kind, [
+    blocker(code, category, message, nextStep)
+  ]);
+}
+function blockedPlanStepFromDetails(id, kind, details, context) {
+  const first = details[0] ?? blocker(
+    `actions:plan:step-blocked:${id}`,
+    "blocked",
+    "The plan step was blocked.",
+    "Inspect blockerDetails and regenerate the plan if needed."
+  );
+  return {
+    id,
+    kind,
+    status: first.category === "unsupported" ? "unsupported" : "blocked",
+    applied: false,
+    changed: false,
+    ...context?.target ? { target: context.target } : {},
+    ...context?.tableAction ? { tableAction: context.tableAction } : {},
+    ...context?.beforeReadback ? { beforeReadback: context.beforeReadback } : {},
+    blockers: Object.freeze(details.map((detail) => detail.code)),
+    blockerDetails: Object.freeze([...details])
+  };
+}
+function summarizePlanResult(mode, steps) {
+  const blocked = steps.filter(
+    (step) => step.status === "blocked" || step.status === "unsupported"
+  );
+  const progressed = steps.filter(
+    (step) => step.status === "planned" || step.status === "read" || step.status === "applied"
+  );
+  const blockers = blocked.flatMap((step) => step.blockers ?? []);
+  const blockerDetails = blocked.flatMap((step) => step.blockerDetails ?? []);
+  const applied = steps.some((step) => step.applied);
+  const changed = steps.some((step) => step.changed);
+  return {
+    status: blocked.length === 0 ? mode === "preview" ? "planned" : "applied" : progressed.length > 0 ? "partial" : "blocked",
+    mode,
+    applied,
+    changed,
+    steps: Object.freeze([...steps]),
+    supportedMethods: ACTION_METHODS,
+    ...blockers.length > 0 ? { blockers: Object.freeze(blockers) } : {},
+    ...blockerDetails.length > 0 ? { blockerDetails: Object.freeze(blockerDetails) } : {}
+  };
+}
+
 // src/api/v3/_create.ts
 function createApiV3(handle, opts) {
   const ai = {
@@ -6147,7 +7939,8 @@ function createApiV3(handle, opts) {
     ...createEvaluateFamily(handle),
     ...createStatsFamily(handle),
     ...createOutlineFamily(handle),
-    ...createTableActionFamily(handle)
+    ...createTableActionFamily(handle),
+    ...createActionsFamily(handle)
   };
   const runtime = {
     document: createDocumentFamily(handle),