@@ -0,0 +1,15 @@
+---
+'create-objectstack': patch
+---
+
+fix(create-objectstack): the blank starter wires every directory `os generate` writes into
+
+`npm create objectstack` scaffolded an `objectstack.config.ts` that imported `./src/objects` alone. `os g view`, `action`, `flow`, `dashboard`, `app` and `skill` each wrote a file and a barrel `index.ts` that nothing imported, and `os validate` then exited 0 printing `Logic: 0 Flows`: the generated metadata was never loaded.
+
+**What a new blank project now ships** is the wiring `os init` writes:
+
+- `objectstack.config.ts` imports every directory `os generate` writes into (`src/objects`, `src/views`, `src/actions`, `src/flows`, `src/dashboards`, `src/apps`, `src/skills`) and hands each barrel's exports to `defineStack` under its key (`objects`, `views`, …). A file `os g` writes there is part of the stack with no edit to the config. The keys read the barrels through a small `exportsOf` helper declared in the config, because `Object.values` on an empty barrel does not type-check against `defineStack`'s collection types.
+- An `index.ts` containing only `export {};` in each of those directories except `src/objects`, which keeps the sample object.
+- `requires: ['automation', 'triggers']`. `automation` was already there for the three connector plugins. `triggers` fires a flow that starts on a record change, the kind `os g flow` writes, and without it the config stops loading as soon as it holds one. A project with no flow boots as before.
+
+**Projects scaffolded by an earlier release** keep their config. `os g` says when a file it wrote is not wired, and prints the lines to add.
@@ -33,10 +33,15 @@ This scaffolds a working project with `objectstack.config.ts`, a sample object,
 
 ```bash
 os generate object customer    # Add a Customer object
-os generate action approve     # Add an action
-os generate flow onboarding    # Add an automation flow
+os generate flow customer      # Add an automation flow on it
+os generate action customer    # Add an action on it that runs the flow
 ```
 
+Each command writes a file and its export line, and the starter's config already
+wires every directory they write into, so all three are part of the stack. The
+flow and the action bind to the object named like them, which is why the object
+comes first: an action bound to an object the stack does not declare is refused.
+
 ### Launch the dev server
 
 ```bash
@@ -739,8 +744,8 @@ the view and the action listed under
 renamed out of that page's `support_desk_` namespace into `my_app_`. That page's `support`
 app is **not** added, and a zero count is never printed, which is why the `UI:` row reads
 `1 Views  1 Actions` with no `Apps`. The walkthrough's `os generate` commands are **not**
-part of the fixture — run those as well and the summary gains `my_app_customer` and a
-`Logic:` row. Timings are machine identity, and the rule count and artifact size track the
+part of the fixture — run those as well and the summary gains `my_app_customer`, a second
+action and a `Logic:` row. Timings are machine identity, and the rule count and artifact size track the
 CLI version; everything else is fixture identity and reproduces.
 </Callout>
 
@@ -1410,7 +1415,8 @@ else a scaffold names (an action's, flow's or app's own `name`) is prefixed.
 
 **Every scaffold reaches the stack, or the command says it does not.** The
 `objectstack.config.ts` that `os init` writes for the `app` and `plugin`
-templates wires every directory in the table below: it imports each
+templates, and the one the `npm create objectstack` starter ships, wires every
+directory in the table below: it imports each
 `src/<dir>/index.ts` barrel and hands its exports to `defineStack` under the key
 in the **Collected as** column, so a file `os g` writes there is part of the
 stack with no edit to the config. It also declares
@@ -1421,8 +1427,8 @@ After writing, `os g` loads the config again and says which of these holds:
   checks it.
 - **Not wired**: the config loads and its stack does not carry the item, or
   there is no config. This is what happens with a config that imports
-  `./src/objects` alone, as `os init` projects from earlier releases and the
-  `npm create objectstack` starter do. The file is written, the config is left
+  `./src/objects` alone, as projects that `os init` and `npm create objectstack`
+  scaffolded in earlier releases do. The file is written, the config is left
   as it was, and the command prints the import and the `defineStack` key that
   wire the directory.
 - **Cannot run**: the stack carries a flow, and its `requires` lacks
 
@@ -91,22 +91,41 @@ my-app/
 ├── tsconfig.json
 ├── AGENTS.md                    # conventions for coding agents
 └── src/
-    └── objects/
-        ├── index.ts             # barrel — re-exports every object
-        └── note.object.ts       # a sample object
+    ├── objects/
+    │   ├── index.ts             # barrel — re-exports every object
+    │   └── note.object.ts       # a sample object
+    ├── views/index.ts           # an empty barrel for each directory
+    ├── actions/index.ts         # `os generate` writes into, already
+    ├── flows/index.ts           # wired into objectstack.config.ts
+    ├── dashboards/index.ts
+    ├── apps/index.ts
+    └── skills/index.ts
 ```
 
 Two files matter most:
 
 **`objectstack.config.ts`** wires everything together. There is no
