@@ -1,5 +1,5 @@
 ---
-'@objectstack/metadata-protocol': minor
+'@objectstack/lint': minor
 ---
 
 **BREAKING** fix(metadata)!: a flow whose loop, parallel or try_catch region is malformed is refused at publish, and its draft read says so, instead of publishing and then never registering
@@ -8,13 +8,13 @@ Clause-②: no (narrowing)
 Metadata-protocol: narrowed
 Skills-docs: none — no published skill teaches that a malformed region publishes; the automation skill's region rules (one entry, one exit, acyclic) stay true, and the publish door now refuses a region that breaks them earlier, in the engine's words.
 
-<!-- adr-0087: not-required (no-migration-prescription) No key of any schema is added, removed, renamed or re-shaped. The publish doors now refuse a flow body whose region the automation engine already refused to register, with the engine's own sentence, so a published body that could never run has nothing a migration could rewrite it to: the author's fix is the one the refusal names. -->
+<!-- adr-0087: not-required (no-migration-prescription) No key of any schema is added, removed, renamed or re-shaped. The publish doors now refuse a flow body the automation engine already refuses to register, with the engine's own sentence, so a published body that could never run has nothing a migration could rewrite it to: the author's fix is the one the refusal names. -->
 
-**BREAKING** accept-set narrowing at the runtime authoring gate (`@objectstack/metadata-protocol`), which the metadata draft read and every publish door run (`PUT /api/v1/meta/:type/:name` live, `POST …/publish`, `POST /api/v1/packages/:id/publish-drafts`).
+**BREAKING** accept-set narrowing at the runtime authoring gate, which the metadata draft read and every publish door run (`PUT /api/v1/meta/:type/:name` live, `POST …/publish`, `POST /api/v1/packages/:id/publish-drafts`). The `@objectstack/lint` authoring rule `validateFlowRegionShape` (`flow-region-shape-invalid`), which `os validate`, `os build` and `os lint` already run, now also runs on that gate for `flow` writes (`surfaces: CLI_AND_RUNTIME`, `runtimeTypes: ['flow']`).
 
 - **Before.** A flow whose ADR-0031 region was malformed (a `loop` body, a `parallel` branch or a `try_catch` try or catch region, at any depth, with no single entry or exit node, a cycle inside it, a shape its region schema refuses, or a `parallel` block with fewer than two branches) saved as a draft, its draft read answered `_diagnostics: { valid: true }`, and it published (`outcome: 'published'`). The automation engine then refused to register it ("loop 'lp' body: region has no entry node …; region contains a cycle (region bodies must be acyclic)"), so the flow never ran, and only the by-name read's `registration` and a boot-log warning said why.
-- **Now.** The draft still saves (drafts are never gated). Its read answers `valid: false` with an error coded `flow-region-malformed` on the container node whose region is at fault (`nodes.N`, or the nested path such as `nodes.1.config.try.nodes.0`), and every publish door refuses it `422 INVALID_METADATA` with that finding; a package publish refuses the batch (`outcome: 'refused'`). The message is the engine's registration refusal, word for word.
-- **One judge.** The gate calls `validateControlFlow` (`@objectstack/spec/automation`), the function the engine's registration calls, on the body parsed through `FlowSchema` as the engine parses it. A body the flow schema refuses is reported by the schema, as before.
-- **Unchanged.** A flow whose regions the engine accepts publishes and registers, as before. `os validate` and `os build` do not run this check yet.
+- **Now.** The draft still saves (drafts are never gated). Its read answers `valid: false` with an error coded `flow-region-shape-invalid`, and every publish door refuses it `422 INVALID_METADATA` with that finding; a package publish refuses the batch (`outcome: 'refused'`). The message is "Flow 'NAME' would be refused at registration: " followed by the engine's registration refusal, word for word. The finding names the flow (one per flow, the engine's first refusal); the sentence names the region.
+- **One judge, one name.** The rule calls `FlowSchema`, then `validateControlFlow` (`@objectstack/spec/automation`), the two calls the engine's registration makes. A flow body the flow schema refuses is reported by this rule too ("could not be judged for its region shape"), as on the CLI.
+- **Unchanged.** A flow whose regions the engine accepts publishes and registers, as before.
 
 **The remedy.** None for a flow that registers today: it publishes exactly as before. A flow this now refuses was already refused by the engine at registration and never ran; the refusal names the region and what is wrong with it. Give the region one entry node and one exit node with no cycle inside it, and give a `parallel` block at least two branches. A stored flow published before this change is re-registered exactly as before (still refused by the engine).
