@@ -132,6 +132,9 @@
     "better-sqlite3": "^13.0.3"
   },
   "devDependencies": {
+    "@objectstack/connector-mcp": "workspace:*",
+    "@objectstack/connector-openapi": "workspace:*",
+    "@objectstack/connector-rest": "workspace:*",
     "@objectstack/driver-turso": "workspace:*",
     "@objectstack/plugin-dev": "workspace:*",
     "@oclif/plugin-help": "^6.2.58",
 
@@ -0,0 +1,164 @@
+// Copyright (c) 2026 ObjectStack. Licensed under the Apache-2.0 license.
+
+/**
+ * PIN (#20333) — `npm create objectstack` → `os g flow` → `os validate`
+ * counts the flow, with `os g object` as the control.
+ *
+ * ## What was measured before the fix
+ *
+ * On `origin/main` `c74de10a9`, a project scaffolded by the on-ramp's real
+ * `bin/` entry, then `os g object order_line` and `os g flow order_line`:
+ *
+ *   os g object   exit 0, "Reaches the stack"   (objects was always wired)
+ *   os g flow     exit 0, "Not wired: … is not part of the stack"
+ *   os validate   exit 0, `Data: 2 Objects` and `Logic: 0 Flows`
+ *
+ * The blank starter's config imported `./src/objects` alone, so the flow was
+ * written and never loaded. The control is what makes the red readable: the
+ * same chain counted the generated object, so a 0 for the flow is the wiring
+ * and not a harness that counts nothing.
+ *
+ * ## The chain, through the real commands
+ *
+ *   node create-objectstack/bin/create-objectstack.js my-app --skip-install --skip-skills
+ *   os g object order_line     → exit 0, reaches the stack
+ *   os g flow order_line       → exit 0, reaches the stack, no wiring lines to add
+ *   os validate                → exit 0, `Data: 2 Objects`, `Logic: 1 Flows`
+ *
+ * Asserted: exit statuses, the named subjects, the absence of the wiring
+ * lines `os g` prints for a scaffold that did not arrive (code an author
+ * pastes), and the counts `os validate` prints. Prose is not pinned. The item
+ * names are read off the generator roster, not written down.
+ *
+ * ## Why here, why a child process, and why this file is NOT named `.e2e`
+ *
+ * `os g` and `os validate` are this package's commands, and it already
+ * depends on `create-objectstack`, so `@objectstack/cli#test`'s `^build`
+ * builds the on-ramp's `dist/` — the tree its `bin/` copies from. The bin and
+ * the blank template are declared cross-package inputs of this package
+ * (scripts/cross-package-test-inputs.mjs, mirrored into turbo.json).
+ *
+ * The project lives under this package's `node_modules`, so the scaffolded
+ * config's imports resolve to workspace copies without an install. Besides
+ * `@objectstack/spec`, the blank config imports three connector packages;
+ * they are this package's devDependencies for that reason alone, which is
+ * also what puts them in this suite's build closure.
+ *
+ * An exit status is the contract, and `process.exit` inside a vitest worker
+ * is not one, so the commands are spawned (the `integration` project). The
+ * name keeps it in the per-PR run. The structural half — the blank config
+ * wires exactly what `os init` wires — is `create-objectstack-wiring-parity.test.ts`.
+ */
+
+import { afterAll, beforeAll, describe, expect, it } from 'vitest';
+import { execFile } from 'node:child_process';
+import { mkdtempSync, readFileSync, rmSync } from 'node:fs';
+import { join, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { GENERATOR_SCAFFOLD_TARGETS } from '../src/commands/generate.js';
+import { childEnv } from './helpers/serve-process.js';
+
+const HERE = resolve(fileURLToPath(import.meta.url), '..');
+const CLI = resolve(HERE, '../bin/run-dev.js');
+const TSX = resolve(HERE, '../../../node_modules/.bin/tsx');
+
+// One `resolve(HERE, …)` call per line: `check:cross-package-test-inputs`
+// reconstructs this read by SOURCE SCAN.
+const ON_RAMP_BIN = resolve(HERE, '../../..', 'packages/create-objectstack/bin/create-objectstack.js');
+
+/** One plain-node scaffold, then three oclif + tsx cold starts, sequential. */
+const RUN_TIMEOUT_MS = 240_000;
+
+const PROJECT = 'my-app';
+const NS = 'my_app';
+const STEM = 'order_line';
+
+interface Run {
+  code: number;
+  stdout: string;
+  stderr: string;
+}
+
+function run(file: string, args: string[], cwd: string): Promise<Run> {
+  return new Promise((resolvePromise) => {
+    execFile(
+      file,
+      args,
+      { cwd, maxBuffer: 8 * 1024 * 1024, env: childEnv({ NO_COLOR: '1' }) },
+      (err, stdout, stderr) => {
+        resolvePromise({
+          // `err.code` is the real exit status; a signalled child has none and
+          // is reported as 1, never as 0.
+          code: err
+            ? typeof (err as { code?: unknown }).code === 'number'
+              ? (err as unknown as { code: number }).code
+              : 1
+            : 0,
+          stdout: String(stdout),
+          stderr: String(stderr),
+        });
+      },
+    );
+  });
+}
+
+const os = (args: string[], cwd: string) => run(TSX, [CLI, ...args], cwd);
+const out = (r: Run) => r.stdout + r.stderr;
+
+const target = (type: string) => {
+  const t = GENERATOR_SCAFFOLD_TARGETS.find((g) => g.type === type);
+  if (!t) throw new Error(`no '${type}' generator in the roster`);
+  return t;
+};
+const OBJECT = target('object');
+const FLOW = target('flow');
+
+let root: string;
+let project: string;
+let scaffold: Run;
+let genObject: Run;
+let genFlow: Run;
+let validate: Run;
+
+beforeAll(async () => {
+  root = mkdtempSync(join(HERE, '..', 'node_modules', '.create-objectstack-reach-'));
+  project = join(root, PROJECT);
+  scaffold = await run(process.execPath, [ON_RAMP_BIN, PROJECT, '--skip-install', '--skip-skills'], root);
+  // Sequential on purpose: the object first, so the flow binds to something
+  // declared, and cold starts in a container several agents share.
+  genObject = await os(['g', 'object', STEM], project);
+  genFlow = await os(['g', 'flow', STEM], project);
+  validate = await os(['validate'], project);
+}, RUN_TIMEOUT_MS);
+
+afterAll(() => {
+  if (root) rmSync(root, { recursive: true, force: true });
+});
+
+describe('[#20333] `npm create objectstack` → `os g flow` → `os validate`', () => {
+  it('the on-ramp scaffolded the project, under the namespace this file assumes', () => {
+    expect(scaffold.code, out(scaffold)).toBe(0);
+    expect(readFileSync(join(project, 'objectstack.config.ts'), 'utf-8')).toContain(`namespace: '${NS}'`);
+  });
+
+  it('CONTROL: `os g object` reaches the stack', () => {
+    expect(genObject.code, out(genObject)).toBe(0);
+    expect(genObject.stdout).toContain(`'${OBJECT.itemName(STEM, NS)}'`);
+    expect(genObject.stdout).not.toContain(`import * as ${OBJECT.stackKey}`);
+  });
+
+  it('`os g flow` reaches the stack, with no wiring lines to add', () => {
+    expect(genFlow.code, out(genFlow)).toBe(0);
+    expect(genFlow.stdout).toContain(`'${FLOW.itemName(STEM, NS)}'`);
+    expect(genFlow.stdout).not.toContain(`import * as ${FLOW.stackKey}`);
+    // Nor a `requires` line: the starter already declares what a flow runs on.
+    expect(genFlow.stdout).not.toContain('requires: [');
+  });
+
+  it('`os validate` exits 0 and counts the generated flow beside the control', () => {
+    expect(validate.code, out(validate)).toBe(0);
+    // The starter's own object plus the generated one.
+    expect(validate.stdout).toMatch(/\bData: 2 Objects\b/);
+    expect(validate.stdout).toMatch(/\bLogic: 1 Flows\b/);
+  });
+});
@@ -0,0 +1,141 @@
+// Copyright (c) 2026 ObjectStack. Licensed under the Apache-2.0 license.
+
+/**
+ * PIN (#20333) — `npm create objectstack`'s blank starter wires exactly the
+ * barrels `os init` wires, in the lines `os init` renders.
+ *
+ * ## The defect
+ *
+ * The blank starter's `objectstack.config.ts` imported `./src/objects` alone.
+ * `os g view|action|flow|dashboard|app|skill` wrote a scaffold and a barrel
+ * that nothing imported, and `os validate` exited 0 with `Logic: 0 Flows`.
+ * `os init` had the same config and was fixed by wiring every generator
+ * barrel (#20215): `SCAFFOLD_WIRED_BARRELS`, derived from the generator
+ * roster, rendered through `exportsOf` over `export {};` barrels, with
+ * `SCAFFOLD_WIRED_REQUIRES` in `requires`.
+ *
+ * ## Why a parity pin, and why it lives in this package
+ *
+ * `create-objectstack` cannot import that roster. The dependency edge runs
+ * the other way (this package depends on it for `created-summary`), and the
+ * npx entry point must not pull the CLI's closure — the same boundary
+ * `scripts/sync-scaffold-emission-policy.mjs` documents. Its template is a
+ * static file tree copied byte for byte, so its wiring is a COPY of what
+ * `os init` renders. A copy with nothing binding it to the source is a second
+ * wiring rule, and it decays: the next generator added to the roster would be
+ * wired by `os init` and silently not by the on-ramp.
+ *
+ * This file is the binding. Every expected value below is READ off the CLI —
+ * `TEMPLATES.app`'s rendered config and barrels, and the two exported
+ * rosters — and none is written down here, so a roster change, a renderer
+ * change or a hand edit of the template reddens this file until the two
+ * scaffolders agree again. Only this package can call the renderer; the
+ * template side is a static file, so reading it IS reading its producer.
+ *
+ * What is compared is code, verbatim: the barrel imports, the `exportsOf`
+ * helper, the stack-key lines, the `requires` tokens, and each empty barrel's
+ * bytes. The prose comments around them are not compared — the starter keeps
+ * its own explanation of `automation` (its connectors need it too).
+ *
+ * The behaviour this wiring buys is pinned through the real commands in
+ * `create-objectstack-stack-reach.test.ts` (`npm create objectstack` →
+ * `os g flow` → `os validate`).
+ */
+
+import { describe, expect, it } from 'vitest';
+import { existsSync, readFileSync } from 'node:fs';
+import { join, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { SCAFFOLD_WIRED_BARRELS, SCAFFOLD_WIRED_REQUIRES, TEMPLATES } from '../src/commands/init.js';
+
+const HERE = resolve(fileURLToPath(import.meta.url), '..');
+
+// One `resolve(HERE, …)` call per line: `check:cross-package-test-inputs`
+// reconstructs these reads by SOURCE SCAN. The blank template is declared as a
+// cross-package input of `@objectstack/cli` (scripts/cross-package-test-inputs.mjs,
+// mirrored into turbo.json), so a template-only diff re-runs this file.
+const BLANK = resolve(HERE, '../../create-objectstack/src/templates/blank');
+
+const blankConfig = readFileSync(join(BLANK, 'objectstack.config.ts'), 'utf8');
+const initConfig = TEMPLATES.app.configContent('my-app', 'my_app');
+
+/** Every line of `text` matching `re`, sorted — order is not the contract. */
+const linesMatching = (text: string, re: RegExp): string[] =>
+  text.split('\n').filter((line) => re.test(line)).sort();
+
+/** `import * as <key> from './src/<dir>';` — one per wired barrel. */
+const BARREL_IMPORT = /^import \* as \w+ from '\.\/src\/[\w-]+';$/;
+/** `  <key>: exportsOf(<key>),` — one per wired barrel, inside `defineStack`. */
+const STACK_KEY = /^\s+\w+: exportsOf\(\w+\),$/;
+/** The helper both configs read their barrels through. */
+const HELPER = /^const exportsOf = /;
+
+/** A barrel whose only code is `export {};` — comments aside. */
+const isEmptyBarrel = (source: string): boolean =>
+  source
+    .split('\n')
+    .filter((line) => line.trim() !== '' && !line.trimStart().startsWith('//'))
+    .join('\n') === 'export {};';
+
+describe('[#20333] the roster this file reads is the real one', () => {
+  it('wires more than objects, and includes flows', () => {
+    // Vacuity guard: an empty or objects-only roster would make every
+    // comparison below agree with the defect.
+    expect(SCAFFOLD_WIRED_BARRELS.length).toBeGreaterThan(1);
+    expect(SCAFFOLD_WIRED_BARRELS.map((b) => b.stackKey)).toContain('flows');
+    expect(SCAFFOLD_WIRED_REQUIRES.length).toBeGreaterThan(0);
+  });
+
+  it('the patterns below find one line per wired barrel in the CLI render', () => {
+    expect(linesMatching(initConfig, BARREL_IMPORT)).toHaveLength(SCAFFOLD_WIRED_BARRELS.length);
+    expect(linesMatching(initConfig, STACK_KEY)).toHaveLength(SCAFFOLD_WIRED_BARRELS.length);
+    expect(linesMatching(initConfig, HELPER)).toHaveLength(1);
+  });
+});
+
+describe('[#20333] the blank config wires what `os init` wires, in its lines', () => {
+  it('imports every wired barrel, and nothing else under ./src', () => {
+    expect(linesMatching(blankConfig, BARREL_IMPORT)).toEqual(linesMatching(initConfig, BARREL_IMPORT));
+  });
+
+  it('reads the barrels through the same `exportsOf` helper', () => {
+    expect(linesMatching(blankConfig, HELPER)).toEqual(linesMatching(initConfig, HELPER));
+  });
+
+  it('hands every wired barrel to its stack key', () => {
+    expect(linesMatching(blankConfig, STACK_KEY)).toEqual(linesMatching(initConfig, STACK_KEY));
+  });
+
+  it('declares every capability the scaffolds need to run', () => {
+    const declared = [...blankConfig.matchAll(/^\s+requires: \[([^\]]*)\],$/gm)];
+    expect(declared, 'exactly one top-level `requires` line').toHaveLength(1);
+    const tokens = declared[0][1].split(',').map((t) => t.trim().replace(/^'|'$/g, ''));
+    // A superset, not an equality: the starter's connectors need `automation`
+    // whether or not a scaffold does.
+    for (const token of SCAFFOLD_WIRED_REQUIRES) expect(tokens, token).toContain(token);
+  });
+});
+
+describe('[#20333] the blank template ships every wired barrel', () => {
+  const barrels = SCAFFOLD_WIRED_BARRELS.map((b) => {
+    const file = `${b.dir}/index.ts`;
+    const render = TEMPLATES.app.srcFiles[file];
+    return { ...b, file, init: render ? render('my-app', 'my_app') : undefined };
+  });
+
+  it.each(barrels.map((b) => [b.file, b] as const))('%s exists', (_file, b) => {
+    expect(existsSync(join(BLANK, b.file))).toBe(true);
+  });
+
+  const empty = barrels.filter((b) => b.init !== undefined && isEmptyBarrel(b.init));
+
+  it('`os init` writes an empty barrel for every wired directory but objects', () => {
+    // Vacuity guard for the byte comparison below.
+    expect(empty.map((b) => b.stackKey).sort())
+      .toEqual(SCAFFOLD_WIRED_BARRELS.map((b) => b.stackKey).filter((k) => k !== 'objects').sort());
+  });
+
+  it.each(empty.map((b) => [b.file, b] as const))('%s is byte-identical to the one `os init` writes', (_file, b) => {
+    expect(readFileSync(join(BLANK, b.file), 'utf8')).toBe(b.init);
+  });
+});