-filename-suffix magic — metadata exists in the app only if it is imported here:
+filename-suffix magic — metadata exists in the app only if it is imported here.
+Every directory `os generate` writes into is already imported, so a generated
+view, action or flow adds a file and one export line to its directory's
+`index.ts` and is part of the stack with no edit to this file:
 
 ```typescript title="objectstack.config.ts"
 import { defineStack } from '@objectstack/spec';
 import { ConnectorRestPlugin } from '@objectstack/connector-rest';
 import { ConnectorOpenApiPlugin } from '@objectstack/connector-openapi';
 import { ConnectorMcpPlugin } from '@objectstack/connector-mcp';
-import * as objects from './src/objects/index.js';
+import * as objects from './src/objects';
+import * as views from './src/views';
+import * as actions from './src/actions';
+import * as flows from './src/flows';
+import * as dashboards from './src/dashboards';
+import * as apps from './src/apps';
+import * as skills from './src/skills';
+
+// Object.values, typed by what the barrel exports, so an empty barrel still
+// type-checks.
+const exportsOf = <M extends object>(barrel: M): M[keyof M][] => Object.values(barrel);
 
 export default defineStack({
   manifest: {
@@ -120,14 +139,22 @@ export default defineStack({
   },
   // `automation` runs flows and, per ADR-0097, materializes declarative
   // `connectors:` entries at boot. The three generic executors below register
-  // their `rest` / `openapi` / `mcp` provider factories with it.
-  requires: ['automation'],
+  // their `rest` / `openapi` / `mcp` provider factories with it. `triggers`
+  // fires a flow that starts on a record change, the kind `os generate flow`
+  // writes.
+  requires: ['automation', 'triggers'],
   plugins: [
     new ConnectorRestPlugin(),
     new ConnectorOpenApiPlugin(),
     new ConnectorMcpPlugin(),
   ],
-  objects: Object.values(objects),
+  objects: exportsOf(objects),
+  views: exportsOf(views),
+  actions: exportsOf(actions),
+  flows: exportsOf(flows),
+  dashboards: exportsOf(dashboards),
+  apps: exportsOf(apps),
+  skills: exportsOf(skills),
 });
 ```
 
 
@@ -77,9 +77,15 @@ my-app/
 ├── README.md
 ├── AGENTS.md                    # conventions for coding agents
 └── src/
-    └── objects/
-        ├── index.ts
-        └── note.object.ts
+    ├── objects/
+    │   ├── index.ts
+    │   └── note.object.ts
+    ├── views/index.ts           # an empty barrel for each directory
+    ├── actions/index.ts         # `objectstack generate` writes into,
+    ├── flows/index.ts           # already wired into objectstack.config.ts
+    ├── dashboards/index.ts
+    ├── apps/index.ts
+    └── skills/index.ts
 ```
 
 Next steps inside the project:
 
@@ -142,7 +142,7 @@ const MONOREPO_ONLY = [
   // "the shallowest point a path reaches"). In THIS population the two give
   // the same answer, for a measured reason: every relative reference the
   // shipped tree carries is `./`-anchored and points DOWNWARD from the file
-  // that writes it (`./note.object.js`, `./src/objects/index.js`), so the
+  // that writes it (`./note.object.js`, `./src/objects`), so the
   // count of `../` here — escaping or merely climbing — is zero. The bare
   // anchor therefore has no correct text to redden. The leading lookbehind is
   // what keeps it that way: it refuses a `..` that is itself part of a longer
 
@@ -46,7 +46,11 @@ Run `npm run build` when you need the compiled `dist/objectstack.json` artifact.
 
 1. **Zod First** — All schema definitions start with Zod. Types are derived via `z.infer<>`.
 2. `defineStack()` is the single configuration entry point in `objectstack.config.ts`.
-3. Use `Object.values()` barrel pattern for metadata arrays.
+3. Metadata reaches the stack through barrels: each `src/*/index.ts` exports what its
+   directory holds, and `objectstack.config.ts` already hands every barrel to
+   `defineStack()` through `exportsOf()` — a typed `Object.values()` that still
+   type-checks while a barrel is empty, so keep it. Export a new file from its barrel
+   rather than adding a key for it.
 4. Import from `@objectstack/spec` — never use relative paths into the spec package.
 5. **Predicates are CEL** — `visible`, `disabled`, `requiredWhen`, validation rules,
    flow conditions and sharing rules reference record fields as `record.<field>`,
 
@@ -38,8 +38,10 @@ the whole time — the `curl` above returns it, and an MCP client can read and
 write it. What it has no route into is the Console's navigation.
 
 **An object appears in Console navigation only when an app lists it.** Add an
-`*.app.ts` under `src/apps/` (plus the views it points at), and the Console
-renders it after the next `pnpm dev` rebuild. The `objectstack-ui` skill covers
+`*.app.ts` under `src/apps/` (plus the views it points at), export each one from
+its directory's `index.ts`, and the Console renders it after the next `pnpm dev`
+rebuild. `objectstack generate app NAME` and `objectstack generate view NAME`
+write the file and its export line together. The `objectstack-ui` skill covers
 the shape; describing the app you want to your coding agent is the intended
 path.
 
@@ -63,8 +65,15 @@ for OAuth, API keys, and which objects/actions become tools.
 
 ## Layout
 
-- `objectstack.config.ts` — environment manifest (objects, API, plugins)
+- `objectstack.config.ts` — environment manifest (objects, API, plugins), and
+  the wiring for every directory below
 - `src/objects/` — object definitions (one file per object)
+- `src/views/`, `src/actions/`, `src/flows/`, `src/dashboards/`, `src/apps/`,
+  `src/skills/` — empty to start. Each directory's `index.ts` exports what it
+  holds and `objectstack.config.ts` hands those exports to the stack, so
+  `objectstack generate flow NAME` (or `view`, `action`, …) adds a file and one
+  export line, and the item is loaded, and counted by `pnpm validate`, with no
+  edit to the config
 
 ## Connectors (default providers)