create-substrat 0.6.1 → 0.6.3

package/index.js

@@ -21,16 +21,23 @@ import { DEV_SERVERS } from './dev-servers.js';
 const HERE = dirname(fileURLToPath(import.meta.url));
 const TEMPLATE = join(HERE, 'template');
 
-// Published today; Substrat is 0.x, so these are caret ranges on the current minor.
-// The runtime packages release together off one version line, so one constant is right
-// for all of them.
-const SUBSTRAT = '^0.71.0';
-// Engines do NOT share a line — each one versions on its own, so a single ENGINES
-// constant silently stops resolving the moment any engine crosses a minor. It did:
-// this file pinned `^0.3.37` while workorder had moved to 0.4.x and invoicing to 0.6.x,
-// so a freshly scaffolded project could not install. One pin per engine, deliberately.
-const ENGINE_WORKORDER = '^0.4.3';
-const ENGINE_INVOICING = '^0.6.2';
+// Substrat is 0.x, so these are caret ranges on the current minor — a caret on 0.x
+// locks the minor, which is what makes a stale pin here a scaffold four minors behind
+// rather than a scaffold that quietly upgrades.
+//
+// EMITTED, NOT EDITED. `pnpm lint:pins` writes this block from each package's own
+// version and `--check` fails CI on drift; `version-packages` runs the write, so a
+// bump and its pins land in the same PR. Hand-maintained, they went stale twice: once
+// resolving nothing (`^0.3.37` after workorder moved to 0.4.x), and once resolving
+// fine but freezing the template against packages nobody ships, which is worse — the
+// scaffold's own tests stayed green while the surface moved underneath them.
+//
+// The runtime packages release together off one version line (the changesets `fixed`
+// group), so one constant is right for all of them. Engines do NOT share a line —
+// each versions on its own, so one pin per engine, deliberately.
+const SUBSTRAT = '^0.76.0';
+const ENGINE_WORKORDER = '^0.6.3';
+const ENGINE_INVOICING = '^0.7.3';
 const BOUNDARY_LINT = '^0.0.7';
 
 const DOCS = 'https://substrat.net';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-substrat",