@@ -1981,11 +1981,12 @@ export const AUTHORING_RULES: readonly AuthoringRule[] = [
     input: 'parsed',
     commands: ALL,
     source: 'packages/lint/src/validate-flow-region-shape.ts',
-    surfaces: CLI_ONLY,
-    surfaceReason:
-      'Not yet on the runtime publish gate: whether a flow write whose region the engine refuses is refused at '
-      + 'publish is the server lane\'s open question for the metadata write path, decided there; this entry '
-      + 'brings the three authoring commands to the engine\'s registration verdict.',
+    // [#29233] Runtime publish gate (#4463): a flow whose region the engine
+    // refuses to register can only ever publish as a flow that never runs, so
+    // the draft read and every publish door refuse it here, through this one
+    // row, rather than through a gate-local copy of the same judgement.
+    surfaces: CLI_AND_RUNTIME,
+    runtimeTypes: ['flow'],
     run: (stack) => validateFlowRegionShape(stack),
   },
   // The same predicate over a declarative connector's four header/env maps
 
@@ -21,28 +21,35 @@ import { validatePredicatePathRefs } from './validate-predicate-path-refs.js';
 import { validateWidgetBindings } from './validate-widget-bindings.js';
 
 /** The issue's measured example: an approval flow whose expression approver is broken CEL. */
