@wairon/cli 5.1.1-dev.102 → 5.1.1-dev.104

package/dist/index.d.ts

@@ -515,6 +515,16 @@ declare const ConformanceRuleConfigSchema: z.ZodObject<{
         }[];
         revisit?: string | undefined;
     }>, "many">>;
+    /**
+     * Opt-in strictness for teams that want CI to say "every designed component
+     * has code": every implementation must have begun (some file it names
+     * exists). When true, SOURCE_FILE_PLANNED and MISSING_SOURCE_PATH are
+     * reported at error, naming this setting, instead of as notices. Off by
+     * default, so a design-only tree passes `validate --ci`. Code-conformance
+     * tuning like the rest of `rules.conformance`: it enters the analyzer's
+     * digest, never the gate identity, so switching it never stales a lock.
+     */
+    requireCode: z.ZodOptional<z.ZodBoolean>;
 }, "strip", z.ZodTypeAny, {
     sourceRoots?: string[] | undefined;
     exclude?: string[] | undefined;
@@ -531,6 +541,7 @@ declare const ConformanceRuleConfigSchema: z.ZodObject<{
         }[];
         revisit?: string | undefined;
     }[] | undefined;
+    requireCode?: boolean | undefined;
 }, {
     sourceRoots?: string[] | undefined;
     exclude?: string[] | undefined;
@@ -547,6 +558,7 @@ declare const ConformanceRuleConfigSchema: z.ZodObject<{
         }[];
         revisit?: string | undefined;
     }[] | undefined;
+    requireCode?: boolean | undefined;
 }>;
 type ConformanceRuleConfig = z.infer<typeof ConformanceRuleConfigSchema>;
 /**
@@ -908,6 +920,16 @@ declare const RulesConfigSchema: z.ZodObject<{
             }[];
             revisit?: string | undefined;
         }>, "many">>;
+        /**
+         * Opt-in strictness for teams that want CI to say "every designed component
+         * has code": every implementation must have begun (some file it names
+         * exists). When true, SOURCE_FILE_PLANNED and MISSING_SOURCE_PATH are
+         * reported at error, naming this setting, instead of as notices. Off by
+         * default, so a design-only tree passes `validate --ci`. Code-conformance
+         * tuning like the rest of `rules.conformance`: it enters the analyzer's
+         * digest, never the gate identity, so switching it never stales a lock.
+         */
+        requireCode: z.ZodOptional<z.ZodBoolean>;
     }, "strip", z.ZodTypeAny, {
         sourceRoots?: string[] | undefined;
         exclude?: string[] | undefined;
@@ -924,6 +946,7 @@ declare const RulesConfigSchema: z.ZodObject<{
             }[];
             revisit?: string | undefined;
         }[] | undefined;
+        requireCode?: boolean | undefined;
     }, {
         sourceRoots?: string[] | undefined;
         exclude?: string[] | undefined;
@@ -940,6 +963,7 @@ declare const RulesConfigSchema: z.ZodObject<{
             }[];
             revisit?: string | undefined;
         }[] | undefined;
+        requireCode?: boolean | undefined;
     }>>;
     /** Project-default design depth (see DesignDepthSchema); subsystems may override. */
     designDepth: z.ZodOptional<z.ZodEnum<["components", "interfaces", "implementations", "narratives"]>>;
@@ -1002,6 +1026,7 @@ declare const RulesConfigSchema: z.ZodObject<{
             }[];
             revisit?: string | undefined;
         }[] | undefined;
+        requireCode?: boolean | undefined;
     } | undefined;
     designDepth?: "components" | "interfaces" | "implementations" | "narratives" | undefined;
 }, {
@@ -1063,6 +1088,7 @@ declare const RulesConfigSchema: z.ZodObject<{
             }[];
             revisit?: string | undefined;
         }[] | undefined;
+        requireCode?: boolean | undefined;
     } | undefined;
     designDepth?: "components" | "interfaces" | "implementations" | "narratives" | undefined;
 }>;
@@ -1262,25 +1288,22 @@ type ExternalSource = z.infer<typeof ExternalSourceSchema>;
 declare const ExternalDeclarationSchema: z.ZodObject<{
     /** The producer's project id; defaults to the alias. Plain string: a malformed id is REPORTED, never unreadable. */
     project: z.ZodOptional<z.ZodString>;
-    source: z.ZodOptional<z.ZodObject<{
-        path: z.ZodOptional<z.ZodString>;
-        hosted: z.ZodOptional<z.ZodString>;
-        /** A git repository URL holding the producer (stage 8). */
-        git: z.ZodOptional<z.ZodString>;
-        /** git only: the branch or tag a pin or an update follows; never read by a verdict. */
-        ref: z.ZodOptional<z.ZodString>;
-        /** git members only: the full commit the member is pinned at (an external's commit is its pin's). */
-        commit: z.ZodOptional<z.ZodString>;
-        /** git only: the producer's root inside the repository. */
-        dir: z.ZodOptional<z.ZodString>;
-    }, "strip", z.ZodTypeAny, {
+    /**
+     * Where the producer is found, in either form: the one location string
+     * members use (`../geo-sdk`, `hosted:<id>`, `<git url>`, `<git url>#<commit>`
+     * — a `#<commit>` read as the ref the pin follows) or the object form
+     * ({ path } | { hosted } | { git, ref?, dir? }). Read leniently: any shape
+     * loads, and one that is not a source is the declaration's problem
+     * (readExternalSource), never a configuration that fails to load.
+     */
+    source: z.ZodOptional<z.ZodType<string | {
         path?: string | undefined;
         hosted?: string | undefined;
         git?: string | undefined;
         ref?: string | undefined;
         commit?: string | undefined;
         dir?: string | undefined;
-    }, {
+    }, z.ZodTypeDef, string | {
         path?: string | undefined;
         hosted?: string | undefined;
         git?: string | undefined;
@@ -1304,7 +1327,7 @@ declare const ExternalDeclarationSchema: z.ZodObject<{
     description: z.ZodOptional<z.ZodString>;
 }, "strip", z.ZodTypeAny, {
     project?: string | undefined;
-    source?: {
+    source?: string | {
         path?: string | undefined;
         hosted?: string | undefined;
         git?: string | undefined;
@@ -1316,7 +1339,7 @@ declare const ExternalDeclarationSchema: z.ZodObject<{
     description?: string | undefined;
 }, {
     project?: string | undefined;
-    source?: {
+    source?: string | {
         path?: string | undefined;
         hosted?: string | undefined;
         git?: string | undefined;
@@ -1492,25 +1515,22 @@ declare const ProjectConfigSchema: z.ZodObject<{
     externals: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
         /** The producer's project id; defaults to the alias. Plain string: a malformed id is REPORTED, never unreadable. */
         project: z.ZodOptional<z.ZodString>;
-        source: z.ZodOptional<z.ZodObject<{
-            path: z.ZodOptional<z.ZodString>;
-            hosted: z.ZodOptional<z.ZodString>;
-            /** A git repository URL holding the producer (stage 8). */
-            git: z.ZodOptional<z.ZodString>;
-            /** git only: the branch or tag a pin or an update follows; never read by a verdict. */
-            ref: z.ZodOptional<z.ZodString>;
-            /** git members only: the full commit the member is pinned at (an external's commit is its pin's). */
-            commit: z.ZodOptional<z.ZodString>;
-            /** git only: the producer's root inside the repository. */
-            dir: z.ZodOptional<z.ZodString>;
-        }, "strip", z.ZodTypeAny, {
+        /**
+         * Where the producer is found, in either form: the one location string
+         * members use (`../geo-sdk`, `hosted:<id>`, `<git url>`, `<git url>#<commit>`
+         * — a `#<commit>` read as the ref the pin follows) or the object form
+         * ({ path } | { hosted } | { git, ref?, dir? }). Read leniently: any shape
+         * loads, and one that is not a source is the declaration's problem
+         * (readExternalSource), never a configuration that fails to load.
+         */
+        source: z.ZodOptional<z.ZodType<string | {
             path?: string | undefined;
             hosted?: string | undefined;
             git?: string | undefined;
             ref?: string | undefined;
             commit?: string | undefined;
             dir?: string | undefined;
-        }, {
+        }, z.ZodTypeDef, string | {
             path?: string | undefined;
             hosted?: string | undefined;
             git?: string | undefined;
@@ -1534,7 +1554,7 @@ declare const ProjectConfigSchema: z.ZodObject<{
         description: z.ZodOptional<z.ZodString>;
     }, "strip", z.ZodTypeAny, {
         project?: string | undefined;
-        source?: {
+        source?: string | {
             path?: string | undefined;
             hosted?: string | undefined;
             git?: string | undefined;
@@ -1546,7 +1566,7 @@ declare const ProjectConfigSchema: z.ZodObject<{
         description?: string | undefined;
     }, {
         project?: string | undefined;
-        source?: {
+        source?: string | {
             path?: string | undefined;
             hosted?: string | undefined;
             git?: string | undefined;
@@ -2054,6 +2074,16 @@ declare const ProjectConfigSchema: z.ZodObject<{
                 }[];
                 revisit?: string | undefined;
             }>, "many">>;
+            /**
+             * Opt-in strictness for teams that want CI to say "every designed component
+             * has code": every implementation must have begun (some file it names
+             * exists). When true, SOURCE_FILE_PLANNED and MISSING_SOURCE_PATH are
+             * reported at error, naming this setting, instead of as notices. Off by
+             * default, so a design-only tree passes `validate --ci`. Code-conformance
+             * tuning like the rest of `rules.conformance`: it enters the analyzer's
+             * digest, never the gate identity, so switching it never stales a lock.
+             */
+            requireCode: z.ZodOptional<z.ZodBoolean>;
         }, "strip", z.ZodTypeAny, {
             sourceRoots?: string[] | undefined;
             exclude?: string[] | undefined;
@@ -2070,6 +2100,7 @@ declare const ProjectConfigSchema: z.ZodObject<{
                 }[];
                 revisit?: string | undefined;
             }[] | undefined;
+            requireCode?: boolean | undefined;
         }, {
             sourceRoots?: string[] | undefined;
             exclude?: string[] | undefined;
@@ -2086,6 +2117,7 @@ declare const ProjectConfigSchema: z.ZodObject<{
                 }[];
                 revisit?: string | undefined;
             }[] | undefined;
+            requireCode?: boolean | undefined;
         }>>;
         /** Project-default design depth (see DesignDepthSchema); subsystems may override. */
         designDepth: z.ZodOptional<z.ZodEnum<["components", "interfaces", "implementations", "narratives"]>>;
@@ -2148,6 +2180,7 @@ declare const ProjectConfigSchema: z.ZodObject<{
                 }[];
                 revisit?: string | undefined;
             }[] | undefined;
+            requireCode?: boolean | undefined;
         } | undefined;
         designDepth?: "components" | "interfaces" | "implementations" | "narratives" | undefined;
     }, {
@@ -2209,6 +2242,7 @@ declare const ProjectConfigSchema: z.ZodObject<{
                 }[];
                 revisit?: string | undefined;
             }[] | undefined;
+            requireCode?: boolean | undefined;
         } | undefined;
         designDepth?: "components" | "interfaces" | "implementations" | "narratives" | undefined;
     }>>;
@@ -2506,6 +2540,7 @@ declare const ProjectConfigSchema: z.ZodObject<{
                 }[];
                 revisit?: string | undefined;
             }[] | undefined;
+            requireCode?: boolean | undefined;
         } | undefined;
         designDepth?: "components" | "interfaces" | "implementations" | "narratives" | undefined;
     };
@@ -2530,7 +2565,7 @@ declare const ProjectConfigSchema: z.ZodObject<{
     description?: string | undefined;
     externals?: Record<string, {
         project?: string | undefined;
-        source?: {
+        source?: string | {
             path?: string | undefined;
             hosted?: string | undefined;
             git?: string | undefined;
@@ -2597,7 +2632,7 @@ declare const ProjectConfigSchema: z.ZodObject<{
     description?: string | undefined;
     externals?: Record<string, {
         project?: string | undefined;
-        source?: {
+        source?: string | {
             path?: string | undefined;
             hosted?: string | undefined;
             git?: string | undefined;
@@ -2699,6 +2734,7 @@ declare const ProjectConfigSchema: z.ZodObject<{
                 }[];
                 revisit?: string | undefined;
             }[] | undefined;
+            requireCode?: boolean | undefined;
         } | undefined;
         designDepth?: "components" | "interfaces" | "implementations" | "narratives" | undefined;
     } | undefined;
@@ -2853,6 +2889,23 @@ interface DeclaredExternal {
     /** The declaration's `use` as written, deduplicated in first-seen order; empty when it imports nothing. */
     use: string[];
 }
+/** The forms an external's `source` is accepted in, as a refusal names them. */
+declare const EXTERNAL_SOURCE_FORMS = "a location string (`../sibling`, `hosted:<id>`, `<git url>` or `<git url>#<commit>`) or an object ({ path } | { hosted } | { git, ref?, dir? })";
+/** An external's source as read: its object form, normalized, or why it cannot be read. */
+interface ReadExternalSource {
+    /** The object form; absent when nothing usable was written. */
+    source?: ExternalSource;
+    /** Why the source cannot be used as written — the declaration's problem, never a load failure. */
+    problem?: string;
+}
+/**
+ * external_declaration.source read leniently: the location string or the
+ * object form, normalized into the object form. A source of the wrong shape,
+ * one naming none or several of path/hosted/git, one naming `commit`, or a
+ * string the grammar refuses is answered as the problem — never thrown — so a
+ * configuration holding it still loads and every other external still shows.
+ */
+declare function readExternalSource(written: unknown): ReadExternalSource;
 /** One `use` entry: `*`, or a public name of [a-z0-9-_]+. */
 declare const USE_ENTRY_RE: RegExp;
 /**
@@ -3134,6 +3187,14 @@ declare const AgentBriefSchema: z.ZodObject<{
      * agent implements nothing.
      */
     typeMapping: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    /**
+     * Where an implementing agent may write CODE: each source file its
+     * implementations name, plus the folder they share below the project root as
+     * `<folder>/**`. Empty when nothing names a file yet (the instructions then
+     * ask the spawning session to name the planned files); absent for an agent
+     * that implements nothing.
+     */
+    codeFence: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
     /**
      * Set only on a brief for a member's agent (an id qualified `<alias>::`): the
      * member's directory relative to the root the brief was asked from. The
@@ -3212,6 +3273,7 @@ declare const AgentBriefSchema: z.ZodObject<{
     readPaths?: string[] | undefined;
     variantGuidance?: string | undefined;
     typeMapping?: string[] | undefined;
+    codeFence?: string[] | undefined;
     root?: string | undefined;
     budget?: {
         toolClass: "read-only" | "implement" | "orchestrate" | "full";
@@ -3238,6 +3300,7 @@ declare const AgentBriefSchema: z.ZodObject<{
     readPaths?: string[] | undefined;
     variantGuidance?: string | undefined;
     typeMapping?: string[] | undefined;
+    codeFence?: string[] | undefined;
     root?: string | undefined;
     budget?: {
         toolClass: "read-only" | "implement" | "orchestrate" | "full";
@@ -3669,6 +3732,15 @@ declare function assertProjectInitialized(): void;
 interface StateId {
     algorithm: string;
     digest: string;
+    /**
+     * On a gate identity only: the same gate identity computed under the
+     * algorithm the bound project's lock record was taken with, when that is the
+     * previous (full-content, format-2) algorithm this release can still
+     * recompute. Present only while the record on disk carries it, so such a
+     * lock is judged exactly as it was taken. Never recorded: a lock writes
+     * algorithm and digest alone.
+     */
+    asRecorded?: StateId;
 }
 /**
  * Deterministic CONTENT StateId over the current (request-scoped) project's
@@ -3685,6 +3757,18 @@ declare function computeStateId(): StateId;
  * marker as computeStateId, so for a project with no members the two agree.
  */
 declare function computeOwnStateId(): StateId;
+/**
+ * state_hash.ownDesign — the DESIGN identity of the bound project's own specs:
+ * exactly ownTree's selection, storage-independence and ordering, but each
+ * spec digested in its design view — an implementation, a type and a
+ * component through their type's designView (code linkage and timestamps
+ * out), every other kind with its timestamps out (canonicalize drops them).
+ * A part's implementation needs no re-expression from the part's root: the
+ * paths are linkage, and the view leaves them out. Algorithm marker
+ * `sha256-design`, so it never compares equal to a content identity. The
+ * content half of the gate identity from lock format 3 on.
+ */
+declare function computeOwnDesignStateId(): StateId;
 
 /** primitive | named | list | set | map | optional | union | async | applied | result. */
 type TypeForm = 'primitive' | 'named' | 'list' | 'set' | 'map' | 'optional' | 'union' | 'async' | 'applied' | 'result';
@@ -4148,6 +4232,16 @@ interface CodeIndex {
      * written down in the code.
      */
     forwardsOf(path: string, name: string, container?: string): ForwardedName[];
+    /**
+     * Whether realization has BEGUN for whatever names these files: true when at
+     * least one of them resolves to a file the run analyzed or could read (any
+     * status but missing or escaped). The one definition every code rule shares
+     * — an implementation has begun when any file it names (its sourcePath or a
+     * method's) exists, a type when its own file or a method's exists; a simPath
+     * harness does not count, it follows the code it wires. Before that a named
+     * file is planned, not missing. Pure: over the index's own facts.
+     */
+    holdsAny(files: string[]): boolean;
 }
 /** One (file, name) a republished name resolves to (forwarded_name). */
 interface ForwardedName {
@@ -4462,6 +4556,13 @@ interface RuleContext {
      * importing it, and the `use` line that would. Null when none does.
      */
     importHint(name: string): string | null;
+    /**
+     * rule_context.aliasSpelling — for a dotted type reference `<first>.<name>`
+     * whose first segment is an alias the bound project declares (not one of its
+     * subsystems) and whose supplier exports the name: the `alias::publicName`
+     * it must be written as. Null otherwise.
+     */
+    aliasSpelling(ref: string): string | null;
     /** Every contract method across the component's interfaces (memoized — eight rules ask per binding or per step). */
     interfaceMethodsOf(compId: string): MethodSignature[];
     /** The run's source-code model keyed for lookup (memoized). */
@@ -4978,6 +5079,7 @@ declare const ProfileDefSchema: z.ZodObject<{
                 }[];
                 revisit?: string | undefined;
             }>, "many">>;
+            requireCode: z.ZodOptional<z.ZodBoolean>;
         }, "strip", z.ZodTypeAny, {
             sourceRoots?: string[] | undefined;
             exclude?: string[] | undefined;
@@ -4994,6 +5096,7 @@ declare const ProfileDefSchema: z.ZodObject<{
                 }[];
                 revisit?: string | undefined;
             }[] | undefined;
+            requireCode?: boolean | undefined;
         }, {
             sourceRoots?: string[] | undefined;
             exclude?: string[] | undefined;
@@ -5010,6 +5113,7 @@ declare const ProfileDefSchema: z.ZodObject<{
                 }[];
                 revisit?: string | undefined;
             }[] | undefined;
+            requireCode?: boolean | undefined;
         }>>>;
         designDepth: z.ZodOptional<z.ZodOptional<z.ZodEnum<["components", "interfaces", "implementations", "narratives"]>>>;
     }, "strip", z.ZodTypeAny, {
@@ -5071,6 +5175,7 @@ declare const ProfileDefSchema: z.ZodObject<{
                 }[];
                 revisit?: string | undefined;
             }[] | undefined;
+            requireCode?: boolean | undefined;
         } | undefined;
         designDepth?: "components" | "interfaces" | "implementations" | "narratives" | undefined;
     }, {
@@ -5132,6 +5237,7 @@ declare const ProfileDefSchema: z.ZodObject<{
                 }[];
                 revisit?: string | undefined;
             }[] | undefined;
+            requireCode?: boolean | undefined;
         } | undefined;
         designDepth?: "components" | "interfaces" | "implementations" | "narratives" | undefined;
     }>>;
@@ -5209,6 +5315,7 @@ declare const ProfileDefSchema: z.ZodObject<{
                 }[];
                 revisit?: string | undefined;
             }[] | undefined;
+            requireCode?: boolean | undefined;
         } | undefined;
         designDepth?: "components" | "interfaces" | "implementations" | "narratives" | undefined;
     } | undefined;
