@astrale-os/sdk 0.5.0-beta.65 → 0.5.0-beta.66

package/CHANGELOG.md

@@ -1,5 +1,12 @@
 # Changelog
 
+## [0.5.0-beta.66](https://github.com/astrale-os/sdk/compare/sdk-v0.5.0-beta.65...sdk-v0.5.0-beta.66) (2026-08-27)
+
+
+### Features
+
+* **state:** use machine transition authority ([#301](https://github.com/astrale-os/sdk/issues/301)) ([6424217](https://github.com/astrale-os/sdk/commit/642421784d391863d33e90e85c0a1c11b1a6ed7b))
+
 ## [0.5.0-beta.65](https://github.com/astrale-os/sdk/compare/sdk-v0.5.0-beta.64...sdk-v0.5.0-beta.65) (2026-08-27)
 
 

package/dist/application/mutation/authoring/builder.d.ts

@@ -29,8 +29,8 @@ export interface RichMutationBuilder {
         readonly class: Class;
         readonly props: RichPropertyDelta<Class>;
     }): this;
-    transition<Machine extends StateMachine, Class extends ResolvedClass<'node'>, Property extends LifecyclePropertyName<Class, Machine>>(input: {
-        readonly lifecycle: Machine;
+    transition<Machine extends StateMachine, Class extends ResolvedClass<'node'>, Property extends StateMachinePropertyName<Class, Machine>>(input: {
+        readonly machine: Machine;
         readonly node: ExistingEndpoint;
         readonly class: Class;
         readonly property: Property;
@@ -60,8 +60,8 @@ export interface EdgeSelector<Class extends ResolvedClass<'edge'>> {
     readonly class: Class;
 }
 export declare function richMutationBuilder(core: MutationBuilder): RichMutationBuilder;
-type LifecyclePropertyName<Class extends ResolvedClass<'node'>, Machine extends StateMachine> = {
-    [Name in RichPropertyName<Class>]: IsExact<Exclude<RichPropertyInput<Class>[Name], undefined>, StateOf<Machine>> extends true ? Name : never;
+type StateMachinePropertyName<Class extends ResolvedClass<'node'>, Machine extends StateMachine> = {
+    [Name in RichPropertyName<Class>]: string extends StateOf<Machine> ? never : IsExact<Exclude<RichPropertyInput<Class>[Name], undefined>, StateOf<Machine>> extends true ? Name : never;
 }[RichPropertyName<Class>];
 type AllowedTransitionDecision<Machine extends StateMachine> = Readonly<{
     kind: 'allowed';

package/dist/application/mutation/authoring/builder.js

@@ -48,19 +48,30 @@ export function richMutationBuilder(core) {
         },
         transition(input) {
             const submitted = input.decision;
-            if (submitted.kind !== 'allowed' ||
-                submitted.transition === undefined ||
-                submitted.transition === null ||
-                typeof submitted.transition !== 'object' ||
-                typeof submitted.transition.from !== 'string' ||
-                typeof submitted.transition.event !== 'string' ||
-                typeof submitted.transition.to !== 'string') {
-                throw new TypeError('Lifecycle transition decision must be allowed.');
+            const kind = submitted.kind;
+            const rawTransition = submitted.transition;
+            if (kind !== 'allowed' ||
+                rawTransition === undefined ||
+                rawTransition === null ||
+                typeof rawTransition !== 'object') {
+                throw new TypeError('StateMachine transition decision must be allowed.');
             }
-            const transition = submitted.transition;
+            const fromState = rawTransition.from;
+            const event = rawTransition.event;
+            const toState = rawTransition.to;
+            if (typeof fromState !== 'string' ||
+                typeof event !== 'string' ||
+                typeof toState !== 'string') {
+                throw new TypeError('StateMachine transition decision must be allowed.');
+            }
+            const transition = Object.freeze({
+                from: fromState,
+                event: event,
+                to: toState,
+            });
             let decision;
             try {
-                decision = input.lifecycle.decide(transition.from, transition.event);
+                decision = input.machine.decide(transition.from, transition.event);
             }
             catch {
                 invalidTransition(transition);
@@ -71,7 +82,7 @@ export function richMutationBuilder(core) {
             const selected = resolvedProperty(input.class, input.property);
             for (const state of [transition.from, transition.to]) {
                 if (selected.validate(state).length > 0) {
-                    throw new TypeError(`Lifecycle property ${String(input.property)} does not admit state ${state}.`);
+                    throw new TypeError(`StateMachine-backed property ${String(input.property)} does not admit state ${state}.`);
                 }
             }
             const from = { [input.property]: transition.from };
@@ -81,7 +92,7 @@ export function richMutationBuilder(core) {
                 Object.hasOwn(suppliedEquals, input.property) &&
                 suppliedEquals[input.property] !== transition.from) ||
                 input.props?.absent?.includes(input.property) === true) {
-                throw new TypeError(`Lifecycle transition conditions conflict with property ${String(input.property)}.`);
+                throw new TypeError(`StateMachine transition conditions conflict with property ${String(input.property)}.`);
             }
             core.expect.node({
                 node: existingEndpoint(input.node),
@@ -148,5 +159,5 @@ function classKey(selected) {
     return ClassKey(selected.key);
 }
 function invalidTransition(transition) {
-    throw new TypeError(`Lifecycle transition witness is not legal: ${transition.from} + ${transition.event} -> ${transition.to}.`);
+    throw new TypeError(`StateMachine transition decision is not legal: ${transition.from} + ${transition.event} -> ${transition.to}.`);
 }

package/dist/tooling/linter/implementations/source/mutations.js

@@ -1,16 +1,16 @@
 import ts from 'typescript';
 import { importedSymbol, propertyChain, staticText, unwrap, visit, } from '../../adapters/typescript/index.js';
-import { lifecycleIdentity, stateSchemaIdentity } from './lifecycle.js';
 import { ambiguity, callback, DSL_MODULES, definitionOriginAmbiguity, definitionObjects, domainProjectorEvidence, forbiddenIoImport, hasForbiddenGlobalCall, production, violation, } from './shared.js';
+import { stateMachineIdentity, stateSchemaIdentity } from './state-machine.js';
 const FORBIDDEN_LAYERS = new Set(['integrations', 'actions', 'providers', 'queries', 'workflows']);
 const FORBIDDEN_CALLS = new Set(['invoke', 'query', 'retry', 'run', 'submit']);
 export const mutationRules = [
     {
         id: 'MUT-STATE-INITIAL',
-        ruleRevision: '0a28cb9b7aad0258e6b5b19962f420a81d04e5a7443d37c1e8182e98fde39d60',
+        ruleRevision: 'd88f178994e9ad56d14f50ad5ffdff398413e42a690985c5ddc669c0f293d9bb',
         evaluate(project) {
             const evidence = [];
-            const lifecycleProperties = lifecyclePropertiesByClass(project);
+            const machineProperties = machinePropertiesByClass(project);
             for (const file of production(project, 'mutations')) {
                 const builderScopes = mutationBuilderScopes(file);
                 visit(file.source, (node) => {
@@ -20,12 +20,12 @@ export const mutationRules = [
                     }
                     const input = staticObject(node.arguments[0]);
                     if (!input) {
-                        if (hasLifecycleCandidates(lifecycleProperties)) {
-                            evidence.push(ambiguity(file, node, 'Mutation createNode input is dynamic, so lifecycle initialization cannot be proven.'));
+                        if (hasMachineCandidates(machineProperties)) {
+                            evidence.push(ambiguity(file, node, 'Mutation createNode input is dynamic, so machine-state initialization cannot be proven.'));
                         }
                         return;
                     }
-                    const selectedClass = propertiesForClass(input, lifecycleProperties);
+                    const selectedClass = propertiesForClass(input, machineProperties);
                     if (selectedClass.kind === 'ambiguous') {
                         evidence.push(ambiguity(file, assignedValue(input, 'class') ?? input, 'Mutation createNode Class has no statically resolvable Schema owner.'));
                         return;
@@ -37,39 +37,40 @@ export const mutationRules = [
                     const props = staticObject(propsValue);
                     if (!props) {
                         evidence.push(propsValue === undefined
-                            ? violation(file, input, 'Mutation creates a lifecycle-backed node without its initial state.')
-                            : ambiguity(file, propsValue, 'Mutation createNode properties are dynamic, so lifecycle initialization cannot be proven.'));
+                            ? violation(file, input, 'Mutation creates a StateMachine-backed node without its initial state.')
+                            : ambiguity(file, propsValue, 'Mutation createNode properties are dynamic, so machine-state initialization cannot be proven.'));
                         return;
                     }
-                    const assignments = lifecycleAssignments(props, selected);
+                    const assignments = machineAssignments(props, selected);
                     const uncertain = [...selected.keys()].filter((name) => spreadMaySet(props, name));
                     if (uncertain.length > 0) {
-                        evidence.push(ambiguity(file, props, `Mutation createNode properties contain a spread that may determine lifecycle ${uncertain.join(', ')}.`));
+                        evidence.push(ambiguity(file, props, `Mutation createNode properties contain a spread that may determine machine-backed ${uncertain.join(', ')}.`));
                     }
                     for (const name of selected.keys()) {
                         if (assignments.some((property) => staticPropertyName(property) === name))
                             continue;
                         if (uncertain.includes(name))
                             continue;
-                        evidence.push(violation(file, props, `Mutation creates a lifecycle-backed node without initial property ${name}.`));
+                        evidence.push(violation(file, props, `Mutation creates a StateMachine-backed node without initial property ${name}.`));
                     }
                     for (const property of assignments) {
                         const name = staticPropertyName(property) ?? '<dynamic>';
                         if (uncertain.includes(name))
                             continue;
                         const expectedIdentity = selected.get(name);
-                        const initial = initialIdentity(project, file, property.initializer);
+                        const value = assignedPropertyValue(property);
+                        const initial = initialIdentity(project, file, value);
                         if (initial.kind === 'resolved' && initial.identity === expectedIdentity)
                             continue;
                         if (initial.kind === 'resolved') {
-                            evidence.push(violation(file, property.initializer, `Mutation initializes lifecycle property ${name} from a different StateMachine authority.`));
+                            evidence.push(violation(file, value, `Mutation initializes machine-backed property ${name} from a different StateMachine authority.`));
                             continue;
                         }
-                        if (staticText(property.initializer) !== undefined) {
-                            evidence.push(violation(file, property.initializer, `Mutation initializes lifecycle property ${name} with a copied state instead of machine.initial.`));
+                        if (staticText(value) !== undefined) {
+                            evidence.push(violation(file, value, `Mutation initializes machine-backed property ${name} with a copied state instead of machine.initial.`));
                         }
                         else {
-                            evidence.push(ambiguity(file, property.initializer, `Mutation lifecycle initializer for ${name} has no resolvable machine.initial source.`));
+                            evidence.push(ambiguity(file, value, `Mutation StateMachine initializer for ${name} has no resolvable machine.initial source.`));
                         }
                     }
                 });
@@ -79,10 +80,10 @@ export const mutationRules = [
     },
     {
         id: 'MUT-STATE-ATOMIC',
-        ruleRevision: '5cbcc25bbc294f48136dda89ae01d5aff62f98d76c92a8f38ecb51d75621bed1',
+        ruleRevision: '0df23be62b6455c45e8cd8a1082c646ab13a786b773326e4276943e017e711fb',
         evaluate(project) {
             const evidence = [];
-            const lifecycleProperties = lifecyclePropertiesByClass(project);
+            const machineProperties = machinePropertiesByClass(project);
             for (const file of production(project, 'mutations')) {
                 const builderScopes = mutationBuilderScopes(file);
                 visit(file.source, (node) => {
@@ -92,14 +93,14 @@ export const mutationRules = [
                     if (member === undefined)
                         return;
                     if (member === 'updateNode') {
-                        if (!hasLifecycleCandidates(lifecycleProperties))
+                        if (!hasMachineCandidates(machineProperties))
                             return;
                         const input = staticObject(node.arguments[0]);
                         if (!input) {
-                            evidence.push(ambiguity(file, node, 'Mutation updateNode input is dynamic and may bypass a lifecycle transition.'));
+                            evidence.push(ambiguity(file, node, 'Mutation updateNode input is dynamic and may bypass a StateMachine transition.'));
                             return;
                         }
-                        const selectedClass = propertiesForClass(input, lifecycleProperties);
+                        const selectedClass = propertiesForClass(input, machineProperties);
                         if (selectedClass.kind === 'ambiguous') {
                             evidence.push(ambiguity(file, assignedValue(input, 'class') ?? input, 'Mutation updateNode Class has no statically resolvable Schema owner.'));
                             return;
@@ -110,84 +111,90 @@ export const mutationRules = [
                         const propsValue = assignedValue(input, 'props');
                         const props = staticObject(propsValue);
                         if (!props) {
-                            evidence.push(ambiguity(file, propsValue ?? input, 'Mutation updateNode properties are dynamic and may bypass a lifecycle transition.'));
+                            evidence.push(ambiguity(file, propsValue ?? input, 'Mutation updateNode properties are dynamic and may bypass a StateMachine transition.'));
                             return;
                         }
                         if (hasSpread(props)) {
-                            evidence.push(ambiguity(file, props, 'Mutation updateNode properties contain a spread that may bypass a lifecycle transition.'));
+                            evidence.push(ambiguity(file, props, 'Mutation updateNode properties contain a spread that may bypass a StateMachine transition.'));
                         }
                         const setValue = assignedValue(props, 'set');
                         const set = staticObject(setValue);
                         if (setValue !== undefined && !set) {
-                            evidence.push(ambiguity(file, setValue, 'Mutation updateNode set patch is dynamic and may bypass a lifecycle transition.'));
+                            evidence.push(ambiguity(file, setValue, 'Mutation updateNode set patch is dynamic and may bypass a StateMachine transition.'));
                         }
                         if (set && hasSpread(set)) {
-                            evidence.push(ambiguity(file, set, 'Mutation updateNode set patch contains a spread that may bypass a lifecycle transition.'));
+                            evidence.push(ambiguity(file, set, 'Mutation updateNode set patch contains a spread that may bypass a StateMachine transition.'));
                         }
-                        for (const property of set ? lifecycleAssignments(set, selected) : []) {
-                            evidence.push(violation(file, property, `Mutation writes lifecycle property ${String(staticPropertyName(property))} through updateNode; use transition for one atomic compare-and-set.`));
+                        for (const property of set ? machineAssignments(set, selected) : []) {
+                            evidence.push(violation(file, property, `Mutation writes machine-backed property ${String(staticPropertyName(property))} through updateNode; use transition for one atomic compare-and-set.`));
                         }
                         const unsetValue = assignedValue(props, 'unset');
                         const unset = unsetValue && staticStringArray(unsetValue);
                         if (unsetValue !== undefined && unset === undefined) {
-                            evidence.push(ambiguity(file, unsetValue, 'Mutation updateNode unset patch is dynamic and may bypass a lifecycle transition.'));
+                            evidence.push(ambiguity(file, unsetValue, 'Mutation updateNode unset patch is dynamic and may bypass a StateMachine transition.'));
                         }
                         else {
                             for (const property of unset ?? []) {
                                 if (!selected.has(property.value))
                                     continue;
-                                evidence.push(violation(file, property.node, `Mutation unsets lifecycle property ${property.value} through updateNode; lifecycle changes require transition.`));
+                                evidence.push(violation(file, property.node, `Mutation unsets machine-backed property ${property.value} through updateNode; StateMachine changes require transition.`));
                             }
                         }
                     }
                     if (member !== 'transition')
                         return;
-                    if (!hasLifecycleCandidates(lifecycleProperties))
+                    if (!hasMachineCandidates(machineProperties))
                         return;
                     const input = staticObject(node.arguments[0]);
                     if (!input) {
-                        evidence.push(ambiguity(file, node, 'Lifecycle transition input is not one static object.'));
+                        evidence.push(ambiguity(file, node, 'StateMachine transition input is not one static object.'));
                         return;
                     }
                     if (assignedValue(input, 'to') !== undefined ||
                         assignedValue(input, 'event') !== undefined ||
                         assignedValue(input, 'transition') !== undefined ||
                         assignedValue(input, 'witness') !== undefined) {
-                        evidence.push(violation(file, input, 'Lifecycle transition accepts one allowed decision, not a target, event, transition, or witness field.'));
+                        evidence.push(violation(file, input, 'StateMachine transition accepts one allowed decision, not a target, event, transition, or witness field.'));
                     }
                     const spread = hasSpread(input);
                     if (spread) {
-                        evidence.push(ambiguity(file, input, 'Lifecycle transition input contains a spread that may override or add governed fields.'));
+                        evidence.push(ambiguity(file, input, 'StateMachine transition input contains a spread that may override or add governed fields.'));
                     }
                     if (assignedValue(input, 'decision') === undefined) {
                         if (!spread) {
-                            evidence.push(violation(file, input, 'Lifecycle transition has no allowed decision.'));
+                            evidence.push(violation(file, input, 'StateMachine transition has no allowed decision.'));
                         }
                     }
-                    const selectedClass = propertiesForClass(input, lifecycleProperties);
+                    const selectedClass = propertiesForClass(input, machineProperties);
                     if (selectedClass.kind === 'ambiguous') {
-                        evidence.push(ambiguity(file, assignedValue(input, 'class') ?? input, 'Lifecycle transition Class has no statically resolvable Schema owner.'));
+                        evidence.push(ambiguity(file, assignedValue(input, 'class') ?? input, 'StateMachine transition Class has no statically resolvable Schema owner.'));
                     }
                     const property = staticTextValue(assignedValue(input, 'property'));
                     if (property === undefined) {
-                        evidence.push(ambiguity(file, assignedValue(input, 'property') ?? input, 'Lifecycle transition property is not static text.'));
+                        evidence.push(ambiguity(file, assignedValue(input, 'property') ?? input, 'StateMachine transition property is not static text.'));
                     }
                     else if (selectedClass.kind === 'absent' ||
                         (selectedClass.kind === 'resolved' && !selectedClass.properties.has(property))) {
-                        evidence.push(violation(file, assignedValue(input, 'property') ?? input, `Lifecycle transition property ${property} is not a lifecycle Property of the selected Class.`));
+                        evidence.push(violation(file, assignedValue(input, 'property') ?? input, `StateMachine transition property ${property} is not a machine-backed Property of the selected Class.`));
                     }
-                    const lifecycle = assignedValue(input, 'lifecycle');
-                    const machine = lifecycle === undefined
+                    const legacyLifecycle = assignedValue(input, 'lifecycle');
+                    if (legacyLifecycle !== undefined) {
+                        evidence.push(violation(file, legacyLifecycle, 'StateMachine transition uses removed lifecycle field; use machine.'));
+                    }
+                    const machineInput = assignedValue(input, 'machine');
+                    const machine = machineInput === undefined
                         ? { kind: 'absent' }
-                        : lifecycleIdentity(project, file, lifecycle);
+                        : stateMachineIdentity(project, file, machineInput);
                     if (machine.kind !== 'resolved') {
-                        evidence.push(ambiguity(file, lifecycle ?? input, 'Lifecycle transition machine has no resolvable canonical States source.'));
+                        if (legacyLifecycle === undefined) {
+                            evidence.push(ambiguity(file, machineInput ?? input, 'StateMachine transition machine has no resolvable canonical States source.'));
+                        }
                     }
                     else if (property !== undefined &&
                         selectedClass.kind === 'resolved' &&
                         selectedClass.properties.get(property) !== undefined &&
                         selectedClass.properties.get(property) !== machine.identity) {
-                        evidence.push(violation(file, lifecycle ?? input, `Lifecycle transition uses a different StateMachine authority than property ${property}.`));
+                        evidence.push(violation(file, machineInput ?? input, `StateMachine transition uses a different authority than property ${property}.`));
                     }
                 });
             }
@@ -339,9 +346,12 @@ export const mutationRules = [
         },
     },
 ];
-function lifecycleAssignments(object, lifecycleProperties) {
-    return object.properties.filter((property) => ts.isPropertyAssignment(property) &&
-        lifecycleProperties.has(staticPropertyName(property) ?? ''));
+function machineAssignments(object, machineProperties) {
+    return object.properties.filter((property) => (ts.isPropertyAssignment(property) || ts.isShorthandPropertyAssignment(property)) &&
+        machineProperties.has(staticPropertyName(property) ?? ''));
+}
+function assignedPropertyValue(property) {
+    return ts.isPropertyAssignment(property) ? property.initializer : property.name;
 }
 function hasSpread(object) {
     return object.properties.some((property) => ts.isSpreadAssignment(property));
@@ -372,13 +382,13 @@ function staticStringArray(expression) {
 function mutationBuilderScopes(file) {
     const mutable = new Map();
     const pending = [];
-    const add = (fn, name) => {
-        const names = mutable.get(fn) ?? new Set();
-        if (names.has(name))
+    const add = (fn, binding) => {
+        const bindings = mutable.get(fn) ?? new Set();
+        if (bindings.has(binding))
             return;
-        names.add(name);
-        mutable.set(fn, names);
-        pending.push([fn, name]);
+        bindings.add(binding);
+        mutable.set(fn, bindings);
+        pending.push([fn, binding]);
     };
     for (const definition of definitionObjects(file, 'defineMutation')) {
         if (definition.origin !== 'resolved')
@@ -386,7 +396,7 @@ function mutationBuilderScopes(file) {
         const build = definition.object && callback(definition.object, 'build');
         const builder = build?.parameters[1]?.name;
         if (build && builder && ts.isIdentifier(builder))
-            add(build, builder.text);
+            add(build, builder);
     }
     const richBuilderTypes = new Set();
     for (const sourceImport of file.imports) {
@@ -408,7 +418,7 @@ function mutationBuilderScopes(file) {
                 ts.isTypeReferenceNode(parameter.type) &&
                 ts.isIdentifier(parameter.type.typeName) &&
                 richBuilderTypes.has(parameter.type.typeName.text)) {
-                add(node, parameter.name.text);
+                add(node, parameter.name);
             }
         }
     });
@@ -416,22 +426,31 @@ function mutationBuilderScopes(file) {
     for (let index = 0; index < pending.length; index += 1) {
         const [owner, builder] = pending[index];
         visitOwnBody(owner, (node) => {
+            if (ts.isVariableDeclaration(node) &&
+                ts.isIdentifier(node.name) &&
+                node.initializer !== undefined &&
+                ts.isIdentifier(unwrap(node.initializer)) &&
+                identifierDeclaration(unwrap(node.initializer)) === builder &&
+                (node.parent.flags & ts.NodeFlags.Const) !== 0) {
+                add(owner, node.name);
+            }
             if (!ts.isCallExpression(node))
                 return;
             const callee = unwrap(node.expression);
             if (!ts.isIdentifier(callee))
                 return;
-            const target = localFunctions.get(callee.text);
+            const declaration = identifierDeclaration(callee);
+            const target = declaration && localFunctions.get(declaration);
             if (!target)
                 return;
             for (let argumentIndex = 0; argumentIndex < node.arguments.length; argumentIndex += 1) {
                 const argument = unwrap(node.arguments[argumentIndex]);
                 const parameter = target.parameters[argumentIndex]?.name;
                 if (ts.isIdentifier(argument) &&
-                    argument.text === builder &&
+                    identifierDeclaration(argument) === builder &&
                     parameter &&
                     ts.isIdentifier(parameter)) {
-                    add(target, parameter.text);
+                    add(target, parameter);
                 }
             }
         });
@@ -446,64 +465,111 @@ function mutationBuilderMember(call, scopes) {
     const expression = unwrap(call.expression);
     if (ts.isPropertyAccessExpression(expression)) {
         const receiver = unwrap(expression.expression);
-        return ts.isIdentifier(receiver) && builders.has(receiver.text)
+        return ts.isIdentifier(receiver) && builders.has(identifierDeclaration(receiver))
             ? expression.name.text
             : undefined;
     }
     if (ts.isElementAccessExpression(expression)) {
         const receiver = unwrap(expression.expression);
-        return ts.isIdentifier(receiver) && builders.has(receiver.text)
+        return ts.isIdentifier(receiver) && builders.has(identifierDeclaration(receiver))
             ? staticText(expression.argumentExpression)
             : undefined;
     }
     if (!ts.isIdentifier(expression))
         return undefined;
-    return destructuredBuilderMember(owner, expression, builders);
+    return destructuredBuilderMember(expression, builders);
 }
-function destructuredBuilderMember(owner, callee, builders) {
-    if (!owner.body || !ts.isBlock(owner.body))
+function destructuredBuilderMember(callee, builders) {
+    const calleeBinding = identifierDeclaration(callee);
+    const element = calleeBinding?.parent;
+    if (!element ||
+        !ts.isBindingElement(element) ||
+        element.dotDotDotToken !== undefined ||
+        element.name !== calleeBinding ||
+        !ts.isObjectBindingPattern(element.parent)) {
         return undefined;
-    for (const statement of owner.body.statements) {
-        if (statement.getStart() >= callee.getStart())
-            break;
-        if (!ts.isVariableStatement(statement))
-            continue;
-        for (const declaration of statement.declarationList.declarations) {
-            const initializer = declaration.initializer && unwrap(declaration.initializer);
-            if (!initializer || !ts.isIdentifier(initializer) || !builders.has(initializer.text))
-                continue;
-            if (!ts.isObjectBindingPattern(declaration.name))
-                continue;
-            for (const element of declaration.name.elements) {
-                if (!ts.isIdentifier(element.name) || element.name.text !== callee.text)
-                    continue;
-                const member = element.propertyName ?? element.name;
-                if (ts.isIdentifier(member) || ts.isStringLiteral(member))
-                    return member.text;
+    }
+    const declaration = element.parent.parent;
+    if (!ts.isVariableDeclaration(declaration))
+        return undefined;
+    const initializer = declaration.initializer && unwrap(declaration.initializer);
+    if (!initializer ||
+        !ts.isIdentifier(initializer) ||
+        !builders.has(identifierDeclaration(initializer))) {
+        return undefined;
+    }
+    const member = element.propertyName ?? element.name;
+    return ts.isIdentifier(member) || ts.isStringLiteral(member) ? member.text : undefined;
+}
+function localFunctionBindings(file) {
+    const functions = new Map();
+    const record = (binding, fn) => {
+        functions.set(binding, fn);
+    };
+    visit(file.source, (node) => {
+        if (ts.isFunctionDeclaration(node) && node.name) {
+            record(node.name, node);
+            return;
+        }
+        if (!ts.isVariableDeclaration(node) || !ts.isIdentifier(node.name) || !node.initializer)
+            return;
+        const value = unwrap(node.initializer);
+        if (ts.isArrowFunction(value) || ts.isFunctionExpression(value)) {
+            record(node.name, value);
+        }
+    });
+    return functions;
+}
+function identifierDeclaration(use) {
+    let current = use.parent;
+    while (current !== undefined) {
+        if (ts.isBlock(current) || ts.isSourceFile(current)) {
+            const binding = directBlockBinding(current, use.text);
+            if (binding !== undefined)
+                return binding;
+        }
+        if (ts.isFunctionLike(current)) {
+            for (const parameter of current.parameters) {
+                const binding = bindingIdentifier(parameter.name, use.text);
+                if (binding !== undefined)
+                    return binding;
             }
         }
+        if (ts.isCatchClause(current) && current.variableDeclaration !== undefined) {
+            const binding = bindingIdentifier(current.variableDeclaration.name, use.text);
+            if (binding !== undefined)
+                return binding;
+        }
+        current = current.parent;
     }
     return undefined;
 }
-function localFunctionBindings(file) {
-    const functions = new Map();
-    for (const statement of file.source.statements) {
-        if (ts.isFunctionDeclaration(statement) && statement.name) {
-            functions.set(statement.name.text, statement);
-            continue;
+function directBlockBinding(block, name) {
+    for (const statement of block.statements) {
+        if (ts.isFunctionDeclaration(statement) && statement.name?.text === name) {
+            return statement.name;
         }
         if (!ts.isVariableStatement(statement))
             continue;
         for (const declaration of statement.declarationList.declarations) {
-            if (!ts.isIdentifier(declaration.name) || !declaration.initializer)
-                continue;
-            const value = unwrap(declaration.initializer);
-            if (ts.isArrowFunction(value) || ts.isFunctionExpression(value)) {
-                functions.set(declaration.name.text, value);
-            }
+            const binding = bindingIdentifier(declaration.name, name);
+            if (binding !== undefined)
+                return binding;
         }
     }
-    return functions;
+    return undefined;
+}
+function bindingIdentifier(binding, name) {
+    if (ts.isIdentifier(binding))
+        return binding.text === name ? binding : undefined;
+    for (const element of binding.elements) {
+        if (ts.isOmittedExpression(element))
+            continue;
+        const identifier = bindingIdentifier(element.name, name);
+        if (identifier !== undefined)
+            return identifier;
+    }
+    return undefined;
 }
 function containingFunction(node) {
     let current = node.parent;
@@ -515,7 +581,7 @@ function containingFunction(node) {
     }
     return undefined;
 }
-function lifecyclePropertiesByClass(project) {
+function machinePropertiesByClass(project) {
     const all = new Map();
     const mutableByClass = new Map();
     const ambiguousByClass = new Map();
@@ -588,7 +654,7 @@ function lifecyclePropertiesByClass(project) {
         ambiguousByClass.set(owner, names);
         mutableByClass.delete(owner);
     }
-    inheritLifecycleProperties(project, mutableByClass, ambiguousByClass);
+    inheritMachineProperties(project, mutableByClass, ambiguousByClass);
     for (const file of production(project, 'schema')) {
         for (const definition of definitionObjects(file, 'defineSchema', undefined, DSL_MODULES, 1)) {
             if (definition.origin !== 'resolved')
@@ -640,7 +706,7 @@ function lifecyclePropertiesByClass(project) {
         ambiguousByClass,
     };
 }
-function inheritLifecycleProperties(project, byClass, ambiguousByClass) {
+function inheritMachineProperties(project, byClass, ambiguousByClass) {
     const parents = new Map();
     for (const file of production(project, 'schema')) {
         visit(file.source, (node) => {
@@ -729,7 +795,7 @@ function propertiesForClass(input, properties) {
     const selected = properties.byClass.get(className);
     return selected === undefined ? { kind: 'absent' } : { kind: 'resolved', properties: selected };
 }
-function hasLifecycleCandidates(properties) {
+function hasMachineCandidates(properties) {
     return properties.all.size > 0 || properties.ambiguousByClass.size > 0;
 }
 function isPropertiesMember(node) {
@@ -777,8 +843,13 @@ function staticPropertyName(property) {
 }
 function initialIdentity(project, file, expression, seen = new Set()) {
     const value = unwrap(expression);
-    if (ts.isPropertyAccessExpression(value) && value.name.text === 'initial') {
-        return lifecycleIdentity(project, file, value.expression);
+    const initialOwner = ts.isPropertyAccessExpression(value) && value.name.text === 'initial'
+        ? value.expression
+        : ts.isElementAccessExpression(value) && staticText(value.argumentExpression) === 'initial'
+            ? value.expression
+            : undefined;
+    if (initialOwner !== undefined) {
+        return stateMachineIdentity(project, file, initialOwner);
     }
     if (ts.isIdentifier(value)) {
         if (seen.has(value.text))

package/dist/tooling/linter/implementations/source/schema.js

@@ -1,7 +1,7 @@
 import ts from 'typescript';
 import { importedSymbol, propertyChain, staticText, unwrap, visit, } from '../../adapters/typescript/index.js';
-import { lifecycleOrigin, stateMachineConstructorOrigin, stateSchemaIdentity } from './lifecycle.js';
 import { ambiguity, forbiddenIoImport, production, violation } from './shared.js';
+import { stateMachineConstructorOrigin, stateMachineOrigin, stateSchemaIdentity, } from './state-machine.js';
 const FORBIDDEN_LAYERS = new Set([
     'integrations',
     'actions',
@@ -24,24 +24,24 @@ const EXECUTION_NAMES = new Set([
 export const schemaRules = [
     {
         id: 'SCH-STATE-SOURCE',
-        ruleRevision: '00c1ad27b0fb32a063d66c98dc68c25cdf2b507c2da118ffa3e6651da8889065',
+        ruleRevision: '4f126e23835b6c46dabb94d2c94021ddb992a8e9a295faef4403df74ecfb2a41',
         evaluate(project) {
             const evidence = [];
-            const lifecycleVocabularies = stateVocabularies(project);
+            const machineVocabularies = stateVocabularies(project);
             for (const file of production(project, 'schema')) {
-                const ownedVocabularies = file.submodule === undefined ? undefined : lifecycleVocabularies.get(file.submodule);
+                const ownedVocabularies = file.submodule === undefined ? undefined : machineVocabularies.get(file.submodule);
                 const reportedEnums = new Set();
                 visit(file.source, (node) => {
                     if (ts.isPropertyAssignment(node) && isPropertiesMember(node)) {
                         const codec = stateSchemaIdentity(project, file, node.initializer);
                         if (codec.kind === 'ambiguous') {
-                            evidence.push(ambiguity(file, node.initializer, 'Schema lifecycle Property codec has no exact stateSchema source.'));
+                            evidence.push(ambiguity(file, node.initializer, 'Schema machine-backed Property codec has no exact stateSchema source.'));
                         }
                     }
                     if (ts.isCallExpression(node)) {
                         const machineOrigin = stateMachineConstructorOrigin(file, node.expression);
                         if (machineOrigin === 'resolved') {
-                            evidence.push(violation(file, node, 'Schema declares a stateMachine; move the lifecycle relation to States.'));
+                            evidence.push(violation(file, node, 'Schema declares a stateMachine; move the StateMachine relation to States.'));
                         }
                         else if (machineOrigin === 'ambiguous') {
                             evidence.push(ambiguity(file, node, 'Schema call resembles stateMachine through a local facade, but its SDK origin is unresolved.'));
@@ -51,17 +51,17 @@ export const schemaRules = [
                             ownedVocabularies?.has(vocabularyKey(values)) === true &&
                             !reportedEnums.has(node.pos)) {
                             reportedEnums.add(node.pos);
-                            evidence.push(ambiguity(file, node, 'Schema declares an enum equal to its States lifecycle vocabulary, but copied semantic ownership cannot be proven from literals alone.'));
+                            evidence.push(ambiguity(file, node, 'Schema declares an enum equal to its States machine vocabulary, but copied semantic ownership cannot be proven from literals alone.'));
                         }
                     }
-                    if (ts.isPropertyAccessExpression(node) &&
-                        (node.name.text === 'stateSchema' || node.name.text === 'eventSchema')) {
-                        const origin = lifecycleOrigin(project, file, node.expression);
+                    const projection = stateMachineCodecProjection(node);
+                    if (projection !== undefined) {
+                        const origin = stateMachineOrigin(project, file, projection.owner);
                         if (origin === 'ambiguous') {
-                            evidence.push(ambiguity(file, node, `Schema lifecycle codec ${node.name.text} has an unresolved States export origin.`));
+                            evidence.push(ambiguity(file, node, `Schema StateMachine codec ${projection.name} has an unresolved States export origin.`));
                         }
                         else if (origin === 'absent') {
-                            evidence.push(violation(file, node, `Schema lifecycle codec ${node.name.text} does not originate from an exported stateMachine.`));
+                            evidence.push(violation(file, node, `Schema StateMachine codec ${projection.name} does not originate from an exported stateMachine.`));
                         }
                     }
                 });
@@ -171,6 +171,20 @@ function enumValues(file, call) {
     const values = argument.elements.map((element) => staticText(element));
     return values.every((value) => value !== undefined) ? values : undefined;
 }
+function stateMachineCodecProjection(node) {
+    if (ts.isPropertyAccessExpression(node)) {
+        if (node.name.text === 'stateSchema' || node.name.text === 'eventSchema') {
+            return { owner: node.expression, name: node.name.text };
+        }
+        return undefined;
+    }
+    if (!ts.isElementAccessExpression(node))
+        return undefined;
+    const name = staticText(node.argumentExpression);
+    return name === 'stateSchema' || name === 'eventSchema'
+        ? { owner: node.expression, name }
+        : undefined;
+}
 function isZodCall(file, expression) {
     const chain = propertyChain(expression);
     const root = chain?.[0];

package/dist/tooling/linter/implementations/source/{lifecycle.d.ts → state-machine.d.ts}

@@ -1,7 +1,7 @@
 import ts from 'typescript';
 import type { SourceFile, SourceProject } from '../../adapters/typescript/index.js';
-export type LifecycleOrigin = 'resolved' | 'ambiguous' | 'absent';
-export type LifecycleResolution = Readonly<{
+export type StateMachineOrigin = 'resolved' | 'ambiguous' | 'absent';
+export type StateMachineResolution = Readonly<{
     kind: 'resolved';
     identity: string;
 }> | Readonly<{
@@ -9,12 +9,12 @@ export type LifecycleResolution = Readonly<{
 }>;
 export type MachineExportStatus = 'exported' | 'private' | 'not-a-declaration';
 /** Resolve a direct or static local alias of the SDK stateMachine constructor. */
-export declare function stateMachineConstructorOrigin(file: SourceFile, expression: ts.Expression, seen?: ReadonlySet<string>): LifecycleOrigin;
+export declare function stateMachineConstructorOrigin(file: SourceFile, expression: ts.Expression, seen?: ReadonlySet<string>): StateMachineOrigin;
 /** Resolve one local binding to an exported SDK stateMachine authority. */
-export declare function lifecycleOrigin(project: SourceProject, file: SourceFile, expression: ts.Expression): LifecycleOrigin;
+export declare function stateMachineOrigin(project: SourceProject, file: SourceFile, expression: ts.Expression): StateMachineOrigin;
 /** Resolve a consumer expression to the exact exported stateMachine declaration that owns it. */
-export declare function lifecycleIdentity(project: SourceProject, file: SourceFile, expression: ts.Expression, seen?: ReadonlySet<string>): LifecycleResolution;
+export declare function stateMachineIdentity(project: SourceProject, file: SourceFile, expression: ts.Expression, seen?: ReadonlySet<string>): StateMachineResolution;
 /** Resolve a Schema codec expression to the exact machine whose stateSchema it aliases. */
-export declare function stateSchemaIdentity(project: SourceProject, file: SourceFile, expression: ts.Expression, seen?: ReadonlySet<string>): LifecycleResolution;
+export declare function stateSchemaIdentity(project: SourceProject, file: SourceFile, expression: ts.Expression, seen?: ReadonlySet<string>): StateMachineResolution;
 /** Classify whether a stateMachine call is the value of an exported top-level binding. */
 export declare function machineExportStatus(file: SourceFile, call: ts.CallExpression): MachineExportStatus;

package/dist/tooling/linter/implementations/source/{lifecycle.js → state-machine.js}

@@ -1,5 +1,5 @@
 import ts from 'typescript';
-import { resolveImportedSymbol, resolveProjectImport, unwrap, visit, } from '../../adapters/typescript/index.js';
+import { resolveImportedSymbol, resolveProjectImport, staticText, unwrap, visit, } from '../../adapters/typescript/index.js';
 const STATE_MODULES = new Set(['@astrale-os/sdk', '@astrale-os/sdk/state']);
 const SCHEMA_MODULES = new Set([
     '@astrale-os/sdk',
@@ -29,11 +29,11 @@ export function stateMachineConstructorOrigin(file, expression, seen = new Set()
     return declaration.constant || origin === 'absent' ? origin : 'ambiguous';
 }
 /** Resolve one local binding to an exported SDK stateMachine authority. */
-export function lifecycleOrigin(project, file, expression) {
-    return lifecycleIdentity(project, file, expression).kind;
+export function stateMachineOrigin(project, file, expression) {
+    return stateMachineIdentity(project, file, expression).kind;
 }
 /** Resolve a consumer expression to the exact exported stateMachine declaration that owns it. */
-export function lifecycleIdentity(project, file, expression, seen = new Set()) {
+export function stateMachineIdentity(project, file, expression, seen = new Set()) {
     const value = unwrap(expression);
     if (ts.isIdentifier(value)) {
         const declaration = localVariable(file, value.text);
@@ -43,7 +43,7 @@ export function lifecycleIdentity(project, file, expression, seen = new Set()) {
                 return { kind: 'ambiguous' };
             const next = new Set(seen);
             next.add(identity);
-            const resolution = lifecycleIdentity(project, file, declaration.initializer, next);
+            const resolution = stateMachineIdentity(project, file, declaration.initializer, next);
             return declaration.constant || resolution.kind === 'absent'
                 ? resolution
                 : { kind: 'ambiguous' };
@@ -60,8 +60,9 @@ export function lifecycleIdentity(project, file, expression, seen = new Set()) {
 /** Resolve a Schema codec expression to the exact machine whose stateSchema it aliases. */
 export function stateSchemaIdentity(project, file, expression, seen = new Set()) {
     const value = unwrap(expression);
-    if (ts.isPropertyAccessExpression(value) && value.name.text === 'stateSchema') {
-        return lifecycleIdentity(project, file, value.expression);
+    const owner = staticMemberReceiver(value, 'stateSchema');
+    if (owner !== undefined) {
+        return stateMachineIdentity(project, file, owner);
     }
     if (ts.isCallExpression(value)) {
         const symbol = resolveImportedSymbol(file, value.expression);
@@ -87,9 +88,8 @@ export function stateSchemaIdentity(project, file, expression, seen = new Set())
     }
     let candidate = false;
     visit(value, (node) => {
-        if (ts.isPropertyAccessExpression(node) &&
-            node.name.text === 'stateSchema' &&
-            lifecycleIdentity(project, file, node.expression).kind !== 'absent') {
+        const owner = ts.isExpression(node) ? staticMemberReceiver(node, 'stateSchema') : undefined;
+        if (owner !== undefined && stateMachineIdentity(project, file, owner).kind !== 'absent') {
             candidate = true;
         }
         if (ts.isIdentifier(node) && node !== value) {
@@ -107,6 +107,16 @@ export function stateSchemaIdentity(project, file, expression, seen = new Set())
     });
     return candidate ? { kind: 'ambiguous' } : { kind: 'absent' };
 }
+function staticMemberReceiver(expression, member) {
+    const value = unwrap(expression);
+    if (ts.isPropertyAccessExpression(value) && value.name.text === member) {
+        return value.expression;
+    }
+    if (ts.isElementAccessExpression(value) && staticText(value.argumentExpression) === member) {
+        return value.expression;
+    }
+    return undefined;
+}
 function importedBinding(file, expression) {
     const value = unwrap(expression);
     if (ts.isIdentifier(value)) {

package/dist/tooling/linter/implementations/source/states.js

@@ -1,7 +1,7 @@
 import ts from 'typescript';
 import { resolveImportedSymbol, resolveProjectImport, staticText, unwrap, visit, } from '../../adapters/typescript/index.js';
-import { machineExportStatus, stateMachineConstructorOrigin } from './lifecycle.js';
 import { ambiguity, forbiddenIoImport, hasForbiddenGlobalCall, production, violation, } from './shared.js';
+import { machineExportStatus, stateMachineConstructorOrigin } from './state-machine.js';
 const STATE_MODULES = new Set(['@astrale-os/sdk', '@astrale-os/sdk/state']);
 const FORBIDDEN_LAYERS = new Set([
     'actions',
@@ -17,7 +17,7 @@ const FORBIDDEN_LAYERS = new Set([
 export const stateRules = [
     {
         id: 'STA-ONE-RELATION',
-        ruleRevision: 'b80d551bf975f75830902816cc98886f670711af012c7869fa6fa956e208f528',
+        ruleRevision: '7b6a334d669288c938b47985dc325c96f6ce277986848858f25e609cdbcc679e',
         evaluate(project) {
             const evidence = [];
             const files = production(project, 'states');
@@ -48,7 +48,7 @@ export const stateRules = [
                     const exportStatus = machineExportStatus(machine.file, machine.call);
                     if (exportStatus !== 'exported') {
                         evidence.push(violation(machine.file, machine.call, exportStatus === 'private'
-                            ? 'State machine relation must be exported as its submodule lifecycle authority.'
+                            ? 'State machine relation must be exported as its submodule StateMachine authority.'
                             : 'State machine relation must be assigned to one exported top-level binding.'));
                     }
                     evidence.push(...admitStaticRelation(machine.file, machine.call));
@@ -65,7 +65,7 @@ export const stateRules = [
                     if ((symbol.kind === 'resolved' || symbol.kind === 'ambiguous') &&
                         symbol.name === 'defineStateMachine' &&
                         STATE_MODULES.has(symbol.module)) {
-                        evidence.push(violation(file, node, 'State lifecycle uses unsupported defineStateMachine; use stateMachine.'));
+                        evidence.push(violation(file, node, 'StateMachine uses unsupported defineStateMachine; use stateMachine.'));
                     }
                 });
             }
@@ -285,7 +285,7 @@ function duplicatedProjection(expression, vocabulary) {
     const value = unwrap(expression);
     if (ts.isPropertyAccessExpression(value) &&
         ['initial', 'states', 'terminalStates', 'transitions'].includes(value.name.text)) {
-        return `${value.name.text} lifecycle projection`;
+        return `${value.name.text} StateMachine projection`;
     }
     if (ts.isStringLiteral(value) && vocabulary.states.has(value.text)) {
         return 'initial-state constant';

package/dist/tooling/linter/policy/generated.js

@@ -1,7 +1,7 @@
 /** Generated from the validated Domain knowledge catalog. Regenerate with pnpm sync:linter-policy. */
-export const domainPolicyDigest = '0f712cdfaa194dc7970d91334b57188194f4fc5658c7f9991449e0bf1acfa5d6';
+export const domainPolicyDigest = '551b8c93f44fc8b4e4dc3f9820361d69611d7c83f51260b6429cd5a13134dfc0';
 export const domainPolicySource = Object.freeze({
-    rules: "id\tscope\tkind\tseverity\tmessage\tverification\texample\nOWN-SEMANTIC\townership\tarchitecture\terror\tEvery semantic fact, rule, representation, transition, and failure meaning has exactly one owner\tInventory declarations by meaning and report each duplicate authority or ownerless concept\tsemantic-owner.md\nMOD-SUBMODULE\tmodules\tstructure\terror\tEvery semantic source file lives in a dedicated semantic submodule or its registered layer facade\tClassify every layer-root source file and report files outside the registered facade or public index\tsemantic-owner.md\nMOD-REQUIRED\tmodules\tstructure\terror\tEvery required layer and root file declared by the injected layout exists\tCompare admitted project entries with required layout entries and report each missing path\trequired-layout.md\nMOD-GOVERNED\tmodules\tstructure\terror\tEvery source file admitted by the Domain compilation scope belongs to a declared layer or supported root\tClassify admitted source paths after declared workspace and tooling delegation and report each unowned path\tgoverned-source.md\nROOT-FACADE\troots\tstructure\terror\tEvery registered layer facade is exposed through a curated public index\tInspect each layer index and facade and report private-owner behavior or misplaced facade declarations\tpackage-facade.md\nROOT-COMPOSE\troots\tstructure\terror\tPackage roots compose only policy-backed Schema, Action handlers, native Routes, Migrations, Provider-backed Integrations, and supported package journeys\tInspect declared composition and package roots and report behavior, provider protocol logic, recursive barrels, or unsupported exports\tcomposition-root.md\nROOT-PACKAGE\troots\tevidence\terror\tEvery public Schema package subpath maps one admitted source entrypoint to its deterministic published declaration and JavaScript targets\tCompare source and publish exports and reject missing duplicate non-Schema locally linked generated or Kernel-leaking package artifacts\tmulti-domain-package.md\nDEP-ALLOWLIST\tdependencies\tdependency\terror\tEvery direct cross-layer import and its runtime or type-only kind appears in the dependency allowlist and dependencies between distinct layers are acyclic\tResolve source imports, reject every absent or kind-mismatched edge, and detect cycles after excluding evidence edges\tsemantic-owner.md\nIMP-FACADE\timports\tdependency\terror\tEvery cross-submodule import uses the semantic owner's facade and every foreign Domain import uses its public package facade\tResolve imports and report private deep paths outside the importing submodule\tcross-domain.md\nIMP-SDK-BOUNDARY\timports\tdependency\terror\tDomain source imports Kernel Core and DSL authoring values only through semantic SDK subpaths\tInspect every static and literal dynamic import and report module specifiers rooted at @astrale-os/kernel-core or @astrale-os/kernel-dsl\tsdk-boundary.md\nIMP-LAYER-ALIAS\timports\tdependency\terror\tEvery local import crossing a layer or semantic-submodule boundary uses the registered # layer alias\tResolve relative imports and report each one whose target leaves the importing semantic submodule\tlayer-aliases.md\nIMP-ALIAS-CFG\timports\tdependency\terror\tPackage and TypeScript resolution exactly implement each active layer-facade and semantic-submodule alias\tCompare active and required layers with the injected alias registry and report missing, undeclared, or drifted mappings\talias-configuration.md\nIMP-STATIC\timports\tdependency\terror\tProduction dependency edges use analyzable static ESM declarations or literal import calls\tReject require calls, import-equals declarations, nonliteral import calls, and unresolved static dependency forms\tstatic-imports.md\nTYP-OWNER\ttypes\tarchitecture\terror\tEvery type and reusable expected error is colocated with the semantic concept that defines its meaning\tTrace each declaration to its semantic authority and report catch-all or remotely owned values\texpected-failure.md\nERR-EXPECTED\terrors\tdataflow\terror\tBoundaries map only declared expected failures and propagate unexpected defects\tInspect catches and result mappings and report broad fallback, swallowed defects, or mappings without a declared source failure\texpected-failure.md\nTST-NO-PROD-IMP\ttests\tdependency\terror\tProduction source imports no root or colocated Test artifact\tResolve production imports and report targets under Root Tests, __tests__, or test, spec, bench, and perf source files\ttest-import-boundary.md\nABS-EARNED\tabstractions\tarchitecture\terror\tAn invariant or real boundary earns an abstraction; reuse alone requires two independent consumers and no duplicated semantic behavior\tIdentify the invariant, boundary, or independent consumers for each abstraction and report reuse wrappers that duplicate an owner's semantics\tsemantic-owner.md\nABS-NO-REPO\tabstractions\tarchitecture\terror\tDomain source places no collection-shaped persistence facade between business code and canonical Query or Mutation definitions\tInspect persistence-facing contracts and report abstractions that replace graph identity, traversal, observation, or atomic change semantics\tsemantic-owner.md\nABS-CANON-GRAPH\tabstractions\tdeclaration\terror\tDomain source declares no alternate Query or Mutation language, AST, compiler, planner, or wire representation\tInspect graph-related declarations and report semantics not identical to canonical Kernel Query or Mutation values\tsemantic-owner.md\nTRUST-ADMIT-ONCE\ttrust\tdataflow\terror\tEvery untrusted value is admitted or translated exactly once at its owning boundary\tTrace values from each external boundary and report missing admission or repeated structural validation\texpected-failure.md\nQLT-EXHAUSTIVE\tquality\tbehavior\terror\tEvery closed alternative is handled exhaustively and no required failure becomes placeholder success\tTrace closed unions and failure paths and report permissive defaults, placeholder success, or catch-and-continue behavior\texpected-failure.md\nQLT-CANON-VALUES\tquality\tdataflow\terror\tNo unchecked cast fabricates a canonical Kernel identity, QueryAST, MutationAST, or admitted schema value\tScan casts to canonical values and require an owning constructor or decoder for each\tsemantic-owner.md\nQLT-DEF-IDS\tquality\tdeclaration\terror\tEvery top-level Query, Mutation, and Migration definition has a stable literal ID unique in its owning namespace\tExtract top-level definition IDs and report missing, dynamic, malformed, or duplicate values\tdefinition-identities.md\nQLT-TYPED-COORD\tquality\tdeclaration\terror\tQueries and Mutations derive graph coordinates from resolved DSL definitions instead of raw string or structural reconstruction\tReject raw PropertyKey calls and structural ClassPath objects; require canonical resolved Classes Properties and keys at graph boundaries\ttyped-coordinates.md\nNODE-INHERITED\tnodes\tdeclaration\terror\tNo Node Class redeclares name, description, createdAt, or updatedAt inherited from Named, Descriptable, and Timestamped\tScan Node Class Properties and report each inherited field redeclaration\tsemantic-owner.md\nDOM-PUBLIC-DEPS\tdomains\tdependency\terror\tEvery directly referenced foreign-Domain graph declaration has one exact Schema dependency\tResolve foreign Schema, Query, and Mutation graph references and report each package without one exact declared Schema dependency\tcross-domain.md\nDOM-CALL-INT\tdomains\tdependency\terror\tEvery cross-Domain callable invocation implements a consumer-owned Integration inside a Provider and uses only the remote Domain's public facade\tTrace foreign callable invocations and report direct Action or Workflow calls, missing Integration contracts, non-Provider call sites, or private remote imports\tremote-domain-call.md\nDOM-ATOMICITY\tdomains\tbehavior\terror\tA cross-Domain change claims atomicity only when it is one MutationAST on one graph; calls combined with other effects are Workflow steps\tTrace atomicity and effect claims and report multiple commits, service boundaries, or foreign calls combined in a Action\tcross-domain.md\nSCH-SUBMODULE\tschema\tdeclaration\terror\tEvery authored declaration and public callable value has exactly one Schema submodule owner\tInventory declarations and callable inputs, results, and failures and report missing, duplicate, or layer-root owners\tschema-facade.md\nSCH-DECL-ONLY\tschema\tdeclaration\terror\tSchema performs no handler execution, Query execution, Mutation submission, Integration call, Workflow step, or Provider call\tResolve Schema imports and call graphs and require zero excluded operations\tpublication-callables.md\nSCH-EXACT-TYPES\tschema\tdeclaration\terror\tSchema authoring values preserve their exact inferred DSL types instead of widening to generic builder contracts\tScan Schema declarations and action returns for explicit generic builder authoring annotations\tschema-facade.md\nSCH-POLICY-AUTH\tschema\tdeclaration\terror\tCallable authority is declared through Policy and Action implementations add no private authorization rule\tTrace callable admission and report authority conditions without one owning Policy\tpolicy.md\nSCH-STATE-SOURCE\tschema\tdeclaration\terror\tEvery lifecycle vocabulary exposed by Schema originates from its canonical States owner rather than a copied literal set\tResolve exact lifecycle origins; report same-owner exact Zod literals as indeterminate and ignore unrelated submodules or DSL method names\tarticle-schema.md\nSTA-ONE-RELATION\tstates\tdeclaration\terror\tEvery lifecycle has one immutable transition relation containing its states, events, initial state, and legal transitions\tIdentify each lifecycle and report missing fields, mutable data, or duplicate transition authorities\tarticle-lifecycle.md\nSTA-PURE\tstates\tdeclaration\terror\tTransition relations contain no executable guard, permission, effect, retry policy, timer, clock, or provider behavior\tInspect transition values and resolved dependencies while treating state and event vocabulary as structural data\tterminal-states.md\nRUL-SYNC\trules\tbehavior\terror\tEvery Rule is synchronous and returns no Promise, continuation, generator, or asynchronous iterator\tInspect Rule signatures and result types and reject asynchronous forms\tnormalization.md\nRUL-PURE\trules\tbehavior\terror\tRules perform no I/O and depend on no graph executor or Domain execution boundary\tResolve imports and effect origins, permitting pure standard value transformations while reporting conclusive I/O and Domain execution dependencies\tpublish-eligibility.md\nRUL-EXPL-FACTS\trules\tbehavior\terror\tEvery clock value, random value, identity, limit, and environmental observation used by a Rule is an explicit input\tTrace every value source and report reads from ambient state, globals, process state, or hidden singletons\ttime-facts.md\nRUL-CLOSED-DEC\trules\tbehavior\terror\tEvery expected business alternative is represented by a closed decision value rather than thrown control flow\tInspect Rule branches and report expected alternatives represented by exceptions or open optional fields\tpublish-eligibility.md\nQRY-CANON\tqueries\tdataflow\terror\tEvery graph request produced by a Query definition is one canonical QueryAST built through Kernel Query APIs\tTrace request construction and reject every non-canonical graph document\tfiltered-query.md\nQRY-CONTRACT\tqueries\tdataflow\terror\tA Query owns its input, observation, optional business projection, pagination, and expected failures\tInspect each Query definition and report a required concern owned elsewhere or omitted\tquery-transforms.md\nQRY-SINGLE\tqueries\tdataflow\terror\tEvery authored single Query definition declares exactly one build callback and at most one project callback\tInspect definition properties and canonical roots; report opaque helper origins as ambiguity rather than assuming cardinality\tsingle-query.md\nQRY-COMPOSE-TYPED\tqueries\tdataflow\terror\tA composite Query constructs one closed QueryPlan containing only typed single-Query leaves, symbolic output references, and explicit result composition\tInspect plan construction, report unresolved call origins as ambiguity, and reject nested composites, raw sessions, graph clients, result-time callbacks, arbitrary promises, or Domain effects\tdependent-query.md\nQRY-COMPOSE-STABLE\tqueries\tdeclaration\terror\tEvery composite Query leaf has a stable semantic literal ID unique within its definition\tInspect declared Query leaves and reject dynamic, malformed, or duplicate leaf identifiers\tdependent-query.md\nQRY-COLL-FANOUT\tqueries\tdataflow\twarning\tThree or more independent same-kind complete-Class collection leaves use one explicit query.union group\tInfer collection kind from canonical definition types and print the direct named replacement plus logical and physical plan counts\tcollection-union.md\nQRY-PROJECT-PURE\tqueries\tdataflow\terror\tEvery Query project callback is synchronous and performs only pure value transformation\tInspect project callback syntax and call graphs and report asynchronous continuation, I/O, mutation, nondeterminism, hidden query execution, or effects\tprojection.md\nQRY-SNAPSHOT\tqueries\tdataflow\terror\tA composite or paginated Query makes no point-in-time graph snapshot claim beyond one Kernel invocation\tReject shared-snapshot claims across leaves unions or continuations and route stronger consistency to an explicit Kernel facility\tdependent-query.md\nMUT-CANON\tmutations\tdataflow\terror\tEvery Mutation definition builds one synchronous change through the canonical builder and constructs no alternate or nested graph document\tInspect every definition build callback and reject missing, asynchronous, alternate, or nested Mutation construction\tatomic-mutation.md\nMUT-CONTRACT\tmutations\tdataflow\terror\tA Mutation owns its input, preconditions, operations, optional business projection, and expected failures\tInspect each definition and report required mutation semantics owned elsewhere or omitted\tcreate-aggregate.md\nMUT-PRECONDS\tmutations\tdataflow\terror\tRules decide eligibility and every live graph condition required for safety is encoded as a precondition in the same MutationAST\tMap decisions to preconditions and report duplicated eligibility or safety enforced only by an earlier observation\tconditional-update.md\nMUT-FRAGMENTS\tmutations\tdataflow\terror\tReusable fragments receive the callback-scoped MutationBuilder and contribute only to the same MutationAST\tResolve fragment signatures and calls and reject escaped builders, opaque documents, or nested MutationAST construction\tmutation-fragments.md\nMUT-PURE\tmutations\tdataflow\terror\tMutation definitions perform no session call, external effect, retry, compensation, or second submission\tScan definition call graphs and require zero excluded operations\tedge-change.md\nMUT-MULTI-WFL\tmutations\tdataflow\terror\tA change requiring several MutationAST values is a Workflow and is never exposed as one atomic Mutation\tTrace multi-commit changes and report definitions or names claiming single-mutation atomicity\tdelete-node.md\nMUT-STATE-INITIAL\tmutations\tdataflow\terror\tEvery lifecycle-backed node is created from its StateMachine initial state\tResolve lifecycle Property initializers and require the canonical machine.initial value rather than a copied state literal\tlifecycle-transition.md\nMUT-STATE-ATOMIC\tmutations\tdataflow\terror\tEvery persisted lifecycle change consumes one allowed StateMachine decision and commits its stale-state precondition and update in the same MutationAST\tInspect lifecycle writes and require transition with the canonical States machine and one allowed decision; reject direct target writes and split precondition updates\tlifecycle-transition.md\nWFL-MULTISTEP\tworkflows\tbehavior\terror\tEvery Workflow definition contains at least two distinct semantic asynchronous operation sites\tInventory operation sites in the definition and report fewer than two; early exit, rejection, and recovery paths may execute fewer\tpublication-workflow.md\nWFL-STEP-EFFECTS\tworkflows\tbehavior\terror\tEvery semantic asynchronous operation maps to one named step.run boundary\tTrace effects and report operations outside step.run\tpublication-workflow.md\nWFL-STEP-IDS\tworkflows\tbehavior\terror\tEvery step identifier is a stable non-empty kebab-case literal unique within its Workflow\tExtract step identifiers and reject dynamic, malformed, empty, or duplicate values\tpublication-workflow.md\nWFL-NO-NEST\tworkflows\tbehavior\terror\tNo step.run callback invokes another step.run directly or through a reachable helper\tInspect callback call graphs and report every nested step.run path\tpublication-workflow.md\nWFL-INT-TYPES\tworkflows\tdeclaration\terror\tWorkflow Integration requirements derive from declared Integration definitions and the SDK projects their clients\tReject Workflow-owned operation interfaces and require its definition generic to reference the declared Integration registry\tcross-domain-workflow.md\nWFL-ONE-OP-STEP\tworkflows\tbehavior\terror\tEvery step owns exactly one semantic asynchronous operation\tTrace each step and report zero or several independently failing operations\tpublication-workflow.md\nWFL-STATE-CODEC\tworkflows\tbehavior\terror\tEvery step result and inter-step value is undefined or portable JSON data\tInspect step values and report actions, clients, symbols, bigint, cycles, or class instances\tpublication-workflow.md\nWFL-RECOVERY\tworkflows\tbehavior\terror\tWhen compensation or unknown-outcome branches exist, they are explicit and rely only on declared operation semantics\tInspect existing recovery branches and report guessed outcomes or compensation without exact evidence\tpublication-workflow.md\nWFL-XDOM-INT\tworkflows\tbehavior\terror\tA Workflow invokes another Domain only through a declared Integration and imports no foreign Domain\tResolve Workflow imports and operations and report foreign Domain imports or calls without Integration ownership\tcross-domain-workflow.md\nMIG-EXACT-REVS\tmigrations\tdataflow\terror\tEvery Migration declares exactly one source revision and one target revision for the same Domain origin\tParse Migration descriptors and reject missing, equal, ambiguous, cross-origin, or dynamically selected revisions\texact-revisions.md\nMIG-APP-DATA\tmigrations\tdataflow\terror\tMigrations transform application-owned facts only and own no schema projection, physical representation, deployment, backup, or external import\tClassify every transformed value and operation and report responsibilities outside application data\trewrite-values.md\nMIG-DEDICATED-CTX\tmigrations\tdataflow\terror\tMigration execution uses only its dedicated source reader, target writer, durable step context, revision-compatible Rules, and generic Utils\tResolve imports and calls and reject ordinary Actions, Workflows, Queries, Mutations, Integrations, Providers, Views, UI, or provider access\texact-revisions.md\nMIG-RESTART-SAFE\tmigrations\tdataflow\terror\tEvery Migration page is idempotent and resumes from a stable checkpoint without reinterpreting accepted target output\tInterrupt before and after every page commit, resume repeatedly, and compare target facts and checkpoints with uninterrupted execution\trestart-safe.md\nMIG-TARGET-PROOF\tmigrations\tdataflow\terror\tA Migration completes only after bounded source coverage and target-revision validation account for every selected source fact\tInject omitted, duplicated, invalid, and over-budget facts and require completion to fail with exact evidence\tverify-target.md\nMIG-DESTRUCTIVE\tmigrations\tdataflow\terror\tEvery destructive or irreversible transform declares and accounts for its intended loss and exposes declared expected failures\tTrace removals and irreversible rewrites and report undeclared or unaccounted loss, open failures, or catch-and-continue behavior\tremove-facts.md\nINT-BOUNDARY\tintegrations\tarchitecture\terror\tEvery Integration represents required behavior across an external, remote-Domain, substitution, process, or trust boundary\tIdentify the boundary for every contract and report behavior that can remain ordinary local Domain code\tpayment-authorization.md\nINT-NEUTRAL\tintegrations\tdeclaration\terror\tEvery Integration owns provider-neutral requests, evidence, correlation, idempotency, trust, and expected failure semantics needed by consumers\tInspect consumers and contracts and report provider fields or missing stable boundary semantics\tid-allocation.md\nINT-PURE\tintegrations\tdependency\terror\tIntegrations remain provider- and execution-boundary-neutral and import no concrete client, credential, configuration, Provider, Action, or Workflow\tResolve runtime and provider imports and report every conclusive concrete or execution-boundary dependency\tdocument-signing.md\nINT-ABILITY-NAME\tintegrations\tstructure\terror\tIntegration submodules are named by required ability and never mirror Schema entities mechanically\tCompare Integration and Schema submodules and report a contract without an independent boundary ability\tobject-storage.md\nACT-ONE-IMPL\tactions\tbehavior\terror\tEvery registered handler binding resolves to exactly one implementation owned by one semantic Actions submodule\tResolve the handler registry and report non-Action owners or duplicate registrations; SDK typing owns callable exhaustiveness\tsynchronous-result.md\nACT-ONE-OP\tactions\tbehavior\terror\tEvery Action performs one terminal semantic operation; only a native binary compatibility Action may precede its Integration call with one exact-receiver Query\tTrace every path and report several terminal effects, writes before effects, non-receiver prerequisite reads, or hidden orchestration\tsingle-operation.md\nACT-OP-KINDS\tactions\tbehavior\terror\tA semantic asynchronous operation is one Query definition, Mutation definition, or Integration call\tClassify every awaited effect and report operations outside the three allowed kinds\tintegration-operation.md\nACT-BOUNDARIES\tactions\tbehavior\terror\tActions use only invocation-bound query and mutate executors, including explicit caller self or union graph partitions, plus declared Integrations; Providers or foreign Domains are never imported\tInspect context use, authority-mode selection, dependencies, imports, and failure mapping; report raw or unbound graph executors, implicit privilege, concrete or foreign dependencies, broad mapping, or swallowed defects\tremote-integration.md\nACT-BINARY-RESULT\tactions\tbehavior\terror\tA binary Action returns detached buffered bytes or streaming bytes with admitted media type status and application headers without collecting or value-framing a provider stream\tExercise buffered and streaming results through their native route; verify exact bytes status headers cancellation and invalid output rejection\tnative-byte-response.md\nRTE-RECIPE\troutes\tdeclaration\terror\tEvery native HTTP Route targets exactly one admitted Action or Workflow recipe\tResolve every route target and report forged missing or several recipes\taction-route.md\nRTE-MAPPING\troutes\tdataflow\terror\tEvery callable input field and instance receiver is mapped exactly once from path query header method or body input\tCompile each route against its resolved callable and reject incomplete ambiguous or unknown mappings\tinstance-route.md\nRTE-CREDENTIAL\troutes\tdataflow\terror\tEvery external credential source is explicit and is never also mapped as callable input\tCompile credential and input mappings and reject duplicate reserved or implicit authority sources\tcredential-route.md\nRTE-ONE-FILE\troutes\tstructure\terror\tEvery Route declaration has one business-intent kebab-case file and Routes composition contains no inline declaration\tInventory route declarations and report generic grouped or inline ownership\tapplication-routes.md\nPRV-INT-IMPL\tproviders\tarchitecture\terror\tEvery Provider implements one or more declared Integrations across a named external or remote-Domain boundary\tIdentify the boundary and implemented contracts and report a Provider without both\tpayment-provider.md\nPRV-BOUNDARY-NAME\tproviders\tstructure\terror\tProvider submodules are named by external system, protocol, or trust boundary rather than Domain entity\tInspect every submodule name and report one justified only by Schema vocabulary\tobject-storage-provider.md\nPRV-ADMIT-RESULT\tproviders\tdataflow\terror\tEvery boundary value is admitted before Integration evidence and recognized boundary failures become stable Integration failures\tTrace input and failure paths and report missing admission, leaked boundary errors, broad mapping, or swallowed defects\twebhook-admission.md\nPRV-NO-DOMAIN\tproviders\tdependency\terror\tProviders perform no local Domain graph operation, business decision, local Action call, or Workflow orchestration\tResolve Provider imports and call graphs and require zero excluded operations\tboundary-composition.md\nPRV-XDOM-TYPED\tproviders\tdependency\terror\tRemote-Domain Providers pass SDK-derived typed callable references to the caller-bound invocation capability without never casts\tInspect Provider execution invoke calls and reject references not constructed through SDK reference, opaque or fabricated references, and never-cast arguments\tremote-domain.md\nPRV-XDOM-REQ\tproviders\tdependency\terror\tEvery statically resolved remote-Domain Provider invocation has one exact Application callable requirement\tMatch each invocation-bound public callable reference to the same foreign facade and callable selector under Application requirements; preserve opaque references or composition as indeterminate\tremote-domain.md\nPRV-XDOM-PUBLIC\tproviders\tdependency\terror\tA remote-Domain Provider uses the remote public facade and invokes at most one public callable per Integration operation\tResolve receiver and facade origins for each remote operation and report private access, missing Integration ownership, unrelated calls, or several public invocations\tremote-domain.md\nVIW-PROJECTION\tviews\tdeclaration\terror\tEvery View converts public Domain values or named Query observations into UI props and connects each action to a named bounded Mutation or public callable contract\tInspect View outputs and actions and report behavior without a Schema, Query, UI, Mutation, Rule, or public callable owner\tdetail-view.md\nVIW-SCHEMA-DECL\tviews\tdeclaration\terror\tSchema owns every DSL View declaration and Views declares no Domain schema construct\tScan View declarations and reject Classes, Properties, Policies, Methods, Actions, or DSL Views\tarticle-list.md\nVIW-DEPS\tviews\tdependency\terror\tViews import only Schema, States, pure Rules, named Queries, bounded named Mutations, UI, shell-react primitives, public callable contracts, and presentation libraries\tInspect resolved imports and report dependencies or raw graph APIs outside the allowlist\tnavigation.md\nVIW-ACTIONS\tviews\tdataflow\terror\tEvery View action executes a named caller-authorized atomic Mutation or invokes a public callable; presentation state is never authorization evidence\tTrace action and authority paths and report inline or raw graph documents, elevated or effectful Mutation use, private Action imports, direct Integration calls, or authority derived from presentation\tform-actions.md\nUI-PRES-DEPS\tui\tdependency\terror\tEvery UI import is a sibling UI module or an external library used only for presentation\tInspect resolved imports and used APIs and report Domain, I/O, persistence, authorization, routing, or provider behavior\tstatus-panel.md\nUI-NO-DOMAIN\tui\tdependency\terror\tUI imports no Domain layer or Domain package facade\tResolve the UI import graph and require zero Domain paths\tresult-list.md\nUI-PURE\tui\tbehavior\terror\tUI performs no I/O, graph access, storage, authorization, business validation, provider call, routing, or Domain result mapping\tInspect components and hooks and report the exact excluded call or branch\tconfirmation-dialog.md\nUI-CALLBACKS\tui\tdataflow\terror\tUI accepts presentation props and forwards intent through callbacks without constructing Domain commands\tInspect props and event handlers and report Domain identities, command construction, or business decisions\tform.md\nUTL-DOM-AGNOSTIC\tutils\tarchitecture\terror\tEvery Utils export is Domain-agnostic and contains no Domain declaration, identity, decision, graph definition, or Workflow step\tInspect signatures and implementations and report the exact Domain concept or business behavior\tresult.md\nUTL-REUSED\tutils\tarchitecture\terror\tEvery Utils extension serves two independent semantic consumers or one package-wide execution boundary\tList direct consumers and report an extension satisfying neither condition\tjson-codec.md\nUTL-PUBLIC-DEPS\tutils\tdependency\terror\tUtils imports only public Kernel, DSL, SDK, standard-library, and sibling Utils modules\tResolve the Utils import graph and reject Domain layers, Providers, or private package paths\tjson-codec.md\nUTL-LIGHTWEIGHT\tutils\tarchitecture\terror\tUtils is private and owns no durable engine, planner, compiler, Repository, service locator, or dependency container\tInspect package exports and declarations and report public exposure or any forbidden framework machinery\tresult.md\nSCR-OPERATOR\tscripts\tbehavior\terror\tEvery root Script implements a supported operator workflow with declared inputs, outcomes, failures, and proof\tInspect each Script contract and report disposable tasks or missing operator semantics\tbackup.md\nSCR-PUBLIC-DEPS\tscripts\tbehavior\terror\tScripts import only dependency-DAG-authorized public facades, standard libraries, and operator libraries and define no Domain behavior\tResolve imports and inspect branches and report private paths, business decisions, graph definitions, or callable behavior\tupgrade.md\nSCR-TEST-DRIVERS\tscripts\tbehavior\terror\tDisposable setup, fixtures, resets, and scenario drivers live under tests/scripts rather than root Scripts\tClassify every Script by supported operator contract and report evidence-only programs at the root\trestore.md\nTST-SYS-OWNER\ttests\tevidence\terror\tRoot Tests owns cross-layer journeys, environments, harnesses, scenarios, seeds, fixtures, and disposable scripts\tInventory evidence support code and report cross-layer artifacts outside Tests or production semantics inside Tests\tmigration-scenario.md\nTST-COLOCATED\ttests\tevidence\terror\tEvery semantic production submodule owns focused evidence in its local __tests__ directory\tJoin production submodules to focused test directories and report missing owners\tfocused-rule.md\n",
+    rules: "id\tscope\tkind\tseverity\tmessage\tverification\texample\nOWN-SEMANTIC\townership\tarchitecture\terror\tEvery semantic fact, rule, representation, transition, and failure meaning has exactly one owner\tInventory declarations by meaning and report each duplicate authority or ownerless concept\tsemantic-owner.md\nMOD-SUBMODULE\tmodules\tstructure\terror\tEvery semantic source file lives in a dedicated semantic submodule or its registered layer facade\tClassify every layer-root source file and report files outside the registered facade or public index\tsemantic-owner.md\nMOD-REQUIRED\tmodules\tstructure\terror\tEvery required layer and root file declared by the injected layout exists\tCompare admitted project entries with required layout entries and report each missing path\trequired-layout.md\nMOD-GOVERNED\tmodules\tstructure\terror\tEvery source file admitted by the Domain compilation scope belongs to a declared layer or supported root\tClassify admitted source paths after declared workspace and tooling delegation and report each unowned path\tgoverned-source.md\nROOT-FACADE\troots\tstructure\terror\tEvery registered layer facade is exposed through a curated public index\tInspect each layer index and facade and report private-owner behavior or misplaced facade declarations\tpackage-facade.md\nROOT-COMPOSE\troots\tstructure\terror\tPackage roots compose only policy-backed Schema, Action handlers, native Routes, Migrations, Provider-backed Integrations, and supported package journeys\tInspect declared composition and package roots and report behavior, provider protocol logic, recursive barrels, or unsupported exports\tcomposition-root.md\nROOT-PACKAGE\troots\tevidence\terror\tEvery public Schema package subpath maps one admitted source entrypoint to its deterministic published declaration and JavaScript targets\tCompare source and publish exports and reject missing duplicate non-Schema locally linked generated or Kernel-leaking package artifacts\tmulti-domain-package.md\nDEP-ALLOWLIST\tdependencies\tdependency\terror\tEvery direct cross-layer import and its runtime or type-only kind appears in the dependency allowlist and dependencies between distinct layers are acyclic\tResolve source imports, reject every absent or kind-mismatched edge, and detect cycles after excluding evidence edges\tsemantic-owner.md\nIMP-FACADE\timports\tdependency\terror\tEvery cross-submodule import uses the semantic owner's facade and every foreign Domain import uses its public package facade\tResolve imports and report private deep paths outside the importing submodule\tcross-domain.md\nIMP-SDK-BOUNDARY\timports\tdependency\terror\tDomain source imports Kernel Core and DSL authoring values only through semantic SDK subpaths\tInspect every static and literal dynamic import and report module specifiers rooted at @astrale-os/kernel-core or @astrale-os/kernel-dsl\tsdk-boundary.md\nIMP-LAYER-ALIAS\timports\tdependency\terror\tEvery local import crossing a layer or semantic-submodule boundary uses the registered # layer alias\tResolve relative imports and report each one whose target leaves the importing semantic submodule\tlayer-aliases.md\nIMP-ALIAS-CFG\timports\tdependency\terror\tPackage and TypeScript resolution exactly implement each active layer-facade and semantic-submodule alias\tCompare active and required layers with the injected alias registry and report missing, undeclared, or drifted mappings\talias-configuration.md\nIMP-STATIC\timports\tdependency\terror\tProduction dependency edges use analyzable static ESM declarations or literal import calls\tReject require calls, import-equals declarations, nonliteral import calls, and unresolved static dependency forms\tstatic-imports.md\nTYP-OWNER\ttypes\tarchitecture\terror\tEvery type and reusable expected error is colocated with the semantic concept that defines its meaning\tTrace each declaration to its semantic authority and report catch-all or remotely owned values\texpected-failure.md\nERR-EXPECTED\terrors\tdataflow\terror\tBoundaries map only declared expected failures and propagate unexpected defects\tInspect catches and result mappings and report broad fallback, swallowed defects, or mappings without a declared source failure\texpected-failure.md\nTST-NO-PROD-IMP\ttests\tdependency\terror\tProduction source imports no root or colocated Test artifact\tResolve production imports and report targets under Root Tests, __tests__, or test, spec, bench, and perf source files\ttest-import-boundary.md\nABS-EARNED\tabstractions\tarchitecture\terror\tAn invariant or real boundary earns an abstraction; reuse alone requires two independent consumers and no duplicated semantic behavior\tIdentify the invariant, boundary, or independent consumers for each abstraction and report reuse wrappers that duplicate an owner's semantics\tsemantic-owner.md\nABS-NO-REPO\tabstractions\tarchitecture\terror\tDomain source places no collection-shaped persistence facade between business code and canonical Query or Mutation definitions\tInspect persistence-facing contracts and report abstractions that replace graph identity, traversal, observation, or atomic change semantics\tsemantic-owner.md\nABS-CANON-GRAPH\tabstractions\tdeclaration\terror\tDomain source declares no alternate Query or Mutation language, AST, compiler, planner, or wire representation\tInspect graph-related declarations and report semantics not identical to canonical Kernel Query or Mutation values\tsemantic-owner.md\nTRUST-ADMIT-ONCE\ttrust\tdataflow\terror\tEvery untrusted value is admitted or translated exactly once at its owning boundary\tTrace values from each external boundary and report missing admission or repeated structural validation\texpected-failure.md\nQLT-EXHAUSTIVE\tquality\tbehavior\terror\tEvery closed alternative is handled exhaustively and no required failure becomes placeholder success\tTrace closed unions and failure paths and report permissive defaults, placeholder success, or catch-and-continue behavior\texpected-failure.md\nQLT-CANON-VALUES\tquality\tdataflow\terror\tNo unchecked cast fabricates a canonical Kernel identity, QueryAST, MutationAST, or admitted schema value\tScan casts to canonical values and require an owning constructor or decoder for each\tsemantic-owner.md\nQLT-DEF-IDS\tquality\tdeclaration\terror\tEvery top-level Query, Mutation, and Migration definition has a stable literal ID unique in its owning namespace\tExtract top-level definition IDs and report missing, dynamic, malformed, or duplicate values\tdefinition-identities.md\nQLT-TYPED-COORD\tquality\tdeclaration\terror\tQueries and Mutations derive graph coordinates from resolved DSL definitions instead of raw string or structural reconstruction\tReject raw PropertyKey calls and structural ClassPath objects; require canonical resolved Classes Properties and keys at graph boundaries\ttyped-coordinates.md\nNODE-INHERITED\tnodes\tdeclaration\terror\tNo Node Class redeclares name, description, createdAt, or updatedAt inherited from Named, Descriptable, and Timestamped\tScan Node Class Properties and report each inherited field redeclaration\tsemantic-owner.md\nDOM-PUBLIC-DEPS\tdomains\tdependency\terror\tEvery directly referenced foreign-Domain graph declaration has one exact Schema dependency\tResolve foreign Schema, Query, and Mutation graph references and report each package without one exact declared Schema dependency\tcross-domain.md\nDOM-CALL-INT\tdomains\tdependency\terror\tEvery cross-Domain callable invocation implements a consumer-owned Integration inside a Provider and uses only the remote Domain's public facade\tTrace foreign callable invocations and report direct Action or Workflow calls, missing Integration contracts, non-Provider call sites, or private remote imports\tremote-domain-call.md\nDOM-ATOMICITY\tdomains\tbehavior\terror\tA cross-Domain change claims atomicity only when it is one MutationAST on one graph; calls combined with other effects are Workflow steps\tTrace atomicity and effect claims and report multiple commits, service boundaries, or foreign calls combined in a Action\tcross-domain.md\nSCH-SUBMODULE\tschema\tdeclaration\terror\tEvery authored declaration and public callable value has exactly one Schema submodule owner\tInventory declarations and callable inputs, results, and failures and report missing, duplicate, or layer-root owners\tschema-facade.md\nSCH-DECL-ONLY\tschema\tdeclaration\terror\tSchema performs no handler execution, Query execution, Mutation submission, Integration call, Workflow step, or Provider call\tResolve Schema imports and call graphs and require zero excluded operations\tpublication-callables.md\nSCH-EXACT-TYPES\tschema\tdeclaration\terror\tSchema authoring values preserve their exact inferred DSL types instead of widening to generic builder contracts\tScan Schema declarations and action returns for explicit generic builder authoring annotations\tschema-facade.md\nSCH-POLICY-AUTH\tschema\tdeclaration\terror\tCallable authority is declared through Policy and Action implementations add no private authorization rule\tTrace callable admission and report authority conditions without one owning Policy\tpolicy.md\nSCH-STATE-SOURCE\tschema\tdeclaration\terror\tEvery StateMachine vocabulary exposed by Schema originates from its canonical States owner rather than a copied literal set\tResolve exact StateMachine origins; report same-owner exact Zod literals as indeterminate and ignore unrelated submodules or DSL method names\tarticle-schema.md\nSTA-ONE-RELATION\tstates\tdeclaration\terror\tEvery finite state topology has one immutable StateMachine relation containing its states, events, initial state, and legal transitions\tIdentify each StateMachine and report missing fields, mutable data, or duplicate transition authorities\tarticle-status.md\nSTA-PURE\tstates\tdeclaration\terror\tTransition relations contain no executable guard, permission, effect, retry policy, timer, clock, or provider behavior\tInspect transition values and resolved dependencies while treating state and event vocabulary as structural data\tterminal-states.md\nRUL-SYNC\trules\tbehavior\terror\tEvery Rule is synchronous and returns no Promise, continuation, generator, or asynchronous iterator\tInspect Rule signatures and result types and reject asynchronous forms\tnormalization.md\nRUL-PURE\trules\tbehavior\terror\tRules perform no I/O and depend on no graph executor or Domain execution boundary\tResolve imports and effect origins, permitting pure standard value transformations while reporting conclusive I/O and Domain execution dependencies\tpublish-eligibility.md\nRUL-EXPL-FACTS\trules\tbehavior\terror\tEvery clock value, random value, identity, limit, and environmental observation used by a Rule is an explicit input\tTrace every value source and report reads from ambient state, globals, process state, or hidden singletons\ttime-facts.md\nRUL-CLOSED-DEC\trules\tbehavior\terror\tEvery expected business alternative is represented by a closed decision value rather than thrown control flow\tInspect Rule branches and report expected alternatives represented by exceptions or open optional fields\tpublish-eligibility.md\nQRY-CANON\tqueries\tdataflow\terror\tEvery graph request produced by a Query definition is one canonical QueryAST built through Kernel Query APIs\tTrace request construction and reject every non-canonical graph document\tfiltered-query.md\nQRY-CONTRACT\tqueries\tdataflow\terror\tA Query owns its input, observation, optional business projection, pagination, and expected failures\tInspect each Query definition and report a required concern owned elsewhere or omitted\tquery-transforms.md\nQRY-SINGLE\tqueries\tdataflow\terror\tEvery authored single Query definition declares exactly one build callback and at most one project callback\tInspect definition properties and canonical roots; report opaque helper origins as ambiguity rather than assuming cardinality\tsingle-query.md\nQRY-COMPOSE-TYPED\tqueries\tdataflow\terror\tA composite Query constructs one closed QueryPlan containing only typed single-Query leaves, symbolic output references, and explicit result composition\tInspect plan construction, report unresolved call origins as ambiguity, and reject nested composites, raw sessions, graph clients, result-time callbacks, arbitrary promises, or Domain effects\tdependent-query.md\nQRY-COMPOSE-STABLE\tqueries\tdeclaration\terror\tEvery composite Query leaf has a stable semantic literal ID unique within its definition\tInspect declared Query leaves and reject dynamic, malformed, or duplicate leaf identifiers\tdependent-query.md\nQRY-COLL-FANOUT\tqueries\tdataflow\twarning\tThree or more independent same-kind complete-Class collection leaves use one explicit query.union group\tInfer collection kind from canonical definition types and print the direct named replacement plus logical and physical plan counts\tcollection-union.md\nQRY-PROJECT-PURE\tqueries\tdataflow\terror\tEvery Query project callback is synchronous and performs only pure value transformation\tInspect project callback syntax and call graphs and report asynchronous continuation, I/O, mutation, nondeterminism, hidden query execution, or effects\tprojection.md\nQRY-SNAPSHOT\tqueries\tdataflow\terror\tA composite or paginated Query makes no point-in-time graph snapshot claim beyond one Kernel invocation\tReject shared-snapshot claims across leaves unions or continuations and route stronger consistency to an explicit Kernel facility\tdependent-query.md\nMUT-CANON\tmutations\tdataflow\terror\tEvery Mutation definition builds one synchronous change through the canonical builder and constructs no alternate or nested graph document\tInspect every definition build callback and reject missing, asynchronous, alternate, or nested Mutation construction\tatomic-mutation.md\nMUT-CONTRACT\tmutations\tdataflow\terror\tA Mutation owns its input, preconditions, operations, optional business projection, and expected failures\tInspect each definition and report required mutation semantics owned elsewhere or omitted\tcreate-aggregate.md\nMUT-PRECONDS\tmutations\tdataflow\terror\tRules decide eligibility and every live graph condition required for safety is encoded as a precondition in the same MutationAST\tMap decisions to preconditions and report duplicated eligibility or safety enforced only by an earlier observation\tconditional-update.md\nMUT-FRAGMENTS\tmutations\tdataflow\terror\tReusable fragments receive the callback-scoped MutationBuilder and contribute only to the same MutationAST\tResolve fragment signatures and calls and reject escaped builders, opaque documents, or nested MutationAST construction\tmutation-fragments.md\nMUT-PURE\tmutations\tdataflow\terror\tMutation definitions perform no session call, external effect, retry, compensation, or second submission\tScan definition call graphs and require zero excluded operations\tedge-change.md\nMUT-MULTI-WFL\tmutations\tdataflow\terror\tA change requiring several MutationAST values is a Workflow and is never exposed as one atomic Mutation\tTrace multi-commit changes and report definitions or names claiming single-mutation atomicity\tdelete-node.md\nMUT-STATE-INITIAL\tmutations\tdataflow\terror\tEvery StateMachine-backed node is created from its machine's initial state\tResolve machine-backed Property initializers and require the canonical machine.initial value rather than a copied state literal\tstate-transition.md\nMUT-STATE-ATOMIC\tmutations\tdataflow\terror\tEvery persisted machine-state change consumes one allowed decision and commits its stale-state precondition and update in the same MutationAST\tInspect machine-backed writes and require transition with the canonical States machine and one allowed decision; reject direct target writes and split precondition updates\tstate-transition.md\nWFL-MULTISTEP\tworkflows\tbehavior\terror\tEvery Workflow definition contains at least two distinct semantic asynchronous operation sites\tInventory operation sites in the definition and report fewer than two; early exit, rejection, and recovery paths may execute fewer\tpublication-workflow.md\nWFL-STEP-EFFECTS\tworkflows\tbehavior\terror\tEvery semantic asynchronous operation maps to one named step.run boundary\tTrace effects and report operations outside step.run\tpublication-workflow.md\nWFL-STEP-IDS\tworkflows\tbehavior\terror\tEvery step identifier is a stable non-empty kebab-case literal unique within its Workflow\tExtract step identifiers and reject dynamic, malformed, empty, or duplicate values\tpublication-workflow.md\nWFL-NO-NEST\tworkflows\tbehavior\terror\tNo step.run callback invokes another step.run directly or through a reachable helper\tInspect callback call graphs and report every nested step.run path\tpublication-workflow.md\nWFL-INT-TYPES\tworkflows\tdeclaration\terror\tWorkflow Integration requirements derive from declared Integration definitions and the SDK projects their clients\tReject Workflow-owned operation interfaces and require its definition generic to reference the declared Integration registry\tcross-domain-workflow.md\nWFL-ONE-OP-STEP\tworkflows\tbehavior\terror\tEvery step owns exactly one semantic asynchronous operation\tTrace each step and report zero or several independently failing operations\tpublication-workflow.md\nWFL-STATE-CODEC\tworkflows\tbehavior\terror\tEvery step result and inter-step value is undefined or portable JSON data\tInspect step values and report actions, clients, symbols, bigint, cycles, or class instances\tpublication-workflow.md\nWFL-RECOVERY\tworkflows\tbehavior\terror\tWhen compensation or unknown-outcome branches exist, they are explicit and rely only on declared operation semantics\tInspect existing recovery branches and report guessed outcomes or compensation without exact evidence\tpublication-workflow.md\nWFL-XDOM-INT\tworkflows\tbehavior\terror\tA Workflow invokes another Domain only through a declared Integration and imports no foreign Domain\tResolve Workflow imports and operations and report foreign Domain imports or calls without Integration ownership\tcross-domain-workflow.md\nMIG-EXACT-REVS\tmigrations\tdataflow\terror\tEvery Migration declares exactly one source revision and one target revision for the same Domain origin\tParse Migration descriptors and reject missing, equal, ambiguous, cross-origin, or dynamically selected revisions\texact-revisions.md\nMIG-APP-DATA\tmigrations\tdataflow\terror\tMigrations transform application-owned facts only and own no schema projection, physical representation, deployment, backup, or external import\tClassify every transformed value and operation and report responsibilities outside application data\trewrite-values.md\nMIG-DEDICATED-CTX\tmigrations\tdataflow\terror\tMigration execution uses only its dedicated source reader, target writer, durable step context, revision-compatible Rules, and generic Utils\tResolve imports and calls and reject ordinary Actions, Workflows, Queries, Mutations, Integrations, Providers, Views, UI, or provider access\texact-revisions.md\nMIG-RESTART-SAFE\tmigrations\tdataflow\terror\tEvery Migration page is idempotent and resumes from a stable checkpoint without reinterpreting accepted target output\tInterrupt before and after every page commit, resume repeatedly, and compare target facts and checkpoints with uninterrupted execution\trestart-safe.md\nMIG-TARGET-PROOF\tmigrations\tdataflow\terror\tA Migration completes only after bounded source coverage and target-revision validation account for every selected source fact\tInject omitted, duplicated, invalid, and over-budget facts and require completion to fail with exact evidence\tverify-target.md\nMIG-DESTRUCTIVE\tmigrations\tdataflow\terror\tEvery destructive or irreversible transform declares and accounts for its intended loss and exposes declared expected failures\tTrace removals and irreversible rewrites and report undeclared or unaccounted loss, open failures, or catch-and-continue behavior\tremove-facts.md\nINT-BOUNDARY\tintegrations\tarchitecture\terror\tEvery Integration represents required behavior across an external, remote-Domain, substitution, process, or trust boundary\tIdentify the boundary for every contract and report behavior that can remain ordinary local Domain code\tpayment-authorization.md\nINT-NEUTRAL\tintegrations\tdeclaration\terror\tEvery Integration owns provider-neutral requests, evidence, correlation, idempotency, trust, and expected failure semantics needed by consumers\tInspect consumers and contracts and report provider fields or missing stable boundary semantics\tid-allocation.md\nINT-PURE\tintegrations\tdependency\terror\tIntegrations remain provider- and execution-boundary-neutral and import no concrete client, credential, configuration, Provider, Action, or Workflow\tResolve runtime and provider imports and report every conclusive concrete or execution-boundary dependency\tdocument-signing.md\nINT-ABILITY-NAME\tintegrations\tstructure\terror\tIntegration submodules are named by required ability and never mirror Schema entities mechanically\tCompare Integration and Schema submodules and report a contract without an independent boundary ability\tobject-storage.md\nACT-ONE-IMPL\tactions\tbehavior\terror\tEvery registered handler binding resolves to exactly one implementation owned by one semantic Actions submodule\tResolve the handler registry and report non-Action owners or duplicate registrations; SDK typing owns callable exhaustiveness\tsynchronous-result.md\nACT-ONE-OP\tactions\tbehavior\terror\tEvery Action performs one terminal semantic operation; only a native binary compatibility Action may precede its Integration call with one exact-receiver Query\tTrace every path and report several terminal effects, writes before effects, non-receiver prerequisite reads, or hidden orchestration\tsingle-operation.md\nACT-OP-KINDS\tactions\tbehavior\terror\tA semantic asynchronous operation is one Query definition, Mutation definition, or Integration call\tClassify every awaited effect and report operations outside the three allowed kinds\tintegration-operation.md\nACT-BOUNDARIES\tactions\tbehavior\terror\tActions use only invocation-bound query and mutate executors, including explicit caller self or union graph partitions, plus declared Integrations; Providers or foreign Domains are never imported\tInspect context use, authority-mode selection, dependencies, imports, and failure mapping; report raw or unbound graph executors, implicit privilege, concrete or foreign dependencies, broad mapping, or swallowed defects\tremote-integration.md\nACT-BINARY-RESULT\tactions\tbehavior\terror\tA binary Action returns detached buffered bytes or streaming bytes with admitted media type status and application headers without collecting or value-framing a provider stream\tExercise buffered and streaming results through their native route; verify exact bytes status headers cancellation and invalid output rejection\tnative-byte-response.md\nRTE-RECIPE\troutes\tdeclaration\terror\tEvery native HTTP Route targets exactly one admitted Action or Workflow recipe\tResolve every route target and report forged missing or several recipes\taction-route.md\nRTE-MAPPING\troutes\tdataflow\terror\tEvery callable input field and instance receiver is mapped exactly once from path query header method or body input\tCompile each route against its resolved callable and reject incomplete ambiguous or unknown mappings\tinstance-route.md\nRTE-CREDENTIAL\troutes\tdataflow\terror\tEvery external credential source is explicit and is never also mapped as callable input\tCompile credential and input mappings and reject duplicate reserved or implicit authority sources\tcredential-route.md\nRTE-ONE-FILE\troutes\tstructure\terror\tEvery Route declaration has one business-intent kebab-case file and Routes composition contains no inline declaration\tInventory route declarations and report generic grouped or inline ownership\tapplication-routes.md\nPRV-INT-IMPL\tproviders\tarchitecture\terror\tEvery Provider implements one or more declared Integrations across a named external or remote-Domain boundary\tIdentify the boundary and implemented contracts and report a Provider without both\tpayment-provider.md\nPRV-BOUNDARY-NAME\tproviders\tstructure\terror\tProvider submodules are named by external system, protocol, or trust boundary rather than Domain entity\tInspect every submodule name and report one justified only by Schema vocabulary\tobject-storage-provider.md\nPRV-ADMIT-RESULT\tproviders\tdataflow\terror\tEvery boundary value is admitted before Integration evidence and recognized boundary failures become stable Integration failures\tTrace input and failure paths and report missing admission, leaked boundary errors, broad mapping, or swallowed defects\twebhook-admission.md\nPRV-NO-DOMAIN\tproviders\tdependency\terror\tProviders perform no local Domain graph operation, business decision, local Action call, or Workflow orchestration\tResolve Provider imports and call graphs and require zero excluded operations\tboundary-composition.md\nPRV-XDOM-TYPED\tproviders\tdependency\terror\tRemote-Domain Providers pass SDK-derived typed callable references to the caller-bound invocation capability without never casts\tInspect Provider execution invoke calls and reject references not constructed through SDK reference, opaque or fabricated references, and never-cast arguments\tremote-domain.md\nPRV-XDOM-REQ\tproviders\tdependency\terror\tEvery statically resolved remote-Domain Provider invocation has one exact Application callable requirement\tMatch each invocation-bound public callable reference to the same foreign facade and callable selector under Application requirements; preserve opaque references or composition as indeterminate\tremote-domain.md\nPRV-XDOM-PUBLIC\tproviders\tdependency\terror\tA remote-Domain Provider uses the remote public facade and invokes at most one public callable per Integration operation\tResolve receiver and facade origins for each remote operation and report private access, missing Integration ownership, unrelated calls, or several public invocations\tremote-domain.md\nVIW-PROJECTION\tviews\tdeclaration\terror\tEvery View converts public Domain values or named Query observations into UI props and connects each action to a named bounded Mutation or public callable contract\tInspect View outputs and actions and report behavior without a Schema, Query, UI, Mutation, Rule, or public callable owner\tdetail-view.md\nVIW-SCHEMA-DECL\tviews\tdeclaration\terror\tSchema owns every DSL View declaration and Views declares no Domain schema construct\tScan View declarations and reject Classes, Properties, Policies, Methods, Actions, or DSL Views\tarticle-list.md\nVIW-DEPS\tviews\tdependency\terror\tViews import only Schema, States, pure Rules, named Queries, bounded named Mutations, UI, shell-react primitives, public callable contracts, and presentation libraries\tInspect resolved imports and report dependencies or raw graph APIs outside the allowlist\tnavigation.md\nVIW-ACTIONS\tviews\tdataflow\terror\tEvery View action executes a named caller-authorized atomic Mutation or invokes a public callable; presentation state is never authorization evidence\tTrace action and authority paths and report inline or raw graph documents, elevated or effectful Mutation use, private Action imports, direct Integration calls, or authority derived from presentation\tform-actions.md\nUI-PRES-DEPS\tui\tdependency\terror\tEvery UI import is a sibling UI module or an external library used only for presentation\tInspect resolved imports and used APIs and report Domain, I/O, persistence, authorization, routing, or provider behavior\tstatus-panel.md\nUI-NO-DOMAIN\tui\tdependency\terror\tUI imports no Domain layer or Domain package facade\tResolve the UI import graph and require zero Domain paths\tresult-list.md\nUI-PURE\tui\tbehavior\terror\tUI performs no I/O, graph access, storage, authorization, business validation, provider call, routing, or Domain result mapping\tInspect components and hooks and report the exact excluded call or branch\tconfirmation-dialog.md\nUI-CALLBACKS\tui\tdataflow\terror\tUI accepts presentation props and forwards intent through callbacks without constructing Domain commands\tInspect props and event handlers and report Domain identities, command construction, or business decisions\tform.md\nUTL-DOM-AGNOSTIC\tutils\tarchitecture\terror\tEvery Utils export is Domain-agnostic and contains no Domain declaration, identity, decision, graph definition, or Workflow step\tInspect signatures and implementations and report the exact Domain concept or business behavior\tresult.md\nUTL-REUSED\tutils\tarchitecture\terror\tEvery Utils extension serves two independent semantic consumers or one package-wide execution boundary\tList direct consumers and report an extension satisfying neither condition\tjson-codec.md\nUTL-PUBLIC-DEPS\tutils\tdependency\terror\tUtils imports only public Kernel, DSL, SDK, standard-library, and sibling Utils modules\tResolve the Utils import graph and reject Domain layers, Providers, or private package paths\tjson-codec.md\nUTL-LIGHTWEIGHT\tutils\tarchitecture\terror\tUtils is private and owns no durable engine, planner, compiler, Repository, service locator, or dependency container\tInspect package exports and declarations and report public exposure or any forbidden framework machinery\tresult.md\nSCR-OPERATOR\tscripts\tbehavior\terror\tEvery root Script implements a supported operator workflow with declared inputs, outcomes, failures, and proof\tInspect each Script contract and report disposable tasks or missing operator semantics\tbackup.md\nSCR-PUBLIC-DEPS\tscripts\tbehavior\terror\tScripts import only dependency-DAG-authorized public facades, standard libraries, and operator libraries and define no Domain behavior\tResolve imports and inspect branches and report private paths, business decisions, graph definitions, or callable behavior\tupgrade.md\nSCR-TEST-DRIVERS\tscripts\tbehavior\terror\tDisposable setup, fixtures, resets, and scenario drivers live under tests/scripts rather than root Scripts\tClassify every Script by supported operator contract and report evidence-only programs at the root\trestore.md\nTST-SYS-OWNER\ttests\tevidence\terror\tRoot Tests owns cross-layer journeys, environments, harnesses, scenarios, seeds, fixtures, and disposable scripts\tInventory evidence support code and report cross-layer artifacts outside Tests or production semantics inside Tests\tmigration-scenario.md\nTST-COLOCATED\ttests\tevidence\terror\tEvery semantic production submodule owns focused evidence in its local __tests__ directory\tJoin production submodules to focused test directories and report missing owners\tfocused-rule.md\n",
     layers: frozenRows([
         {
             id: 'schema',
@@ -211,7 +211,7 @@ export const domainPolicySource = Object.freeze({
             source: 'migrations',
             target: 'states',
             kind: 'type-only',
-            condition: 'Migration transforms preserve lifecycle vocabulary',
+            condition: 'Migration transforms preserve machine-state vocabulary',
         },
         {
             source: 'migrations',

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@astrale-os/sdk",
-  "version": "0.5.0-beta.65",
+  "version": "0.5.0-beta.66",
   "description": "Schema-first SDK for defining, composing, and deploying Astrale domains",
   "keywords": [
     "astrale",