+// [#29233] Spelled as a body the flow schema accepts (a `type`, node labels,
+// an edge list, no top-level `trigger`), since the publish gate now runs the
+// region-shape rule, which refuses a flow the schema refuses. Each case below
+// still isolates the one thing it pins: the approver expression.
 const brokenApprovalFlow = {
   name: 'leave_approval',
   label: 'Leave approval',
-  trigger: { type: 'record_change', object: 'leave_request', events: ['create'] },
+  type: 'autolaunched',
   nodes: [
-    { id: 'start', type: 'start' },
+    { id: 'start', type: 'start', label: 'Start' },
     {
       id: 'approve',
       type: 'approval',
+      label: 'Approve',
       config: { approvers: [{ type: 'expression', value: 'record.owner ==' }] },
     },
   ],
+  edges: [{ id: 'e1', source: 'start', target: 'approve' }],
 };
 
 /** The same flow with an approver expression that parses and uses a legal root. */
 const cleanApprovalFlow = {
   ...brokenApprovalFlow,
   nodes: [
-    { id: 'start', type: 'start' },
+    { id: 'start', type: 'start', label: 'Start' },
     {
       id: 'approve',
       type: 'approval',
+      label: 'Approve',
       config: {
         approvers: [{ type: 'expression', value: 'current.owner' }],
       },
 
@@ -1099,13 +1099,17 @@ describe('validateFlowTriggerReadiness', () => {
       config: Record<string, unknown>,
       overrides: Record<string, unknown> = {},
     ): Record<string, unknown> {
+      // [#29233] A label on the flow and its nodes: the runtime publish gate
+      // the cases below cross now runs the region-shape rule, which refuses a
+      // body the flow schema refuses.
       return {
         name: 'inbound_order',
+        label: 'Inbound order',
         type: 'api',
         status: 'active',
         nodes: [
-          { id: 'start', type: 'start', config },
-          { id: 'end', type: 'end' },
+          { id: 'start', type: 'start', label: 'Start', config },
+          { id: 'end', type: 'end', label: 'End' },
         ],
         edges: [{ id: 'e1', source: 'start', target: 'end' }],
         ...overrides,
@@ -1298,8 +1302,8 @@ describe('validateFlowTriggerReadiness', () => {
         // it `flows[0].nodes[1].config.secret`, the rule's own finding path.
         const startSecond = apiFlow({ hookId: 'intake' }, {
           nodes: [
-            { id: 'end', type: 'end' },
-            { id: 'start', type: 'start', config: { hookId: 'intake' } },
+            { id: 'end', type: 'end', label: 'End' },
+            { id: 'start', type: 'start', label: 'Start', config: { hookId: 'intake' } },
           ],
         });
         const at = (paths: string[]) =>
 
@@ -464,7 +464,7 @@ const CASES: Array<{ rule: string; type: string; item: { name: string } & Record
         // [#29233] A loop whose body closes on itself (body a → b → a, the
         // card's reproduction). It saved, read valid:true and PUBLISHED, and
         // the engine's region check then refused to register it.
-        rule: 'flow-region-malformed',
+        rule: 'flow-region-shape-invalid',
         type: 'flow',
         item: regionFlow('region_loop', {
             id: 'lp',
@@ -614,11 +614,13 @@ describe('a draft reads the verdict its publish gives (#26707)', () => {
         expect(published).toMatchObject({ success: true, publishedCount: 3, failedCount: 0 });
     });
 
-    it('[#29233] the region verdict is located at the container, at its depth, on the draft read', async () => {
+    it('[#29233] the region verdict on the draft read is the registry rule\'s: the engine\'s sentence, at the item root', async () => {
         const { engine } = makeStubEngine();
         const protocol = new ObjectStackProtocolImplementation(engine);
-        // A one-branch parallel block nested in a try region: the engine names
-        // both levels, and the finding lands on the inner container.
+        // A one-branch parallel block nested in a try region. The registry rule
+        // judges the flow as one unit (as the engine does) and anchors the
+        // flow itself, so the item-relative path is the item root; the
+        // sentence names the region.
         const flow = regionFlow('nested_region', {
             id: 'guard', type: 'try_catch', label: 'Guard',
             config: {
@@ -633,10 +635,10 @@ describe('a draft reads the verdict its publish gives (#26707)', () => {
 
         const diagnostics = await draftDiagnostics(protocol, 'flow', flow.name);
         expect(diagnostics.valid).toBe(false);
-        expect((diagnostics.errors ?? []).filter((e) => e.code === 'flow-region-malformed')).toEqual([{
-            path: 'nodes.1.config.try.nodes.0',
-            message: "parallel 'fan': a parallel block needs at least 2 branches",
-            code: 'flow-region-malformed',
+        expect((diagnostics.errors ?? []).filter((e) => e.code === 'flow-region-shape-invalid')).toEqual([{
+            path: '',
+            message: "Flow 'nested_region' would be refused at registration: parallel 'fan': a parallel block needs at least 2 branches",
+            code: 'flow-region-shape-invalid',
         }]);
     });
 
 
@@ -1,19 +1,23 @@
 // Copyright (c) 2026 ObjectStack. Licensed under the Apache-2.0 license.
 
 /**
- * [#29233] The gate-local `flow-region-malformed` rule, on the pure gate: the
- * gate refuses the ADR-0031 regions the engine's registration refuses (a loop
- * body, a parallel branch, a try or catch region, at any depth), with the
- * sentence the engine throws, located on the container it names. The judge is
- * `validateControlFlow`, the function `canonicalizeFlow` calls; every expected
- * message below is that function's own answer for the case, never a
- * restatement. The draft-read and publish doors over a real protocol are pinned
- * in `protocol.draft-publish-verdict.test.ts`.
+ * [#29233] The registry rule `flow-region-shape-invalid`
+ * (`validateFlowRegionShape`, `@objectstack/lint`) on the pure runtime gate:
+ * the gate refuses the ADR-0031 regions the engine's registration refuses (a
+ * loop body, a parallel branch, a try or catch region, at any depth), with the
+ * sentence the engine throws. The judge is `validateControlFlow`, the function
+ * `canonicalizeFlow` calls; every expected sentence below is that function's
+ * own answer for the case, never a restatement. The draft-read and publish
+ * doors over a real protocol are pinned in
+ * `protocol.draft-publish-verdict.test.ts`.
  */
 
 import { describe, expect, it } from 'vitest';
 import { FlowSchema, validateControlFlow } from '@objectstack/spec/automation';
-import { evaluateRuntimeAuthoringGate, FLOW_REGION_MALFORMED } from './runtime-authoring-gate.js';
+import { evaluateRuntimeAuthoringGate } from './runtime-authoring-gate.js';
+
+/** The registry rule's id (`FLOW_REGION_SHAPE_INVALID` in `@objectstack/lint`). */
+const RULE = 'flow-region-shape-invalid';
 
 type Rec = Record<string, unknown>;
 
@@ -57,11 +61,14 @@ function engineRefusal(flow: unknown): string | null {
 function regionIssues(flow: { name: string }, state: 'active' | 'draft' = 'active') {
     const verdict = evaluateRuntimeAuthoringGate({ type: 'flow', name: flow.name, state, body: structuredClone(flow) });
     const err = verdict.error as (Error & { code: string; status: number; issues: any[]; rulesRun: string[] }) | null;
-    return { err, issues: (err?.issues ?? []).filter((i) => i.rule === FLOW_REGION_MALFORMED) };
+    return { err, issues: (err?.issues ?? []).filter((i) => i.rule === RULE) };
 }
 
-describe('[#29233] the publish gate refuses the regions the engine refuses', () => {
-    it('the card: a loop body a → b → a is refused on the loop, in the engine\'s sentence', () => {
+/** The registry rule's message: the engine's refusal behind the flow's name. */
+const refusedAt = (name: string, sentence: string | null) => `Flow '${name}' would be refused at registration: ${sentence}`;
+
+describe('[#29233] the publish gate refuses the regions the engine refuses, through the registry rule', () => {
+    it('the card: a loop body a → b → a is refused, in the engine\'s sentence', () => {
         const flow = flowOf('rgnprobe_loop', [loop('lp', closedBody('k'))]);
         const sentence = engineRefusal(flow);
         expect(sentence).toBe(
@@ -71,63 +78,57 @@ describe('[#29233] the publish gate refuses the regions the engine refuses', ()
         );
         const { err, issues } = regionIssues(flow);
         expect(err).toMatchObject({ code: 'INVALID_METADATA', status: 422 });
-        expect(err!.rulesRun).toContain(FLOW_REGION_MALFORMED);
+        expect(err!.rulesRun).toContain('validateFlowRegionShape');
         expect(issues).toEqual([{
             severity: 'error',
-            rule: FLOW_REGION_MALFORMED,
-            where: 'flow "rgnprobe_loop" · node "Loop lp"',
-            path: 'flows[0].nodes[1]',
-            message: sentence,
+            rule: RULE,
+            where: "flow 'rgnprobe_loop'",
+            path: 'flows[0]',
+            message: refusedAt('rgnprobe_loop', sentence),
             hint: expect.any(String),
         }]);
     });
 
-    it('a parallel block with one branch is refused on the block', () => {
+    it('a parallel block with one branch is refused', () => {
         const flow = flowOf('one_branch', [{ id: 'fan', type: 'parallel', label: 'Fan', config: { branches: [oneStep('only')] } }]);
         expect(regionIssues(flow).issues).toEqual([
-            expect.objectContaining({ path: 'flows[0].nodes[1]', message: engineRefusal(flow) }),
+            expect.objectContaining({ path: 'flows[0]', message: refusedAt('one_branch', engineRefusal(flow)) }),
         ]);
     });
 
-    it('a try region that closes on itself is refused on the try_catch', () => {
+    it('a try region that closes on itself is refused', () => {
         const flow = flowOf('closed_try', [{
             id: 'guard', type: 'try_catch', label: 'Guard', config: { try: closedBody('t'), catch: oneStep('c') },
         }]);
         const sentence = engineRefusal(flow);
         expect(sentence).toMatch(/^try_catch 'guard' try: /);
-        expect(regionIssues(flow).issues).toEqual([
-            expect.objectContaining({ path: 'flows[0].nodes[1]', message: sentence }),
-        ]);
+        expect(regionIssues(flow).issues).toEqual([expect.objectContaining({ message: refusedAt('closed_try', sentence) })]);
     });
 
     it('a region its schema refuses is refused with the engine\'s "invalid region" sentence', () => {
         const flow = flowOf('shapeless', [loop('lp', { nodes: 'not a list' })]);
         const sentence = engineRefusal(flow);
         expect(sentence).toMatch(/^loop 'lp' body: invalid region — /);
-        expect(regionIssues(flow).issues).toEqual([
-            expect.objectContaining({ path: 'flows[0].nodes[1]', message: sentence }),
-        ]);
+        expect(regionIssues(flow).issues).toEqual([expect.objectContaining({ message: refusedAt('shapeless', sentence) })]);
     });
 
-    it('a malformed region nested in another names both levels and lands on the inner container', () => {
+    it('a malformed region nested in another is refused, its sentence naming both levels', () => {
         const flow = flowOf('nested', [{
             id: 'guard', type: 'try_catch', label: 'Guard',
             config: { try: { nodes: [loop('inner', closedBody('n'))], edges: [] }, catch: oneStep('c') },
         }]);
         const sentence = engineRefusal(flow)!;
         expect(sentence).toMatch(/^try_catch 'guard' try → loop 'inner' body: /);
         expect(regionIssues(flow).issues).toEqual([
-            expect.objectContaining({
-                where: 'flow "nested" · node "Loop inner"',
-                path: 'flows[0].nodes[1].config.try.nodes[0]',
-                message: sentence,
-            }),
+            expect.objectContaining({ path: 'flows[0]', message: refusedAt('nested', sentence) }),
         ]);
     });
 
-    it('two malformed top-level containers are reported one finding each', () => {
+    it('two malformed containers give one finding, the engine\'s first refusal', () => {
         const flow = flowOf('two_bad', [loop('first', closedBody('f')), loop('second', closedBody('s'))]);
-        expect(regionIssues(flow).issues.map((i) => i.path)).toEqual(['flows[0].nodes[1]', 'flows[0].nodes[2]']);
+        const sentence = engineRefusal(flow)!;
+        expect(sentence).toMatch(/^loop 'first' body: /);
+        expect(regionIssues(flow).issues).toEqual([expect.objectContaining({ message: refusedAt('two_bad', sentence) })]);
     });
 
     it('controls: a well-formed loop, parallel and try_catch region, nested too, raise nothing', () => {
@@ -140,18 +141,13 @@ describe('[#29233] the publish gate refuses the regions the engine refuses', ()
             },
         ]);
         expect(engineRefusal(flow)).toBeNull();
-        expect(regionIssues(flow).issues).toEqual([]);
+        const verdict = evaluateRuntimeAuthoringGate({ type: 'flow', name: flow.name, state: 'active', body: structuredClone(flow) });
+        expect(((verdict.error as any)?.issues ?? []).filter((i: any) => i.rule === RULE)).toEqual([]);
     });
 
     it('a draft is not gated (D1)', () => {
         const flow = flowOf('draft_loop', [loop('lp', closedBody('d'))]);
         expect(evaluateRuntimeAuthoringGate({ type: 'flow', name: flow.name, state: 'draft', body: structuredClone(flow) }).error)
             .toBeNull();
     });
-
-    it('a body the flow schema refuses is the schema\'s to report: no region finding', () => {
-        const flow = { ...flowOf('no_label', [loop('lp', closedBody('x'))]), label: undefined };
-        expect(FlowSchema.safeParse(flow).success).toBe(false);
-        expect(regionIssues(flow).issues).toEqual([]);
-    });
 });