@@ -5272,6 +5379,7 @@ declare const ProfileDefSchema: z.ZodObject<{
                 }[];
                 revisit?: string | undefined;
             }[] | undefined;
+            requireCode?: boolean | undefined;
         } | undefined;
         designDepth?: "components" | "interfaces" | "implementations" | "narratives" | undefined;
     } | undefined;
@@ -5788,6 +5896,7 @@ declare const DeclarativePackSchema: z.ZodObject<{
                     }[];
                     revisit?: string | undefined;
                 }>, "many">>;
+                requireCode: z.ZodOptional<z.ZodBoolean>;
             }, "strip", z.ZodTypeAny, {
                 sourceRoots?: string[] | undefined;
                 exclude?: string[] | undefined;
@@ -5804,6 +5913,7 @@ declare const DeclarativePackSchema: z.ZodObject<{
                     }[];
                     revisit?: string | undefined;
                 }[] | undefined;
+                requireCode?: boolean | undefined;
             }, {
                 sourceRoots?: string[] | undefined;
                 exclude?: string[] | undefined;
@@ -5820,6 +5930,7 @@ declare const DeclarativePackSchema: z.ZodObject<{
                     }[];
                     revisit?: string | undefined;
                 }[] | undefined;
+                requireCode?: boolean | undefined;
             }>>>;
             designDepth: z.ZodOptional<z.ZodOptional<z.ZodEnum<["components", "interfaces", "implementations", "narratives"]>>>;
         }, "strip", z.ZodTypeAny, {
@@ -5881,6 +5992,7 @@ declare const DeclarativePackSchema: z.ZodObject<{
                     }[];
                     revisit?: string | undefined;
                 }[] | undefined;
+                requireCode?: boolean | undefined;
             } | undefined;
             designDepth?: "components" | "interfaces" | "implementations" | "narratives" | undefined;
         }, {
@@ -5942,6 +6054,7 @@ declare const DeclarativePackSchema: z.ZodObject<{
                     }[];
                     revisit?: string | undefined;
                 }[] | undefined;
+                requireCode?: boolean | undefined;
             } | undefined;
             designDepth?: "components" | "interfaces" | "implementations" | "narratives" | undefined;
         }>>;
@@ -6019,6 +6132,7 @@ declare const DeclarativePackSchema: z.ZodObject<{
                     }[];
                     revisit?: string | undefined;
                 }[] | undefined;
+                requireCode?: boolean | undefined;
             } | undefined;
             designDepth?: "components" | "interfaces" | "implementations" | "narratives" | undefined;
         } | undefined;
@@ -6082,6 +6196,7 @@ declare const DeclarativePackSchema: z.ZodObject<{
                     }[];
                     revisit?: string | undefined;
                 }[] | undefined;
+                requireCode?: boolean | undefined;
             } | undefined;
             designDepth?: "components" | "interfaces" | "implementations" | "narratives" | undefined;
         } | undefined;
@@ -6437,6 +6552,7 @@ declare const DeclarativePackSchema: z.ZodObject<{
                     }[];
                     revisit?: string | undefined;
                 }[] | undefined;
+                requireCode?: boolean | undefined;
             } | undefined;
             designDepth?: "components" | "interfaces" | "implementations" | "narratives" | undefined;
         } | undefined;
@@ -6566,6 +6682,7 @@ declare const DeclarativePackSchema: z.ZodObject<{
                     }[];
                     revisit?: string | undefined;
                 }[] | undefined;
+                requireCode?: boolean | undefined;
             } | undefined;
             designDepth?: "components" | "interfaces" | "implementations" | "narratives" | undefined;
         } | undefined;
