@beyondwork/docx-react-component 1.0.105 → 1.0.108

package/src/runtime/scopes/compiler-service.ts

@@ -37,10 +37,12 @@ import type {
   WorkflowMetadataEntry,
   WorkflowMetadataSnapshot,
   WorkflowOverlay,
+  WorkflowEventOrigin,
 } from "./_scope-dependencies.ts";
 import type { CanonicalDocumentEnvelope } from "../../core/state/editor-state.ts";
 import type { TelemetryBus } from "../debug/telemetry-bus.ts";
 import type { AIAction } from "../workflow/ai-action-policy.ts";
+import type { ScopeGeometryEvidenceProvider } from "./geometry-evidence.ts";
 
 import {
   buildParagraphIndexMap,
@@ -49,6 +51,12 @@ import {
 } from "./compile-scope.ts";
 import { compileScopeBundleById } from "./compile-scope-bundle.ts";
 import { enumerateScopes, type EnumeratedScope } from "./enumerate-scopes.ts";
+import {
+  collectTopLevelTableBlockIdsFromRenderSnapshot,
+  createRuntimeTableFrameLayoutEvidenceProvider,
+  type ScopeRuntimeLayoutEvidenceSource,
+  type ScopeRuntimeRenderSnapshotLike,
+} from "./layout-evidence.ts";
 import {
   attachExplanation,
   type AttachExplanationResult,
@@ -59,6 +67,12 @@ import {
   type IssueSeverity,
   type IssueStatus,
 } from "./create-issue.ts";
+import {
+  resolveIssueLifecycleTarget,
+  transitionScopeIssueLifecycle,
+  type IssueLifecycleAction,
+  type TransitionScopeIssueLifecycleResult,
+} from "./issue-lifecycle.ts";
 import {
   applyScopeReplacement,
   type ApplyScopeReplacementResult,
@@ -69,12 +83,12 @@ import {
 } from "./formatting/apply.ts";
 import { proposeReplacement } from "./replacement/propose.ts";
 import type {
-  ReplacementOperationKind,
   ReplacementPreservePolicy,
   ReplacementScope,
   RuntimeOperationPlan,
   ScopeFormattingAction,
   ScopeFormattingScope,
+  ScopeReplacementOperationKind,
   ScopeBundle,
   ScopeHandle,
   SemanticScope,
@@ -98,10 +112,16 @@ export interface CompilerServiceRuntime {
   getInteractionGuardSnapshot(): InteractionGuardSnapshot;
   getCompatibilityReport(): CompatibilityReport;
   getWorkflowMetadataSnapshot(): WorkflowMetadataSnapshot;
-  setWorkflowMetadataEntries(entries: readonly WorkflowMetadataEntry[]): void;
+  setWorkflowMetadataEntries(
+    entries: readonly WorkflowMetadataEntry[],
+    origin?: WorkflowEventOrigin,
+  ): void;
+  getRenderSnapshot?(): ScopeRuntimeRenderSnapshotLike;
   getSessionState(): ScopeSessionState;
   applyScopeReplacement(plan: RuntimeOperationPlan): void;
   applyScopeFormatting(plan: RuntimeOperationPlan): boolean;
+  readonly geometry?: ScopeGeometryEvidenceProvider;
+  readonly layout?: ScopeRuntimeLayoutEvidenceSource;
   debug?: { bus: TelemetryBus };
 }
 
@@ -113,7 +133,7 @@ export interface CompileScopeByIdResult {
 
 export interface ApplyReplacementRequest {
   readonly targetScopeId: string;
-  readonly operation: ReplacementOperationKind;
+  readonly operation: ScopeReplacementOperationKind;
   /**
    * Flat text payload. Shorthand for
    * `proposedContent: {kind: "text", text}`. Ignored when
@@ -165,6 +185,14 @@ export interface CreateIssueRequest {
   readonly status?: IssueStatus;
 }
 
+export interface TransitionIssueLifecycleRequest {
+  readonly issueId: string;
+  readonly action: IssueLifecycleAction;
+  readonly actorId: string;
+  readonly origin: "ui" | "agent" | "host";
+  readonly emittedAtUtc: string;
+}
+
 export interface ScopeCompilerService {
   /**
    * Enumerate + compile every live scope in the document. Per-call the
@@ -197,7 +225,7 @@ export interface ScopeCompilerService {
   buildReplacementScope(
     targetHandle: ScopeHandle,
     input: {
-      readonly operation: ReplacementOperationKind;
+      readonly operation: ScopeReplacementOperationKind;
       readonly proposedText?: string;
       readonly formatting?: ReplacementScope["formatting"];
       readonly preserve?: ReplacementPreservePolicy;
@@ -238,6 +266,17 @@ export interface ScopeCompilerService {
    * overlay-only constraint as `attachExplanation`.
    */
   createIssue(request: CreateIssueRequest): CreateIssueResult;
+
+  /**
+   * Resolve/reopen an existing `ai.issue` metadata entry through the L06
+   * durable lifecycle substrate, but only after its scope target still compiles
+   * through Layer 08. This is intentionally not a public L09 API yet; it is the
+   * scope/evidence join that L09 will consume when `ai.resolveIssue` /
+   * `ai.reopenIssue` graduate.
+   */
+  transitionIssueLifecycle(
+    request: TransitionIssueLifecycleRequest,
+  ): TransitionScopeIssueLifecycleResult;
 }
 
 /**
@@ -324,12 +363,24 @@ export function createScopeCompilerService(
       // operations go through `attachScopeMetadata` via this same
       // runtime surface, so the snapshot is always fresh here.
       const workflowMetadataEntries = runtime.getWorkflowMetadataSnapshot().entries;
+      const layout =
+        runtime.layout
+          ? createRuntimeTableFrameLayoutEvidenceProvider({
+              layout: runtime.layout,
+              tableBlockIdsByBlockIndex:
+                collectTopLevelTableBlockIdsFromRenderSnapshot(
+                  runtime.getRenderSnapshot?.(),
+                ),
+            })
+          : undefined;
       return compileScopeBundleById(scopeId, {
         document,
         ...(overlay ? { overlay } : {}),
         nowUtc,
         catalog: document.styles,
         workflowMetadataEntries,
+        ...(runtime.geometry ? { geometry: runtime.geometry } : {}),
+        ...(layout ? { layout } : {}),
       });
     },
 
@@ -361,6 +412,7 @@ export function createScopeCompilerService(
           reason: "scope-not-resolvable",
           validation: {
             safe: false,
+            posture: "hard-refusal",
             blockedReasons: Object.freeze([
               `scope-not-resolvable:${request.targetScopeId}`,
             ]),
@@ -400,6 +452,7 @@ export function createScopeCompilerService(
             runtime.getInteractionGuardSnapshot(),
           getCompatibilityReport: () => runtime.getCompatibilityReport(),
           applyScopeReplacement: (plan) => runtime.applyScopeReplacement(plan),
+          verifyReadback: true,
         },
         proposed,
         ...(request.actionId ? { actionId: request.actionId } : {}),
@@ -418,6 +471,7 @@ export function createScopeCompilerService(
           reason: "scope-not-resolvable",
           validation: {
             safe: false,
+            posture: "hard-refusal",
             blockedReasons: Object.freeze([
               `scope-not-resolvable:${request.targetScopeId}`,
             ]),
@@ -498,5 +552,55 @@ export function createScopeCompilerService(
         },
       );
     },
+
+    transitionIssueLifecycle(
+      request: TransitionIssueLifecycleRequest,
+    ): TransitionScopeIssueLifecycleResult {
+      const target = resolveIssueLifecycleTarget(
+        runtime.getWorkflowMetadataSnapshot(),
+        request.issueId,
+      );
+      if (!target) {
+        const reason = `issue-not-found:${request.issueId}`;
+        return {
+          transitioned: false,
+          issueId: request.issueId,
+          reason,
+          blockers: Object.freeze([reason]),
+        };
+      }
+
+      const compiled = this.compileScopeById(target.scopeId);
+      if (!compiled) {
+        const reason = `scope-not-resolvable:${target.scopeId}`;
+        return {
+          transitioned: false,
+          issueId: target.issueId,
+          reason,
+          blockers: Object.freeze([reason]),
+          scopeId: target.scopeId,
+        };
+      }
+
+      const documentBefore = runtime.getCanonicalDocument();
+      const result = transitionScopeIssueLifecycle({
+        runtime: {
+          getCanonicalDocument: () => runtime.getCanonicalDocument(),
+          getWorkflowMetadataSnapshot: () =>
+            runtime.getWorkflowMetadataSnapshot(),
+          setWorkflowMetadataEntries: (entries, origin) =>
+            runtime.setWorkflowMetadataEntries([...entries], origin),
+        },
+        documentBefore,
+        targetScopeSnapshot: compiled.scope,
+        issueId: target.issueId,
+        action: request.action,
+        actorId: request.actorId,
+        origin: request.origin,
+        emittedAtUtc: request.emittedAtUtc,
+        ...(runtime.debug?.bus ? { bus: runtime.debug.bus } : {}),
+      });
+      return result;
+    },
   };
 }

package/src/runtime/scopes/content-control-evidence.ts

@@ -0,0 +1,79 @@
+/**
+ * Content-control / SDT evidence for scope bundles and preservation checks.
+ *
+ * SDTs are package-backed wrappers, not L08 scope truth. This helper only
+ * reports overlap with a scope range so capability and validation surfaces can
+ * stay preserve-first until L02/L04 expose richer source/layout refs.
+ */
+
+import type {
+  CanonicalDocument,
+  DocumentRootNode,
+  SdtNode,
+} from "../../model/canonical-document.ts";
+import type { CanonicalDocumentEnvelope } from "../../core/state/editor-state.ts";
+
+import { computeBlockPositions, type ScopePositionRange } from "./position-map.ts";
+import { rangesOverlap } from "./scope-range.ts";
+import type {
+  ScopeContentControlEvidence,
+  ScopeContentControlEvidenceEntry,
+} from "./semantic-scope-types.ts";
+
+function documentRoot(
+  document: Pick<CanonicalDocument, "content"> | CanonicalDocumentEnvelope,
+): DocumentRootNode {
+  const envelope = document as CanonicalDocumentEnvelope;
+  return "content" in envelope
+    ? (envelope.content as DocumentRootNode)
+    : (document as unknown as DocumentRootNode);
+}
+
+function entryForSdt(
+  blockIndex: number,
+  sdt: SdtNode,
+): ScopeContentControlEvidenceEntry {
+  const typePart = sdt.properties.sdtType ?? "unknown";
+  return {
+    evidenceId: `sdt:${blockIndex}:${typePart}`,
+    blockIndex,
+    ...(sdt.properties.sdtType ? { sdtType: sdt.properties.sdtType } : {}),
+    ...(sdt.properties.alias ? { alias: sdt.properties.alias } : {}),
+    ...(sdt.properties.tag ? { tag: sdt.properties.tag } : {}),
+    ...(sdt.properties.lock ? { lock: sdt.properties.lock } : {}),
+  };
+}
+
+export function findContentControlsIntersectingRange(
+  document: Pick<CanonicalDocument, "content"> | CanonicalDocumentEnvelope,
+  range: ScopePositionRange | null,
+): readonly ScopeContentControlEvidenceEntry[] {
+  if (!range) return Object.freeze([]);
+
+  const root = documentRoot(document);
+  const blockRanges = computeBlockPositions(document);
+  const entries: ScopeContentControlEvidenceEntry[] = [];
+
+  for (const blockRange of blockRanges) {
+    const block = root.children[blockRange.blockIndex];
+    if (!block || block.type !== "sdt") continue;
+    if (!rangesOverlap(range, { from: blockRange.from, to: blockRange.to })) {
+      continue;
+    }
+    entries.push(entryForSdt(blockRange.blockIndex, block));
+  }
+
+  return Object.freeze(entries);
+}
+
+export function deriveScopeContentControlEvidence(
+  document: Pick<CanonicalDocument, "content"> | CanonicalDocumentEnvelope,
+  range: ScopePositionRange | null,
+): ScopeContentControlEvidence {
+  const entries = findContentControlsIntersectingRange(document, range);
+  return {
+    status: entries.length > 0 ? "present" : "none",
+    count: entries.length,
+    entries,
+  };
+}

package/src/runtime/scopes/create-issue.ts

@@ -9,10 +9,9 @@
  * Issues are metadata records rather than a dedicated overlay section
  * in this slice — matches the Slice-6 plan's "issue store is a new
  * section on the workflow overlay" intent without requiring an
- * overlay-schema minor bump. When CLM workblocks need richer lifecycle
- * (resolve/reopen transitions, assigned owners), a follow-up sub-slice
- * promotes issues to a first-class overlay kind and the storage
- * migrates — the metadataId stays stable so callers don't break.
+ * overlay-schema minor bump. Layer 06 owns the durable lifecycle substrate for
+ * the stable metadataId; L08/L09 still own scope/API shaped resolve/reopen
+ * exposure.
  *
  * Scope coverage (coord-06 §13c shipped 2026-04-23): both overlay
  * (workflow) scopes AND derived paragraph / heading / list-item
@@ -28,9 +27,10 @@ import type {
   MetadataWriterRuntime,
 } from "../workflow/metadata-writer.ts";
 import { attachScopeMetadata } from "../workflow/metadata-writer.ts";
+import { AI_ISSUE_METADATA_ID } from "../workflow/ai-issue-lifecycle.ts";
 
 /** Stable metadataId for AI-authored issues. */
-export const AI_ISSUE_METADATA_ID = "ai.issue" as const;
+export { AI_ISSUE_METADATA_ID };
 
 export type IssueSeverity = "info" | "warning" | "error";
 export type IssueStatus = "open" | "resolved";

package/src/runtime/scopes/evidence.ts

@@ -24,10 +24,21 @@ import type {
 } from "./_scope-dependencies.ts";
 
 import { AI_EXPLANATION_METADATA_ID } from "./attach-explanation.ts";
+import { deriveScopeCapabilities } from "./capabilities.ts";
+import { deriveScopeContentControlEvidence } from "./content-control-evidence.ts";
 import { AI_ISSUE_METADATA_ID } from "./create-issue.ts";
 import type { EnumeratedScope } from "./enumerate-scopes.ts";
+import {
+  deriveScopeGeometryEvidence,
+  type ScopeGeometryEvidenceProvider,
+} from "./geometry-evidence.ts";
+import {
+  deriveScopeLayoutEvidence,
+  type ScopeLayoutEvidenceProvider,
+} from "./layout-evidence.ts";
 import { buildScopePositionMap, type ScopePositionRange } from "./position-map.ts";
 import { rangesOverlap, resolveScopeRange } from "./scope-range.ts";
+import { deriveScopeVisualization } from "./visualization.ts";
 import type {
   AIExplanationSummary,
   AIIssueSummary,
@@ -86,6 +97,16 @@ export interface EvidenceInputs {
    * `runtime.getWorkflowMetadataSnapshot().entries` through here.
    */
   readonly workflowMetadataEntries?: readonly WorkflowMetadataEntry[];
+  /**
+   * Layer-05 geometry facet subset. When present, evidence includes the
+   * current replacement envelope or an explicit requires-rehydration status.
+   */
+  readonly geometry?: ScopeGeometryEvidenceProvider;
+  /**
+   * Optional lower-layer layout evidence seam. Missing provider or missing
+   * rows are surfaced explicitly in `ScopeBundleEvidence.layout`.
+   */
+  readonly layout?: ScopeLayoutEvidenceProvider;
 }
 
 function normalizeSeverity(raw: unknown): AIIssueSummary["severity"] {
@@ -98,6 +119,38 @@ function normalizeStatus(raw: unknown): AIIssueSummary["status"] {
   return "open";
 }
 
+function projectIssueTransition(raw: unknown): AIIssueSummary["lastTransition"] | undefined {
+  const value = raw as
+    | {
+        action?: unknown;
+        actorId?: unknown;
+        at?: unknown;
+        origin?: unknown;
+        fromStatus?: unknown;
+        toStatus?: unknown;
+      }
+    | undefined;
+  if (!value || typeof value !== "object") return undefined;
+  if (value.action !== "resolve" && value.action !== "reopen") return undefined;
+  if (typeof value.actorId !== "string") return undefined;
+  if (typeof value.at !== "string") return undefined;
+  if (typeof value.origin !== "string") return undefined;
+  if (value.fromStatus !== "open" && value.fromStatus !== "resolved") {
+    return undefined;
+  }
+  if (value.toStatus !== "open" && value.toStatus !== "resolved") {
+    return undefined;
+  }
+  return {
+    action: value.action,
+    actorId: value.actorId,
+    at: value.at,
+    origin: value.origin,
+    fromStatus: value.fromStatus,
+    toStatus: value.toStatus,
+  };
+}
+
 function projectAIExplanation(
   entry: WorkflowMetadataEntry,
 ): AIExplanationSummary | null {
@@ -127,9 +180,18 @@ function projectAIIssue(
         severity?: unknown;
         status?: unknown;
         createdAtUtc?: string;
+        statusUpdatedAtUtc?: string;
+        resolvedAtUtc?: string;
+        resolvedBy?: string;
+        reopenedAtUtc?: string;
+        reopenedBy?: string;
+        lifecycle?: unknown[];
       }
     | undefined;
   if (!value || typeof value.summary !== "string") return null;
+  const lastTransition = Array.isArray(value.lifecycle)
+    ? projectIssueTransition(value.lifecycle[value.lifecycle.length - 1])
+    : undefined;
   return {
     issueId:
       typeof value.issueId === "string" && value.issueId.length > 0
@@ -141,6 +203,22 @@ function projectAIIssue(
     ...(typeof value.createdAtUtc === "string"
       ? { createdAtUtc: value.createdAtUtc }
       : {}),
+    ...(typeof value.statusUpdatedAtUtc === "string"
+      ? { statusUpdatedAtUtc: value.statusUpdatedAtUtc }
+      : {}),
+    ...(typeof value.resolvedAtUtc === "string"
+      ? { resolvedAtUtc: value.resolvedAtUtc }
+      : {}),
+    ...(typeof value.resolvedBy === "string"
+      ? { resolvedBy: value.resolvedBy }
+      : {}),
+    ...(typeof value.reopenedAtUtc === "string"
+      ? { reopenedAtUtc: value.reopenedAtUtc }
+      : {}),
+    ...(typeof value.reopenedBy === "string"
+      ? { reopenedBy: value.reopenedBy }
+      : {}),
+    ...(lastTransition ? { lastTransition } : {}),
   };
 }
 
@@ -221,11 +299,24 @@ export function composeEvidence(inputs: EvidenceInputs): ScopeBundleEvidence {
   aiExplanations.sort((a, b) => a.explanationId.localeCompare(b.explanationId));
   aiIssues.sort((a, b) => a.issueId.localeCompare(b.issueId));
 
+  const layout = deriveScopeLayoutEvidence(scope.handle.scopeId, inputs.layout);
+  const geometry = deriveScopeGeometryEvidence(scope.handle.scopeId, inputs.geometry);
+  const contentControls = deriveScopeContentControlEvidence(document, selfRange);
+
   return {
     formattingSummary: formattingSummaryOf(scope),
     reviewItemIds,
     overlappingWorkflowScopeIds,
     compatibilityFlags,
+    layout,
+    geometry,
+    visualization: deriveScopeVisualization(scope),
+    contentControls,
+    capabilities: deriveScopeCapabilities(scope, {
+      layout,
+      geometry,
+      contentControls,
+    }),
     ...(inputs.workflowMetadataEntries
       ? { aiExplanations, aiIssues }
       : {}),

package/src/runtime/scopes/formatting/apply.ts

@@ -156,6 +156,7 @@ export function applyScopeFormatting(
   if (!resolvedScope || !resolvedEnumerated) {
     const validation: ValidationResult = {
       safe: false,
+      posture: "hard-refusal",
       blockedReasons: Object.freeze([
         `scope-not-resolvable:${proposed.targetHandle.scopeId}`,
       ]),
@@ -211,6 +212,7 @@ export function applyScopeFormatting(
         : `compile-refused:${resolvedScope.kind}:formatting-not-implemented`;
     const refused: ValidationResult = {
       safe: false,
+      posture: "hard-refusal",
       blockedReasons: Object.freeze([blocker]),
       warnings: verdict.warnings,
     };

package/src/runtime/scopes/geometry-evidence.ts

@@ -0,0 +1,130 @@
+/**
+ * Scope geometry evidence projection.
+ *
+ * Layer 08 consumes the Layer 05 replacement-envelope seam when it is wired,
+ * but it does not compute geometry itself. Cold or missing geometry remains
+ * explicit evidence, not a synthesized rectangle.
+ */
+
+import type {
+  ScopeGeometryEvidence,
+  ScopeGeometryEvidencePrecision,
+  ScopeGeometryEvidenceRect,
+  ScopeLayoutContinuationEvidence,
+} from "./semantic-scope-types.ts";
+
+type GeometrySpace = ScopeGeometryEvidenceRect["space"];
+
+interface EnvelopeRectLike {
+  readonly leftPx: number;
+  readonly topPx: number;
+  readonly widthPx: number;
+  readonly heightPx: number;
+  readonly space: GeometrySpace;
+  readonly precision?: ScopeGeometryEvidencePrecision;
+}
+
+interface EnvelopeLike {
+  readonly scopeRects: readonly EnvelopeRectLike[];
+  readonly pageIds?: readonly string[];
+  readonly continuation?: ScopeLayoutContinuationEvidence;
+  readonly attachPoint: {
+    readonly xPx: number;
+    readonly yPx: number;
+    readonly space: GeometrySpace;
+  };
+  readonly confidence: "exact" | "medium" | "detached";
+  readonly linesCrossed: number;
+  readonly rehydrationStatus?: "realized" | "requires-rehydration" | "unavailable";
+  readonly precision?: ScopeGeometryEvidencePrecision;
+  readonly sourceIdentity?: {
+    readonly storyKey?: string;
+    readonly blockPath?: string;
+    readonly tableKey?: string;
+    readonly rowKey?: string;
+    readonly cellKey?: string;
+    readonly scopeKey?: string;
+    readonly scopeId?: string;
+    readonly objectKey?: string;
+    readonly inlinePath?: string;
+    readonly objectKind?: string;
+    readonly editPosture?: string;
+    readonly joinKind?: string;
+  };
+}
+
+export interface ScopeGeometryEvidenceProvider {
+  getReplacementEnvelope(scopeId: string): EnvelopeLike | null;
+}
+
+function mapRect(rect: EnvelopeRectLike): ScopeGeometryEvidenceRect {
+  return {
+    x: rect.leftPx,
+    y: rect.topPx,
+    width: rect.widthPx,
+    height: rect.heightPx,
+    space: rect.space,
+    ...(rect.precision ? { precision: rect.precision } : {}),
+  };
+}
+
+export function deriveScopeGeometryEvidence(
+  scopeId: string,
+  provider?: ScopeGeometryEvidenceProvider,
+): ScopeGeometryEvidence {
+  if (!provider) {
+    return {
+      status: "unavailable",
+      requiresRehydration: false,
+      reason: "geometry-facet-unavailable",
+    };
+  }
+
+  const envelope = provider.getReplacementEnvelope(scopeId);
+  if (!envelope) {
+    return {
+      status: "requires-rehydration",
+      requiresRehydration: true,
+      reason: "replacement-envelope-unavailable",
+    };
+  }
+
+  if (envelope.rehydrationStatus === "unavailable") {
+    return {
+      status: "unavailable",
+      requiresRehydration: false,
+      reason: "replacement-envelope-unavailable",
+      ...(envelope.pageIds ? { pageIds: Object.freeze([...envelope.pageIds]) } : {}),
+      ...(envelope.continuation
+        ? { continuationState: { ...envelope.continuation } }
+        : {}),
+      ...(envelope.sourceIdentity
+        ? { sourceIdentity: { ...envelope.sourceIdentity } }
+        : {}),
+    };
+  }
+
+  const requiresRehydration =
+    envelope.rehydrationStatus === "requires-rehydration";
+  return {
+    status: requiresRehydration ? "requires-rehydration" : "available",
+    requiresRehydration,
+    ...(requiresRehydration ? { reason: "replacement-envelope-requires-rehydration" } : {}),
+    ...(envelope.pageIds ? { pageIds: Object.freeze([...envelope.pageIds]) } : {}),
+    confidence: envelope.confidence,
+    ...(envelope.precision ? { precision: envelope.precision } : {}),
+    rects: Object.freeze(envelope.scopeRects.map(mapRect)),
+    attachPoint: {
+      x: envelope.attachPoint.xPx,
+      y: envelope.attachPoint.yPx,
+      space: envelope.attachPoint.space,
+    },
+    linesCrossed: envelope.linesCrossed,
+    ...(envelope.continuation
+      ? { continuationState: { ...envelope.continuation } }
+      : {}),
+    ...(envelope.sourceIdentity
+      ? { sourceIdentity: { ...envelope.sourceIdentity } }
+      : {}),
+  };
+}