@wairon/cli 5.1.1-dev.15 → 5.1.1-dev.17

package/dist/cli/index.js

@@ -65,7 +65,7 @@ var init_defaults = __esm({
       copilot: ".github/prompts",
       codex: ".codex/agents"
     };
-    WAIRON_VERSION = "5.1.1-dev.15";
+    WAIRON_VERSION = "5.1.1-dev.17";
     GITHUB_REPO = "SYW-Apps/Waffle-AIron";
     SUPPORTED_ALIASES = ["wai"];
     SCAN_EXCLUDE_DIRS = /* @__PURE__ */ new Set([
@@ -382,10 +382,10 @@ ${GUIDE_MARKER_END}
   fs4.writeFileSync(filePath, newContent, "utf-8");
 }
 function stripGuideSection(content) {
-  const start = content.indexOf(GUIDE_MARKER_START);
+  const start2 = content.indexOf(GUIDE_MARKER_START);
   const end = content.indexOf(GUIDE_MARKER_END);
-  if (start === -1 || end === -1) return content;
-  return content.slice(0, start) + content.slice(end + GUIDE_MARKER_END.length);
+  if (start2 === -1 || end === -1) return content;
+  return content.slice(0, start2) + content.slice(end + GUIDE_MARKER_END.length);
 }
 function writeRootGuideDelegator(projectRoot2, targetType) {
   if (targetType === "claude") {
@@ -500,7 +500,7 @@ This project uses **wairon**. System specs live under \`.wai/specs/\` (L0 System
 1. **Design before code**: Complete spec and pass validator before writing source code.
 2. **Human-in-the-loop**: Ask user approval for each spec layer before proceeding.
 3. **Spec consistency**: If a 1:1 narrative match is incorrect or conflicts with L0 requirements, escalate a spec revision first. Never ship mismatched code.
-4. **No persistence shortcuts & strict layers**: A Portal must never depend directly on a Store, Registry, or Adapter. Portal reads MAY go through a Repository/Index facade (passthrough reads need no per-entity Orchestrator ceremony), but a Portal narrative calling a write-effect facade method is an error (\`PORTAL_WRITE_SHORTCUT\`) \u2014 writes always route through an Orchestrator. Held domain state always lives in a dedicated data component, never as fields inside an Orchestrator or Specialist. Two sanctioned shapes: the RECOMMENDED Repository pattern (owns Store + Registry + Index; consumers depend on the facade), or \u2014 for genuinely simple state \u2014 a deliberately standalone Store (workflow-layer consumers only, acknowledged with a lint.allow reason on the UNOWNED_STORE warning). Never combine Store/Registry/Index roles into one component, and never fold state into a consuming component because a link was refused.
+4. **No persistence shortcuts & strict layers**: A Portal must never depend directly on a Store, Registry, or Adapter. Portal reads MAY go through a Repository/Index facade (passthrough reads need no per-entity Orchestrator ceremony), but a Portal narrative call or dispatch-table binding that reaches a write-effect facade method is an error (\`PORTAL_WRITE_SHORTCUT\`) \u2014 writes always route through an Orchestrator. Held domain state always lives in a dedicated data component, never as fields inside an Orchestrator or Specialist. Two sanctioned shapes: the RECOMMENDED Repository pattern (owns Store + Registry + Index; consumers depend on the facade), or \u2014 for genuinely simple state \u2014 a deliberately standalone Store (workflow-layer consumers only, acknowledged with a lint.allow reason on the UNOWNED_STORE warning). Never combine Store/Registry/Index roles into one component, and never fold state into a consuming component because a link was refused.
 
 ### Component Vocabulary
 * **Blocks**: Portal, Orchestrator, Supervisor, Actor, Store, Index, Registry, Adapter, Observer, Specialist.
@@ -1118,7 +1118,7 @@ function defaultNarrativeDetail(component) {
   if (componentType === "Portal" || componentType === "Observer" || componentType === "Adapter") {
     return "calls-only";
   }
-  if (componentType === "Store" || componentType === "Index" || componentType === "Registry") {
+  if (componentType === "Store" || componentType === "Index" || componentType === "Query" || componentType === "Registry") {
     return "intent";
   }
   return "full";
@@ -1151,7 +1151,7 @@ function implementationSourceFiles(impl) {
   for (const method2 of impl.methods ?? []) add(method2.sourcePath);
   return files;
 }
-var import_zod7, SpecIdSchema, SpecStatusSchema, BoundaryItemSchema, RequirementItemSchema, DatabaseSpecSchema, DiagramConfigSchema, SURFACE_AUDIENCES, SurfaceAudienceSchema, SystemPublicInterfaceSchema, SystemSpecSchema, PublicInterfaceTypeSchema, PublicInterfaceSchema, TrustedLinkSchema, LintAllowSchema, LintConfigSchema, ExtDataSchema, LifecycleEntrypointSchema, SubsystemSpecSchema, ComponentTypeSchema, PATTERN_TYPES, PortalTypeSchema, DispatchBindingSchema, DurabilitySchema, PatternRefSchema, EventBindingSchema, ExternalLinkTypeSchema, ExternalLinkSchema, PortalAuthSchemeSchema, PortalAuthSchema, ComponentSpecSchema, HttpMethodSchema, TransportSchema, EndpointSchema, SEMANTIC_GUARANTEES, GuaranteeSchema, MethodParamSchema, FindingDeclarationSchema, MethodSignatureSchema, INTENT_FLOOR_MIN_CHARS, InterfaceSpecSchema, NarrativeStepTypeSchema, LoopKindSchema, SwitchCaseSchema, CatchClauseSchema, ParallelBranchSchema, NarrativeStepSchema, NarrativeDetailSchema, ConformanceTierSchema, MethodImplementationSchema, ImplementationSpecSchema, TypeKindSchema, TypeFieldSchema, TypeMethodSchema, InvariantSchema, TypeSpecSchema, SurfaceOriginSchema, SurfaceTypeDefSchema, SurfaceContractEntrySchema, SurfaceSnapshotSchema, NamedOpenApiSpecSchema, GroupSpecSchema;
+var import_zod7, SpecIdSchema, SpecStatusSchema, BoundaryItemSchema, RequirementItemSchema, DatabaseSpecSchema, DiagramConfigSchema, SURFACE_AUDIENCES, SurfaceAudienceSchema, SystemPublicInterfaceSchema, SystemSpecSchema, PublicInterfaceTypeSchema, PublicInterfaceSchema, TrustedLinkSchema, LintAllowSchema, LintConfigSchema, ExtDataSchema, LifecycleEntrypointSchema, SubsystemSpecSchema, ComponentTypeSchema, PATTERN_TYPES, PortalTypeSchema, DispatchBindingSchema, DurabilitySchema, DependencyClassSchema, PatternRefSchema, EventBindingSchema, ExternalLinkTypeSchema, ExternalLinkSchema, PortalAuthSchemeSchema, PortalAuthSchema, ComponentSpecSchema, HttpMethodSchema, TransportSchema, EndpointSchema, SEMANTIC_GUARANTEES, GuaranteeSchema, MethodParamSchema, FindingDeclarationSchema, MethodSignatureSchema, INTENT_FLOOR_MIN_CHARS, InterfaceSpecSchema, NarrativeStepTypeSchema, LoopKindSchema, SwitchCaseSchema, CatchClauseSchema, ParallelBranchSchema, NarrativeStepSchema, NarrativeDetailSchema, ConformanceTierSchema, MethodImplementationSchema, ImplementationSpecSchema, TypeKindSchema, TypeFieldSchema, TypeMethodSchema, InvariantSchema, TypeSpecSchema, SurfaceOriginSchema, SurfaceTypeDefSchema, SurfaceContractEntrySchema, SurfaceSnapshotSchema, NamedOpenApiSpecSchema, GroupSpecSchema;
 var init_specs = __esm({
   "src/models/specs.ts"() {
     "use strict";
@@ -1317,21 +1317,27 @@ var init_specs = __esm({
       "Actor",
       "Store",
       "Index",
+      "Query",
+      // Repository member for computed reads over its Store
       "Registry",
       "Adapter",
       "Observer",
-      "Specialist",
       "View",
       // Pure presenter/UI component
       // Patterns (compositions of blocks)
       "Repository",
-      "Gateway",
       "FeatureComponent",
       // Logic Hook + View Presenter pattern
-      "RouterComponent"
+      "RouterComponent",
       // Switch/routing component pattern
+      // Retired stereotypes: still parsed so a tree using them loads and the
+      // rules can report them (STEREOTYPE_RETIRED), never authored new
+      "Specialist",
+      // logic is an Orchestrator with a dependencyClass
+      "Gateway"
+      // a gateway is a Portal with the gateway variant
     ]);
-    PATTERN_TYPES = /* @__PURE__ */ new Set(["Repository", "Gateway", "FeatureComponent", "RouterComponent"]);
+    PATTERN_TYPES = /* @__PURE__ */ new Set(["Repository", "FeatureComponent", "RouterComponent"]);
     PortalTypeSchema = import_zod7.z.enum(["HTTP_API", "gRPC", "GraphQL", "MessageBus", "CLI", "NamedPipe", "IPC", "Custom"]);
     DispatchBindingSchema = import_zod7.z.object({
       /** Capability name exactly as dispatched at runtime (e.g. "shadow_module.get"). */
@@ -1344,6 +1350,7 @@ var init_specs = __esm({
       description: import_zod7.z.string().optional()
     });
     DurabilitySchema = import_zod7.z.enum(["ram-projection", "durable", "read-through", "cache"]);
+    DependencyClassSchema = import_zod7.z.enum(["pure", "read"]);
     PatternRefSchema = import_zod7.z.object({
       id: import_zod7.z.string(),
       version: import_zod7.z.string().optional()
@@ -1398,6 +1405,8 @@ var init_specs = __esm({
       dispatch: import_zod7.z.array(DispatchBindingSchema).optional(),
       /** Store-only: whether held state survives restart (see DurabilitySchema). */
       durability: DurabilitySchema.optional(),
+      /** Orchestrator-only: what the logic may depend on; unset means a workflow (see DependencyClassSchema). */
+      dependencyClass: DependencyClassSchema.optional(),
       /** Topics this component publishes to (see EventBindingSchema). */
       emits: import_zod7.z.array(EventBindingSchema).optional(),
       /** Topics this component consumes (see EventBindingSchema) — typical on Observers. */
@@ -1488,9 +1497,10 @@ var init_specs = __esm({
       }).optional(),
       /**
        * The finding codes this method can report, each with its default severity
-       * and summary (see FindingDeclarationSchema). Each declared code must appear
-       * as a string literal in the method's source file (UNREALIZED_FINDING). A
-       * code is declared once per method.
+       * and summary (see FindingDeclarationSchema). Each declared code must be
+       * anchored in the method's source file as a string literal or a
+       * property-access name (UNREALIZED_FINDING). A code is declared once per
+       * method.
        */
       findings: import_zod7.z.array(FindingDeclarationSchema).superRefine((findings, ctx) => {
         const seen = /* @__PURE__ */ new Set();
@@ -2822,15 +2832,13 @@ var init_hierarchy_integrity = __esm({
           }
         }
         for (const impl of ctx.implementations) {
-          const contract = ctx.interfaces.find((i) => i.id === impl.contract);
-          const isDraftCtx = impl.status === "draft" || impl.status === "design" || contract && (ctx.isComponentDraft(contract.component) || contract.status === "draft" || contract.status === "design");
           if (!ctx.interfaceIds.has(impl.contract)) {
             ctx.addIssue(
               "error",
               "INVALID_INTERFACE_REFERENCE",
               `Implementation "${impl.id}" references non-existent interface contract "${impl.contract}".`,
               impl.id,
-              isDraftCtx
+              ctx.isImplementationDraft(impl)
             );
           }
         }
@@ -2946,11 +2954,7 @@ var init_type_references2 = __esm({
             for (const field of t.fields) {
               const refs = fieldTypeRefs(t, field.type);
               for (const ref of refs) {
-                if (ctx.isBuiltinType(ref)) {
-                  continue;
-                }
-                const resolved = ctx.types.find((spec) => typeMatchesRef(spec, ref));
-                if (!resolved) {
+                if (!ctx.isTypeResolved(ref, /* @__PURE__ */ new Set())) {
                   ctx.addIssue(
                     "error",
                     "UNDEFINED_TYPE_REFERENCE",
@@ -3182,14 +3186,27 @@ var init_contract_symmetry_and_narratives = __esm({
                 );
                 continue;
               }
-              const isCrossTreeForm = ctx.isExternalNamespaceRef(step.targetComponent);
-              const fromSubsystem = ctx.componentMap.get(contract.component)?.subsystem;
-              const isCollapsedForm = !isCrossTreeForm && fromSubsystem !== void 0 && ctx.isCollapsedCrossTreeRef(step.targetComponent, fromSubsystem);
+              const target = step.targetComponent;
+              const isCrossTreeForm = ctx.isExternalNamespaceRef(target);
+              const caller = ctx.componentMap.get(contract.component);
+              const fromSubsystem = caller?.subsystem;
+              const isCollapsedForm = !isCrossTreeForm && fromSubsystem !== void 0 && ctx.isCollapsedCrossTreeRef(target, fromSubsystem);
+              const reportUndeclared = (reaches, surfaceResolved) => {
+                if (!caller || target === caller.id || caller.dependsOn.includes(target) || caller.owns.includes(target)) return;
+                ctx.addIssue(
+                  "error",
+                  "UNDECLARED_DEPENDENCY_CALL",
+                  `Method "${implMethod.name}" in implementation "${impl.id}" (component "${caller.id}") ${reaches} component "${target}" (step ${step.stepNumber}) but component "${caller.id}" does not list "${target}" as a dependency.`,
+                  impl.id,
+                  isDraftCtx || ctx.isComponentDraft(caller.id),
+                  surfaceResolved
+                );
+              };
               if (step.type === "dispatch") {
-                const dispatchTarget = ctx.componentMap.get(step.targetComponent);
+                const dispatchTarget = ctx.componentMap.get(target);
                 if (!dispatchTarget) {
                   if (isCrossTreeForm || isCollapsedForm) {
-                    const resolved = ctx.resolveSurfaceRef(step.targetComponent, fromSubsystem);
+                    const resolved = ctx.resolveSurfaceRef(target, fromSubsystem);
                     if (resolved.kind === "ambiguous") {
                       ctx.addIssue(
                         "error",
@@ -3197,7 +3214,7 @@ var init_contract_symmetry_and_narratives = __esm({
                         ambiguityMessage(
                           resolved,
                           `Method "${implMethod.name}" in implementation "${impl.id}" dispatches (step ${step.stepNumber}) through`,
-                          step.targetComponent
+                          target
                         ),
                         impl.id,
                         isDraftCtx
@@ -3205,11 +3222,12 @@ var init_contract_symmetry_and_narratives = __esm({
                       continue;
                     }
                     if (resolved.kind === "resolved") {
+                      reportUndeclared("dispatches through", true);
                       if (step.capability && !(resolved.entry.dispatch ?? []).some((b) => b.capability === step.capability)) {
                         ctx.addIssue(
                           "error",
                           "SURFACE_REF_NOT_EXPOSED",
-                          `Method "${implMethod.name}" in implementation "${impl.id}" dispatches capability "${step.capability}" through cross-tree portal "${step.targetComponent}" (step ${step.stepNumber}), but the surface snapshot of "${resolved.snapshot.projectName}" does not serve that capability on "${resolved.entry.id}".`,
+                          `Method "${implMethod.name}" in implementation "${impl.id}" dispatches capability "${step.capability}" through cross-tree portal "${target}" (step ${step.stepNumber}), but the surface snapshot of "${resolved.snapshot.projectName}" does not serve that capability on "${resolved.entry.id}".`,
                           impl.id,
                           isDraftCtx,
                           true
@@ -3222,7 +3240,7 @@ var init_contract_symmetry_and_narratives = __esm({
                     ctx.addIssue(
                       "warning",
                       "CROSS_TREE_REF_UNRESOLVED",
-                      `Method "${implMethod.name}" in implementation "${impl.id}" dispatches through cross-tree component "${step.targetComponent}" (step ${step.stepNumber}), and no surface snapshot covers it \u2014 validate from the parent project, pin the family surfaces ("wairon surface pin"), or import the producing project's surface.`,
+                      `Method "${implMethod.name}" in implementation "${impl.id}" dispatches through cross-tree component "${target}" (step ${step.stepNumber}), and no surface snapshot covers it \u2014 validate from the parent project, pin the family surfaces ("wairon surface pin"), or import the producing project's surface.`,
                       impl.id,
                       isDraftCtx
                     );
@@ -3230,23 +3248,14 @@ var init_contract_symmetry_and_narratives = __esm({
                     ctx.addIssue(
                       "error",
                       "INVALID_TARGET_COMPONENT_REFERENCE",
-                      `Method "${implMethod.name}" in implementation "${impl.id}" dispatches through component "${step.targetComponent}" which does not exist (step ${step.stepNumber}).`,
+                      `Method "${implMethod.name}" in implementation "${impl.id}" dispatches through component "${target}" which does not exist (step ${step.stepNumber}).`,
                       impl.id,
                       isDraftCtx
                     );
                   }
                   continue;
                 }
-                const dispatchCaller = ctx.componentMap.get(contract.component);
-                if (dispatchCaller && step.targetComponent !== dispatchCaller.id && !dispatchCaller.dependsOn.includes(step.targetComponent) && !dispatchCaller.owns.includes(step.targetComponent)) {
-                  ctx.addIssue(
-                    "error",
-                    "UNDECLARED_DEPENDENCY_CALL",
-                    `Method "${implMethod.name}" in implementation "${impl.id}" (component "${dispatchCaller.id}") dispatches through component "${step.targetComponent}" (step ${step.stepNumber}) but component "${dispatchCaller.id}" does not list "${step.targetComponent}" as a dependency.`,
-                    impl.id,
-                    isDraftCtx || ctx.isComponentDraft(dispatchCaller.id)
-                  );
-                }
+                reportUndeclared("dispatches through");
                 continue;
               }
               const verb = step.type === "register" ? "registers callback" : "calls";
@@ -3260,10 +3269,10 @@ var init_contract_symmetry_and_narratives = __esm({
                 );
                 continue;
               }
-              const targetComp = ctx.componentMap.get(step.targetComponent);
+              const targetComp = ctx.componentMap.get(target);
               if (!targetComp) {
                 if (isCrossTreeForm || isCollapsedForm) {
-                  const resolved = ctx.resolveSurfaceRef(step.targetComponent, fromSubsystem);
+                  const resolved = ctx.resolveSurfaceRef(target, fromSubsystem);
                   if (resolved.kind === "ambiguous") {
                     ctx.addIssue(
                       "error",
@@ -3271,7 +3280,7 @@ var init_contract_symmetry_and_narratives = __esm({
                       ambiguityMessage(
                         resolved,
                         `Method "${implMethod.name}" in implementation "${impl.id}" ${verb} "${step.targetMethod}" (step ${step.stepNumber}) on`,
-                        step.targetComponent
+                        target
                       ),
                       impl.id,
                       isDraftCtx
@@ -3279,12 +3288,13 @@ var init_contract_symmetry_and_narratives = __esm({
                     continue;
                   }
                   if (resolved.kind === "resolved") {
+                    reportUndeclared(verb, true);
                     const surfaceMethod = resolved.entry.methods.find((m) => m.name === step.targetMethod);
                     if (!surfaceMethod) {
                       ctx.addIssue(
                         "error",
                         "SURFACE_REF_NOT_EXPOSED",
-                        `Method "${implMethod.name}" in implementation "${impl.id}" ${verb} "${step.targetMethod}" on cross-tree component "${step.targetComponent}" (step ${step.stepNumber}), but the surface snapshot of "${resolved.snapshot.projectName}" does not expose that method on "${resolved.entry.id}".`,
+                        `Method "${implMethod.name}" in implementation "${impl.id}" ${verb} "${step.targetMethod}" on cross-tree component "${target}" (step ${step.stepNumber}), but the surface snapshot of "${resolved.snapshot.projectName}" does not expose that method on "${resolved.entry.id}".`,
                         impl.id,
                         isDraftCtx,
                         true
@@ -3311,7 +3321,7 @@ var init_contract_symmetry_and_narratives = __esm({
                   ctx.addIssue(
                     "warning",
                     "CROSS_TREE_REF_UNRESOLVED",
-                    `Method "${implMethod.name}" in implementation "${impl.id}" ${verb} cross-tree component "${step.targetComponent}" (step ${step.stepNumber}), and no surface snapshot covers it \u2014 validate from the parent project, pin the family surfaces ("wairon surface pin"), or import the producing project's surface.`,
+                    `Method "${implMethod.name}" in implementation "${impl.id}" ${verb} cross-tree component "${target}" (step ${step.stepNumber}), and no surface snapshot covers it \u2014 validate from the parent project, pin the family surfaces ("wairon surface pin"), or import the producing project's surface.`,
                     impl.id,
                     isDraftCtx
                   );
@@ -3319,26 +3329,15 @@ var init_contract_symmetry_and_narratives = __esm({
                   ctx.addIssue(
                     "error",
                     "INVALID_TARGET_COMPONENT_REFERENCE",
-                    `Method "${implMethod.name}" in implementation "${impl.id}" ${verb} component "${step.targetComponent}" which does not exist (step ${step.stepNumber}).`,
+                    `Method "${implMethod.name}" in implementation "${impl.id}" ${verb} component "${target}" which does not exist (step ${step.stepNumber}).`,
                     impl.id,
                     isDraftCtx
                   );
                 }
                 continue;
               }
-              const callingComponent = ctx.componentMap.get(contract.component);
-              if (callingComponent && step.targetComponent !== callingComponent.id) {
-                if (!callingComponent.dependsOn.includes(step.targetComponent) && !callingComponent.owns.includes(step.targetComponent)) {
-                  ctx.addIssue(
-                    "error",
-                    "UNDECLARED_DEPENDENCY_CALL",
-                    `Method "${implMethod.name}" in implementation "${impl.id}" (component "${callingComponent.id}") ${verb} component "${step.targetComponent}" (step ${step.stepNumber}) but component "${callingComponent.id}" does not list "${step.targetComponent}" as a dependency.`,
-                    impl.id,
-                    isDraftCtx || ctx.isComponentDraft(callingComponent.id)
-                  );
-                }
-              }
-              const targetInterfaces = ctx.interfacesByComponent.get(step.targetComponent) ?? [];
+              reportUndeclared(verb);
+              const targetInterfaces = ctx.interfacesByComponent.get(target) ?? [];
               let targetMethodSpec;
               for (const targetIntf of targetInterfaces) {
                 const found = targetIntf.methods.find((m) => m.name === step.targetMethod);
@@ -3351,9 +3350,9 @@ var init_contract_symmetry_and_narratives = __esm({
                 ctx.addIssue(
                   "error",
                   "INVALID_TARGET_METHOD_REFERENCE",
-                  `Method "${implMethod.name}" in implementation "${impl.id}" ${verb} method "${step.targetMethod}" on component "${step.targetComponent}" which is not defined on any of its interfaces (step ${step.stepNumber}).`,
+                  `Method "${implMethod.name}" in implementation "${impl.id}" ${verb} method "${step.targetMethod}" on component "${target}" which is not defined on any of its interfaces (step ${step.stepNumber}).`,
                   impl.id,
-                  isDraftCtx || ctx.isComponentDraft(step.targetComponent)
+                  isDraftCtx || ctx.isComponentDraft(target)
                 );
               } else {
                 const declared = new Set(targetMethodSpec.guarantees ?? []);
@@ -3363,9 +3362,9 @@ var init_contract_symmetry_and_narratives = __esm({
                       ctx.addIssue(
                         "warning",
                         "NARRATIVE_SEMANTIC_UNBACKED",
-                        `Step ${step.stepNumber} of "${implMethod.name}" in implementation "${impl.id}" explicitly asserts guarantee "${g}", but the method it calls \u2014 "${step.targetMethod}" on "${step.targetComponent}" \u2014 does not list "${g}" among its L3 contract guarantees. Declare it on that method (and ensure its shape can deliver it), or revise the narrative.`,
+                        `Step ${step.stepNumber} of "${implMethod.name}" in implementation "${impl.id}" explicitly asserts guarantee "${g}", but the method it calls \u2014 "${step.targetMethod}" on "${target}" \u2014 does not list "${g}" among its L3 contract guarantees. Declare it on that method (and ensure its shape can deliver it), or revise the narrative.`,
                         impl.id,
-                        isDraftCtx || ctx.isComponentDraft(step.targetComponent)
+                        isDraftCtx || ctx.isComponentDraft(target)
                       );
                     }
                   }
@@ -3695,43 +3694,47 @@ var init_narrative_flow = __esm({
 });
 
 // src/core/rules/narrative/narrative-antipatterns.ts
-function isTerminal(step, nextOf) {
-  if (step.type === "return" || step.type === "throw") return true;
-  const n = step.stepNumber;
-  switch (step.type) {
-    case "local":
-    case "call":
-    case "register":
-    case "dispatch":
-      return nextOf(n) === void 0;
-    case "branch":
-      return step.onTrueStep === void 0 && nextOf(n) === void 0;
-    case "switch":
-      return step.defaultStep === void 0 && nextOf(n) === void 0;
-    case "loop":
-    case "try":
-      return step.endStep !== void 0 && nextOf(step.endStep) === void 0;
-    default:
-      return false;
-  }
+function completedStepGraph(steps) {
+  const numbers = steps.flatMap((s) => [
+    s.stepNumber,
+    s.onTrueStep,
+    s.onFalseStep,
+    s.defaultStep,
+    s.endStep,
+    s.finallyStep,
+    s.toStep,
+    ...(s.cases ?? []).map((c) => c.step),
+    ...(s.catches ?? []).map((c) => c.step),
+    ...(s.branches ?? []).map((b) => b.step)
+  ]).filter((n) => n !== void 0);
+  const completion = {
+    stepNumber: Math.max(0, ...numbers) + 1,
+    description: "The method completes by falling off the end of its narrative",
+    type: "return"
+  };
+  return stepGraph({ narrative: [...steps, completion] });
 }
 function isUnavoidable(steps, target) {
-  const { stepNumbers: nums, stepAt, nextOf, successorsOf } = stepGraph({ narrative: steps });
-  if (nums.length === 0) return false;
-  if (nums[0] === target) return true;
-  const visited = /* @__PURE__ */ new Set();
-  const stack = [nums[0]];
-  while (stack.length) {
-    const n = stack.pop();
-    if (n === target || visited.has(n)) continue;
-    visited.add(n);
-    const s = stepAt(n);
-    if (isTerminal(s, nextOf)) return false;
-    for (const t of successorsOf(n)) {
-      if (t !== target && !visited.has(t)) stack.push(t);
+  if (steps.length === 0) return false;
+  const graph = completedStepGraph(steps);
+  const completes = /* @__PURE__ */ new Set();
+  const canComplete = (n) => {
+    const s = graph.stepAt(n);
+    if (s.type === "return" || s.type === "throw") return true;
+    const arms = s.type === "parallel" ? (s.branches ?? []).map((b) => b.step).filter((e) => graph.stepAt(e) !== void 0) : [];
+    if (arms.length) return arms.every((e) => completes.has(e));
+    return graph.successorsOf(n).some((t) => completes.has(t));
+  };
+  const order = [...graph.stepNumbers].reverse();
+  for (let grew = true; grew; ) {
+    grew = false;
+    for (const n of order) {
+      if (n === target || completes.has(n) || !canComplete(n)) continue;
+      completes.add(n);
+      grew = true;
     }
   }
-  return true;
+  return !completes.has(graph.stepNumbers[0]);
 }
 function stronglyConnected(nums, successorsOf) {
   const index = /* @__PURE__ */ new Map();
@@ -3783,11 +3786,12 @@ function stronglyConnected(nums, successorsOf) {
   }
   return sccs;
 }
-var narrativeAntipatternsRule;
+var byCodeUnit, narrativeAntipatternsRule;
 var init_narrative_antipatterns = __esm({
   "src/core/rules/narrative/narrative-antipatterns.ts"() {
     "use strict";
     init_models();
+    byCodeUnit = (a, b) => a < b ? -1 : a > b ? 1 : 0;
     narrativeAntipatternsRule = {
       name: "narrative-antipatterns",
       description: "Provable narrative bugs, caught at spec level before implementation: a step-graph cycle with no exit edge and no return/throw member never terminates by construction (INESCAPABLE_CYCLE); a branch or switch whose arms all target the same step decides nothing (MEANINGLESS_BRANCH); a method-level call cycle across components in which every call edge is unavoidable on every entry-to-exit path is unbounded recursion (UNCONDITIONAL_CALL_CYCLE \u2014 dispatch steps resolved through their portal tables; a cycle with even one guarded edge is NOT flagged, since prose conditions are never judged). Structure-only claims \u2014 warnings, lint.allow-suppressible.",
@@ -3806,29 +3810,33 @@ var init_narrative_antipatterns = __esm({
             const steps = implMethod.narrative;
             if (!steps.length) continue;
             const where = `Method "${implMethod.name}" in implementation "${impl.id}": `;
-            const graph = stepGraph(implMethod);
+            const graph = completedStepGraph(steps);
+            const decisionTargets = (stepNumber, explicit, fallThroughField) => {
+              const targets = new Set(explicit);
+              if (fallThroughField !== void 0) targets.add(fallThroughField);
+              else for (const t of graph.successorsOf(stepNumber)) targets.add(t);
+              return [...targets];
+            };
             for (const s of steps) {
               if (s.type === "branch" && s.onFalseStep !== void 0) {
-                const onTrue = s.onTrueStep ?? graph.nextOf(s.stepNumber);
-                if (onTrue !== void 0 && onTrue === s.onFalseStep) {
+                const targets = decisionTargets(s.stepNumber, [s.onFalseStep], s.onTrueStep);
+                if (targets.length === 1) {
                   ctx.addIssue(
                     "warning",
                     "MEANINGLESS_BRANCH",
-                    `${where}branch step ${s.stepNumber} sends both arms to step ${onTrue} \u2014 the condition decides nothing. Point the arms at different steps, or replace the branch with a local step.`,
+                    `${where}branch step ${s.stepNumber} sends both arms to step ${targets[0]} \u2014 the condition decides nothing. Point the arms at different steps, or replace the branch with a local step.`,
                     impl.id,
                     isDraftCtx
                   );
                 }
               }
               if (s.type === "switch" && s.cases?.length) {
-                const targets = new Set(s.cases.map((c) => c.step));
-                const def = s.defaultStep ?? graph.nextOf(s.stepNumber);
-                if (def !== void 0) targets.add(def);
-                if (targets.size === 1) {
+                const targets = decisionTargets(s.stepNumber, s.cases.map((c) => c.step), s.defaultStep);
+                if (targets.length === 1) {
                   ctx.addIssue(
                     "warning",
                     "MEANINGLESS_BRANCH",
-                    `${where}switch step ${s.stepNumber} sends every case (and the default) to step ${[...targets][0]} \u2014 the dispatch decides nothing.`,
+                    `${where}switch step ${s.stepNumber} sends every case (and the default) to step ${targets[0]} \u2014 the dispatch decides nothing.`,
                     impl.id,
                     isDraftCtx
                   );
@@ -3901,8 +3909,8 @@ var init_narrative_antipatterns = __esm({
           if (!isCycle) continue;
           const memberEdges = keys.flatMap((k) => (adjacency.get(k) ?? []).filter((e) => inScc.has(e.toKey)));
           if (memberEdges.length === 0) continue;
-          const anchor = [...memberEdges].sort((a, b) => a.fromKey.localeCompare(b.fromKey))[0];
-          const path70 = [...keys].sort().join(" \u2192 ");
+          const anchor = [...memberEdges].sort((a, b) => byCodeUnit(a.fromKey, b.fromKey) || byCodeUnit(a.impl.id, b.impl.id) || a.stepNumber - b.stepNumber)[0];
+          const path70 = [...keys].sort(byCodeUnit).join(" \u2192 ");
           ctx.addIssue(
             "warning",
             "UNCONDITIONAL_CALL_CYCLE",
@@ -4154,14 +4162,15 @@ var init_portal_endpoints = __esm({
             continue;
           }
           for (const intf of compInterfaces) {
+            const isIntfDraft = intf.status === "draft" || intf.status === "design";
             for (const m of intf.methods) {
               if (m.endpoint) {
                 ctx.addIssue(
                   "error",
                   "ARCHITECTURE_VIOLATION_NON_PORTAL_ENDPOINT",
                   `Architectural violation: Component "${comp.id}" is a ${comp.componentType}, but method "${m.name}" on its interface "${intf.id}" declares an endpoint. Only Portal components may carry endpoints.`,
-                  comp.id,
-                  isDraftCtx
+                  intf.id,
+                  isDraftCtx || isIntfDraft
                 );
               }
             }
@@ -4292,7 +4301,7 @@ var init_stereotype_dependencies = __esm({
         { code: "ARCHITECTURE_VIOLATION_ADAPTER_DEP", defaultSeverity: "error", summary: "Adapter depending on Orchestrators or Stores" },
         { code: "ARCHITECTURE_VIOLATION_INDEX_DEP", defaultSeverity: "error", summary: "Index depending on anything but its Store or an Adapter" },
         { code: "ARCHITECTURE_VIOLATION_VIEW_DEP", defaultSeverity: "error", summary: "View depending on logic/persistence layers" },
-        { code: "PORTAL_WRITE_SHORTCUT", defaultSeverity: "error", summary: "Portal narrative calls a write-effect method on a Repository/Index directly \u2014 reads may shortcut, writes route through an Orchestrator (judged on effect-tagged facade methods; untagged methods are not yet judged)" }
+        { code: "PORTAL_WRITE_SHORTCUT", defaultSeverity: "error", summary: "Portal narrative call or dispatch-table binding reaches a write-effect method on a Repository/Index directly \u2014 reads may shortcut, writes route through an Orchestrator (judged on effect-tagged facade methods; untagged methods are not yet judged)" }
       ],
       check(ctx) {
         for (const comp of ctx.components) {
@@ -4364,10 +4373,11 @@ var init_stereotype_dependencies = __esm({
                   crossDraft
                 );
               } else if (depComp.componentType !== "Portal" && depComp.componentType !== "Gateway") {
+                const crosser = comp.componentType === "Adapter" ? "client Adapter" : comp.componentType;
                 ctx.addIssue(
                   "error",
                   "CROSS_SUBSYSTEM_TARGET_NON_PORTAL",
-                  `Boundary violation: client Adapter "${comp.id}" enters subsystem "${depComp.subsystem}" through "${depComp.id}" (${depComp.componentType}), not its inbound Portal. A cross-subsystem hop must target the remote subsystem's Portal (its front door), which dispatches inward \u2014 publishing/depending on an internal ${depComp.componentType} leaks the boundary and breaks the distribution seam. Expose a Portal for "${depComp.subsystem}" and point this Adapter at it.`,
+                  `Boundary violation: ${crosser} "${comp.id}" enters subsystem "${depComp.subsystem}" through "${depComp.id}" (${depComp.componentType}), not its inbound Portal. A cross-subsystem hop must target the remote subsystem's Portal (its front door), which dispatches inward \u2014 publishing/depending on an internal ${depComp.componentType} leaks the boundary and breaks the distribution seam. Expose a Portal for "${depComp.subsystem}" and point "${comp.id}" at it.`,
                   comp.id,
                   crossDraft
                 );
@@ -4491,6 +4501,23 @@ var init_stereotype_dependencies = __esm({
             }
           }
         }
+        for (const comp of ctx.components) {
+          if (comp.componentType !== "Portal" || !comp.dispatch || comp.dispatch.length === 0) continue;
+          const isDraftCtx = ctx.isComponentDraft(comp.id);
+          for (const binding of comp.dispatch) {
+            const target = ctx.componentMap.get(binding.component);
+            if (!target || target.componentType !== "Repository" && target.componentType !== "Index") continue;
+            const targetMethod = ctx.interfaceMethodsOf(target.id).find((m) => m.name === binding.method);
+            if (targetMethod?.effect !== "write") continue;
+            ctx.addIssue(
+              "error",
+              "PORTAL_WRITE_SHORTCUT",
+              `Portal "${comp.id}": dispatch binding "${binding.capability}" routes to write-effect method ${target.id}.${binding.method} directly. The Portal\u2192${target.componentType} shortcut is licensed for READS only \u2014 route the write through an Orchestrator that owns the workflow.`,
+              comp.id,
+              isDraftCtx || ctx.isComponentDraft(target.id)
+            );
+          }
+        }
       }
     };
   }
@@ -4514,7 +4541,7 @@ var init_pattern_ownership = __esm({
         { code: "REPOSITORY_CONTAINMENT", defaultSeverity: "error", summary: "Repository owning a non Store/Registry/Index/Adapter member" },
         { code: "GATEWAY_CONTAINMENT", defaultSeverity: "error", summary: "Gateway owning a non Portal/Orchestrator/Specialist member" },
         { code: "FEATURE_COMPONENT_CONTAINMENT", defaultSeverity: "error", summary: "FeatureComponent not owning exactly one Orchestrator + one or more Views" },
-        { code: "ROUTER_COMPONENT_CONTAINMENT", defaultSeverity: "error", summary: "RouterComponent missing its Portal facade or children" },
+        { code: "ROUTER_COMPONENT_CONTAINMENT", defaultSeverity: "error", summary: "RouterComponent not owning exactly one Portal facade, or owning no children to route to" },
         { code: "VISIBILITY_VIOLATION", defaultSeverity: "error", summary: "Dependency on a block privately owned by another pattern" },
         { code: "UNOWNED_STORE", defaultSeverity: "warning", summary: "Store not owned by any pattern \u2014 recommended shape is a Repository; a deliberate standalone Store needs a lint.allow" },
         { code: "REGISTRY_WITHOUT_STORE", defaultSeverity: "warning", summary: "Standalone Registry with no Store to write to \u2014 either mistyped (a fused file-backed store belongs typed Store) or orphaned" }
@@ -4536,14 +4563,15 @@ var init_pattern_ownership = __esm({
               ctx.addIssue("error", "INVALID_OWNED_MEMBER", `Component "${comp.id}" owns "${memberId}" which does not exist.`, comp.id, isDraftCtx);
               continue;
             }
+            if (!pattern) continue;
             if (isPattern(member)) {
               ctx.addIssue("error", "PATTERN_OWNS_PATTERN", `Pattern "${comp.id}" owns "${memberId}", which is itself a pattern. Patterns own only building blocks \u2014 compose patterns at the subsystem (L1) level.`, comp.id, isDraftCtx);
             }
-            const prev = ownedBy.get(memberId);
-            if (prev && prev !== comp.id) {
-              ctx.addIssue("error", "SHARED_OWNED_MEMBER", `Block "${memberId}" is owned by both "${prev}" and "${comp.id}"; a block has exactly one owner.`, comp.id, isDraftCtx);
+            const firstOwner = ownedBy.get(memberId);
+            if (firstOwner && firstOwner !== comp.id) {
+              ctx.addIssue("error", "SHARED_OWNED_MEMBER", `Block "${memberId}" is owned by both "${firstOwner}" and "${comp.id}"; a block has exactly one owner.`, comp.id, isDraftCtx);
             }
-            ownedBy.set(memberId, comp.id);
+            if (!firstOwner) ownedBy.set(memberId, comp.id);
           }
           if (comp.componentType === "Repository") {
             const allowed = /* @__PURE__ */ new Set(["Store", "Registry", "Index", "Adapter"]);
@@ -4578,14 +4606,14 @@ var init_pattern_ownership = __esm({
             }
           }
           if (comp.componentType === "RouterComponent") {
-            let hasPortal = false;
+            let portals = 0;
             let hasChildren = false;
             for (const memberId of comp.owns) {
               const t = ctx.componentMap.get(memberId)?.componentType;
-              if (t === "Portal") hasPortal = true;
+              if (t === "Portal") portals++;
               else if (t) hasChildren = true;
             }
-            if (!hasPortal) {
+            if (portals !== 1) {
               ctx.addIssue("error", "ROUTER_COMPONENT_CONTAINMENT", `RouterComponent "${comp.id}" must own exactly one Portal component to act as its facade.`, comp.id, isDraftCtx);
             }
             if (!hasChildren) {
@@ -5087,54 +5115,43 @@ var init_dependency_cycles = __esm({
     "use strict";
     cyclesRule = {
       name: "dependency-cycles",
-      description: "The component dependsOn graph must be a DAG; the first detected cycle is reported with its full path.",
+      description: "The component dependsOn graph must be a DAG; the first cycle through a component in the run's scope is reported with its full path.",
       codes: [
         { code: "CIRCULAR_DEPENDENCY", defaultSeverity: "error", summary: "Circular dependency between components" }
       ],
       check(ctx) {
-        const visited = /* @__PURE__ */ new Set();
-        const recStack = /* @__PURE__ */ new Set();
-        const dfs = (compId, pathTrace) => {
-          visited.add(compId);
-          recStack.add(compId);
-          pathTrace.push(compId);
-          const comp = ctx.componentMap.get(compId);
-          if (comp) {
-            for (const depId of comp.dependsOn) {
-              if (!visited.has(depId)) {
-                if (dfs(depId, pathTrace)) {
-                  recStack.delete(compId);
-                  pathTrace.pop();
-                  return true;
-                }
-              } else if (recStack.has(depId)) {
+        const cycleFrom = (startId) => {
+          const visited = /* @__PURE__ */ new Set([startId]);
+          const pathTrace = [startId];
+          const search = (compId) => {
+            for (const depId of ctx.componentMap.get(compId)?.dependsOn ?? []) {
+              if (depId === startId) {
                 pathTrace.push(depId);
-                const cyclePath = pathTrace.slice(pathTrace.indexOf(depId)).join(" -> ");
-                const isDraftCtx = ctx.isComponentDraft(compId) || ctx.isComponentDraft(depId);
-                ctx.addIssue(
-                  "error",
-                  "CIRCULAR_DEPENDENCY",
-                  `Circular dependency detected: ${cyclePath}`,
-                  compId,
-                  isDraftCtx
-                );
-                pathTrace.pop();
-                recStack.delete(compId);
-                pathTrace.pop();
                 return true;
               }
+              if (visited.has(depId)) continue;
+              visited.add(depId);
+              pathTrace.push(depId);
+              if (search(depId)) return true;
+              pathTrace.pop();
             }
-          }
-          recStack.delete(compId);
-          pathTrace.pop();
-          return false;
+            return false;
+          };
+          return search(startId) ? pathTrace : void 0;
         };
         for (const comp of ctx.components) {
-          if (!visited.has(comp.id)) {
-            if (dfs(comp.id, [])) {
-              break;
-            }
-          }
+          if (!ctx.isSpecInScope(comp.id)) continue;
+          const cycle = cycleFrom(comp.id);
+          if (!cycle) continue;
+          const closing = cycle[cycle.length - 2];
+          ctx.addIssue(
+            "error",
+            "CIRCULAR_DEPENDENCY",
+            `Circular dependency detected: ${cycle.join(" -> ")}`,
+            comp.id,
+            ctx.isComponentDraft(comp.id) || ctx.isComponentDraft(closing)
+          );
+          return;
         }
       }
     };
@@ -5263,19 +5280,18 @@ var init_dispatch_tables = __esm({
                 );
                 continue;
               }
-              if (step.assertsGuarantees?.length) {
-                const boundMethod = ctx.interfaceMethodsOf(binding.component).find((m) => m.name === binding.method);
-                const declared = new Set(boundMethod?.guarantees ?? []);
-                for (const g of step.assertsGuarantees) {
-                  if (!declared.has(g)) {
-                    ctx.addIssue(
-                      "warning",
-                      "NARRATIVE_SEMANTIC_UNBACKED",
-                      `${where} asserts guarantee "${g}", but capability "${step.capability}" resolves to "${binding.component}.${binding.method}", which does not list "${g}" among its L3 contract guarantees. Declare it there (and ensure its shape can deliver it), or revise the narrative.`,
-                      impl.id,
-                      isDraftCtx || ctx.isComponentDraft(binding.component)
-                    );
-                  }
+              const boundMethod = ctx.interfaceMethodsOf(binding.component).find((m) => m.name === binding.method);
+              if (!boundMethod) continue;
+              const declared = new Set(boundMethod.guarantees ?? []);
+              for (const g of step.assertsGuarantees ?? []) {
+                if (!declared.has(g)) {
+                  ctx.addIssue(
+                    "warning",
+                    "NARRATIVE_SEMANTIC_UNBACKED",
+                    `${where} asserts guarantee "${g}", but capability "${step.capability}" resolves to "${binding.component}.${binding.method}", which does not list "${g}" among its L3 contract guarantees. Declare it there (and ensure its shape can deliver it), or revise the narrative.`,
+                    impl.id,
+                    isDraftCtx || ctx.isComponentDraft(binding.component)
+                  );
                 }
               }
             }
@@ -5480,12 +5496,11 @@ var init_unused_detection = __esm({
         const invokedBySeeds = [];
         for (const intf of ctx.interfaces) {
           if (!ctx.componentMap.has(intf.component)) continue;
-          const comp = ctx.componentMap.get(intf.component);
           for (const m of intf.methods) {
             if (!m.invokedBy) continue;
             invokedBySeeds.push({ compId: intf.component, methodName: m.name });
             if (!ctx.isSpecInScope(intf.id)) continue;
-            const isDraftCtx = comp.status === "draft" || comp.status === "design" || intf.status === "draft" || intf.status === "design";
+            const isDraftCtx = ctx.isComponentDraft(intf.component) || intf.status === "draft" || intf.status === "design";
             if (!passesIntentFloor(m.invokedBy.caller, m.name)) {
               ctx.addIssue(
                 "warning",
@@ -5510,7 +5525,7 @@ var init_unused_detection = __esm({
         for (const comp of ctx.components) {
           if (!ctx.isSpecInScope(comp.id)) continue;
           if (!reach.reachesComponent(comp.id)) {
-            const isDraftCtx = comp.status === "draft" || comp.status === "design";
+            const isDraftCtx = ctx.isComponentDraft(comp.id);
             ctx.addIssue(
               "warning",
               "UNUSED_COMPONENT",
@@ -5522,12 +5537,12 @@ var init_unused_detection = __esm({
             for (const intf of ctx.interfacesByComponent.get(comp.id) ?? []) {
               for (const m of intf.methods) {
                 if (!reach.reachesMethod(comp.id, m.name)) {
-                  const isDraftCtx = comp.status === "draft" || comp.status === "design" || intf.status === "draft" || intf.status === "design";
+                  const isDraftCtx = ctx.isComponentDraft(comp.id) || intf.status === "draft" || intf.status === "design";
                   ctx.addIssue(
                     "warning",
                     "UNUSED_METHOD",
                     `Method "${m.name}" on component "${comp.id}" is defined but never called by any narrative step.`,
-                    comp.id,
+                    intf.id,
                     isDraftCtx
                   );
                 }
@@ -5638,20 +5653,20 @@ var init_durability_round_trip = __esm({
 });
 
 // src/core/rules/wiring/untyped-seams.ts
-function unwrapPromise(typeRef) {
-  const m = /^promise\s*<(.+)>$/i.exec(typeRef.trim());
-  return (m ? m[1] : typeRef).trim();
+function namesBareType(refs) {
+  return refs.some((ref) => BARE_SEAM_TYPES.has(ref.toLowerCase()));
 }
 var BARE_SEAM_TYPES, untypedSeamRule;
 var init_untyped_seams = __esm({
   "src/core/rules/wiring/untyped-seams.ts"() {
     "use strict";
+    init_models();
     BARE_SEAM_TYPES = /* @__PURE__ */ new Set(["json", "any", "unknown", "object"]);
     untypedSeamRule = {
       name: "untyped-seams",
-      description: "Methods on a subsystem's published components (its public surface) should not take or return bare Json/any/unknown \u2014 cross-subsystem contracts are the swap seam and must be typed. Generic-dispatch portals carry per-capability types via their dispatch table instead.",
+      description: "Methods on a subsystem's published components (its public surface) should not take or return bare Json/any/unknown/object, judged through each method's type references so a prose signature is judged like structured params: cross-subsystem contracts are the swap seam and must be typed. Generic-dispatch portals carry per-capability types via their dispatch table instead.",
       codes: [
-        { code: "UNTYPED_SEAM", defaultSeverity: "warning", summary: "Bare Json/any/unknown parameter or return crossing a subsystem public surface" }
+        { code: "UNTYPED_SEAM", defaultSeverity: "warning", summary: "Bare Json/any/unknown/object parameter or return crossing a subsystem public surface" }
       ],
       check(ctx) {
         for (const sub of ctx.subsystems) {
@@ -5665,14 +5680,17 @@ var init_untyped_seams = __esm({
               const isDraftCtx = ctx.isComponentDraft(compId) || intf.status === "draft" || intf.status === "design";
               for (const m of intf.methods) {
                 const offenders = [];
-                for (const p of m.params ?? []) {
-                  if (BARE_SEAM_TYPES.has(unwrapPromise(p.type).toLowerCase())) {
-                    offenders.push(`param "${p.name}: ${p.type}"`);
+                if (m.params && m.params.length > 0) {
+                  for (const p of m.params) {
+                    if (namesBareType(extractTypeIdentifiers(p.type))) {
+                      offenders.push(`param "${p.name}: ${p.type}"`);
+                    }
                   }
-                }
-                const ret = unwrapPromise(m.returns ?? "");
-                if (BARE_SEAM_TYPES.has(ret.toLowerCase())) {
-                  offenders.push(`return "${m.returns}"`);
+                  if (namesBareType(extractTypeIdentifiers(m.returns ?? ""))) {
+                    offenders.push(`return "${m.returns}"`);
+                  }
+                } else if (namesBareType(methodTypeRefs(m))) {
+                  offenders.push(`signature "${m.signature}"`);
                 }
                 if (offenders.length) {
                   ctx.addIssue(
@@ -5697,15 +5715,19 @@ function componentOfImpl(ctx, implContract) {
   const contract = ctx.interfaceMap.get(implContract);
   return contract ? ctx.componentMap.get(contract.component) : void 0;
 }
-var DATA_STEREOTYPES, CLAIM_PHRASES, proseClaimRule;
+function withoutQuotedText(text2) {
+  return text2.replace(QUOTED_SPAN, " ");
+}
+var DATA_STEREOTYPES, CLAIM_PHRASES, QUOTED_SPAN, proseClaimRule;
 var init_prose_claims = __esm({
   "src/core/rules/wiring/prose-claims.ts"() {
     "use strict";
     DATA_STEREOTYPES = /* @__PURE__ */ new Set(["Store", "Registry", "Index", "Adapter", "Repository"]);
-    CLAIM_PHRASES = /\b(persist(s|ed|ent)?|survives?\s+(a\s+)?restart|writ(es?|ten)\s+to\s+disk|registered\s+into|durabl[ey])\b/i;
+    CLAIM_PHRASES = /\b(persist(s|ed|ent|ing|ence)?|survives?\s+(a\s+)?restart|writ(es?|ten)\s+to\s+disk|registered\s+into|durabl[ey])\b/i;
+    QUOTED_SPAN = /"[^"]*"|“[^”]*”|`[^`]*`|(?<![\p{L}\p{N}])['‘](?:[^'‘’]|(?<=[\p{L}\p{N}])['’](?=[\p{L}\p{N}]))*['’](?![\p{L}\p{N}])/gu;
     proseClaimRule = {
       name: "prose-claims",
-      description: 'Flags durability/side-effect claims that exist only in prose: a local step description or an intent paragraph claiming persistence ("persisted", "survives restart", "registered into") on a logic component whose narrative has no call/dispatch edge to any data-layer component (Store/Registry/Index/Adapter/Repository). Data-layer components are exempt \u2014 they ARE the persistence.',
+      description: 'Flags durability/side-effect claims that exist only in prose: a local step description or an intent paragraph claiming persistence ("persisted", "persistence", "survives restart", "registered into") on a logic component whose narrative has no call, register or dispatch edge to any data-layer component (Store/Registry/Index/Adapter/Repository). Text inside quotes or backticks names a value or quotes a message and claims nothing. Data-layer components are exempt \u2014 they ARE the persistence.',
       codes: [
         { code: "UNREALIZED_CLAIM", defaultSeverity: "warning", summary: "Durability/side-effect claim in prose with no matching structural edge" }
       ],
@@ -5716,11 +5738,11 @@ var init_prose_claims = __esm({
           if (DATA_STEREOTYPES.has(comp.componentType)) continue;
           const isDraftCtx = ctx.isImplementationDraft(impl);
           for (const implMethod of impl.methods) {
-            const stepClaims = implMethod.narrative.filter((step) => step.type === "local").map((step) => ({ step, claim: CLAIM_PHRASES.exec(step.description) })).filter((c) => c.claim !== null);
-            const intentClaim = implMethod.intent ? CLAIM_PHRASES.exec(implMethod.intent) : null;
+            const stepClaims = implMethod.narrative.filter((step) => step.type === "local").map((step) => ({ step, claim: CLAIM_PHRASES.exec(withoutQuotedText(step.description)) })).filter((c) => c.claim !== null);
+            const intentClaim = implMethod.intent ? CLAIM_PHRASES.exec(withoutQuotedText(implMethod.intent)) : null;
             if (!stepClaims.length && !intentClaim) continue;
             const hasDataEdge = implMethod.narrative.some((step) => {
-              if (step.type !== "call" && step.type !== "dispatch") return false;
+              if (step.type !== "call" && step.type !== "register" && step.type !== "dispatch") return false;
               if (!step.targetComponent) return false;
               const target = ctx.componentMap.get(step.targetComponent);
               if (target && DATA_STEREOTYPES.has(target.componentType)) return true;
@@ -5733,7 +5755,7 @@ var init_prose_claims = __esm({
                 ctx.addIssue(
                   "warning",
                   "UNREALIZED_CLAIM",
-                  `Step ${step.stepNumber} of "${implMethod.name}" in implementation "${impl.id}" claims "${claim[0]}" but no call/dispatch edge in this narrative reaches a Store/Registry/Index/Adapter \u2014 realize the claim as a structural edge (and durability tags), or reword the prose.`,
+                  `Step ${step.stepNumber} of "${implMethod.name}" in implementation "${impl.id}" claims "${claim[0]}" but no call/register/dispatch edge in this narrative reaches a Store/Registry/Index/Adapter \u2014 realize the claim as a structural edge (and durability tags), or reword the prose.`,
                   impl.id,
                   isDraftCtx
                 );
@@ -5792,6 +5814,10 @@ function stepAsserts(impl, methodName, type, invariantId) {
     (step) => (step.assertsInvariants ?? []).some((ref) => refMatchesInvariant(ref, type, invariantId))
   );
 }
+function isEntityDraft(t, ctx) {
+  const sub = t.subsystem ? ctx.subsystems.find((s) => s.id === t.subsystem) : void 0;
+  return sub !== void 0 && isDraftSubsystem(sub);
+}
 function resolveComponentClass(t, ctx) {
   if (!t.componentClass) return void 0;
   const direct = ctx.componentMap.get(t.componentClass);
@@ -5818,6 +5844,7 @@ var init_invariant_backing = __esm({
         for (const t of ctx.types) {
           const invariants = t.invariants ?? [];
           if (invariants.length === 0) continue;
+          const entityDraft = isEntityDraft(t, ctx);
           const seen = /* @__PURE__ */ new Set();
           for (const inv of invariants) {
             if (seen.has(inv.id)) {
@@ -5825,7 +5852,8 @@ var init_invariant_backing = __esm({
                 "error",
                 "DUPLICATE_INVARIANT_ID",
                 `Entity "${t.id}" declares invariant id "${inv.id}" more than once \u2014 invariant ids must be unique within the entity.`,
-                t.id
+                t.id,
+                entityDraft
               );
             }
             seen.add(inv.id);
@@ -5836,7 +5864,8 @@ var init_invariant_backing = __esm({
               "warning",
               "INVARIANT_UNANCHORED",
               `Entity "${t.id}" declares ${invariants.length} invariant(s) but ${t.componentClass ? `its componentClass "${t.componentClass}" does not resolve to a component` : "has no componentClass"} \u2014 without an owning component there is no write path to hold the invariant against. Link the lifecycle owner via componentClass.`,
-              t.id
+              t.id,
+              entityDraft
             );
             continue;
           }
@@ -5850,13 +5879,13 @@ var init_invariant_backing = __esm({
               "INVARIANT_UNANCHORED",
               `Entity "${t.id}" declares ${invariants.length} invariant(s) anchored to "${comp.id}", but none of that component's contract methods declare effect: write \u2014 the validator cannot identify the write paths that must assert them. Tag the mutating methods with effect: write.`,
               t.id,
-              ctx.isComponentDraft(comp.id)
+              entityDraft || ctx.isComponentDraft(comp.id)
             );
             continue;
           }
           for (const { intf, method: method2 } of writeMethods) {
             for (const impl of ctx.implementationsByContract.get(intf.id) ?? []) {
-              const isDraftCtx = ctx.isImplementationDraft(impl);
+              const isDraftCtx = entityDraft || ctx.isImplementationDraft(impl);
               for (const inv of invariants) {
                 if (stepAsserts(impl, method2.name, t, inv.id)) continue;
                 ctx.addIssue(
@@ -5894,30 +5923,35 @@ var init_invariant_backing = __esm({
 
 // src/core/rules/wiring/event-topology.ts
 function collectEnds(ctx) {
-  const emitters = [];
-  const subscribers = [];
+  const emitters = /* @__PURE__ */ new Map();
+  const subscribers = /* @__PURE__ */ new Map();
+  const addEnd = (ends, topic, compId, via) => {
+    const key = `${compId}#${topic}`;
+    const end = ends.get(key);
+    if (!end) ends.set(key, { topic, compId, vias: [via] });
+    else if (!end.vias.includes(via)) end.vias.push(via);
+  };
   for (const comp of ctx.components) {
     for (const e of comp.emits ?? []) {
-      emitters.push({ topic: e.topic, compId: comp.id, via: "emits declaration" });
+      addEnd(emitters, e.topic, comp.id, "emits declaration");
     }
     for (const s of comp.subscribesTo ?? []) {
-      subscribers.push({ topic: s.topic, compId: comp.id, via: "subscribesTo declaration" });
+      addEnd(subscribers, s.topic, comp.id, "subscribesTo declaration");
     }
   }
   for (const intf of ctx.interfaces) {
     for (const method2 of intf.methods) {
       const ep = method2.endpoint;
       if (!ep || ep.transport !== "MessageBus") continue;
-      const end = {
-        topic: ep.topic,
-        compId: intf.component,
-        via: `MessageBus endpoint on ${intf.id}.${method2.name}`
-      };
-      if (ep.direction === "publish") emitters.push(end);
-      else subscribers.push(end);
+      addEnd(
+        ep.direction === "publish" ? emitters : subscribers,
+        ep.topic,
+        intf.component,
+        `MessageBus endpoint on ${intf.id}.${method2.name}`
+      );
     }
   }
-  return { emitters, subscribers };
+  return { emitters: [...emitters.values()], subscribers: [...subscribers.values()] };
 }
 var eventTopologyRule;
 var init_event_topology = __esm({
@@ -5925,7 +5959,7 @@ var init_event_topology = __esm({
     "use strict";
     eventTopologyRule = {
       name: "event-topology",
-      description: "Bipartite completeness of the declared pub/sub graph: every topic a component emits (emits declarations, MessageBus publish endpoints) must have at least one subscriber (subscribesTo declarations, MessageBus subscribe endpoints), and every subscription must have at least one source. Pairing is by exact topic name. Trees that declare no event edges see nothing \u2014 the rule costs request/response systems zero noise. Warnings + lint.allow: a topic produced for (or consumed from) an EXTERNAL system is a legitimate, declarable exception.",
+      description: "Bipartite completeness of the declared pub/sub graph: every topic a component emits (emits declarations, MessageBus publish endpoints) must have at least one subscriber (subscribesTo declarations, MessageBus subscribe endpoints), and every subscription must have at least one source. Pairing is by exact topic name, and a topic is reported once per component however many declarations bind it there. Trees that declare no event edges see nothing \u2014 the rule costs request/response systems zero noise. Warnings + lint.allow: a topic produced for (or consumed from) an EXTERNAL system is a legitimate, declarable exception.",
       codes: [
         { code: "UNCONSUMED_TOPIC", defaultSeverity: "warning", summary: "Topic is emitted but nothing in the tree subscribes to it" },
         { code: "UNSOURCED_SUBSCRIPTION", defaultSeverity: "warning", summary: "Topic is subscribed to but nothing in the tree emits it" }
@@ -5940,7 +5974,7 @@ var init_event_topology = __esm({
           ctx.addIssue(
             "warning",
             "UNCONSUMED_TOPIC",
-            `Component "${e.compId}" emits topic "${e.topic}" (${e.via}), but nothing in this tree subscribes to it \u2014 the event goes nowhere. Wire a subscriber (subscribesTo, or a MessageBus subscribe endpoint), fix the topic name, or lint.allow with the external consumer named.`,
+            `Component "${e.compId}" emits topic "${e.topic}" (${e.vias.join(", ")}), but nothing in this tree subscribes to it \u2014 the event goes nowhere. Wire a subscriber (subscribesTo, or a MessageBus subscribe endpoint), fix the topic name, or lint.allow with the external consumer named.`,
             e.compId,
             ctx.isComponentDraft(e.compId)
           );
@@ -5950,7 +5984,7 @@ var init_event_topology = __esm({
           ctx.addIssue(
             "warning",
             "UNSOURCED_SUBSCRIPTION",
-            `Component "${s.compId}" subscribes to topic "${s.topic}" (${s.via}), but nothing in this tree emits it \u2014 the handler can never fire from inside this system. Wire the emitter (emits, or a MessageBus publish endpoint), fix the topic name, or lint.allow with the external source named.`,
+            `Component "${s.compId}" subscribes to topic "${s.topic}" (${s.vias.join(", ")}), but nothing in this tree emits it \u2014 the handler can never fire from inside this system. Wire the emitter (emits, or a MessageBus publish endpoint), fix the topic name, or lint.allow with the external source named.`,
             s.compId,
             ctx.isComponentDraft(s.compId)
           );
@@ -5969,13 +6003,13 @@ var init_structural_conformance = __esm({
     quoteList = (names) => names.map((n) => `"${n}"`).join(", ");
     structuralConformanceRule = {
       name: "structural-conformance",
-      description: "Code\u2194spec Level 1: every source file an implementation names \u2014 its own sourcePath and each method's \u2014 must resolve to a real file inside the project root, and every L3 contract method must be realized in its own source file (the method's sourcePath, else the implementation's) at its conformance tier (declared | anchored | off; Portals default to anchored, everything else to declared; per-method `symbol` maps intent-language names to code names), and every finding code a contract method declares must appear as a string literal in that file (UNREALIZED_FINDING). A file that escapes the root, is missing or cannot be read is reported once and blocks only the methods realized in it. Findings carry the analysis grade (exact AST | pattern table | generic scan) so weaker analysis is visible. Implementations under chained subsystems (projectPath) validate standalone in their own project run and are skipped here.",
+      description: "Code\u2194spec Level 1: every source file an implementation names \u2014 its own sourcePath and each method's \u2014 must resolve to a real file inside the project root, and every L3 contract method must be realized in its own source file (the method's sourcePath, else the implementation's) at its conformance tier (declared | anchored | off; Portals default to anchored, everything else to declared; per-method `symbol` maps intent-language names to code names), and every finding code a contract method declares must be anchored in that file \u2014 as a string literal or, at exact grade, a property-access name (UNREALIZED_FINDING). A file that escapes the root, is missing or cannot be read is reported once and blocks only the methods realized in it. Findings carry the analysis grade (exact AST | pattern table | generic scan) so weaker analysis is visible. Implementations under chained subsystems (projectPath) validate standalone in their own project run and are skipped here.",
       codes: [
         { code: "MISSING_SOURCE_PATH", defaultSeverity: "warning", summary: "An implementation names no source file at all, or a contract method is left without one \u2014 structural conformance cannot link it to code" },
         { code: "MISSING_SOURCE_FILE", defaultSeverity: "error", summary: "A source file an implementation or one of its methods names does not resolve to a file on disk" },
         { code: "SOURCE_PATH_ESCAPES_ROOT", defaultSeverity: "error", summary: "A source file an implementation or one of its methods names is absolute or escapes the project root (containment refusal)" },
         { code: "UNREALIZED_METHOD", defaultSeverity: "warning", summary: "An L3 contract method has no anchor in its own source file (the method's sourcePath, else the implementation's) at the required conformance tier" },
-        { code: "UNREALIZED_FINDING", defaultSeverity: "warning", summary: "A finding code a contract method declares does not appear as a string literal in the method's source file" },
+        { code: "UNREALIZED_FINDING", defaultSeverity: "warning", summary: "A finding code a contract method declares appears in the method's source file neither as a string literal nor as a property-access name (below exact grade, any identifier counts)" },
         { code: "CONFORMANCE_ANALYSIS_SKIPPED", defaultSeverity: "warning", summary: "A source file an implementation or one of its methods names could not be analyzed (binary/unreadable) \u2014 realization of the methods in it was not checked" },
         { code: "CONFORMANCE_DEGRADED", defaultSeverity: "warning", summary: "TypeScript/JavaScript files were analyzed below exact grade (compiler not resolvable) \u2014 dependency conformance skips them" }
       ],
@@ -5985,7 +6019,7 @@ var init_structural_conformance = __esm({
           lookups.set(pathKey(facts.path), {
             declared: /* @__PURE__ */ new Set([...facts.declaredNames, ...facts.exportedNames]),
             anchored: /* @__PURE__ */ new Set([...facts.declaredNames, ...facts.exportedNames, ...facts.anchoredNames]),
-            literals: new Set(facts.anchoredNames),
+            findingAnchors: new Set(facts.anchoredNames),
             facts
           });
         }
@@ -6105,11 +6139,11 @@ var init_structural_conformance = __esm({
             if (!checked) continue;
             const { file, lookup } = checked;
             for (const finding of method2.findings) {
-              if (lookup.literals.has(finding.code)) continue;
+              if (lookup.findingAnchors.has(finding.code)) continue;
               ctx.addIssue(
                 "warning",
                 "UNREALIZED_FINDING",
-                `Method "${method2.name}" of contract "${impl.contract}" declares finding "${finding.code}", but "${file}" has no string literal "${finding.code}" (analysis grade: ${lookup.facts.analysisGrade}) \u2014 report the finding under its declared code, or remove the declaration.`,
+                `Method "${method2.name}" of contract "${impl.contract}" declares finding "${finding.code}", but "${file}" has no string literal or property-access name "${finding.code}" (analysis grade: ${lookup.facts.analysisGrade}) \u2014 report the finding under its declared code, or remove the declaration.`,
                 impl.id,
                 draft
               );
@@ -6225,12 +6259,18 @@ var init_hidden_state = __esm({
       check(ctx) {
         const byPath = /* @__PURE__ */ new Map();
         for (const impl of ctx.implementations) {
-          if (impl.conformance === "off") continue;
           const contract = ctx.interfaceMap.get(impl.contract);
           const component = contract ? ctx.componentMap.get(contract.component) : void 0;
           if (!component) continue;
           if (ctx.isInChainedSubproject(component.subsystem)) continue;
-          for (const file of implementationSourceFiles(impl)) {
+          const trusted = [];
+          if (impl.sourcePath && impl.conformance !== "off") trusted.push(impl.sourcePath);
+          for (const method2 of impl.methods) {
+            if ((method2.conformance ?? impl.conformance) === "off") continue;
+            const file = methodSourceFile(method2, impl.sourcePath);
+            if (file) trusted.push(file);
+          }
+          for (const file of trusted) {
             const key = pathKey(file);
             const list2 = byPath.get(key) ?? [];
             if (list2.some((m) => m.impl === impl)) continue;
@@ -6381,7 +6421,7 @@ var init_dependency_conformance = __esm({
           const fromFiles = filesByComponent.get(component.id);
           if (!fromFiles) continue;
           const isMountingDeclarer = component.componentType === "Portal" || component.componentType === "Observer";
-          const declaredTargets = [...component.dependsOn, ...component.owns ?? []];
+          const declaredTargets = [.../* @__PURE__ */ new Set([...component.dependsOn, ...component.owns ?? []])];
           for (const targetId of declaredTargets) {
             const target = ctx.componentMap.get(targetId);
             if (!target) continue;
@@ -6402,11 +6442,14 @@ var init_dependency_conformance = __esm({
             }
             const impls = implsByComponent.get(component.id) ?? [];
             const anchor = impls[0];
+            const declaredDependsOn = component.dependsOn.includes(targetId);
+            const declaredOwns = (component.owns ?? []).includes(targetId);
+            const relation = declaredDependsOn && declaredOwns ? "dependsOn and owns" : declaredDependsOn ? "dependsOn" : "owns";
             const draft = ctx.isComponentDraft(component.id) || ctx.isComponentDraft(targetId) || impls.some((i) => ctx.isImplementationDraft(i));
             ctx.addIssue(
               "warning",
               "UNREALIZED_DEPENDENCY",
-              `Component "${component.id}" declares ${component.dependsOn.includes(targetId) ? "dependsOn" : "owns"} "${targetId}", but no runtime import connects their source files (${[...fromFiles].join(", ")} \u219B ${target.subsystem !== component.subsystem ? `subsystem ${target.subsystem}` : [...filesByComponent.get(targetId) ?? []].join(", ")}) \u2014 either the collaboration is wired indirectly (DI) or the declared edge is stale.`,
+              `Component "${component.id}" declares ${relation} "${targetId}", but no runtime import connects their source files (${[...fromFiles].join(", ")} \u219B ${target.subsystem !== component.subsystem ? `subsystem ${target.subsystem}` : [...filesByComponent.get(targetId) ?? []].join(", ")}) \u2014 either the collaboration is wired indirectly (DI) or the declared edge is stale.`,
               anchor?.id ?? component.id,
               draft
             );
@@ -6438,31 +6481,31 @@ var init_integration_conformance = __esm({
         const filesByComponent = /* @__PURE__ */ new Map();
         const filesBySubsystem = /* @__PURE__ */ new Map();
         const implsByComponent = /* @__PURE__ */ new Map();
+        const adopted = /* @__PURE__ */ new Set();
+        const exists = (p) => {
+          const status2 = factsByPath.get(p)?.status;
+          return status2 === "analyzed" || status2 === "unreadable";
+        };
         for (const impl of ctx.implementations) {
           const contract = ctx.interfaceMap.get(impl.contract);
           const comp = contract ? ctx.componentMap.get(contract.component) : void 0;
-          if (!comp) continue;
+          if (!comp || ctx.isInChainedSubproject(comp.subsystem)) continue;
           if (!implsByComponent.has(comp.id)) implsByComponent.set(comp.id, []);
           implsByComponent.get(comp.id).push(impl);
           for (const file of implementationSourceFiles(impl)) {
             const p = pathKey(file);
+            if (!exists(p)) continue;
             if (!filesByComponent.has(comp.id)) filesByComponent.set(comp.id, /* @__PURE__ */ new Set());
             filesByComponent.get(comp.id).add(p);
             if (!filesBySubsystem.has(comp.subsystem)) filesBySubsystem.set(comp.subsystem, /* @__PURE__ */ new Set());
             filesBySubsystem.get(comp.subsystem).add(p);
           }
+          if (impl.simPath) adopted.add(comp.subsystem);
         }
         const isTechBoundary = (compId) => (implsByComponent.get(compId) ?? []).some((i) => (i.technologies ?? []).length > 0);
-        const adopted = /* @__PURE__ */ new Set();
-        for (const impl of ctx.implementations) {
-          if (!impl.simPath) continue;
-          const contract = ctx.interfaceMap.get(impl.contract);
-          const comp = contract ? ctx.componentMap.get(contract.component) : void 0;
-          if (comp) adopted.add(comp.subsystem);
-        }
-        const reachFrom = (start) => {
-          const seen = /* @__PURE__ */ new Set([start]);
-          const stack = [start];
+        const reachFrom = (start2) => {
+          const seen = /* @__PURE__ */ new Set([start2]);
+          const stack = [start2];
           while (stack.length) {
             const from = stack.pop();
             const facts = factsByPath.get(from);
@@ -6656,8 +6699,8 @@ var init_coupling_health = __esm({
             );
           }
         }
-        const threshold = ctx.rules?.complexity?.maxComponentDependencies ?? DEFAULT_GOD_COMPONENT_THRESHOLD;
         for (const comp of ctx.components) {
+          const threshold = ctx.complexityConfigFor(comp.subsystem)?.maxComponentDependencies ?? DEFAULT_GOD_COMPONENT_THRESHOLD;
           if (comp.dependsOn.length > threshold) {
             ctx.addIssue(
               "warning",
@@ -6785,7 +6828,7 @@ var init_target_language = __esm({
           if (!lang) continue;
           const gaps = gapsFor(lang);
           if (Object.keys(gaps).length === 0) continue;
-          const isDraftCtx = impl.status === "draft" || impl.status === "design" || contract.status === "draft" || contract.status === "design" || ctx.isComponentDraft(contract.component);
+          const isDraftCtx = ctx.isImplementationDraft(impl);
           for (const implMethod of impl.methods) {
             for (const step of implMethod.narrative) {
               const constructs = [
@@ -6887,7 +6930,7 @@ var init_technology_boundaries = __esm({
               "TECH_ON_LOGIC_COMPONENT",
               `Implementation "${impl.id}" binds technology (${impl.technologies.join(", ")}) on component "${comp.id}" (${comp.componentType}). Technology belongs behind a data-layer seam \u2014 extract an Adapter (or Store/Registry/Index) behind an intent interface and let this component depend on that.`,
               impl.id,
-              ctx.isComponentDraft(comp.id)
+              ctx.isImplementationDraft(impl)
             );
           }
           const compSet = ownsClosure(ownershipRoot(comp.id));
@@ -6925,7 +6968,7 @@ var init_technology_boundaries = __esm({
                 "VENDOR_NAME_IN_CONTRACT",
                 `Interface "${intf.id}" exposes technology "${home.label}" in contract identifiers (method${offending.length > 1 ? "s" : ""}: ${offending.join(", ")}). Name the intent, not the vendor \u2014 the technology is owned by component ${ownersDesc(home)} and must stay swappable behind this contract.`,
                 intf.id,
-                ctx.isComponentDraft(intf.component)
+                ctx.isComponentDraft(intf.component) || intf.status === "draft" || intf.status === "design"
               );
             }
           }
@@ -6956,7 +6999,8 @@ var init_technology_boundaries = __esm({
                 "warning",
                 "TECH_LEAKAGE",
                 `Subsystem "${sub.id}" references "${home.label}" outside the technology's owning boundary (component ${ownersDesc(home)}).`,
-                sub.id
+                sub.id,
+                isDraftSubsystem(sub)
               );
             }
           }
@@ -6969,7 +7013,7 @@ var init_technology_boundaries = __esm({
                 "TECH_LEAKAGE",
                 `Interface "${intf.id}" describes "${home.label}" outside its owning boundary (component ${ownersDesc(home)}) \u2014 consumers must not know backend specifics.`,
                 intf.id,
-                ctx.isComponentDraft(intf.component)
+                ctx.isComponentDraft(intf.component) || intf.status === "draft" || intf.status === "design"
               );
             }
           }
@@ -6989,7 +7033,8 @@ var init_technology_boundaries = __esm({
                 "warning",
                 "TECH_LEAKAGE",
                 `Implementation "${impl.id}" references "${home.label}" outside its owning boundary \u2014 call the intent interface of component ${ownersDesc(home)} instead of naming its technology.`,
-                impl.id
+                impl.id,
+                ctx.isImplementationDraft(impl)
               );
             }
           }
@@ -7052,6 +7097,7 @@ var casingPatterns, isAllUppercase, namingRule;
 var init_naming_conventions = __esm({
   "src/core/rules/heuristic/naming-conventions.ts"() {
     "use strict";
+    init_models();
     casingPatterns = {
       camelCase: /^[a-z][a-zA-Z0-9]*$/,
       PascalCase: /^[A-Z][a-zA-Z0-9]*$/,
@@ -7072,9 +7118,10 @@ var init_naming_conventions = __esm({
         for (const sub of ctx.subsystems) {
           const namingConfig = ctx.namingConfigFor(sub.id);
           if (!namingConfig?.subsystems) continue;
+          const isDraft = isDraftSubsystem(sub);
           const baseId = getBaseId(sub.id);
-          checkNamedValue(ctx, baseId, namingConfig.subsystems, `Subsystem ID "${sub.id}" does not match naming convention "${namingConfig.subsystems}".`, sub.id);
-          checkNamedValue(ctx, sub.name, namingConfig.subsystems, `Subsystem Name "${sub.name}" does not match naming convention "${namingConfig.subsystems}".`, sub.id);
+          checkNamedValue(ctx, baseId, namingConfig.subsystems, `Subsystem ID "${sub.id}" does not match naming convention "${namingConfig.subsystems}".`, sub.id, isDraft);
+          checkNamedValue(ctx, sub.name, namingConfig.subsystems, `Subsystem Name "${sub.name}" does not match naming convention "${namingConfig.subsystems}".`, sub.id, isDraft);
         }
         for (const comp of ctx.components) {
           const namingConfig = ctx.namingConfigFor(comp.subsystem);
@@ -7159,7 +7206,7 @@ var init_naming_conventions = __esm({
           const intf = ctx.interfaceMap.get(impl.contract);
           const comp = intf ? ctx.componentMap.get(intf.component) : void 0;
           const namingConfig = ctx.namingConfigFor(comp?.subsystem);
-          const isDraft = impl.status === "draft" || impl.status === "design";
+          const isDraft = ctx.isImplementationDraft(impl);
           if (namingConfig?.methods) {
             for (const m of impl.methods) {
               checkNamedValue(ctx, m.name, namingConfig.methods, `Implementation method "${m.name}" on "${impl.id}" does not match naming convention "${namingConfig.methods}".`, impl.id, isDraft);
@@ -7223,6 +7270,7 @@ var complexityRule;
 var init_complexity_and_metadata = __esm({
   "src/core/rules/heuristic/complexity-and-metadata.ts"() {
     "use strict";
+    init_models();
     complexityRule = {
       name: "complexity-and-metadata",
       description: "Enforces metadata documentation completeness (checking if descriptions are missing or too short) and structural complexity caps (limits on methods per interface, dependencies per component, and narrative steps per method) configured globally or in architectural profiles.",
@@ -7238,7 +7286,8 @@ var init_complexity_and_metadata = __esm({
       check(ctx) {
         for (const sub of ctx.subsystems) {
           const docConfig = ctx.documentationConfigFor(sub.id);
-          checkDescription(ctx, sub.description, docConfig?.requireDescriptions ?? false, docConfig?.minDescriptionLength, sub.id, "Subsystem", false);
+          const isSubDraft = isDraftSubsystem(sub);
+          checkDescription(ctx, sub.description, docConfig?.requireDescriptions ?? false, docConfig?.minDescriptionLength, sub.id, "Subsystem", isSubDraft);
           const complexityConfig = ctx.complexityConfigFor(sub.id);
           const directComponents = ctx.components.filter((c) => c.subsystem === sub.id).length;
           if (complexityConfig?.maxSubsystemComponents !== void 0 && directComponents > complexityConfig.maxSubsystemComponents) {
@@ -7246,7 +7295,8 @@ var init_complexity_and_metadata = __esm({
               "warning",
               "EXCESSIVE_SUBSYSTEM_COMPONENTS",
               `Subsystem "${sub.id}" has ${directComponents} direct components, exceeding the configured limit of ${complexityConfig.maxSubsystemComponents}.`,
-              sub.id
+              sub.id,
+              isSubDraft
             );
           }
         }
@@ -7322,7 +7372,7 @@ var init_complexity_and_metadata = __esm({
           const intf = ctx.interfaceMap.get(impl.contract);
           const comp = intf ? ctx.componentMap.get(intf.component) : void 0;
           const complexityConfig = ctx.complexityConfigFor(comp?.subsystem);
-          const isDraft = impl.status === "draft" || impl.status === "design";
+          const isDraft = ctx.isImplementationDraft(impl);
           if (complexityConfig?.maxNarrativeSteps !== void 0) {
             for (const m of impl.methods) {
               if (m.narrative.length > complexityConfig.maxNarrativeSteps) {
@@ -8838,14 +8888,14 @@ function buildExcalidrawScene(model, L) {
     const src = rectById[edge.from], tgt = rectById[edge.to];
     if (!a || !b || !src || !tgt) return;
     const leftToRight = b.x >= a.x + a.w;
-    const start = leftToRight ? { x: a.x + a.w, y: a.y + a.h / 2 } : { x: a.x, y: a.y + a.h / 2 };
+    const start2 = leftToRight ? { x: a.x + a.w, y: a.y + a.h / 2 } : { x: a.x, y: a.y + a.h / 2 };
     const end = leftToRight ? { x: b.x, y: b.y + b.h / 2 } : { x: b.x + b.w, y: b.y + b.h / 2 };
     const id = "edge-" + edgeN++;
-    const arrow = base(id, "arrow", { x: start.x, y: start.y, w: Math.abs(end.x - start.x), h: Math.abs(end.y - start.y) });
+    const arrow = base(id, "arrow", { x: start2.x, y: start2.y, w: Math.abs(end.x - start2.x), h: Math.abs(end.y - start2.y) });
     arrow.roundness = { type: 2 };
     arrow.strokeColor = edge.cross ? "#c26767" : "#8d97a5";
     arrow.strokeWidth = edge.cross ? 2 : 1;
-    arrow.points = [[0, 0], [end.x - start.x, end.y - start.y]];
+    arrow.points = [[0, 0], [end.x - start2.x, end.y - start2.y]];
     arrow.lastCommittedPoint = null;
     arrow.startBinding = { elementId: src.id, focus: 0, gap: 4 };
     arrow.endBinding = { elementId: tgt.id, focus: 0, gap: 4 };
@@ -14029,7 +14079,7 @@ function buildRuleContext(opts) {
       return rules.sddRuleSeverity[ruleCode];
     }
     const sub = subsystemId ? subsystems.find((s) => s.id === subsystemId) : void 0;
-    const profileSeverity = extensions.profiles[sub?.profile ?? projectType]?.rules?.sddRuleSeverity?.[ruleCode];
+    const profileSeverity = extensions.profiles[sub?.profile || projectType]?.rules?.sddRuleSeverity?.[ruleCode];
     if (profileSeverity) {
       return profileSeverity;
     }
@@ -14516,28 +14566,52 @@ var init_domains = __esm({
 function globalVariantsDir() {
   return process.env.WAIRON_VARIANTS_DIR ?? path16.join(os5.homedir(), ".wairon", "variants");
 }
-function readVariantsDir(dir) {
+function builtinVariantsDir() {
+  const candidates = [
+    path16.resolve(__dirname, "..", "templates", "variants"),
+    // src/core & dist/cli
+    path16.resolve(__dirname, "templates", "variants")
+    // dist (library entry)
+  ];
+  return candidates.find((dir) => fs12.existsSync(dir)) ?? candidates[0];
+}
+function projectVariantsDir() {
+  return path16.join(getProjectRoot(), ".wai", "variants");
+}
+function variantFiles(dir) {
   let entries;
   try {
     entries = fs12.readdirSync(dir, { withFileTypes: true });
   } catch {
     return [];
   }
+  return entries.filter((e) => e.isFile() && /\.ya?ml$/i.test(e.name)).sort((a, b) => a.name.localeCompare(b.name)).map((e) => path16.join(dir, e.name));
+}
+function parseVariants(raw) {
+  if (raw == null) return [];
+  return (Array.isArray(raw) ? raw : [raw]).map((item) => VariantDefSchema.parse(item));
+}
+function reportSkippedFile(file, err) {
+  console.error(`[variants] skipped "${file}": ${err instanceof Error ? err.message : String(err)}`);
+}
+function readVariantsDir(dir) {
   const out = [];
-  for (const e of entries.sort((a, b) => a.name.localeCompare(b.name))) {
-    if (!e.isFile() || !/\.ya?ml$/i.test(e.name)) continue;
-    const full = path16.join(dir, e.name);
+  for (const file of variantFiles(dir)) {
     try {
-      const raw = readYamlFile(full);
-      if (raw == null) continue;
-      const items = Array.isArray(raw) ? raw : [raw];
-      for (const item of items) out.push(VariantDefSchema.parse(item));
+      out.push(...parseVariants(readYamlFile(file)));
     } catch (err) {
-      console.error(`[variants] skipped "${full}": ${err instanceof Error ? err.message : String(err)}`);
+      reportSkippedFile(file, err);
     }
   }
   return out;
 }
+function mergeById(...layers) {
+  const byId = /* @__PURE__ */ new Map();
+  for (const layer of layers) {
+    for (const v of layer) byId.set(v.id, v);
+  }
+  return [...byId.values()];
+}
 function resolveVariantGuidance(component, allComponents, variantsById) {
   if (!component.variant) return null;
   const def = variantsById.get(component.variant);
@@ -14571,10 +14645,11 @@ function composeVariantGuidance(comps, allComponents, variantsById) {
 }
 function loadProjectVariants() {
   try {
-    const byId = /* @__PURE__ */ new Map();
-    for (const v of readVariantsDir(globalVariantsDir())) byId.set(v.id, v);
-    for (const v of readVariantsDir(path16.join(getProjectRoot(), ".wai", "variants"))) byId.set(v.id, v);
-    return [...byId.values()];
+    return mergeById(
+      readVariantsDir(builtinVariantsDir()),
+      readVariantsDir(globalVariantsDir()),
+      readVariantsDir(projectVariantsDir())
+    );
   } catch {
     return [];
   }
@@ -14592,7 +14667,7 @@ var init_variants = __esm({
     VariantDefSchema = import_zod10.z.object({
       /** Variant id referenced by a component's `variant` (e.g. "publisher", "org/external-config-adapter"). */
       id: import_zod10.z.string().min(1),
-      /** The core stereotype this variant specializes — authoritative for generic semantics (Adapter, Specialist, …). */
+      /** The core stereotype this variant specializes — authoritative for generic semantics (Adapter, Orchestrator, …). */
       base: import_zod10.z.string().min(1),
       /** How to implement a component of this variant — the recipe the implementer follows and reuses across same-variant components. */
       guidance: import_zod10.z.string().min(1),
@@ -16377,10 +16452,10 @@ var require_node = __commonJS({
       0
     ]);
     var clim = new u8([16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15]);
-    var freb = function(eb, start) {
+    var freb = function(eb, start2) {
       var b = new u16(31);
       for (var i2 = 0; i2 < 31; ++i2) {
-        b[i2] = start += 1 << eb[i2 - 1];
+        b[i2] = start2 += 1 << eb[i2 - 1];
       }
       var r = new i32(b[30]);
       for (var i2 = 1; i2 < 30; ++i2) {
@@ -24775,7 +24850,7 @@ NOTICE:
     name: import_zod11.z.string().describe("Human-readable display name"),
     description: import_zod11.z.string().describe("Responsibility / internal architecture details"),
     subsystem: import_zod11.z.string().describe("The L1 subsystem ID this component belongs to"),
-    componentType: import_zod11.z.enum(["Portal", "Orchestrator", "Supervisor", "Actor", "Store", "Index", "Registry", "Adapter", "Observer", "Specialist", "Repository", "Gateway"]).describe("The building block, or pattern (Repository/Gateway)"),
+    componentType: import_zod11.z.enum(["Portal", "Orchestrator", "Supervisor", "Actor", "Store", "Index", "Query", "Registry", "Adapter", "Observer", "Repository"]).describe("The building block, or the pattern Repository. Specialist and Gateway are retired and cannot be authored: logic is an Orchestrator with a dependencyClass, a gateway is a Portal with the gateway variant"),
     owns: import_zod11.z.array(import_zod11.z.string()).optional().describe("Member block ids privately owned by this component (patterns only)"),
     dependsOn: import_zod11.z.array(import_zod11.z.string()).optional().describe("IDs of other components this collaborates with (facades or standalone blocks)"),
     portalType: import_zod11.z.enum(["HTTP_API", "gRPC", "GraphQL", "MessageBus", "CLI", "NamedPipe", "IPC", "Custom"]).optional().describe("Portal-only, and expected on every Portal. OMIT IT on any other componentType \u2014 passing it there is refused at the write (UNEXPECTED_PORTAL_FIELD), nothing is saved."),
@@ -24787,6 +24862,7 @@ NOTICE:
       description: import_zod11.z.string().optional()
     })).optional().describe("Portal-only: capability \u2192 component.method dispatch table for generic-handle portals. Gives the reachability walker real edges and is validated against target interfaces (UNSERVED_CAPABILITY)."),
     durability: import_zod11.z.enum(["ram-projection", "durable", "read-through", "cache"]).optional().describe("Store-only \u2014 OMIT IT on any other componentType, where it is refused at the write (DURABILITY_ON_NON_STORE) and nothing is saved. Every Store should declare one (MISSING_DURABILITY): durable = persisted RAM projection (hydration read-back from a lifecycle init entrypoint required \u2014 MISSING_HYDRATION); read-through = persisted with no RAM copy (every read is the read-back, hydration exempt); ram-projection = rebuilt not restored; cache = evictable loss-safe memo state."),
+    dependencyClass: import_zod11.z.enum(["pure", "read"]).optional().describe("Orchestrator-only \u2014 OMIT IT on any other componentType, where it is refused at the write (DEPENDENCY_CLASS_ON_NON_ORCHESTRATOR) and nothing is saved. Declares what logic may depend on, enforced as a Store's durability is (DEPENDENCY_CLASS_VIOLATION): pure = depends only on pure Orchestrators (a computation over the values it is handed, e.g. an arbiter or codec); read = also on read Orchestrators, Repositories, Indexes and Adapters, never calling their write methods; unset = a workflow."),
     emits: import_zod11.z.array(import_zod11.z.object({
       topic: import_zod11.z.string().describe("Topic/channel name exactly as used on the bus"),
       event: import_zod11.z.string().optional().describe("Optional event name within the topic (informational; pairing is by topic)"),
@@ -24804,10 +24880,10 @@ NOTICE:
     server,
     "sdd_add_component",
     {
-      description: `Add an L2 Component under a subsystem. componentType is a building block (Portal, Orchestrator, Supervisor, Actor, Store, Index, Registry, Adapter, Observer, Specialist) or a pattern (Repository, Gateway). Patterns set "owns" (their private member blocks); all components set "dependsOn" (collaborators \u2014 facades or standalone blocks). Held/persisted state (configs, permissions, sessions, caches): model the Repository recipe \u2014 a Store + Registry (write) + Index (read) owned by a Repository facade consumers depend on; a deliberately standalone Store is the sanctioned lightweight form (workflow-layer consumers + lint.allow on UNOWNED_STORE). Never hold state as fields inside an Orchestrator/Specialist because a Store link was refused. Re-running it on an existing id RE-AUTHORS it: the fields above are replaced (an omitted array is CLEARED), while lint.allow, a Portal's auth, variant, patterns and externalLinks are carried forward \u2014 edit those with sdd_update_spec.`,
+      description: `Add an L2 Component under a subsystem. componentType is a building block (Portal, Orchestrator, Supervisor, Actor, Store, Index, Query, Registry, Adapter, Observer) or the pattern Repository. Specialist and Gateway are retired (STEREOTYPE_RETIRED) and cannot be authored: logic is an Orchestrator with a dependencyClass (pure | read; unset = a workflow), and a gateway is a Portal with the gateway variant (set variant with sdd_update_spec). Patterns set "owns" (their private member blocks); all components set "dependsOn" (collaborators \u2014 facades or standalone blocks). Held/persisted state (configs, permissions, sessions, caches): model the Repository recipe \u2014 a Store + Registry (write) + Index (read), plus a Query for computed reads over the Store, owned by a Repository facade consumers depend on; a deliberately standalone Store is the sanctioned lightweight form (workflow-layer consumers + lint.allow on UNOWNED_STORE). Never hold state as fields inside an Orchestrator because a Store link was refused. Re-running it on an existing id RE-AUTHORS it: the fields above are replaced (an omitted array is CLEARED), while lint.allow, a Portal's auth, variant, patterns and externalLinks are carried forward \u2014 edit those with sdd_update_spec.`,
       inputSchema: componentInput
     },
-    ({ id, name, description, subsystem, componentType, owns, dependsOn, portalType, basePath, dispatch, durability, emits, subscribesTo, ext }) => {
+    ({ id, name, description, subsystem, componentType, owns, dependsOn, portalType, basePath, dispatch, durability, dependencyClass, emits, subscribesTo, ext }) => {
       try {
         const { loadSubsystemSpec: loadSubsystemSpec2, loadComponentSpec: loadComponentSpec2 } = requireSpecs();
         const sub = loadSubsystemSpec2(subsystem);
@@ -24825,6 +24901,7 @@ NOTICE:
           ...basePath ? { basePath } : {},
           ...dispatch ? { dispatch } : {},
           ...durability ? { durability } : {},
+          ...dependencyClass ? { dependencyClass } : {},
           ...emits ? { emits } : {},
           ...subscribesTo ? { subscribesTo } : {},
           ...ext ? { ext } : {},
@@ -24876,7 +24953,7 @@ NOTICE:
       code: import_zod11.z.string().describe("UPPER_SNAKE finding code, unique within the method; a pack's codes carry the pack prefix (<PACK>_<CODE>)"),
       severity: import_zod11.z.enum(["error", "warning"]).describe("Default severity, before project severity overrides and draft-context downgrades"),
       summary: import_zod11.z.string().describe("One line saying what the finding means")
-    })).optional().describe("The finding codes this method can report, each with its default severity and summary. Each declared code must appear as a string literal in the method's source file (UNREALIZED_FINDING). A code is declared once per method; sdd_update_spec upserts and deletes findings by code."),
+    })).optional().describe("The finding codes this method can report, each with its default severity and summary. Each declared code must be anchored in the method's source file, as a string literal or a property-access name (UNREALIZED_FINDING). A code is declared once per method; sdd_update_spec upserts and deletes findings by code."),
     ext: import_zod11.z.record(import_zod11.z.unknown()).optional().describe("Opaque pack/tool extension data for this method (namespaced keys) \u2014 preserved verbatim")
   };
   const interfaceMethodInputFields = Object.keys(interfaceMethodShape);
@@ -24892,7 +24969,7 @@ NOTICE:
     server,
     "sdd_define_interface",
     {
-      description: "Define an L3 Contract / Interface with method signatures for a component. Prefer supplying structured `params` per method \u2014 they are the authoritative source for type checking (the free-form signature string then becomes display-only and is never heuristically parsed). A method declares the finding codes it reports in `findings` ({code, severity, summary}); each code must appear as a string literal in the method's source file. Re-defining an existing id REPLACES the method list: a method left out of the input is REMOVED (and reported); spec-level lint/ext and each method's endpoint binding are carried forward.",
+      description: "Define an L3 Contract / Interface with method signatures for a component. Prefer supplying structured `params` per method \u2014 they are the authoritative source for type checking (the free-form signature string then becomes display-only and is never heuristically parsed). A method declares the finding codes it reports in `findings` ({code, severity, summary}); each code must be anchored in the method's source file, as a string literal or a property-access name (UNREALIZED_FINDING). Re-defining an existing id REPLACES the method list: a method left out of the input is REMOVED (and reported); spec-level lint/ext and each method's endpoint binding are carried forward.",
       inputSchema: interfaceInput
     },
     ({ id, name, description, component, methods }) => {
@@ -27526,14 +27603,14 @@ var http = __toESM(require("http"));
 var https = __toESM(require("https"));
 init_defaults();
 function downloadFile(url, dest) {
-  return new Promise((resolve31, reject) => {
+  return new Promise((resolve32, reject) => {
     const file = fs23.createWriteStream(dest);
     const get4 = url.startsWith("https://") ? https.get : http.get;
     get4(url, { headers: { "User-Agent": `wairon/${WAIRON_VERSION}` }, agent: false }, (res) => {
       if (res.statusCode === 301 || res.statusCode === 302) {
         file.close();
         res.destroy();
-        downloadFile(res.headers.location, dest).then(resolve31).catch(reject);
+        downloadFile(res.headers.location, dest).then(resolve32).catch(reject);
         return;
       }
       if (res.statusCode !== 200) {
@@ -27545,7 +27622,7 @@ function downloadFile(url, dest) {
       res.pipe(file);
       file.on("finish", () => {
         res.destroy();
-        file.close(() => resolve31());
+        file.close(() => resolve32());
       });
       file.on("error", (err) => {
         res.destroy();
@@ -27722,7 +27799,7 @@ function releaseChannelLabel(tag) {
   return version.slice(dash + 1).replace(/\.\d+$/, "") || "stable";
 }
 function fetchReleases(repo) {
-  return new Promise((resolve31, reject) => {
+  return new Promise((resolve32, reject) => {
     const url = `https://api.github.com/repos/${repo}/releases?per_page=100`;
     const options = {
       headers: {
@@ -27742,7 +27819,7 @@ function fetchReleases(repo) {
           return;
         }
         try {
-          resolve31(JSON.parse(data));
+          resolve32(JSON.parse(data));
         } catch {
           reject(new Error("Failed to parse GitHub API response"));
         }
@@ -27917,7 +27994,7 @@ async function filteredCheckbox(config) {
     32,
     Math.max(...items.map((i) => i.label.length))
   );
-  return new Promise((resolve31) => {
+  return new Promise((resolve32) => {
     const checked = /* @__PURE__ */ new Set();
     let cursor = 0;
     let filterIdx = 0;
@@ -27984,7 +28061,7 @@ async function filteredCheckbox(config) {
       );
       teardown();
       const result = items.filter((_, idx) => checked.has(idx)).map((i) => i.value);
-      resolve31(result);
+      resolve32(result);
     }
     function abort() {
       process.stdout.write("\n");
@@ -36141,7 +36218,7 @@ async function awaitApproval(cfg, credential, requestId, timeoutSeconds) {
   let current2 = req;
   while (current2.status === "pending" && Date.now() < deadline) {
     const remaining = deadline - Date.now();
-    await new Promise((resolve31) => setTimeout(resolve31, Math.min(AWAIT_POLL_INTERVAL_MS, remaining)));
+    await new Promise((resolve32) => setTimeout(resolve32, Math.min(AWAIT_POLL_INTERVAL_MS, remaining)));
     expirePendingApprovals(cfg.dataDir, (/* @__PURE__ */ new Date()).toISOString());
     current2 = getApprovalRequestById(cfg.dataDir, requestId) ?? current2;
   }
@@ -41391,6 +41468,52 @@ function serveSharedDownload(cfg, token, kind, req, res) {
   res.end(result.content);
 }
 
+// src/server/backup-schedule.ts
+var TICK_MS = 6e4;
+var timer;
+function sweep(config) {
+  try {
+    runPeriodicGitSync(config);
+  } catch (err) {
+    console.error("[git-sync] project sweep failed: " + (err instanceof Error ? err.message : String(err)));
+  }
+  try {
+    runPeriodicBackingSync(config);
+  } catch (err) {
+    console.error("[git-backing] backing sweep failed: " + (err instanceof Error ? err.message : String(err)));
+  }
+}
+function start(config) {
+  if (timer) clearInterval(timer);
+  timer = setInterval(() => sweep(config), TICK_MS);
+  timer.unref();
+}
+function stop() {
+  if (timer) {
+    clearInterval(timer);
+    timer = void 0;
+  }
+}
+
+// src/server/instance-bootstrap.ts
+var DEV_UNIT_ID = "local";
+function bootstrapInstance(cfg) {
+  ensureInstanceIdentity(cfg.dataDir);
+  if (cfg.devMode && !getOrganizationUnit(cfg.dataDir, DEV_UNIT_ID)) {
+    const system = { userId: "system", kind: "service", issuer: "local" };
+    createUnit(cfg.dataDir, {
+      id: DEV_UNIT_ID,
+      name: "Local Development",
+      kind: "team",
+      slug: DEV_UNIT_ID,
+      // a root unit's qualified id IS its slug
+      status: "active",
+      createdAt: "",
+      createdBy: system
+    });
+  }
+}
+
 // src/server/http.ts
 var MAX_BODY_BYTES = 8 * 1024 * 1024;
 var PayloadTooLargeError = class extends Error {
@@ -41815,23 +41938,6 @@ async function routeAdmin(cfg, req, res) {
     sendJson(res, 400, { error: err instanceof Error ? err.message : String(err) });
   }
 }
-var DEV_UNIT_ID = "local";
-function initHostInstance(cfg) {
-  ensureInstanceIdentity(cfg.dataDir);
-  if (cfg.devMode && !getOrganizationUnit(cfg.dataDir, DEV_UNIT_ID)) {
-    const system = { userId: "system", kind: "service", issuer: "local" };
-    createUnit(cfg.dataDir, {
-      id: DEV_UNIT_ID,
-      name: "Local Development",
-      kind: "team",
-      slug: DEV_UNIT_ID,
-      // a root unit's qualified id IS its slug
-      status: "active",
-      createdAt: "",
-      createdBy: system
-    });
-  }
-}
 function warnIfDataDirUnmigrated(cfg) {
   try {
     const report2 = migratePermissionModel(cfg.dataDir, false);
@@ -41866,7 +41972,7 @@ function startHostServer(cfg) {
       );
     }
   }
-  initHostInstance(cfg);
+  bootstrapInstance(cfg);
   warnIfDataDirUnmigrated(cfg);
   const dataServer = http2.createServer((req, res) => routeData(cfg, req, res));
   const adminServer = http2.createServer((req, res) => {
@@ -41877,23 +41983,10 @@ function startHostServer(cfg) {
   });
   dataServer.listen(cfg.port, cfg.host);
   adminServer.listen(cfg.adminPort, cfg.adminHost);
-  const GIT_SYNC_TICK_MS = 6e4;
-  const gitSyncTimer = setInterval(() => {
-    try {
-      runPeriodicGitSync(cfg);
-    } catch (err) {
-      console.error("[git-sync] project sweep failed: " + (err instanceof Error ? err.message : String(err)));
-    }
-    try {
-      runPeriodicBackingSync(cfg);
-    } catch (err) {
-      console.error("[git-backing] backing sweep failed: " + (err instanceof Error ? err.message : String(err)));
-    }
-  }, GIT_SYNC_TICK_MS);
-  gitSyncTimer.unref();
+  start(cfg);
   return {
     close() {
-      clearInterval(gitSyncTimer);
+      stop();
       getRealtimeHub().closeAll();
       dataServer.close();
       adminServer.close();
@@ -42454,11 +42547,11 @@ async function runServe(options = {}) {
   logger.info(`  data dir:    ${import_chalk17.default.gray(cfg.dataDir)}`);
   logger.blank();
   logger.info("Press Ctrl+C to stop.");
-  await new Promise((resolve31) => {
+  await new Promise((resolve32) => {
     const shutdown = () => {
       logger.info("Shutting down\u2026");
       handle.close();
-      resolve31();
+      resolve32();
     };
     process.on("SIGINT", shutdown);
     process.on("SIGTERM", shutdown);
@@ -42523,11 +42616,11 @@ async function runDev(options = {}) {
   logger.blank();
   logger.info("An agent edits specs; refresh the page to see the live graph. Press Ctrl+C to stop.");
   if (options.open) openBrowser(url);
-  await new Promise((resolve31) => {
+  await new Promise((resolve32) => {
     const shutdown = () => {
       logger.info("Shutting down\u2026");
       handle.close();
-      resolve31();
+      resolve32();
     };
     process.on("SIGINT", shutdown);
     process.on("SIGTERM", shutdown);