@@ -7060,6 +7177,14 @@ interface ValidationIssue {
      * root. Absent on the owner's own run.
      */
     project?: string;
+    /**
+     * True on a finding reported beside a gate rather than by it — the live
+     * comparison of an external with its producer (family_validator.advise).
+     * Printed and counted with its severity, but never part of a failure
+     * decision: `valid` and `validate --ci` both ignore it, because the pin is
+     * the reproducible gate and a live producer is not.
+     */
+    advisory?: boolean;
 }
 interface ValidationResult {
     valid: boolean;
@@ -7083,6 +7208,12 @@ interface ValidationResult {
      * and on a family run.
      */
     analysis?: CodeAnalysis;
+    /**
+     * A family run only: the aliases of the bound project's externals the run
+     * composed as part of its gate (their producers in reach) — the advisory
+     * live comparison skips them, so they get no second word.
+     */
+    composed?: string[];
 }
 /**
  * project_verdict — one project's line in a family run: which project it is,
@@ -7213,7 +7344,7 @@ declare function builtinProjectKinds(): string[];
 /**
  * The gate identity a lock records and every staleness check compares
  * (ispec_validator/ivalidator_portal.computeGateStateId): the project's OWN
- * content identity, the design doctrine, its own consumed contract inputs, its
+ * DESIGN identity (code linkage and timestamps out), the design doctrine, its own consumed contract inputs, its
  * `composition`, and each direct member's composition subject — read from the
  * member's own lock record, never recomputed and never its specs. So a
  * parent's identity costs its own tree plus one lock file per direct member,
@@ -7289,6 +7420,31 @@ interface CodeAnalysis {
     warnings: number;
     notices: number;
 }
+/**
+ * spec_digest_reading — which reading of a spec file a lock record's per-spec
+ * digests were taken in. `content`: the raw text, line endings normalized —
+ * what every record written before format 3 carries (the field absent).
+ * `design`: the spec's design view (code linkage and timestamps out) in
+ * canonical form, so a sourcePath, a whitespace edit or a no-op re-save never
+ * moves it.
+ */
+type SpecDigestReading = 'content' | 'design';
+/**
+ * lock_reexpression — provenance on a lock record a tool carried into a newer
+ * reading after PROVING the design is the one approved (its own earlier
+ * identity, recomputed over the tree as it stands, matched), rather than a
+ * human re-approving it. Who approved and when stay the human's.
+ */
+interface LockReexpression {
+    /** ISO-8601 time of the re-expression. */
+    at: string;
+    /** The gate algorithm the record carried before. */
+    fromAlgorithm: string;
+    /** The per-spec digest reading the record carried before. */
+    fromReading: SpecDigestReading;
+    /** The command that re-expressed it (e.g. `wairon doctor --fix`), never a person. */
+    by: string;
+}
 /** A project's approval state as seen from its own root. */
 type ProjectApprovalState = 'approved' | 'drifted' | 'never';
 /** How a parent's lock pinned a member. */
@@ -7386,8 +7542,26 @@ interface LockRecord {
      * one release as the member pins; never written from stage 5 on.
      */
     children?: Record<string, string>;
-    /** The record format: 2 from stage 5 on; absent means format 1. */
+    /**
+     * The record format: 3 from the release in which code linkage left the
+     * approval (stateId under the design gate algorithm, `specs` in the design
+     * reading), 2 from stage 5 on, absent means format 1. A format-2 record stays
+     * valid as written: it is judged under its own algorithm (StateId.asRecorded)
+     * and its own reading until it is re-locked or re-expressed.
+     */
     format?: number;
+    /**
+     * The reading `specs` was digested in: `design` on every record written from
+     * format 3 on, absent on an earlier record (raw-content digests). A reader
+     * compares the tree in the reading the record names, never in another.
+     */
+    specsReading?: SpecDigestReading;
+    /**
+     * Present when a tool carried this record into the current reading and gate
+     * algorithm after proving the design unchanged (doctor --fix), instead of a
+     * human re-approving it.
+     */
+    reexpressed?: LockReexpression;
     /**
      * Each DIRECT member, keyed by alias → its composition subject and approval
      * state as they stood when this project locked. Present (possibly empty) on
@@ -7414,11 +7588,6 @@ interface LockRecord {
 }
 /** Read the current project's lock record, or null when absent/unreadable. */
 declare function readLockRecord(): LockRecord | null;
-/**
- * Persist the lock record atomically to .wai/lock.json (overwrites any prior).
- * A legacy `children` map is never written: `members` is recorded instead.
- */
-declare function writeLockRecord(record: LockRecord): void;
 
 declare class WaironError extends Error {
     constructor(message: string);
@@ -7483,6 +7652,241 @@ interface CarriedRekey {
     to: string;
 }
 
+interface CanvasModel {
+    system: {
+        name: string;
+        vision?: string;
+        targetLanguage?: string;
+        databases?: {
+            id: string;
+            name: string;
+            engine: string;
+            description?: string;
+            tables?: string[];
+        }[];
+        diagram?: {
+            lineStyle?: 'bezier' | 'straight' | 'taxi';
+            defaultView?: 'architecture' | 'types' | 'databases';
+            showDatabases?: boolean;
+        };
+    };
+    generatedAt: string;
+    subsystems: {
+        id: string;
+        name: string;
+        description: string;
+        targetLanguage?: string;
+        status?: string;
+        trustedLinks: {
+            subsystem: string;
+            reason: string;
+        }[];
+        /** A member project's node (stage 3): its id is the member's key, its name the
+         *  alias its parent declares it under; the member's specs hang under it. */
+        project?: boolean;
+        /** Hosted (stage 7): a member project node's record id, present only when the
+         *  caller may read that record — the web app links the node to its page. */
+        recordId?: string;
+        /** Stage 8: the storage badge of a subsystem a PART holds (it is this
+         *  project's own subsystem, stored elsewhere) — `part <alias> · contained`,
+         *  `… · ../admin`, `… · git a1b2c3d` — or of a referenced project node. */
+        storage?: string;
+        /** A declared external that is no project of the family, drawn as a
+         *  project node of its own (dashed) that its consumption edges land on. */
+        external?: boolean;
+        /** Opt-in deep expansion: with Internals on, this subsystem's box renders
+         *  its WHOLE subtree (nested boundary boxes + leaf tiles + direct relation
+         *  lines) instead of one layer. Never set by buildCanvasModel — the hosted
+         *  environment adapter stamps it on unit-derived frames. Absent ⇒ the
+         *  engine behaves exactly as before. */
+        deepInternals?: boolean;
+    }[];
+    components: {
+        id: string;
+        name: string;
+        description: string;
+        subsystem: string;
+        componentType: string;
+        portalType?: string;
+        status?: string;
+        public: boolean;
+        /** The L0 gateway entry id this component backs (the OpenAPI operation tag),
+         *  present only for a component published in the system's public surface. */
+        apiTag?: string;
+        owner?: string;
+        owns: string[];
+        dependsOn: string[];
+        interfaces: {
+            id: string;
+            name: string;
+            description: string;
+            methods: {
+                name: string;
+                description: string;
+                signature: string;
+                returns: string;
+                params?: {
+                    name: string;
+                    type: string;
+                    optional?: boolean;
+                }[];
+                /** Where the method takes its params and returns from, shown beside its signature ("from X"). */
+                signatureFrom?: string;
+                endpoint?: unknown;
+                guarantees?: string[];
+            }[];
+        }[];
+        narratives: {
+            method: string;
+            steps: {
+                n: number;
+                text: string;
+                kind: string;
+                call?: {
+                    component: string;
+                    method: string;
+                };
+                cond?: string;
+                onTrue?: number;
+                onFalse?: number;
+                on?: string;
+                cases?: {
+                    value: string;
+                    step: number;
+                }[];
+                defaultStep?: number;
+                loopKind?: string;
+                over?: string;
+                end?: number;
+                catches?: {
+                    error: string;
+                    step: number;
+                }[];
+                fin?: number;
+                to?: number;
+                /** parallel: arm entry steps (contiguous ordered sub-regions of the body). */
+                branches?: {
+                    step: number;
+                    name?: string;
+                }[];
+                /** call/dispatch: fire-and-forget — failure does not propagate to this flow. */
+                detach?: boolean;
+                outcome?: string;
+                err?: string;
+            }[];
+        }[];
+        /** Opaque external references surfaced on the canvas element (see ExternalLinkSchema).
+         *  wairon never fetches them; an `implementation` link is the external source-of-record. */
+        externalLinks?: {
+            url: string;
+            type: string;
+            label?: string;
+        }[];
+        /** Methods specified as intent prose instead of a narrative (the detail dial). */
+        intents: {
+            method: string;
+            text: string;
+        }[];
+    }[];
+    /** `consumption`: the edge's ends lie in different projects (or it lands on a
+     *  referenced or external project node); `relation`: the CanvasRelation it
+     *  takes its health from, present only when the model carries relations. */
+    edges: {
+        from: string;
+        to: string;
+        cross: boolean;
+        consumption?: boolean;
+        relation?: string;
+    }[];
+    /** Relation health, one per consumer→producer pair the edges connect. PRESENT
+     *  only when health was computed (empty when nothing is consumed); ABSENT when
+     *  it was not — then consumption edges are drawn neutral, "not checked". */
+    relations?: CanvasRelation[];
+    types: {
+        id: string;
+        name: string;
+        kind: string;
+        subsystem?: string;
+        fields: {
+            name: string;
+            type: string;
+            optional?: boolean;
+            key?: string;
+            references?: string;
+        }[];
+        methods: {
+            name: string;
+            signature: string;
+            returns: string;
+            description?: string;
+        }[];
+        /** A signature type's derived text, `(a: T, b?: U): R` — drawn in place of a field list. */
+        signature?: string;
+        /** An enum's values in declared order — drawn in place of a field list. */
+        values?: {
+            name: string;
+            description?: string;
+        }[];
+        /** A named scalar's primitive — drawn compactly beside its name, with no field rows and no edges. */
+        holds?: string;
+        /** Interface methods whose params/returns reference this type (usage trace). */
+        usedBy: {
+            component: string;
+            method: string;
+        }[];
+        componentClass?: string;
+        database?: string;
+        table?: string;
+        linkedEntity?: string;
+    }[];
+    /** Type → type references derived from field type strings (ERD edges). */
+    typeEdges: {
+        from: string;
+        to: string;
+        field: string;
+        card: '1' | '0..1' | '*';
+    }[];
+    /** Data-coupling edges: a component depends on another subsystem's data
+     *  (uses a type it owns), pointed at that subsystem's published portal. */
+    dataEdges: {
+        from: string;
+        to: string;
+    }[];
+    issues: {
+        severity: string;
+        code: string;
+        message: string;
+        specId?: string;
+    }[];
+}
+/**
+ * canvas_relation — one consumer-project-to-producer-project relation as the
+ * canvas draws it: the health every consumption edge between the two takes,
+ * and the detail a reader sees on hover or in the details panel.
+ */
+interface CanvasRelation {
+    /** `<consumer>→<producer>`: the key a consumption edge names in its `relation`. */
+    id: string;
+    /** The consuming project's key ('' for the bound root). */
+    consumer: string;
+    /** The alias the consumer reaches the producer under. */
+    producer: string;
+    health: RelationHealth;
+    /** The uses that are NOT unchanged, with their state and why. */
+    uses: {
+        name: string;
+        state: string;
+        detail?: string;
+    }[];
+    /** How many uses compared unchanged. */
+    unchanged: number;
+    pinnedCommit?: string;
+    pinnedDigest?: string;
+    comparedAt: string;
+    /** Why the relation is unavailable, when it is. */
+    detail?: string;
+}
+
 /** What a landscape edge says about its two ends. */
 type LandscapeEdgeKind = 'contains' | 'owns' | 'shared_with' | 'publishes' | 'consumes' | 'depends_on' | 'mirrors';
 /** A directed edge of the hosted landscape graph. */
@@ -7534,6 +7938,49 @@ interface WebGraphModel {
     scope?: string;
 }
 
+/** The formats the architecture diagram renders to. */
+type DiagramFormat = 'canvas' | 'mermaid' | 'drawio' | 'excalidraw';
+/**
+ * The full CanvasModel for the current (request-scoped) project — the same model
+ * `renderDiagram('canvas')` renders to the standalone HTML, but returned as data
+ * so the React web app can mount the shared renderer directly (no iframe) and,
+ * later, receive it in on-demand scope slices. Pure derivation, no side effects;
+ * relation health is drawn only when passed in.
+ */
+declare function buildCanvasDataModel(relations?: ProjectRelations[]): CanvasModel;
+interface DiagramFile {
+    /** Path relative to the diagrams output directory, using forward slashes. */
+    relPath: string;
+    title: string;
+    /** Raw mermaid source (no markdown fence). */
+    mermaid: string;
+}
+interface SpecGraph {
+    systemName: string;
+    subsystems: SubsystemSpec[];
+    components: ComponentSpec[];
+    interfaces: InterfaceSpec[];
+    implementations: ImplementationSpec[];
+    /** Component ids published via some subsystem's publicInterfaces. */
+    publicComponents: Set<string>;
+}
+declare function loadSpecGraph(): SpecGraph;
+interface ComponentDiagramOptions {
+    /** Scope to one subsystem (its components plus directly-connected externals). */
+    subsystem?: string;
+}
+declare function generateComponentDiagram(options?: ComponentDiagramOptions): string;
+interface SequenceDiagramOptions {
+    /** Max call-expansion depth (default 3). Depth 1 = only the method's own steps. */
+    depth?: number;
+}
+declare function generateSequenceDiagram(componentId: string, methodName: string, options?: SequenceDiagramOptions): string;
+declare function generateDiagramSet(): DiagramFile[];
+/** Wrap raw mermaid in a titled markdown document (renders on GitHub / IDEs). */
+declare function toMarkdown(file: DiagramFile): string;
+/** Index README linking every generated diagram. */
+declare function diagramSetIndex(files: DiagramFile[], systemName: string): string;
+
 /** spec_index — the bound tree as one scan read it: every spec by kind, and the file each is stored in. */
 interface SpecIndex {
     subsystems: SubsystemSpec[];
@@ -7930,7 +8377,8 @@ interface LockStatus {
 /**
  * Resolve the project's lock into one of three honest states, comparing the
  * recorded gate identity against the one the caller computed now
- * (validator_portal.computeGateStateId). Nothing is hashed here: the gate
+ * (validator_portal.computeGateStateId) — or, for a format-2 record, against
+ * its asRecorded reading. Nothing is hashed here: the gate
  * identity is the validator's, because the doctrine it covers is the
  * validator's rule set.
  *
@@ -7942,6 +8390,18 @@ interface LockStatus {
  * every caller now shares this.
  */
 declare function readLockState(current: StateId): LockStatus;
+/**
+ * core_orchestrator.writeLockRecord — the lock record written through the lock
+ * store. The approval portal publishes THIS function, so a Portal never reaches
+ * the store's write itself: writes route through the Orchestrator.
+ */
+declare function writeLockRecord(record: LockRecord): void;
+/**
+ * core_orchestrator.renderDiagram — the spec tree rendered in the requested
+ * format by the architecture diagrams, with the relation health passed through
+ * (only the canvas draws it). The spec tree portal publishes this function.
+ */
+declare function renderDiagram(format: DiagramFormat, relations?: ProjectRelations[]): string;
 /** Write a fresh configuration for a project that has none; refuses when one exists. */
 declare function createProjectConfig(config: ProjectConfig): void;
 /** Select a pack by name, moving a re-selected pack last; returns whether an earlier selection was replaced. */
@@ -14847,6 +15307,57 @@ declare function storedTypeMethod<M extends StoredTypeMethod>(method: M): Stored
 declare function typeSourceFiles(type: Pick<TypeSpec, 'sourcePath'> & {
     methods?: ReadonlyArray<Pick<TypeMethod, 'sourcePath'>>;
 }): string[];
+/** Each schema's fields, split into the design (approved) and the code linkage (not approved). */
+declare const DESIGN_VIEW_FIELDS: {
+    readonly implementation: {
+        readonly linkage: readonly ["sourcePath", "simPath", "injectedParams", "conformance", "createdAt", "updatedAt"];
+        readonly design: readonly ["id", "name", "description", "contract", "technologies", "methods", "detail", "previousIds", "lint", "ext", "status"];
+    };
+    readonly implementationMethod: {
+        readonly linkage: readonly ["sourcePath", "symbol", "exportedVia", "conformance"];
+        readonly design: readonly ["name", "narrative", "detail", "intent", "calls", "ext"];
+    };
+    readonly type: {
+        readonly linkage: readonly ["sourcePath", "symbol", "createdAt", "updatedAt"];
+        readonly design: readonly ["kind", "id", "name", "description", "subsystem", "group", "fields", "methods", "componentClass", "invariants", "database", "table", "linkedEntity", "previousIds", "lint", "ext", "params", "returns", "values", "holds"];
+    };
+    readonly typeMethod: {
+        readonly linkage: readonly ["sourcePath", "symbol"];
+        readonly design: readonly ["name", "signature", "params", "returns", "description"];
+    };
+    readonly component: {
+        readonly linkage: readonly ["externalLinks", "createdAt", "updatedAt"];
+        readonly design: readonly ["id", "name", "description", "subsystem", "componentType", "owns", "dependsOn", "portalType", "basePath", "auth", "dispatch", "mounts", "durability", "dependencyClass", "emits", "subscribesTo", "patterns", "variant", "previousIds", "lint", "ext", "status"];
+    };
+    readonly portalMount: {
+        readonly linkage: readonly ["via"];
+        readonly design: readonly ["portal", "prefixes"];
+    };
+};
+/**
+ * implementation_spec.designView — this implementation as the approval sees it:
+ * its own sourcePath, simPath, injectedParams and conformance tier, each
+ * method's sourcePath, symbol, exportedVia and conformance tier, and the
+ * timestamps left out. Everything else — the contract, technologies, the
+ * detail dial, each method's narrative, intent and calls, the rename trace,
+ * lint, ext, status — stays. Pure: a sourcePath added, moved or removed never
+ * changes it. Reads a stored (raw) spec as readily as a loaded one.
+ */
+declare function implementationDesignView<T extends object>(impl: T): T;
+/**
+ * type_spec.designView — this type as the approval sees it: its own sourcePath
+ * and symbol, each method's sourcePath and symbol, and the timestamps left
+ * out; its fields, methods' signatures and descriptions, invariants, values,
+ * holds, rename trace, lint and ext stay. Pure.
+ */
+declare function typeDesignView<T extends object>(type: T): T;
+/**
+ * component_spec.designView — this component as the approval sees it: each
+ * mount's `via` (the router entry the portal's file exports, held to code by
+ * UNREALIZED_EXPORT_HANDLE), its externalLinks and the timestamps left out. A
+ * mount's portal and prefixes, and every other field, stay. Pure.
+ */
+declare function componentDesignView<T extends object>(component: T): T;
 declare const SurfaceOriginSchema: z.ZodEnum<["generated", "exchanged", "authored"]>;
 type SurfaceOrigin = z.infer<typeof SurfaceOriginSchema>;
 /** A self-contained type definition embedded in a snapshot (closure member). */
@@ -14902,6 +15413,12 @@ declare const SurfaceTypeDefSchema: z.ZodObject<{
     }>, "many">>;
     /** A named scalar's one primitive, in place of fields; only on a value-object that declares it. */
     holds: z.ZodOptional<z.ZodString>;
+    /**
+     * The type's rename trace as the producer recorded it (previousIds), so a
+     * consumer pinned to a former name reads a rename rather than a removal.
+     * Provenance, never signature: it enters no digest. Absent when never renamed.
+     */
+    formerly: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
 }, "strip", z.ZodTypeAny, {
     id: string;
     name: string;
@@ -14924,6 +15441,7 @@ declare const SurfaceTypeDefSchema: z.ZodObject<{
     }[] | undefined;
     returns?: string | undefined;
     holds?: string | undefined;
+    formerly?: string[] | undefined;
 }, {
     id: string;
     name: string;
@@ -14946,6 +15464,7 @@ declare const SurfaceTypeDefSchema: z.ZodObject<{
     kind?: string | undefined;
     returns?: string | undefined;
     holds?: string | undefined;
+    formerly?: string[] | undefined;
 }>;
 type SurfaceTypeDef = z.infer<typeof SurfaceTypeDefSchema>;
 /** A type the producer exports by name (a typeDef export); its definition is in the type closure. */
@@ -14976,7 +15495,11 @@ declare const SurfaceContractEntrySchema: z.ZodObject<{
     type: z.ZodDefault<z.ZodString>;
     /** Local name of the backing Portal in the producing project. */
     component: z.ZodString;
-    /** Full contract methods (params, returns, guarantees, effect, endpoint), resolved: a snapshot names no producer-internal source. */
+    /**
+     * Full contract methods (params, returns, guarantees, effect, endpoint),
+     * resolved: a snapshot names no producer-internal source. A renamed method
+     * carries its former names as `formerly` (provenance, outside every digest).
+     */
     methods: z.ZodDefault<z.ZodArray<z.ZodObject<{
         name: z.ZodString;
         description: z.ZodString;
@@ -15135,6 +15658,8 @@ declare const SurfaceContractEntrySchema: z.ZodObject<{
     } & {
         signature: z.ZodString;
         returns: z.ZodString;
+    } & {
+        formerly: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
     }, "strip", z.ZodTypeAny, {
         name: string;
         description: string;
@@ -15191,6 +15716,7 @@ declare const SurfaceContractEntrySchema: z.ZodObject<{
             caller?: string | undefined;
         } | undefined;
         previousNames?: string[] | undefined;
+        formerly?: string[] | undefined;
     }, {
         name: string;
         description: string;
@@ -15247,6 +15773,7 @@ declare const SurfaceContractEntrySchema: z.ZodObject<{
             caller?: string | undefined;
         } | undefined;
         previousNames?: string[] | undefined;
+        formerly?: string[] | undefined;
     }>, "many">>;
     /** The backing portal's capability dispatch table, when generic-dispatch. */
     dispatch: z.ZodOptional<z.ZodArray<z.ZodObject<{
@@ -15335,6 +15862,15 @@ declare const SurfaceContractEntrySchema: z.ZodObject<{
     componentType: z.ZodOptional<z.ZodString>;
     /** The L3 interface the export narrows to, when it narrows. */
     interface: z.ZodOptional<z.ZodString>;
+    /**
+     * The rename trace behind the entry's public name: the former public names
+     * the producer's rename trace (the narrowed interface's, else the backing
+     * component's previousIds) records. Carried into the pin snapshot and the
+     * surface export so a consumer can follow a rename instead of reading a
+     * delete plus an add. Provenance, never signature: it enters neither
+     * memberDigest nor contentDigest. Absent when never renamed.
+     */
+    formerly: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
 }, "strip", z.ZodTypeAny, {
     id: string;
     type: string;
@@ -15395,6 +15931,7 @@ declare const SurfaceContractEntrySchema: z.ZodObject<{
             caller?: string | undefined;
         } | undefined;
         previousNames?: string[] | undefined;
+        formerly?: string[] | undefined;
     }[];
     component: string;
     details: string;
@@ -15427,6 +15964,7 @@ declare const SurfaceContractEntrySchema: z.ZodObject<{
         capability: string;
         description?: string | undefined;
     }[] | undefined;
+    formerly?: string[] | undefined;
 }, {
     id: string;
     name: string;
@@ -15489,6 +16027,7 @@ declare const SurfaceContractEntrySchema: z.ZodObject<{
             caller?: string | undefined;
         } | undefined;
         previousNames?: string[] | undefined;
+        formerly?: string[] | undefined;
     }[] | undefined;
     interface?: string | undefined;
     componentType?: string | undefined;
@@ -15519,6 +16058,7 @@ declare const SurfaceContractEntrySchema: z.ZodObject<{
         capability: string;
         description?: string | undefined;
     }[] | undefined;
+    formerly?: string[] | undefined;
 }>;
 type SurfaceContractEntry = z.infer<typeof SurfaceContractEntrySchema>;
 declare const SurfaceSnapshotSchema: z.ZodObject<{
@@ -15539,7 +16079,11 @@ declare const SurfaceSnapshotSchema: z.ZodObject<{
         type: z.ZodDefault<z.ZodString>;
         /** Local name of the backing Portal in the producing project. */
         component: z.ZodString;
-        /** Full contract methods (params, returns, guarantees, effect, endpoint), resolved: a snapshot names no producer-internal source. */
+        /**
+         * Full contract methods (params, returns, guarantees, effect, endpoint),
+         * resolved: a snapshot names no producer-internal source. A renamed method
+         * carries its former names as `formerly` (provenance, outside every digest).
+         */
         methods: z.ZodDefault<z.ZodArray<z.ZodObject<{
             name: z.ZodString;
             description: z.ZodString;
@@ -15698,6 +16242,8 @@ declare const SurfaceSnapshotSchema: z.ZodObject<{
         } & {
             signature: z.ZodString;
             returns: z.ZodString;
+        } & {
+            formerly: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
         }, "strip", z.ZodTypeAny, {
             name: string;
             description: string;
@@ -15754,6 +16300,7 @@ declare const SurfaceSnapshotSchema: z.ZodObject<{
                 caller?: string | undefined;
             } | undefined;
             previousNames?: string[] | undefined;
+            formerly?: string[] | undefined;
         }, {
             name: string;
             description: string;
@@ -15810,6 +16357,7 @@ declare const SurfaceSnapshotSchema: z.ZodObject<{
                 caller?: string | undefined;
             } | undefined;
             previousNames?: string[] | undefined;
+            formerly?: string[] | undefined;
         }>, "many">>;
         /** The backing portal's capability dispatch table, when generic-dispatch. */
         dispatch: z.ZodOptional<z.ZodArray<z.ZodObject<{
@@ -15898,6 +16446,15 @@ declare const SurfaceSnapshotSchema: z.ZodObject<{
         componentType: z.ZodOptional<z.ZodString>;
         /** The L3 interface the export narrows to, when it narrows. */
         interface: z.ZodOptional<z.ZodString>;
+        /**
+         * The rename trace behind the entry's public name: the former public names
+         * the producer's rename trace (the narrowed interface's, else the backing
+         * component's previousIds) records. Carried into the pin snapshot and the
+         * surface export so a consumer can follow a rename instead of reading a
+         * delete plus an add. Provenance, never signature: it enters neither
+         * memberDigest nor contentDigest. Absent when never renamed.
+         */
+        formerly: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
     }, "strip", z.ZodTypeAny, {
         id: string;
         type: string;
@@ -15958,6 +16515,7 @@ declare const SurfaceSnapshotSchema: z.ZodObject<{
                 caller?: string | undefined;
             } | undefined;
             previousNames?: string[] | undefined;
+            formerly?: string[] | undefined;
         }[];
         component: string;
         details: string;
@@ -15990,6 +16548,7 @@ declare const SurfaceSnapshotSchema: z.ZodObject<{
             capability: string;
             description?: string | undefined;
         }[] | undefined;
+        formerly?: string[] | undefined;
     }, {
         id: string;
         name: string;
@@ -16052,6 +16611,7 @@ declare const SurfaceSnapshotSchema: z.ZodObject<{
                 caller?: string | undefined;
             } | undefined;
             previousNames?: string[] | undefined;
+            formerly?: string[] | undefined;
         }[] | undefined;
         interface?: string | undefined;
         componentType?: string | undefined;
@@ -16082,6 +16642,7 @@ declare const SurfaceSnapshotSchema: z.ZodObject<{
             capability: string;
             description?: string | undefined;
         }[] | undefined;
+        formerly?: string[] | undefined;
     }>, "many">>;
     /** Transitive type closure of every exported signature and exported type — self-contained. */
     types: z.ZodDefault<z.ZodArray<z.ZodObject<{
@@ -16136,6 +16697,12 @@ declare const SurfaceSnapshotSchema: z.ZodObject<{
         }>, "many">>;
         /** A named scalar's one primitive, in place of fields; only on a value-object that declares it. */
         holds: z.ZodOptional<z.ZodString>;
+        /**
+         * The type's rename trace as the producer recorded it (previousIds), so a
+         * consumer pinned to a former name reads a rename rather than a removal.
+         * Provenance, never signature: it enters no digest. Absent when never renamed.
+         */
+        formerly: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
     }, "strip", z.ZodTypeAny, {
         id: string;
         name: string;
@@ -16158,6 +16725,7 @@ declare const SurfaceSnapshotSchema: z.ZodObject<{
         }[] | undefined;
         returns?: string | undefined;
         holds?: string | undefined;
+        formerly?: string[] | undefined;
     }, {
         id: string;
         name: string;
@@ -16180,6 +16748,7 @@ declare const SurfaceSnapshotSchema: z.ZodObject<{
         kind?: string | undefined;
         returns?: string | undefined;
         holds?: string | undefined;
+        formerly?: string[] | undefined;
     }>, "many">>;
     /** The producing project's effective id, beside the display-oriented projectName. */
     projectId: z.ZodOptional<z.ZodString>;
@@ -16267,6 +16836,7 @@ declare const SurfaceSnapshotSchema: z.ZodObject<{
                 caller?: string | undefined;
             } | undefined;
             previousNames?: string[] | undefined;
+            formerly?: string[] | undefined;
         }[];
         component: string;
         details: string;
@@ -16299,6 +16869,7 @@ declare const SurfaceSnapshotSchema: z.ZodObject<{
             capability: string;
             description?: string | undefined;
         }[] | undefined;
+        formerly?: string[] | undefined;
     }[];
     types: {
         id: string;
@@ -16322,6 +16893,7 @@ declare const SurfaceSnapshotSchema: z.ZodObject<{
         }[] | undefined;
         returns?: string | undefined;
         holds?: string | undefined;
+        formerly?: string[] | undefined;
     }[];
     projectName: string;
     origin: "generated" | "exchanged" | "authored";
@@ -16402,6 +16974,7 @@ declare const SurfaceSnapshotSchema: z.ZodObject<{
                 caller?: string | undefined;
             } | undefined;
             previousNames?: string[] | undefined;
+            formerly?: string[] | undefined;
         }[] | undefined;
         interface?: string | undefined;
         componentType?: string | undefined;
@@ -16432,6 +17005,7 @@ declare const SurfaceSnapshotSchema: z.ZodObject<{
             capability: string;
             description?: string | undefined;
         }[] | undefined;
+        formerly?: string[] | undefined;
     }[] | undefined;
     types?: {
         id: string;
@@ -16455,6 +17029,7 @@ declare const SurfaceSnapshotSchema: z.ZodObject<{
         kind?: string | undefined;
         returns?: string | undefined;
         holds?: string | undefined;
+        formerly?: string[] | undefined;
     }[] | undefined;
     audience?: string | undefined;
     stateId?: string | undefined;
@@ -16675,8 +17250,53 @@ interface ExternalPin {
     /** Why an alias was unresolved or unreachable, or which used members could not be pinned. */
     detail?: string;
 }
+/**
+ * external_request — what `wairon externals add` and sdd_add_external ask for:
+ * one external to declare in the bound project's `.wai/project.yaml`, written
+ * exactly as a person would say it.
+ */
+interface ExternalRequest {
+    /** The alias the project's specs will reference it by (`alias::name`). */
+    alias: string;
+    /** Where the producer is, in the one location grammar; omitted when the family provides it. */
+    source?: string;
+    /** The producer's project id when it differs from the alias. */
+    project?: string;
+    /** git only: the branch, tag or full commit the pin follows. */
+    ref?: string;
+    /** git only: the producer's root inside the repository. */
+    dir?: string;
+    /** Public names to import bare (`*` for all). */
+    use?: string[];
+    /** What the producer is to this project. */
+    description?: string;
+    /** Pin it right after declaring it (default true). */
+    pin?: boolean;
+    /** Answer what would be declared, writing nothing. */
+    dryRun?: boolean;
+}
+/**
+ * external_addition — the answer to declaring one external: what was written
+ * (or would be, on a dry run), the producer it reached and the pin — or why
+ * nothing was written, as one sentence naming the accepted form.
+ */
+interface ExternalAddition {
+    alias: string;
+    /** Whether `.wai/project.yaml` now carries the declaration (false on a refusal and on a dry run). */
+    written: boolean;
+    /** The declaration as written (object form, normalized); null on a refusal. */
+    declaration: ExternalDeclaration | null;
+    /** The producer's project id as the producer answered to it. */
+    project?: string;
+    /** The pin taken right after, when asked. */
+    pin?: ExternalPin | null;
+    /** Why nothing was written, in one sentence naming the accepted form. */
+    refusal?: string;
+    /** Set when the declaration was written but its producer could not be read: why, and that nothing was pinned. */
+    unreachable?: string;
+}
 /** The verdict on one used member of a pinned external. */
-type ExternalUseState = 'unchanged' | 'changed' | 'removed' | 'unlocked' | 'unavailable';
+type ExternalUseState = 'unchanged' | 'changed' | 'removed' | 'unlocked' | 'unavailable' | 'renamed';
 /** external_use_status — the verdict on one used member of one pinned external. */
 interface ExternalUseStatus {
     publicName?: string;
@@ -16685,6 +17305,12 @@ interface ExternalUseStatus {
     /** EXTERNAL_CHECK_UNAVAILABLE on an unavailable entry — never a pass. */
     code?: string;
     detail?: string;
+    /**
+     * On a renamed use: the public name (and member, as `name.member`) the live
+     * producer's rename trace carries the used name forward to — what the
+     * consumer's references should now name.
+     */
+    renamedTo?: string;
 }
 /** external_status — the status of one declared external. */
 interface ExternalStatus {
@@ -17098,6 +17724,20 @@ interface CallSiteFact {
      * and only where the class holds a body under the invoked name.
      */
     enclosingClass?: string;
+    /**
+     * The receiver written as a CHAIN of property accesses — set only when the
+     * call was written `this.<field>.<property>….name(…)`
+     * (`this.c.tracker.checkIn()` → ["this", "c", "tracker"]) or
+     * `<name>.<property>….name(…)` (`deps.tracker.checkIn()` → ["deps",
+     * "tracker"]), and never together with `via`, `field`, `constructed`,
+     * `returnedBy` or `enclosingClass`. The shape constructor-injected
+     * collaborators take when they arrive as ONE bag object. Followed link by
+     * link through what the code DECLARES each link to be — the root's field
+     * or annotated type, then each property's declared type on the shape that
+     * declares it — and, like every receiver past an import binding, a
+     * POSSIBLE origin and never a proven one.
+     */
+    receiverPath?: string[];
     /**
      * The file this site was READ in, set only when it is not the file these
      * facts describe — a pure re-export barrel carries the sites of the function
@@ -17348,7 +17988,9 @@ interface SourceFileFacts {
      * bindings therefore keep EVERY declared type, and a wider answer only ever
      * widens what a call may have reached. A binding the file annotates with
      * nothing records nothing, and so does one annotated with anything but a
-     * plain type reference: what an initializer INFERS is not what the code
+     * plain type reference or a member-preserving utility (`Pick`, `Omit`,
+     * `Partial`, `Required`, `Readonly`) around one, which names the type it
+     * wraps: what an initializer INFERS is not what the code
      * declares, and a guess is not a fact.
      */
     localTypes?: Record<string, string[]>;
@@ -17362,6 +18004,27 @@ interface SourceFileFacts {
      * rather than folded in.
      */
     typeOnlyBindings?: Record<string, string>;
+    /**
+     * The type names each PROPERTY of a named shape the file declares is
+     * DECLARED with, keyed `<shape>.<property>` — an interface's or a type
+     * literal alias's property signatures, and a class's property declarations
+     * and constructor parameter properties. EXACT grade only.
+     *
+     * What a receiver CHAIN (`CallSiteFact.receiverPath`) is followed through:
+     * a bag of collaborators handed to a constructor names each one's type
+     * exactly here. Read the way `fieldTypes` is, and a property annotated with
+     * anything else records nothing.
+     */
+    memberTypes?: Record<string, string[]>;
+    /**
+     * The ONE type each type alias NAMES outright, by alias name —
+     * `type Contract = Pick<HabitRepository, 'find'>` names HabitRepository,
+     * `type Store = SpecStore` names SpecStore. EXACT grade only. Read the way
+     * `fieldTypes` is, so a union, an intersection, a literal or any other
+     * generic names nothing. The one hop a declared type is followed through
+     * when it is an alias of this file.
+     */
+    aliasTargets?: Record<string, string>;
     /**
      * The members of each named shape the file declares, by declaration name
      * (see TypeShapeFact). EXACT grade only — below it a member list cannot be
@@ -17513,6 +18176,20 @@ declare function fieldTypesOf(facts: SourceFileFacts, field: string): string[];
  * field.
  */
 declare function localTypesOf(facts: SourceFileFacts, name: string): string[];
+/**
+ * source_file_facts.memberTypesOf — the type names a property of a named
+ * shape this file declares is DECLARED with, or EMPTY when the file declares
+ * no such shape or property, annotates it with nothing, or was analyzed below
+ * exact grade. The empty answer keeps an unresolvable link of a receiver
+ * chain from becoming a guess.
+ */
+declare function memberTypesOf(facts: SourceFileFacts, shape: string, property: string): string[];
+/**
+ * source_file_facts.aliasTargetOf — the type a type alias this file declares
+ * names outright, or undefined when the name is no such alias or its right
+ * side names no single type.
+ */
+declare function aliasTargetOf(facts: SourceFileFacts, name: string): string | undefined;
 /**
  * source_file_facts.typeBindingOf — the module specifier a NAME was imported
  * from, whether the import was type-only or a runtime one, since a declared
@@ -35965,7 +36642,7 @@ type DesignExport = z.infer<typeof DesignExportSchema>;
 
 declare const DEFAULT_TARGET_DIRS: Record<string, string>;
 declare function defaultTargetConfig(type: 'claude' | 'gemini' | 'agy' | 'cursor' | 'copilot' | 'codex'): BuiltinTargetConfig;
-declare const WAIRON_VERSION = "5.1.1-dev.102";
+declare const WAIRON_VERSION = "5.1.1-dev.104";
 declare const GITHUB_REPO = "SYW-Apps/Waffle-AIron";
 declare const ARCHITECT_AGENT_ID = "agent-architect";
 declare const ARCHITECT_TEMPLATE_ID = "architect";
@@ -35988,9 +36665,11 @@ declare function saveTopologyConfig(config: TopologyConfig): void;
 /**
  * iexternal_producers.resolveDeclared — every declared external of the bound
  * project, and every referenced project member it declares (stage 8), bound to
- * its producer, each with the project's usage of it by public name.
+ * its producer, each with the project's usage of it by public name. Offline,
+ * nothing touches the network: a git external is bound unreachable with the
+ * reason that `wairon externals status` fetches it.
  */
-declare function resolveDeclared(): ExternalBinding[];
+declare function resolveDeclared(offline?: boolean): ExternalBinding[];
 
 /**
  * ipart_context.excerpt — with a part's root bound: the ParentExcerpt it can
@@ -36122,7 +36801,7 @@ declare function moveMember(alias: string, newPath: string): void;
  * `as: project` it then promotes the new part — the pre-stage-8 externalize —
  * every promote refusal found before anything moves.
  */
-declare function externalizeSubsystem(subsystemId: string, path: string, as?: string): void;
+declare function externalizeSubsystem(subsystemId: string, path: string, as?: string): PromoteResult | undefined;
 /**
  * core_orchestrator.promoteMember — promote a part of the bound project to an
  * independent project IN PLACE (stage 8): its files stay where they are and
@@ -36132,7 +36811,24 @@ declare function externalizeSubsystem(subsystemId: string, path: string, as?: st
  * `<parent id>::name` the other), the parent declared as its external and its
  * L0 re-exports re-pointed at the member. Locks nothing.
  */
-declare function promoteMember(alias: string, id?: string): void;
+declare function promoteMember(alias: string, id?: string): PromoteResult;
+/**
+ * promote_result — what a promote (or an externalize as project) wrote across
+ * the new boundary, each one named, so a plan lists exactly what its rehearsal
+ * wrote.
+ */
+interface PromoteResult {
+    /** Every reference of the parent's specs respelled across the boundary, at its parsed position. */
+    respelled: ReferenceEdit[];
+    /** Every reference of the new project's specs respelled: back into the parent, or a self-prefix made bare. */
+    memberRespelled: ReferenceEdit[];
+    /** One line per export entry written, naming the side. */
+    exported: string[];
+    /** One line per bare type name imported by name. */
+    imported: string[];
+    /** One line per consumers entry dropped because it named a subsystem across the boundary. */
+    consumersDropped: string[];
+}
 /**
  * internalize_result — what internalizing a member did with each thing the
  * member held: the subsystems and types it moved, where each piece of the
@@ -36147,6 +36843,12 @@ interface InternalizeResult {
     deleted: string[];
     /** Each piece of metadata deliberately not carried, with the reason. */
     notCarried: string[];
+    /**
+     * Demote only: one line per consumers list widened by the subsystems across
+     * the old boundary that depend on the surface it restricts — the use the
+     * project boundary's export table granted, kept as the list a part needs.
+     */
+    consumersRestored: string[];
 }
 /**
  * core_orchestrator.internalizeMember — fold a member back into the bound
@@ -36290,16 +36992,6 @@ interface TypeRename {
     /** Every edit the rename made to the debt register: an entry anchored on the type. */
     carried: CarriedRekey[];
 }
-/**
- * Rename a type and every reference to it in the bound tree (core_orchestrator.renameType).
- * The type moves to the new id under the same owner, its old id appended to
- * its rename trace; every type position naming it is respelled, and an export
- * entry's typeDef — one that stated no `as` first keeping its public name.
- * Before writing anything it refuses a type that does not exist
- * (type-missing), one in another project (chained-type), a new id outside the
- * id grammar (invalid-id), and a new id another type of the same owner holds
- * or retired (id-taken, id-retired).
- */
 declare function renameType(typeId: string, newId: string): TypeRename;
 /**
  * core_orchestrator.moveMountToMembers — move one legacy L1 mount of the bound
@@ -36316,285 +37008,6 @@ declare function moveMountToMembers(alias: string): boolean;
  */
 declare function normalizeReferences(kind: WritableSpecKind, id: string): boolean;
 
-interface CanvasModel {
-    system: {
-        name: string;
-        vision?: string;
-        targetLanguage?: string;
-        databases?: {
-            id: string;
-            name: string;
-            engine: string;
-            description?: string;
-            tables?: string[];
-        }[];
-        diagram?: {
-            lineStyle?: 'bezier' | 'straight' | 'taxi';
-            defaultView?: 'architecture' | 'types' | 'databases';
-            showDatabases?: boolean;
-        };
-    };
-    generatedAt: string;
-    subsystems: {
-        id: string;
-        name: string;
-        description: string;
-        targetLanguage?: string;
-        status?: string;
-        trustedLinks: {
-            subsystem: string;
-            reason: string;
-        }[];
-        /** A member project's node (stage 3): its id is the member's key, its name the
-         *  alias its parent declares it under; the member's specs hang under it. */
-        project?: boolean;
-        /** Hosted (stage 7): a member project node's record id, present only when the
-         *  caller may read that record — the web app links the node to its page. */
-        recordId?: string;
-        /** Stage 8: the storage badge of a subsystem a PART holds (it is this
-         *  project's own subsystem, stored elsewhere) — `part <alias> · contained`,
-         *  `… · ../admin`, `… · git a1b2c3d` — or of a referenced project node. */
-        storage?: string;
-        /** A declared external that is no project of the family, drawn as a
-         *  project node of its own (dashed) that its consumption edges land on. */
-        external?: boolean;
-        /** Opt-in deep expansion: with Internals on, this subsystem's box renders
-         *  its WHOLE subtree (nested boundary boxes + leaf tiles + direct relation
-         *  lines) instead of one layer. Never set by buildCanvasModel — the hosted
-         *  environment adapter stamps it on unit-derived frames. Absent ⇒ the
-         *  engine behaves exactly as before. */
-        deepInternals?: boolean;
-    }[];
-    components: {
-        id: string;
-        name: string;
-        description: string;
-        subsystem: string;
-        componentType: string;
-        portalType?: string;
-        status?: string;
-        public: boolean;
-        /** The L0 gateway entry id this component backs (the OpenAPI operation tag),
-         *  present only for a component published in the system's public surface. */
-        apiTag?: string;
-        owner?: string;
-        owns: string[];
-        dependsOn: string[];
-        interfaces: {
-            id: string;
-            name: string;
-            description: string;
-            methods: {
-                name: string;
-                description: string;
-                signature: string;
-                returns: string;
-                params?: {
-                    name: string;
-                    type: string;
-                    optional?: boolean;
-                }[];
-                /** Where the method takes its params and returns from, shown beside its signature ("from X"). */
-                signatureFrom?: string;
-                endpoint?: unknown;
-                guarantees?: string[];
-            }[];
-        }[];
-        narratives: {
-            method: string;
-            steps: {
-                n: number;
-                text: string;
-                kind: string;
-                call?: {
-                    component: string;
-                    method: string;
-                };
-                cond?: string;
-                onTrue?: number;
-                onFalse?: number;
-                on?: string;
-                cases?: {
-                    value: string;
-                    step: number;
-                }[];
-                defaultStep?: number;
-                loopKind?: string;
-                over?: string;
-                end?: number;
-                catches?: {
-                    error: string;
-                    step: number;
-                }[];
-                fin?: number;
-                to?: number;
-                /** parallel: arm entry steps (contiguous ordered sub-regions of the body). */
-                branches?: {
-                    step: number;
-                    name?: string;
-                }[];
-                /** call/dispatch: fire-and-forget — failure does not propagate to this flow. */
-                detach?: boolean;
-                outcome?: string;
-                err?: string;
-            }[];
-        }[];
-        /** Opaque external references surfaced on the canvas element (see ExternalLinkSchema).
-         *  wairon never fetches them; an `implementation` link is the external source-of-record. */
-        externalLinks?: {
-            url: string;
-            type: string;
-            label?: string;
-        }[];
-        /** Methods specified as intent prose instead of a narrative (the detail dial). */
-        intents: {
-            method: string;
-            text: string;
-        }[];
-    }[];
-    /** `consumption`: the edge's ends lie in different projects (or it lands on a
-     *  referenced or external project node); `relation`: the CanvasRelation it
-     *  takes its health from, present only when the model carries relations. */
-    edges: {
-        from: string;
-        to: string;
-        cross: boolean;
-        consumption?: boolean;
-        relation?: string;
-    }[];
-    /** Relation health, one per consumer→producer pair the edges connect. PRESENT
-     *  only when health was computed (empty when nothing is consumed); ABSENT when
-     *  it was not — then consumption edges are drawn neutral, "not checked". */
-    relations?: CanvasRelation[];
-    types: {
-        id: string;
-        name: string;
-        kind: string;
-        subsystem?: string;
-        fields: {
-            name: string;
-            type: string;
-            optional?: boolean;
-            key?: string;
-            references?: string;
-        }[];
-        methods: {
-            name: string;
-            signature: string;
-            returns: string;
-            description?: string;
-        }[];
-        /** A signature type's derived text, `(a: T, b?: U): R` — drawn in place of a field list. */
-        signature?: string;
-        /** An enum's values in declared order — drawn in place of a field list. */
-        values?: {
-            name: string;
-            description?: string;
-        }[];
-        /** A named scalar's primitive — drawn compactly beside its name, with no field rows and no edges. */
-        holds?: string;
-        /** Interface methods whose params/returns reference this type (usage trace). */
-        usedBy: {
-            component: string;
-            method: string;
-        }[];
-        componentClass?: string;
-        database?: string;
-        table?: string;
-        linkedEntity?: string;
-    }[];
-    /** Type → type references derived from field type strings (ERD edges). */
-    typeEdges: {
-        from: string;
-        to: string;
-        field: string;
-        card: '1' | '0..1' | '*';
-    }[];
-    /** Data-coupling edges: a component depends on another subsystem's data
-     *  (uses a type it owns), pointed at that subsystem's published portal. */
-    dataEdges: {
-        from: string;
-        to: string;
-    }[];
-    issues: {
-        severity: string;
-        code: string;
-        message: string;
-        specId?: string;
-    }[];
-}
-/**
- * canvas_relation — one consumer-project-to-producer-project relation as the
- * canvas draws it: the health every consumption edge between the two takes,
- * and the detail a reader sees on hover or in the details panel.
- */
-interface CanvasRelation {
-    /** `<consumer>→<producer>`: the key a consumption edge names in its `relation`. */
-    id: string;
-    /** The consuming project's key ('' for the bound root). */
-    consumer: string;
-    /** The alias the consumer reaches the producer under. */
-    producer: string;
-    health: RelationHealth;
-    /** The uses that are NOT unchanged, with their state and why. */
-    uses: {
-        name: string;
-        state: string;
-        detail?: string;
-    }[];
-    /** How many uses compared unchanged. */
-    unchanged: number;
-    pinnedCommit?: string;
-    pinnedDigest?: string;
-    comparedAt: string;
-    /** Why the relation is unavailable, when it is. */
-    detail?: string;
-}
-
-/** The formats the architecture diagram renders to. */
-type DiagramFormat = 'canvas' | 'mermaid' | 'drawio' | 'excalidraw';
-declare function renderDiagram(format: DiagramFormat, relations?: ProjectRelations[]): string;
-/**
- * The full CanvasModel for the current (request-scoped) project — the same model
- * `renderDiagram('canvas')` renders to the standalone HTML, but returned as data
- * so the React web app can mount the shared renderer directly (no iframe) and,
- * later, receive it in on-demand scope slices. Pure derivation, no side effects;
- * relation health is drawn only when passed in.
- */
-declare function buildCanvasDataModel(relations?: ProjectRelations[]): CanvasModel;
-interface DiagramFile {
-    /** Path relative to the diagrams output directory, using forward slashes. */
-    relPath: string;
-    title: string;
-    /** Raw mermaid source (no markdown fence). */
-    mermaid: string;
-}
-interface SpecGraph {
-    systemName: string;
-    subsystems: SubsystemSpec[];
-    components: ComponentSpec[];
-    interfaces: InterfaceSpec[];
-    implementations: ImplementationSpec[];
-    /** Component ids published via some subsystem's publicInterfaces. */
-    publicComponents: Set<string>;
-}
-declare function loadSpecGraph(): SpecGraph;
-interface ComponentDiagramOptions {
-    /** Scope to one subsystem (its components plus directly-connected externals). */
-    subsystem?: string;
-}
-declare function generateComponentDiagram(options?: ComponentDiagramOptions): string;
-interface SequenceDiagramOptions {
-    /** Max call-expansion depth (default 3). Depth 1 = only the method's own steps. */
-    depth?: number;
-}
-declare function generateSequenceDiagram(componentId: string, methodName: string, options?: SequenceDiagramOptions): string;
-declare function generateDiagramSet(): DiagramFile[];
-/** Wrap raw mermaid in a titled markdown document (renders on GitHub / IDEs). */
-declare function toMarkdown(file: DiagramFile): string;
-/** Index README linking every generated diagram. */
-declare function diagramSetIndex(files: DiagramFile[], systemName: string): string;
-
 /**
  * Scan a project root and return all domain candidates.
  * Already-tracked domain paths are marked with alreadyTracked: true.
@@ -37029,6 +37442,18 @@ declare function approvalRecord(root?: string): LockRecord | null;
  * which is the behaviour a project has before anyone has gated it.
  */
 declare function settledSpecPaths(root?: string): Set<string> | null;
+/**
+ * approval_comparison.reexpress — the record on file carried into the design
+ * reading WITHOUT a new approval, when that is provably sound: a record that
+ * names no design reading (format 2) whose stateId equals gate.asRecorded —
+ * the identity it certified, recomputed over the tree as it stands, so nothing
+ * it covered moved. Keeps lockedAt, lockedBy, the validation and code results,
+ * the members' pins and the provenance exactly; replaces stateId with the gate
+ * (asRecorded dropped), specs with the design-reading capture, and adds
+ * `reexpressed`. Null when there is nothing to carry or it cannot be proven.
+ * Writes nothing: the caller writes the answer.
+ */
+declare function reexpress(gate: StateId): LockRecord | null;
 /**
  * What the lock says about the tree as it stands: the sentence to show, and
  * whether it is drift.
@@ -37043,6 +37468,8 @@ interface ApprovalVerdict {
     text: string;
     /** Whether the tree has actually moved since it was approved. */
     drifted: boolean;
+    /** Every own spec that moved since the approval, prefixed `~` changed, `+` added, `-` removed; absent when none moved. */
+    moved?: string[];
 }
 /**
  * What has changed since the human last approved this tree.
@@ -37420,9 +37847,25 @@ declare function getRequestParentReach(): {
 declare function setProjectRoot(dir: string | null): void;
 /** Get the raw project root override value (or null if none set) */
 declare function getProjectRootOverride(): string | null;
+/** How a project came to be bound. */
+type ProjectBindingVia = 'here' | 'ancestor' | 'declared-member';
+/** project_binding — the project a folder binds to, and how. */
+interface ProjectBinding {
+    /** The bound project root (absolute). */
+    root: string;
+    /** here: the folder itself; ancestor: a folder above it, inside its repository; declared-member: a project above the repository root that declares it. */
+    via: ProjectBindingVia;
+    /** The repository root the walk was bounded by, when the folder is inside one. */
+    repositoryRoot?: string;
+}
 /**
- * Walk up from startDir to the nearest ancestor containing a wairon project
- * with system.yaml in its specs folder. Returns null if none is found.
+ * Resolve the project a folder binds to by the binding rule; null when none
+ * does. Never fails: an unreadable ancestor configuration declares nothing.
+ */
+declare function resolveProjectBinding(startDir: string): ProjectBinding | null;
+/**
+ * The root the binding rule binds from startDir (resolveProjectBinding), or
+ * null when no project binds it.
  */
 declare function findSystemRoot(startDir: string): string | null;
 /** The resolved project root: the request-scoped root if bound (hosting server),
@@ -37536,7 +37979,8 @@ declare function listSnapshots(): SurfaceSnapshot[];
 declare function getSnapshot(projectName: string): SurfaceSnapshot | null;
 declare function removeSnapshot(projectName: string): boolean;
 declare function pinExternals(aliases?: string[]): ExternalPin[];
-declare function getExternalsStatus(): ExternalStatus[];
+/** isurface_portal.getExternalsStatus — each declared external's pin against its live producer; offline, no producer is read over the network. */
+declare function getExternalsStatus(offline?: boolean): ExternalStatus[];
 declare function listExternals(): ExternalListing[];
 declare function listPinnedExternals(): PinnedExternal[];
 /** isurface_portal.pinnedParent — a part's pinned parent, from its own .wai/externals files only (stage 8); null at a project. */
@@ -37559,4 +38003,4 @@ declare function schemaFingerprint(): string;
  */
 declare function loadProjectConfig(): ProjectConfig;
 
-export { AI_PATHS, ARCHITECT_AGENT_ID, ARCHITECT_TEMPLATE_ID, type AgentBrief, AgentBriefSchema, type AgentRecord, AgentRecordSchema, type AgentStatus, AgentStatusSchema, type AgentTemplate, AgentTemplateSchema, type AnalysisGrade, type ApiKeyLocation, ApiKeyLocationSchema, type ApprovalDiff, type ApprovalVerdict, type ArchProfile, type AuthoredReference, BACKEND_COMMANDS, BUILTIN_PROFILES, type BoundaryItem, BoundaryItemSchema, type BuildContextOptions, type BuiltinTarget, type BuiltinTargetConfig, BuiltinTargetConfigSchema, BuiltinTargetSchema, BundleNotFoundError, type CallSiteFact, type CarriedDebt, type CarriedDebtKind, CarriedDebtKindSchema, CarriedDebtSchema, type CarriedFinding, type CarriedFindingEntry, CarriedFindingSchema, type CatchClause, CatchClauseSchema, ChainingMigrationRefusedError, ClaudeExporter, type ClaudeExporterOptions, type CodeIndex, type CodeModel, type ComplexityRuleConfig, ComplexityRuleConfigSchema, type ComponentRename, type ComponentSpec, ComponentSpecSchema, type ComponentType, ComponentTypeSchema, type CompositionConfig, CompositionConfigSchema, ConfigValidationError, type ConformanceRuleConfig, ConformanceRuleConfigSchema, type ConformanceTier, ConformanceTierSchema, type CrossProjectReference, CustomExporter, type CustomTarget, type CustomTargetConfig, CustomTargetConfigSchema, CustomTargetSchema, DEFAULT_TARGET_DIRS, DESIGN_APPROVALS, DESIGN_DEPENDENCY_ROLES, DESIGN_FORMAT, DESIGN_FORMAT_VERSION, type DatabaseSpec, DatabaseSpecSchema, type DeclarativePack, type DeclaredCall, type DeclaredExternal, type DeclaredMember, type DependencyClass, DependencyClassSchema, type DependencyEdge, type DependencyEdges, type DesignApproval, DesignApprovalSchema, type DesignComponent, DesignComponentSchema, type DesignDependency, type DesignDependencyRole, DesignDependencyRoleSchema, DesignDependencySchema, type DesignDepth, DesignDepthSchema, type DesignExport, type DesignExportEntry, DesignExportEntrySchema, DesignExportSchema, type DesignField, DesignFieldSchema, type DesignImplementation, DesignImplementationSchema, type DesignInterface, DesignInterfaceSchema, type DesignMethod, type DesignMethodBody, DesignMethodBodySchema, DesignMethodSchema, type DesignParam, DesignParamSchema, type DesignProject, DesignProjectSchema, type DesignSource, DesignSourceSchema, type DesignSubsystem, DesignSubsystemSchema, type DesignType, type DesignTypeRef, DesignTypeRefSchema, DesignTypeSchema, type DetectedDomainCandidate, type DiagramConfig, DiagramConfigSchema, type DiagramLineStyle, DiagramLineStyleSchema, type DiagramView, DiagramViewSchema, type DispatchBinding, DispatchBindingSchema, DoctorOptionsError, type DocumentationRuleConfig, DocumentationRuleConfigSchema, type Domain, DomainSchema, type DomainType, DomainTypeSchema, type Durability, DurabilitySchema, EXTERNAL_ALIAS_RE, type EdgeReach, type Endpoint, EndpointSchema, type EnumValue, EnumValueSchema, type EventBinding, EventBindingSchema, type ExportAliasFact, type ExportContext, type ExportKind, type ExportProblem, type ExportProblemKind, type ExportResult, type ExportTableLevel, type ExportUsage, type ExportUse, type Exporter, type ExtData, ExtDataSchema, type ExtensionPack, type ExternalBinding, type ExternalDeclaration, ExternalDeclarationSchema, type ExternalLink, ExternalLinkSchema, type ExternalLinkType, ExternalLinkTypeSchema, type ExternalListing, type ExternalLockEntry, ExternalLockEntrySchema, type ExternalPin, type ExternalPinOutcome, type ExternalRelation, type ExternalRole, type ExternalSource, type ExternalSourceKind, ExternalSourceSchema, type ExternalStatus, type ExternalUseState, type ExternalUseStatus, type ExternalsLock, ExternalsLockSchema, FULL_COMMIT_RE, type FamilyProblemKind, type FamilySwitches, type FindingDeclaration, FindingDeclarationSchema, type FindingParts, type ForeignFieldRepair, type ForwardedName, type FunctionBodyFact, GITHUB_REPO, GeminiExporter, type GenerateOptions, type GenerateSummary, type GroupSpec, GroupSpecSchema, type Guarantee, GuaranteeSchema, HOLDABLE_PRIMITIVES, type HostedRecordLookup, type HttpMethod, HttpMethodSchema, type ImplementationSpec, ImplementationSpecSchema, type ImportBindingFact, type ImportGraph, type ImportSection, type InstalledPack, type InterfaceSpec, InterfaceSpecSchema, type InternalizeDestination, type InternalizeResult, type Invariant, InvariantSchema, type InvocationKind, InvocationKindSchema, type IssueSeverity, type LegacySpecFile, type LifecycleEntrypoint, LifecycleEntrypointSchema, type LifecyclePhase, LifecyclePhaseSchema, type LintAllow, LintAllowSchema, type LintConfig, LintConfigSchema, type LoadedExtensions, type LoadedPackSkill, type LockRecord, type LockStatus, type LogLevel, type LoopKind, LoopKindSchema, type MemberAdvance, type MemberCreation, type MemberDeclaration, MemberDeclarationSchema, type MemberKind, type MemberPin, type MemberSource, type MemberStorage, type MethodEffect, MethodEffectSchema, type MethodImplementation, MethodImplementationSchema, type MethodLike, type MethodParam, MethodParamSchema, type MethodRename, type MethodSignature, MethodSignatureSchema, type MountForm, type NamedOpenApiSpec, NamedOpenApiSpecSchema, type NamingRuleConfig, NamingRuleConfigSchema, type NarrativeDetail, NarrativeDetailSchema, type NarrativeStep, NarrativeStepSchema, type NarrativeStepType, NarrativeStepTypeSchema, type OAuthFlow, OAuthFlowSchema, type OutputTarget, OutputTargetSchema, type OwnershipIndex, PATTERN_TYPES, PRIMITIVE_TYPES, PROJECT_ID_RE, PROJECT_KINDS, PUBLIC_NAME_RE, type PackDiagnosis, type PackEntry, type PackPath, type PackRef, type PackRequirement, PackRequirementSchema, type PackScope, type PackSelection, PackSelectionSchema, type ParallelBranch, ParallelBranchSchema, type ParameterFact, type ParentExcerpt, ParentExcerptSchema, type ParsedMemberSource, type PartOf, PartOfSchema, type PathsConfig, PathsConfigSchema, type PatternRef, PatternRefSchema, type PinnedExternal, type PinnedParent, type PortalAuth, PortalAuthSchema, type PortalAuthScheme, PortalAuthSchemeSchema, type PortalMount, PortalMountSchema, type PortalType, PortalTypeSchema, PreviousIdsSchema, PreviousNamesSchema, ProfileSelectionSubjectSchema, type ProjectConfig, ProjectConfigSchema, type ProjectFamily, type ProjectFamilyProblem, type ProjectIdOrigin, type ProjectIdSource, type ProjectIdentity, type ProjectIdentityProblem, type ProjectImport, type ProjectNode, ProjectNotInitializedError, type ProjectProfileSelection, ProjectProfileSelectionSchema, type ProjectRelations, type PublicInterface, PublicInterfaceSchema, type PublicInterfaceType, PublicInterfaceTypeSchema, RETIRED_STEREOTYPES, type ReadableProject, type RealizationIndex, type ReexportBindingFact, type ReferenceBinding, type ReferenceEdit, type ReferenceForm, type ReferenceLanding, type ReferenceResolution, type Registry, RegistrySchema, type RelationHealth, type RenameTraceHolders, type RequirementItem, RequirementItemSchema, type ResolutionOutcome, type ResolvedBody, type ResolvedDetail, type ResolvedExport, type ResolvedExportTable, type ResolvedExternal, ResolvedInterfaceSpecSchema, type ResolvedMethod, ResolvedMethodSignatureSchema, ResolvedTypeMethodSchema, ResolvedTypeSpecSchema, type RouteFact, type RuleCode, type RuleContext, type RuleJudgement, type RuleScope, type RulesConfig, RulesConfigSchema, SCAN_EXCLUDE_DIRS, SDD_RULES, SEMANTIC_GUARANTEES, STEP_COMMON_FIELDS, STEP_LABEL_TWINS, STEP_TYPE_FIELDS, SUPPORTED_ALIASES, SURFACE_AUDIENCES, type ScopeFilterOptions, type SddRule, type Severity, type ShapeMemberFact, type ShapeOrigin, type SignatureFacts, type SignatureResolution, type SignatureSourceFact, type SignatureTextRepair, type SourceFileFacts, type SourceFileStatus, type SpecId, type SpecIdKind, SpecIdSchema, type SpecIndex, type SpecScanOptions, type SpecStatus, SpecStatusSchema, type SpecialistRetirement, type SpecialistRetype, type StaleSignatureText, type StateId, type StatusDecor, type StatusOptions, type StatusReport, type StepConfigCode, type StepConfigProblem, type StepConfigVerdict, type StepGraph, type StoredInterfaceSpec, type StoredMethodSignature, StoredMethodSignatureSchema, type StoredTypeMethod, StoredTypeMethodSchema, type StoredTypeSpec, type SubsystemSpec, SubsystemSpecSchema, type SubsystemWriteRule, type SupportedAlias, type SurfaceAudience, SurfaceAudienceSchema, type SurfaceContractEntry, SurfaceContractEntrySchema, type SurfaceOrigin, SurfaceOriginSchema, type SurfaceRefResolution, type SurfaceSnapshot, SurfaceSnapshotSchema, type SurfaceTypeDef, SurfaceTypeDefSchema, type SurfaceTypeExport, SurfaceTypeExportSchema, type SwitchCase, SwitchCaseSchema, type SyncResult, type SystemPublicInterface, SystemPublicInterfaceSchema, type SystemSpec, SystemSpecSchema, type TargetConfig, TargetConfigSchema, type Technology, TechnologySchema, type Template, TemplateNotFoundError, TemplateSchema, type TopologyConfig, TopologyConfigSchema, type Transport, TransportSchema, type TreeExportResult, type TreeImportOptions, type TreeImportResult, type TrustedLink, TrustedLinkSchema, type TypeCanonicalization, type TypeDialect, type TypeEnumProposal, type TypeExpression, type TypeExpressionProblem, TypeExpressionSchema, type TypeField, TypeFieldSchema, type TypeForm, type TypeKind, TypeKindSchema, type TypeMethod, TypeMethodSchema, type TypeParse, type TypePosition, type TypeProblemCode, type TypeRename, type TypeRespelling, type TypeShapeFact, type TypeSpec, TypeSpecSchema, type TypeSpellingFacts, type TypeSpellingRepair, type TypedSpecKind, USE_ENTRY_RE, WAIRON_MANAGED_BANNER, WAIRON_MANAGED_MARKER, WAIRON_VERSION, type WaiPaths, WaironError, type WriteReach, activeTargetTypes, addDomain, admits, advanceMember, aiDir, aiDirAt, aiPathsAt, ambiguityMessage, approvalKeyIn, approvalRecord, approvalVerdict, assertContainedProjectPath, assertProjectInitialized, backendCommand, backfillChainedSubprojectConfigs, backupBeside, bodySitesOf, buildCanvasDataModel, buildProjectGraph, buildRuleContext, builtinProfileIds, builtinProjectKinds, callSitesOf, canonicalTypeRef, canonicalTypeText, captureApprovedSpecs, checkDeclarativePack, clearLoaderIssues, cognitiveScore, complexityLevel, composeAgentBrief, composeRuleSequence, computeGateStateId, computeOwnStateId, computeStateId, computeStateIdAt, conceptNoun, consumedContractInputs, containedPathOf, contentDigest, createAgentRecord, createEmptyRegistry, createEmptyTopologyConfig, createMember, createProjectConfig, currentRootBinding, declareExternal, declareMember, declaredExternals, declaredMembers, declaredPackNames, declaredProfileIds, declares, declaresGlobalPacks, defaultConformanceTier, defaultNarrativeDetail, defaultPackSelections, defaultTargetConfig, deleteSpec, demoteMember, dependencyCycles, deregisterPackRef, deriveExecutionProfile, deriveMethodSignature, deriveTypeSignature, derivedDocPaths, describeProject, detectDomainCandidates, diagnoseProjectPacks, diagramSetIndex, dialectOf, diffAgainstApproval, diffSize, discoverPacks, dryRunSerializeSpecs, effectiveDetail, effectiveProjectId, emptyExtensions, emptyTypeSpellingFacts, ensureDir, ensureProjectInitialized, excerpt as excerptParent, exportDesign, exportSpecTree, exportSurface, exportTargetKey, exportUsage, externalizeSubsystem, extractTypeIdentifiers, factsFor, familyApprovals, familyNode, familyRelations, fieldTypeRefs, fieldTypesOf, findChainingParent, findChainingSubprojectsMissingConfig, findLegacySpecFiles, findProjectRoot, findSystemRoot, findTestsReferencing, fromProjectRoot, generateAgent, generateAll, generateComponentDiagram, generateDiagramSet, generateSequenceDiagram, getExporter, getExternalsStatus, getHostedLookup, getLoaderIssues, getProjectRoot, getProjectRootOverride, getRequestParentReach, getRequestProjectRoot, getSnapshot, getStatusReport, getWriteReach, globalGuideFilePath, globalPacksDir, globalPacksEnabled, globalTemplatesDir, hasContext, hasFunctionBody, headNoun, holdsState, implementationSourceFiles, importBindingOf, importNames, importSpecTree, importSurface, injectGuide, installPackFromDirectory, interfaceCanonicalTypes, interfaceGenericParameters, internalizeMember, isDraftSubsystem, isLogic, isOutsideRoot, isOwnComponentEntry, isPart, isPattern, isProjectInitialized, isProvidedBy, isRetired, isTypeVocabulary, judgesCode, keyIn, landReference, languageOfSourcePath, lineEndingFor, listDirectChainedSubprojects, listExternals, listFiles, listFilesRecursive, listInstalledPacks, listPinnedExternals, listRules, listSnapshots, loadComponentSpec, loadComponentSpecs, loadExtensionPacks, loadExtensions, loadFor as loadExtensionsFor, loadImplementationSpec, loadImplementationSpecs, loadInterfaceSpec, loadInterfaceSpecs, loadProjectConfig, loadProjectExtensions, loadProjectVariants, loadRegistry, loadSpec, loadSpecGraph, loadSubsystemSpec, loadSubsystemSpecs, loadSystemSpec, loadTopologyConfig, loadTypeSpec, loadTypeSpecs, localApprover, localGuideFilePath, localTypesOf, logger, makeScopeFilter, markSelectionsBundled, matchTypeRef, measurePackDoctrine, measurePackImpact, memberDeclarationOf, memberDigest, memberLocationOf, methodGenericParameters, methodSourceFile, methodTypeRefs, moveMember, moveMethods, moveMountToMembers, nameKey, namesAnInteger, narrativeStepForeignFields, normalizeReferences, ownerOf, packDirEntry, packEntryLabel, packEntryRef, manifestOf as packManifest, packStoreDir, parseDeclarativePack, parseDeclaredCall, parseMemberSource, parseTypeExpression, parseTypePosition, parseYaml, passesIntentFloor, pathExists, pathKey, pinExternals, pinInstalledPacksAsSelections, pinnedParent, producerOf, projectConfigExists, graph as projectFamily, projectIdentity, promoteMember, provisionProject, qualifiedTypeId, rangeProblem, readCodeAnnotation, readFileOrNull, readJsonFile, readLockRecord, readLockState, readStampVersion, readYamlFile, recordProfileSelection, registerExporter, registerPackRef, reinjectLocalGuides, relationHealth, removeDomain, removeExternal, removeMember, removePackSelection, removeSnapshot, renameAlias, renameComponent, renameProjectId as renameId, renameMethod, renameType, renderDiagram, repairForeignStepFields, repairSignatures, repairTypeSpellings, repointExternal, requiredPolicies, resolveAgentTopology, resolveBudget, resolveChainingParent, resolveDomains, resolveExpectedOutputPaths, resolveDeclared as resolveExternals, resolveImport, resolveInstalledPack, resolveProjectExports, resolveSignatures, resolveSubprojectForNamespace, resolveSubsystemExports, resolveVariantGuidance, retireSpecialists, returnTypeOf, rewriteReferences, runWithHostedLookup, runWithProjectBinding, runWithProjectRoot, sameContract, saveSpec, saveTopologyConfig, scanAllSpecs, schemaFingerprint, selectsFamily, serializeYaml, setExecutionTier, setProjectId as setId, setLogLevel, setProjectRoot, setProjectType, settledSpecPaths, signatureFacts, signatureTypeRefs, specIndexRetiredBy, specPathsInScope, splitNamespace, stepConfigVerdict, stepFieldsFor, stepGraph, storedMethodSignature, storedTypeMethod, syncContextFiles, technologyName, technologyTokens, toMarkdown, typeBindingOf, typeCanonicalTypes, typeDialectFor, typeGenericParameters, typeIsMany, typeMatchesRef, typeNamedRefs, typeProblemEnumProposal, typeProblemIntProposal, typeSourceFiles, typeSpellingFacts, uninstallPack, updateMember, updateSpec, upsertPackSelection, validateAsComplete, validateComponentCandidate, validateFamily, validateProject, validateProjectConfig, validateRegistry, withLineEndings, withPack, writeFile, writeFileIfChanged, writeJsonFile, writeLockRecord, writeReachDenials, writeReachPermits, writeRootGuideDelegator, writeYamlFile, writtenTypeRefs };
+export { AI_PATHS, ARCHITECT_AGENT_ID, ARCHITECT_TEMPLATE_ID, type AgentBrief, AgentBriefSchema, type AgentRecord, AgentRecordSchema, type AgentStatus, AgentStatusSchema, type AgentTemplate, AgentTemplateSchema, type AnalysisGrade, type ApiKeyLocation, ApiKeyLocationSchema, type ApprovalDiff, type ApprovalVerdict, type ArchProfile, type AuthoredReference, BACKEND_COMMANDS, BUILTIN_PROFILES, type BoundaryItem, BoundaryItemSchema, type BuildContextOptions, type BuiltinTarget, type BuiltinTargetConfig, BuiltinTargetConfigSchema, BuiltinTargetSchema, BundleNotFoundError, type CallSiteFact, type CarriedDebt, type CarriedDebtKind, CarriedDebtKindSchema, CarriedDebtSchema, type CarriedFinding, type CarriedFindingEntry, CarriedFindingSchema, type CatchClause, CatchClauseSchema, ChainingMigrationRefusedError, ClaudeExporter, type ClaudeExporterOptions, type CodeIndex, type CodeModel, type ComplexityRuleConfig, ComplexityRuleConfigSchema, type ComponentRename, type ComponentSpec, ComponentSpecSchema, type ComponentType, ComponentTypeSchema, type CompositionConfig, CompositionConfigSchema, ConfigValidationError, type ConformanceRuleConfig, ConformanceRuleConfigSchema, type ConformanceTier, ConformanceTierSchema, type CrossProjectReference, CustomExporter, type CustomTarget, type CustomTargetConfig, CustomTargetConfigSchema, CustomTargetSchema, DEFAULT_TARGET_DIRS, DESIGN_APPROVALS, DESIGN_DEPENDENCY_ROLES, DESIGN_FORMAT, DESIGN_FORMAT_VERSION, DESIGN_VIEW_FIELDS, type DatabaseSpec, DatabaseSpecSchema, type DeclarativePack, type DeclaredCall, type DeclaredExternal, type DeclaredMember, type DependencyClass, DependencyClassSchema, type DependencyEdge, type DependencyEdges, type DesignApproval, DesignApprovalSchema, type DesignComponent, DesignComponentSchema, type DesignDependency, type DesignDependencyRole, DesignDependencyRoleSchema, DesignDependencySchema, type DesignDepth, DesignDepthSchema, type DesignExport, type DesignExportEntry, DesignExportEntrySchema, DesignExportSchema, type DesignField, DesignFieldSchema, type DesignImplementation, DesignImplementationSchema, type DesignInterface, DesignInterfaceSchema, type DesignMethod, type DesignMethodBody, DesignMethodBodySchema, DesignMethodSchema, type DesignParam, DesignParamSchema, type DesignProject, DesignProjectSchema, type DesignSource, DesignSourceSchema, type DesignSubsystem, DesignSubsystemSchema, type DesignType, type DesignTypeRef, DesignTypeRefSchema, DesignTypeSchema, type DetectedDomainCandidate, type DiagramConfig, DiagramConfigSchema, type DiagramLineStyle, DiagramLineStyleSchema, type DiagramView, DiagramViewSchema, type DispatchBinding, DispatchBindingSchema, DoctorOptionsError, type DocumentationRuleConfig, DocumentationRuleConfigSchema, type Domain, DomainSchema, type DomainType, DomainTypeSchema, type Durability, DurabilitySchema, EXTERNAL_ALIAS_RE, EXTERNAL_SOURCE_FORMS, type EdgeReach, type Endpoint, EndpointSchema, type EnumValue, EnumValueSchema, type EventBinding, EventBindingSchema, type ExportAliasFact, type ExportContext, type ExportKind, type ExportProblem, type ExportProblemKind, type ExportResult, type ExportTableLevel, type ExportUsage, type ExportUse, type Exporter, type ExtData, ExtDataSchema, type ExtensionPack, type ExternalAddition, type ExternalBinding, type ExternalDeclaration, ExternalDeclarationSchema, type ExternalLink, ExternalLinkSchema, type ExternalLinkType, ExternalLinkTypeSchema, type ExternalListing, type ExternalLockEntry, ExternalLockEntrySchema, type ExternalPin, type ExternalPinOutcome, type ExternalRelation, type ExternalRequest, type ExternalRole, type ExternalSource, type ExternalSourceKind, ExternalSourceSchema, type ExternalStatus, type ExternalUseState, type ExternalUseStatus, type ExternalsLock, ExternalsLockSchema, FULL_COMMIT_RE, type FamilyProblemKind, type FamilySwitches, type FindingDeclaration, FindingDeclarationSchema, type FindingParts, type ForeignFieldRepair, type ForwardedName, type FunctionBodyFact, GITHUB_REPO, GeminiExporter, type GenerateOptions, type GenerateSummary, type GroupSpec, GroupSpecSchema, type Guarantee, GuaranteeSchema, HOLDABLE_PRIMITIVES, type HostedRecordLookup, type HttpMethod, HttpMethodSchema, type ImplementationSpec, ImplementationSpecSchema, type ImportBindingFact, type ImportGraph, type ImportSection, type InstalledPack, type InterfaceSpec, InterfaceSpecSchema, type InternalizeDestination, type InternalizeResult, type Invariant, InvariantSchema, type InvocationKind, InvocationKindSchema, type IssueSeverity, type LegacySpecFile, type LifecycleEntrypoint, LifecycleEntrypointSchema, type LifecyclePhase, LifecyclePhaseSchema, type LintAllow, LintAllowSchema, type LintConfig, LintConfigSchema, type LoadedExtensions, type LoadedPackSkill, type LockRecord, type LockStatus, type LogLevel, type LoopKind, LoopKindSchema, type MemberAdvance, type MemberCreation, type MemberDeclaration, MemberDeclarationSchema, type MemberKind, type MemberPin, type MemberSource, type MemberStorage, type MethodEffect, MethodEffectSchema, type MethodImplementation, MethodImplementationSchema, type MethodLike, type MethodParam, MethodParamSchema, type MethodRename, type MethodSignature, MethodSignatureSchema, type MountForm, type NamedOpenApiSpec, NamedOpenApiSpecSchema, type NamingRuleConfig, NamingRuleConfigSchema, type NarrativeDetail, NarrativeDetailSchema, type NarrativeStep, NarrativeStepSchema, type NarrativeStepType, NarrativeStepTypeSchema, type OAuthFlow, OAuthFlowSchema, type OutputTarget, OutputTargetSchema, type OwnershipIndex, PATTERN_TYPES, PRIMITIVE_TYPES, PROJECT_ID_RE, PROJECT_KINDS, PUBLIC_NAME_RE, type PackDiagnosis, type PackEntry, type PackPath, type PackRef, type PackRequirement, PackRequirementSchema, type PackScope, type PackSelection, PackSelectionSchema, type ParallelBranch, ParallelBranchSchema, type ParameterFact, type ParentExcerpt, ParentExcerptSchema, type ParsedMemberSource, type PartOf, PartOfSchema, type PathsConfig, PathsConfigSchema, type PatternRef, PatternRefSchema, type PinnedExternal, type PinnedParent, type PortalAuth, PortalAuthSchema, type PortalAuthScheme, PortalAuthSchemeSchema, type PortalMount, PortalMountSchema, type PortalType, PortalTypeSchema, PreviousIdsSchema, PreviousNamesSchema, ProfileSelectionSubjectSchema, type ProjectBinding, type ProjectBindingVia, type ProjectConfig, ProjectConfigSchema, type ProjectFamily, type ProjectFamilyProblem, type ProjectIdOrigin, type ProjectIdSource, type ProjectIdentity, type ProjectIdentityProblem, type ProjectImport, type ProjectNode, ProjectNotInitializedError, type ProjectProfileSelection, ProjectProfileSelectionSchema, type ProjectRelations, type PromoteResult, type PublicInterface, PublicInterfaceSchema, type PublicInterfaceType, PublicInterfaceTypeSchema, RETIRED_STEREOTYPES, type ReadExternalSource, type ReadableProject, type RealizationIndex, type ReexportBindingFact, type ReferenceBinding, type ReferenceEdit, type ReferenceForm, type ReferenceLanding, type ReferenceResolution, type Registry, RegistrySchema, type RelationHealth, type RenameTraceHolders, type RequirementItem, RequirementItemSchema, type ResolutionOutcome, type ResolvedBody, type ResolvedDetail, type ResolvedExport, type ResolvedExportTable, type ResolvedExternal, ResolvedInterfaceSpecSchema, type ResolvedMethod, ResolvedMethodSignatureSchema, ResolvedTypeMethodSchema, ResolvedTypeSpecSchema, type RouteFact, type RuleCode, type RuleContext, type RuleJudgement, type RuleScope, type RulesConfig, RulesConfigSchema, SCAN_EXCLUDE_DIRS, SDD_RULES, SEMANTIC_GUARANTEES, STEP_COMMON_FIELDS, STEP_LABEL_TWINS, STEP_TYPE_FIELDS, SUPPORTED_ALIASES, SURFACE_AUDIENCES, type ScopeFilterOptions, type SddRule, type Severity, type ShapeMemberFact, type ShapeOrigin, type SignatureFacts, type SignatureResolution, type SignatureSourceFact, type SignatureTextRepair, type SourceFileFacts, type SourceFileStatus, type SpecId, type SpecIdKind, SpecIdSchema, type SpecIndex, type SpecScanOptions, type SpecStatus, SpecStatusSchema, type SpecialistRetirement, type SpecialistRetype, type StaleSignatureText, type StateId, type StatusDecor, type StatusOptions, type StatusReport, type StepConfigCode, type StepConfigProblem, type StepConfigVerdict, type StepGraph, type StoredInterfaceSpec, type StoredMethodSignature, StoredMethodSignatureSchema, type StoredTypeMethod, StoredTypeMethodSchema, type StoredTypeSpec, type SubsystemSpec, SubsystemSpecSchema, type SubsystemWriteRule, type SupportedAlias, type SurfaceAudience, SurfaceAudienceSchema, type SurfaceContractEntry, SurfaceContractEntrySchema, type SurfaceOrigin, SurfaceOriginSchema, type SurfaceRefResolution, type SurfaceSnapshot, SurfaceSnapshotSchema, type SurfaceTypeDef, SurfaceTypeDefSchema, type SurfaceTypeExport, SurfaceTypeExportSchema, type SwitchCase, SwitchCaseSchema, type SyncResult, type SystemPublicInterface, SystemPublicInterfaceSchema, type SystemSpec, SystemSpecSchema, type TargetConfig, TargetConfigSchema, type Technology, TechnologySchema, type Template, TemplateNotFoundError, TemplateSchema, type TopologyConfig, TopologyConfigSchema, type Transport, TransportSchema, type TreeExportResult, type TreeImportOptions, type TreeImportResult, type TrustedLink, TrustedLinkSchema, type TypeCanonicalization, type TypeDialect, type TypeEnumProposal, type TypeExpression, type TypeExpressionProblem, TypeExpressionSchema, type TypeField, TypeFieldSchema, type TypeForm, type TypeKind, TypeKindSchema, type TypeMethod, TypeMethodSchema, type TypeParse, type TypePosition, type TypeProblemCode, type TypeRename, type TypeRespelling, type TypeShapeFact, type TypeSpec, TypeSpecSchema, type TypeSpellingFacts, type TypeSpellingRepair, type TypedSpecKind, USE_ENTRY_RE, WAIRON_MANAGED_BANNER, WAIRON_MANAGED_MARKER, WAIRON_VERSION, type WaiPaths, WaironError, type WriteReach, activeTargetTypes, addDomain, admits, advanceMember, aiDir, aiDirAt, aiPathsAt, aliasTargetOf, ambiguityMessage, approvalKeyIn, approvalRecord, approvalVerdict, assertContainedProjectPath, assertProjectInitialized, backendCommand, backfillChainedSubprojectConfigs, backupBeside, bodySitesOf, buildCanvasDataModel, buildProjectGraph, buildRuleContext, builtinProfileIds, builtinProjectKinds, callSitesOf, canonicalTypeRef, canonicalTypeText, captureApprovedSpecs, checkDeclarativePack, clearLoaderIssues, cognitiveScore, complexityLevel, componentDesignView, composeAgentBrief, composeRuleSequence, computeGateStateId, computeOwnDesignStateId as computeOwnDesignId, computeOwnStateId, computeStateId, computeStateIdAt, conceptNoun, consumedContractInputs, containedPathOf, contentDigest, createAgentRecord, createEmptyRegistry, createEmptyTopologyConfig, createMember, createProjectConfig, currentRootBinding, declareExternal, declareMember, declaredExternals, declaredMembers, declaredPackNames, declaredProfileIds, declares, declaresGlobalPacks, defaultConformanceTier, defaultNarrativeDetail, defaultPackSelections, defaultTargetConfig, deleteSpec, demoteMember, dependencyCycles, deregisterPackRef, deriveExecutionProfile, deriveMethodSignature, deriveTypeSignature, derivedDocPaths, describeProject, detectDomainCandidates, diagnoseProjectPacks, diagramSetIndex, dialectOf, diffAgainstApproval, diffSize, discoverPacks, dryRunSerializeSpecs, effectiveDetail, effectiveProjectId, emptyExtensions, emptyTypeSpellingFacts, ensureDir, ensureProjectInitialized, excerpt as excerptParent, exportDesign, exportSpecTree, exportSurface, exportTargetKey, exportUsage, externalizeSubsystem, extractTypeIdentifiers, factsFor, familyApprovals, familyNode, familyRelations, fieldTypeRefs, fieldTypesOf, findChainingParent, findChainingSubprojectsMissingConfig, findLegacySpecFiles, findProjectRoot, findSystemRoot, findTestsReferencing, fromProjectRoot, generateAgent, generateAll, generateComponentDiagram, generateDiagramSet, generateSequenceDiagram, getExporter, getExternalsStatus, getHostedLookup, getLoaderIssues, getProjectRoot, getProjectRootOverride, getRequestParentReach, getRequestProjectRoot, getSnapshot, getStatusReport, getWriteReach, globalGuideFilePath, globalPacksDir, globalPacksEnabled, globalTemplatesDir, hasContext, hasFunctionBody, headNoun, holdsState, implementationDesignView, implementationSourceFiles, importBindingOf, importNames, importSpecTree, importSurface, injectGuide, installPackFromDirectory, interfaceCanonicalTypes, interfaceGenericParameters, internalizeMember, isDraftSubsystem, isLogic, isOutsideRoot, isOwnComponentEntry, isPart, isPattern, isProjectInitialized, isProvidedBy, isRetired, isTypeVocabulary, judgesCode, keyIn, landReference, languageOfSourcePath, lineEndingFor, listDirectChainedSubprojects, listExternals, listFiles, listFilesRecursive, listInstalledPacks, listPinnedExternals, listRules, listSnapshots, loadComponentSpec, loadComponentSpecs, loadExtensionPacks, loadExtensions, loadFor as loadExtensionsFor, loadImplementationSpec, loadImplementationSpecs, loadInterfaceSpec, loadInterfaceSpecs, loadProjectConfig, loadProjectExtensions, loadProjectVariants, loadRegistry, loadSpec, loadSpecGraph, loadSubsystemSpec, loadSubsystemSpecs, loadSystemSpec, loadTopologyConfig, loadTypeSpec, loadTypeSpecs, localApprover, localGuideFilePath, localTypesOf, logger, makeScopeFilter, markSelectionsBundled, matchTypeRef, measurePackDoctrine, measurePackImpact, memberDeclarationOf, memberDigest, memberLocationOf, memberTypesOf, methodGenericParameters, methodSourceFile, methodTypeRefs, moveMember, moveMethods, moveMountToMembers, nameKey, namesAnInteger, narrativeStepForeignFields, normalizeReferences, ownerOf, packDirEntry, packEntryLabel, packEntryRef, manifestOf as packManifest, packStoreDir, parseDeclarativePack, parseDeclaredCall, parseMemberSource, parseTypeExpression, parseTypePosition, parseYaml, passesIntentFloor, pathExists, pathKey, pinExternals, pinInstalledPacksAsSelections, pinnedParent, producerOf, projectConfigExists, graph as projectFamily, projectIdentity, promoteMember, provisionProject, qualifiedTypeId, rangeProblem, readCodeAnnotation, readExternalSource, readFileOrNull, readJsonFile, readLockRecord, readLockState, readStampVersion, readYamlFile, recordProfileSelection, reexpress, registerExporter, registerPackRef, reinjectLocalGuides, relationHealth, removeDomain, removeExternal, removeMember, removePackSelection, removeSnapshot, renameAlias, renameComponent, renameProjectId as renameId, renameMethod, renameType, renderDiagram, repairForeignStepFields, repairSignatures, repairTypeSpellings, repointExternal, requiredPolicies, resolveAgentTopology, resolveBudget, resolveChainingParent, resolveDomains, resolveExpectedOutputPaths, resolveDeclared as resolveExternals, resolveImport, resolveInstalledPack, resolveProjectBinding, resolveProjectExports, resolveSignatures, resolveSubprojectForNamespace, resolveSubsystemExports, resolveVariantGuidance, retireSpecialists, returnTypeOf, rewriteReferences, runWithHostedLookup, runWithProjectBinding, runWithProjectRoot, sameContract, saveSpec, saveTopologyConfig, scanAllSpecs, schemaFingerprint, selectsFamily, serializeYaml, setExecutionTier, setProjectId as setId, setLogLevel, setProjectRoot, setProjectType, settledSpecPaths, signatureFacts, signatureTypeRefs, specIndexRetiredBy, specPathsInScope, splitNamespace, stepConfigVerdict, stepFieldsFor, stepGraph, storedMethodSignature, storedTypeMethod, syncContextFiles, technologyName, technologyTokens, toMarkdown, typeBindingOf, typeCanonicalTypes, typeDesignView, typeDialectFor, typeGenericParameters, typeIsMany, typeMatchesRef, typeNamedRefs, typeProblemEnumProposal, typeProblemIntProposal, typeSourceFiles, typeSpellingFacts, uninstallPack, updateMember, updateSpec, upsertPackSelection, validateAsComplete, validateComponentCandidate, validateFamily, validateProject, validateProjectConfig, validateRegistry, withLineEndings, withPack, writeFile, writeFileIfChanged, writeJsonFile, writeLockRecord, writeReachDenials, writeReachPermits, writeRootGuideDelegator, writeYamlFile, writtenTypeRefs };