-  "version": "0.6.1",
+  "version": "0.6.3",
   "description": "Scaffold a Substrat vertical — `npm create substrat <dir>`.",
   "license": "Apache-2.0",
   "repository": {

package/template/.substrat/hooks/session-start.mjs

@@ -19,8 +19,13 @@
  * This file lives in `.substrat/` — the tool-neutral home, next to `playbook.md` —
  * not in `.claude/`. `.claude/settings.json` is a three-line adapter that runs it,
  * and any other client that grows a session hook binds the same way. It also
- * means the plugin distribution (#753) can ship this script unchanged rather than
- * forking it.
+ * means the plugin distribution (#753) ships this script unchanged rather than
+ * forking it: `plugin/substrat/scripts/session-start.mjs` is emitted from this
+ * file byte-for-byte, and `pnpm lint:plugin --check` fails if the two diverge.
+ *
+ * The plugin copy is what reaches a project scaffolded before this hook existed.
+ * When a project owns its own copy, the plugin's stays silent — see
+ * `isPluginCopy()` below — so a scaffolded project announces itself once.
  *
  * ## Deliberately silent, and deliberately offline
  *
@@ -33,8 +38,9 @@
  *
  * Opt out by creating `.substrat/no-session-context`.
  */
-import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'node:fs';
-import { dirname, join } from 'node:path';
+import { existsSync, readFileSync, realpathSync, writeFileSync, mkdirSync } from 'node:fs';
+import { dirname, join, relative, isAbsolute } from 'node:path';
+import { fileURLToPath } from 'node:url';
 
 const DOCS = 'https://substrat.net';
 const KERNEL = '@substrat-run/kernel';
@@ -42,6 +48,33 @@ const KERNEL = '@substrat-run/kernel';
 /** Where the project is. Claude Code sets this; fall back to the cwd it ran us in. */
 const root = process.env.CLAUDE_PROJECT_DIR || process.cwd();
 
+/** Where this script is. The two copies differ only in where they sit on disk. */
+const self = fileURLToPath(import.meta.url);
+
+/** Symlinks resolved, so a project reached through one is not mistaken for elsewhere. */
+function real(path) {
+  try {
+    return realpathSync(path);
+  } catch {
+    return path;
+  }
+}
+
+/**
+ * True when we are the plugin's copy rather than the project's own.
+ *
+ * Asked positionally instead of by a flag, because the two copies must stay
+ * byte-identical for `lint:plugin` to have anything to check: a copy that is
+ * invoked differently is a copy that can be edited differently. Both sides are
+ * resolved first — on macOS a project under `/tmp` is handed to us as
+ * `/private/tmp`, and an unresolved compare would read the project's own copy as
+ * foreign and silence the very hook that should speak.
+ */
+function isPluginCopy() {
+  const inside = relative(real(root), real(self));
+  return inside.startsWith('..') || isAbsolute(inside);
+}
+
 /** The marker: which kernel version this project last announced. */
 const MARKER = join(root, '.substrat', '.docs-pin');
 const OPT_OUT = join(root, '.substrat', 'no-session-context');
@@ -67,6 +100,11 @@ function main() {
   // file to invent, and nothing to keep in sync.
   if (!pkg?.substrat) silent();
 
+  // The project's own copy wins. It ships beside the playbook it points at, so it
+  // is the one that matches what is actually checked out here; the plugin's exists
+  // for projects scaffolded before this hook did, and must not double-announce.
+  if (isPluginCopy() && existsSync(join(root, '.substrat', 'hooks', 'session-start.mjs'))) silent();
+
   if (existsSync(OPT_OUT)) silent();
 
   // What is actually installed beats what package.json asked for: a caret range on

package/template/src/worker.ts

@@ -164,8 +164,15 @@ mountPlatformSurface<Env>(app, {
   hostFor,
   roles: ROLES,
   ownerRoleKey: OWNER_ROLE_KEY,
-  onProvision: (env, b) => sweeper(env).noteScope(b.tenantId, b.scopeId),
-  onDeleteScope: (env, s) => sweeper(env).forgetScope(s),
+  // Both hooks are `Promise<void>`: the roster's own count is its business, and
+  // returning it here would make the platform's response shape depend on what a
+  // vertical happens to hand back. Await, discard.
+  onProvision: async (env, b) => {
+    await sweeper(env).noteScope(b.tenantId, b.scopeId);
+  },
+  onDeleteScope: async (env, s) => {
+    await sweeper(env).forgetScope(s);
+  },
 });
 
 // Unmatched /api/* fails as JSON; everything else gets a pointer, not a UI —

package/template/test/scenario.test.ts

@@ -160,14 +160,18 @@ describe('bike-shop scenario', () => {
     expect(underlag[0]!.status).toBe('open');
     expect(underlag[0]!.total).toBe('336.5');
 
-    const detail = await greta.invoke<{ lines: { source_id: string; source_type: string }[] }>(
-      'invoicing/get',
-      { underlagId: underlag[0]!.id },
-    );
+    // Provenance is two-level: `document_*` is which delivery produced the line
+    // (this work order), `source_*` is what the line itself is (time vs material).
+    // Both come from the engine's own event payload — the vertical never joins
+    // into invoicing's tables to find out.
+    const detail = await greta.invoke<
+      { lines: { document_id: string; document_type: string; source_type: string | null }[] }
+    >('invoicing/get', { underlagId: underlag[0]!.id });
     expect(detail.lines).toHaveLength(2);
-    expect(detail.lines.every((l) => l.source_type === 'workorder' && l.source_id === repairId)).toBe(
-      true,
-    );
+    expect(
+      detail.lines.every((l) => l.document_type === 'workorder' && l.document_id === repairId),
+    ).toBe(true);
+    expect(detail.lines.map((l) => l.source_type).sort()).toEqual(['material', 'time']);
   });
 
   it('7. portal isolation: Lisbeth sees her repair, Otto sees nothing', async () => {