dreamteamer 0.7.0 → 0.9.0

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "dreamteamer",
-	"version": "0.7.0",
+	"version": "0.9.0",
 	"description": "A workspace compiler for coding agents \u2014 schema-validated records as plain files over git, compiled into every harness",
 	"license": "Apache-2.0",
 	"author": "Gilad Khen <giladkhen@gmail.com>",

package/skills/building-dreamteamer/SKILL.md

@@ -62,7 +62,7 @@ These were duplicated across seven skills; they are true for all of them.
    conversation already in progress. A new command, agent or skill is available in the **next**
    session. Say so rather than letting the operator wonder.
 6. **References are qualified** — `skills/<id>`, `agents/<id>`, `commands/<id>`, `collections/<id>`,
-   `users/<id>`. A bare name fails `check`.
+   and `<collection>/<id>` for any record. A bare name fails `check`.
 7. **Never edit generated output.** `.dreamteamer/`, `.claude/`, `.agents/`, `.cursor/` are all
    overwritten and pruned on the next compile. If you found the thing you want to change in one of
    those, you are in the wrong file.
@@ -73,9 +73,11 @@ These were duplicated across seven skills; they are true for all of them.
 9. **Never duplicate a procedure across records.** A command body that restates a skill, an agent
    body that inlines its skill's steps, a command that re-types another command's prompt — each is two
    copies that drift. Reference the one that owns it.
-10. **Module-shipped entities must not name a workspace's own users, accounts or paths.** Use
-    `@initiator` / `@me`, and read per-install values from `.env` naming the variable. A hard-coded
-    `users/<someone>` does not resolve in anyone else's workspace.
+10. **Module-shipped entities must not name a workspace's own people, accounts or paths.** Read
+    per-install values from `.env` naming the variable, and leave who-did-what to a collection the
+    workspace owns. A hard-coded `contacts/<someone>` does not resolve in anyone else's workspace.
+    ⚠ **There is no `@me` since 0.8.0** — it expanded to `users/<slug>`, and `users` is gone. A
+    ui-view filter still using it is a compile error, not a view that quietly shows nothing.
 
 ## the loop
 
@@ -97,11 +99,12 @@ a collection about people, meetings, tasks, products, content — belongs in a m
 version of it belongs in the `recipes` repo rather than here.
 
 **The test is: does the ENGINE read it?** Core's collections are the entity kinds the compiler itself
-materializes, plus `users` (because `@me` resolves against it) and `repos` (because `repos ensure`
-clones them). Everything else has been ejected on exactly that test — `teams` (nothing resolved a
+materializes, plus `repos` (because `repos ensure` clones them). Everything else has been ejected on
+exactly that test — `teams` (nothing resolved a
 team), `mounts` (a one-implementation adapter enum over an `.env` key), `module-registries` (zero
 readers), `workflows`/`workflow-runs`/`workflow-triggers`/`cursors` and `migrations`/`migration-runs`
-(measured unused), and finally `tasks`, whose only claim to core had been the workflow gate that no
+(measured unused), `users` (0.8.0 — its justification was circular: core because `@me` resolved
+against it, and `@me` existed because it was core), and finally `tasks`, whose only claim to core had been the workflow gate that no
 longer exists. `npm run metrics` in the engine holds the budgets that keep this honest.
 
 ## common mistakes

package/skills/building-dreamteamer/references/commands.md

@@ -13,7 +13,7 @@ description: triage every open task assigned to me, one at a time
 argument-hint: "[assignee]"
 ---
 load this workspace's tasks skill. list my open tasks
-(`npm run --silent dt -- tasks list --assignee users/<me> --status todo`), then walk them one at a
+(`npm run --silent dt -- tasks list --status todo`), then walk them one at a
 time: restate it, ask me to keep / reassign / drop, apply the decision with `tasks set`.
 done when the list is empty or I say stop.
 ```

package/skills/building-dreamteamer/references/ui-views.md

@@ -5,7 +5,7 @@ route plus the id of an already-registered layout, plus how to shape the data. N
 
 The surface reads compiled ui-view records at boot: `nav` becomes a sidebar entry, `path` becomes a
 live route, `target: list` renders the named `layout` over the collection with `filter`/`options`
-applied (`@me` resolves to the current operator). After authoring: compile, then reload the surface.
+applied. After authoring: compile, then reload the surface.
 
 ```yaml
 path: /inbox
@@ -13,10 +13,14 @@ nav: { label: Inbox, icon: inbox, order: 1 }
 target: list
 collection: collections/tasks
 layout: table
-filter: { assignee: { _eq: "@me" } }        # operator objects, never a bare value
-options: { columns: [name, status, due, run], sort: -due }
+filter: { status: { _eq: todo } }           # operator objects, never a bare value
+options: { columns: [name, status, due], sort: -due }
 ```
 
+⚠ **`@me` no longer exists** — it was removed with the `users` collection in 0.8.0, and a filter using
+it is a compile error rather than a view that quietly shows nothing. Filter on a field this workspace
+owns; where a person is genuinely the axis, the workspace ships its own collection of people.
+
 | field | required | notes |
 |---|---|---|
 | `path` | yes | the route — `/inbox`, `/views/meetings/recent` |
@@ -53,7 +57,8 @@ through the same compile gate.
 |---|---|
 | a `layout` id you assumed exists | compile validates it only for `target: list`; otherwise the view renders nothing |
 | bare `collection: tasks` | qualified refs only |
-| `filter: { assignee: "@me" }` | filters are operator objects: `{ assignee: { _eq: "@me" } }` |
+| `filter: { status: "todo" }` | filters are operator objects: `{ status: { _eq: todo } }` |
+| a filter using `@me` | gone in 0.8.0 with `users` — compile refuses it by name |
 | a column the schema does not have | dropped silently — the row loses that value with no error |
 | a ui-view that restates the built-in fallback | a record to maintain for zero gain |
-| a module ui-view filtered to a named user | use `@me`; a hard-coded id breaks elsewhere |
+| a module ui-view naming one person | a hard-coded id resolves in no other workspace |

package/skills/using-dreamteamer/SKILL.md

@@ -63,8 +63,8 @@ when you're not sure the runtime is fresh.
 | the workspace lacks the capability entirely | `building-dreamteamer` → `references/before-you-build.md` |
 
 Domain work — meetings, contacts, tasks, content, design — is owned by the **module** that ships those
-collections, not by core. Read that module's own skills. Core knows about entity kinds, `users` and
-`repos`, and deliberately nothing else.
+collections, not by core. Read that module's own skills. Core knows about entity kinds and `repos`,
+and deliberately nothing else — including nothing about people. There is no `users` collection.
 
 ## conventions
 
@@ -84,9 +84,10 @@ collections, not by core. Read that module's own skills. Core knows about entity
 - **validate after bulk edits**: `npm run check` reports violations and never modifies files.
 - workspace-level rules live in `CLAUDE.md`, and a workspace's decision log (where one exists) wins
   over older documents.
-- **session greeting** — surface the operator's inbox: `npm run --silent dt -- tasks list --assignee
-  users/<user> --status todo`. ⚠ the current user is a record in `data/users/` whose id is
-  `slug(git config user.name)`; when those disagree the inbox comes back **empty with no error**.
+- **session greeting** — surface the operator's inbox from whatever collection this workspace uses for
+  work, e.g. `npm run --silent dt -- tasks list --status todo`. ⚠ **there is no `users` collection and
+  no `@me`** (both removed in 0.8.0); read the operator from `git config user.name` at the point you
+  need one, and never filter on a person unless this workspace owns a collection of them.
 
 ## common mistakes
 
@@ -95,6 +96,6 @@ collections, not by core. Read that module's own skills. Core knows about entity
 | editing something under `.dreamteamer/` | generated + gitignored; the change vanishes on the next compile |
 | changing a source and not compiling | the harness and `check` still read the stale runtime |
 | hand-writing a record the CLI could add | skips validation, id generation and defaults |
-| bare refs (`ada`, `data/users/x.user.md`) | refs are `<collection>/<id>`; anything else fails check |
+| bare refs (`ada`, `data/contacts/x.contact.md`) | refs are `<collection>/<id>`; anything else fails check |
 | assuming a write was committed | it was not, unless `auto-commit` is on — `dt status` says what is pending |
 | `git add -A` in a shared tree | steals another session's uncommitted work, invisibly |

package/skills/using-dreamteamer/references/records.md

@@ -68,7 +68,7 @@ fields, the body is the single `x-body: true` field):
 ---
 title: Fix login flow
 status: todo
-assignee: users/ada
+assignee: contacts/ada
 due: '2026-07-28'
 ---
 Users report the login button does nothing on mobile.

package/src/compile.js

@@ -520,10 +520,13 @@ export function compile({ root, pkg }) {
 		const base = group.find((g) => !g.doc.extends);
 		if (base) collOwner.set(name, base.moduleName);
 	}
-	// The engine's own nine collections are an implicit dependency of every module: seven entity
-	// kinds plus the two the compiler materializes. Requiring every module to declare a dependency
-	// on the host it cannot run without would be ceremony, not verification.
-	const CORE_COLLECTIONS = new Set([...KINDS, ...DERIVED_KINDS, 'users', 'repos']);
+	// The engine's own nine collections are an implicit dependency of every module: the entity kinds
+	// the compiler materializes, plus `repos` (because `repos ensure` clones them). Requiring every
+	// module to declare a dependency on the host it cannot run without would be ceremony, not
+	// verification. ⚠ `users` was in this set until 0.8.0 — a module still declaring
+	// `x-reference: users` now FAILS here, which is the intended loud outcome rather than a ref
+	// pointing at a collection nothing provides.
+	const CORE_COLLECTIONS = new Set([...KINDS, ...DERIVED_KINDS, 'repos']);
 	const wsDir = config['workspace-module'];
 	const wsModuleName = wsDir
 		? sources.find((s) => rel(s.root) === path.join('modules', wsDir))?.name
@@ -802,6 +805,12 @@ export function compile({ root, pkg }) {
 		// fail at compile, not silently at render (review finding 5)
 		const badOps = view?.filter ? [...unknownOperators(view.filter)] : [];
 		if (badOps.length) fail(`${rt}: unknown filter operator(s) ${badOps.join(', ')}`);
+		// `@me` died with the `users` collection in 0.8.0. It expanded to `users/<slug>`, so on this
+		// engine it can only ever match nothing — and a filter that narrows to zero rows is the exact
+		// silent failure this block exists to prevent. Refuse it by name, with the fix.
+		if (view?.filter && JSON.stringify(view.filter).includes('"@me"')) {
+			fail(`${rt}: filter uses "@me", which was removed with the \`users\` collection in 0.8.0 — it would now match nothing.\n  filter on a field this workspace owns instead (e.g. { status: { _eq: "todo" } }).`);
+		}
 	}
 
 	// ---- command-binding validation --------------------------------------------------

package/src/init.js

@@ -4,8 +4,6 @@
 import { execFileSync, spawnSync } from 'node:child_process';
 import fs from 'node:fs';
 import path from 'node:path';
-import { dump } from './yaml.js';
-import { slugOrHash } from './template.js';
 import { discoverModules, KINDS } from './compile.js';
 import { Store } from './store.js';
 
@@ -76,7 +74,17 @@ export function init({ flags = {} } = {}) {
 		'data-path': dataPath,
 		harnesses,
 		'gitignore-runtime-folder': true,
-		'workspace-module': name, // workspace-owned system sources live in modules/<name>/ — data and logic stay separated
+		// The workspace's own sources live in `modules/default/`, and the folder is named for its ROLE,
+		// not for the vault. It used to be named after the workspace, and that name went stale twice in
+		// one repo (`hq3` → `gk`, decision 213 reversed by 224) — each rename rewriting every path that
+		// RESOLVES while the historical documents deliberately kept the old spelling, so a stale-looking
+		// `modules/hq3` was correct in prose and a bug in a path. A role name cannot go stale.
+		//
+		// `default` is deliberately the same word `RESERVED_NAMESPACES` holds (namespace.js): this module
+		// owns the DEFAULT-namespace collections, and the default namespace is the empty prefix. The one
+		// misreading it invites — `default/tasks` — is a compile error whose message states the rule.
+		// Override with `--workspace-module <name>` if a workspace wants its own spelling.
+		'workspace-module': flags['workspace-module'] ?? 'default',
 		'git-modules': {},
 		disable: [],
 		...pkg.dreamteamer,
@@ -102,23 +110,16 @@ export function init({ flags = {} } = {}) {
 	fs.mkdirSync(path.join(root, dataPath), { recursive: true });
 	fs.mkdirSync(path.join(root, 'state'), { recursive: true });
 
-	// seed the operator's user record from the git identity.
+	// NO user record is seeded, and there is no `users` collection — both removed from core in 0.8.0.
+	// It failed the "does the ENGINE read it?" test on a circular justification: `users` was core
+	// because `@me` resolved against it, and `@me` existed because `users` was core. Nothing else in
+	// the compiler, the store or `check` ever read a user record. One record per workspace, whose only
+	// job was to restate `git config user.name` in a file that then had to AGREE with it — and when it
+	// disagreed the symptom was an empty inbox with no error (decision 99b), a trap that now cannot
+	// happen because there is nothing to disagree with.
 	//
-	// The id MUST be slugOrHash(git user.name) — that is exactly how `@me` resolves in filters and
-	// ui-views (server.js / fsdata.ts), so seeding it from the same source is what makes the core
-	// /inbox view work by construction. A workspace where a user record is authored by hand under a
-	// different id gets an EMPTY inbox with no error (decision 99b) — hence the setup-script step in
-	// any workspace with a second person.
-	//
-	// No `everyone` team is seeded: `teams` was removed from core 2026-07-31. It was a one-record
-	// abstraction with no reader — nothing in the engine, in `check`, or in any view resolved a team.
-	const gitName = tryGit(root, ['config', 'user.name']) ?? 'operator';
-	const gitEmail = tryGit(root, ['config', 'user.email']);
-	const userId = slugOrHash(gitName);
-	const usersDir = path.join(root, dataPath, 'users');
-	fs.mkdirSync(usersDir, { recursive: true });
-	const userFile = path.join(usersDir, `${userId}.user.yaml`);
-	if (!fs.existsSync(userFile)) fs.writeFileSync(userFile, dump({ name: gitName, ...(gitEmail ? { email: gitEmail } : {}) }));
+	// A workspace that needs people as records ships its own collection (a module's `contacts` already
+	// does), and reads the operator from git where it needs one. `teams` went the same way 2026-07-31.
 
 	// .gitignore + .env.example (append-if-missing, never clobber)
 	appendMissing(path.join(root, '.gitignore'), GITIGNORE);

package/src/schema-ops.js

@@ -64,6 +64,37 @@ export function workspaceSystemDir(ws, kind) {
 	return kindDir(wm ? path.join(ws.root, 'modules', wm) : ws.root, kind);
 }
 
+/**
+ * WHERE A COLLECTION'S DESCRIPTOR ACTUALLY LIVES — asked of the manifest, not assumed.
+ *
+ * `renameCollection` used to derive this from `workspaceSystemDir`, which silently meant "only the
+ * workspace module's own collections can be renamed". That is the wrong line. The guard exists to
+ * stop a write that will be ERASED, and the thing that erases writes is `npm install` — so the test
+ * is `node_modules/`, not "which module". A module whose sources are inline in the workspace repo is
+ * under the same git history as everything else and is perfectly safe to rewrite; refusing it made
+ * `collections rename` unusable for exactly the migration it was built for, because a workspace's
+ * domain collections almost always live in a module.
+ *
+ * Returns `{ dir, sources }` — the kind dir to write into (the SAME module the descriptor came from,
+ * so a rename never teleports a collection into the workspace module), and every descriptor source
+ * that contributed, so the caller can refuse the cases this cannot honestly do.
+ */
+function descriptorSourceDir(ws, name) {
+	const entry = readManifest(ws.root)?.entries?.[`collections/${name}.collection.yaml`];
+	// `sources` mixes the descriptor with any collection-templates it merged, so match on the shape
+	// of a descriptor path for THIS collection. A namespaced name is nested, hence the full suffix.
+	const suffix = `collections/${name}.collection.yaml`;
+	const sources = (entry?.sources ?? [])
+		.map((s) => s.path)
+		.filter((p) => p.endsWith(suffix));
+	if (!sources.length) return { dir: null, sources };
+	// The BASE descriptor is the one to move. With an overlay present there are two, and the overlay's
+	// `extends` names the base by its old qualified id — rewriting that is a second, different
+	// migration, so the caller refuses rather than half-doing it.
+	const moduleRoot = path.join(ws.root, sources[0].slice(0, sources[0].length - suffix.length));
+	return { dir: kindDir(moduleRoot, 'collections'), sources };
+}
+
 // ---- ops ------------------------------------------------------------------------
 
 export function createCollection(ws, store, { name, template, namespace }) {
@@ -143,6 +174,15 @@ export function removeCollection(ws, store, name, { force = false } = {}) {
  * already scopes prose to `[[wikilinks]]` (decision 7) — a fresh `oldName/` pattern would have to
  * relearn both, and would corrupt `data/tasks/` in a path or a URL on its first outing. N passes over
  * the record files is the price, and at human scale it is worth paying for reusing the correct code.
+ *
+ * ⚠ MEASURED 2026-08-17, so the cost is a number rather than a hope: a 2,291-record collection in a
+ * 3,391-file workspace — gk-brain's `finance-transactions` — takes **3 minutes**, of which 142s is
+ * system time. That is 7.7M file reads to rewrite ZERO references, because the pass runs per id
+ * whether or not anything points at the collection. Tolerable for a one-time migration and left
+ * alone on that basis; it is O(records x files), so a workspace 3x larger pays 27 minutes. The fix
+ * when it is needed is a batch entry point on the store that reads each file ONCE and loops the ref
+ * set in memory, with `text.includes(oldName + '/')` as a cheap NEGATIVE filter only — never as the
+ * matcher, for the reason above.
  */
 export function renameCollection(ws, store, oldName, newName) {
 	const d = store.descriptor(oldName); // throws with the known-collection list if absent
@@ -156,10 +196,21 @@ export function renameCollection(ws, store, oldName, newName) {
 	if (store.descriptors.has(newName)) throw new Error(`collection "${newName}" already exists`);
 	if (d.storage.base === 'runtime') throw new Error(`"${oldName}" is a compiled source, not a data collection — it cannot be renamed`);
 
-	const src = path.join(workspaceSystemDir(ws, 'collections'), `${oldName}.collection.yaml`);
-	const dest = path.join(workspaceSystemDir(ws, 'collections'), `${newName}.collection.yaml`);
+	// The descriptor is renamed IN THE MODULE THAT SHIPS IT — see `descriptorSourceDir`. Two cases
+	// this refuses, both because doing them halfway is worse than not doing them:
+	const { dir: sourceDir, sources } = descriptorSourceDir(ws, oldName);
+	if (sources.length > 1) {
+		throw new Error(`"${oldName}" is overlaid — ${sources.length} modules contribute a descriptor (${sources.join(', ')}).\n  the overlay's \`extends\` names the base by its current id, so renaming the base alone would break it. merge or remove the overlay first.`);
+	}
+	if (sources.some((p) => p.split(path.sep).includes('node_modules'))) {
+		throw new Error(`"${oldName}" ships from node_modules (${sources[0]}) — a write there is erased by the next \`npm install\`. rename it in its own repo and release, or overlay it with \`extends\`.`);
+	}
+	const src = sourceDir
+		? path.join(sourceDir, `${oldName}.collection.yaml`)
+		: path.join(workspaceSystemDir(ws, 'collections'), `${oldName}.collection.yaml`);
+	const dest = path.join(sourceDir ?? workspaceSystemDir(ws, 'collections'), `${newName}.collection.yaml`);
 	if (!fs.existsSync(src)) {
-		throw new Error(`"${oldName}" is not workspace-owned — it ships with a module, so rename it there (or overlay it with \`extends\`)`);
+		throw new Error(`"${oldName}" has no writable descriptor source — the manifest names none under a module in this workspace. it may be contributed by the engine itself; overlay it with \`extends\` instead.`);
 	}
 
 	const doc = load(fs.readFileSync(src, 'utf8'));

package/src/server.js

@@ -14,12 +14,6 @@ import { matchesFilter } from './filter.js';
 import { sortRows } from './temporal.js';
 import { commandsFor, recordResolver } from './record-commands.js';
 import { distinctValues } from './field-values.js';
-import { slugOrHash } from './template.js';
-
-// git calls whose failure we CATCH must not print git's own error: execFileSync forwards the
-// child's stderr to ours unless told otherwise, so a handled "not a git repository" still
-// reached the user's terminal. stdout stays piped because we read it.
-const QUIET = ['ignore', 'pipe', 'ignore'];
 
 
 export function startServer(ws, { port = 8080, host = '127.0.0.1' } = {}) {
@@ -44,13 +38,10 @@ export function startServer(ws, { port = 8080, host = '127.0.0.1' } = {}) {
 	const api = express.Router();
 	api.use((req, res, next) => { freshStore(); next(); });
 
-	// current operator id — same rule init seeds users with (slugOrHash of git user.name),
-	// so `@me` filters in ui-views resolve to the seeded user record.
-	let operatorId = null;
-	try {
-		operatorId = slugOrHash(execFileSync('git', ['config', 'user.name'], { cwd: ws.root, stdio: QUIET }).toString().trim());
-	} catch { /* no git identity — @me filters simply won't narrow */ }
-
+	// ⚠ NO `user` on /info since 0.8.0, and no `@me` — both went with the `users` collection. The
+	// token expanded to the literal string `users/<slug of git user.name>`, so with no such
+	// collection it could only ever produce a dangling reference. A workspace that wants
+	// operator-scoped views filters on a field it owns.
 	api.get('/info', (req, res) => {
 		const manifest = readManifest(ws.root);
 		const stale = staleness(ws.root);
@@ -60,7 +51,6 @@ export function startServer(ws, { port = 8080, host = '127.0.0.1' } = {}) {
 			compiled: manifest?.compiled,
 			modules: manifest?.modules ?? [],
 			ui: manifest?.ui ?? [], // module UI bundles staged at /ui/<name>/app.js
-			user: operatorId,
 			stale: stale.stale?.length ?? 0,
 			collections: [...store.descriptors.keys()],
 		});

package/collections/users.collection.yaml

@@ -1,21 +0,0 @@
-name: users
-storage: { path: data/users, codec: yaml, shape: file, suffix: user }
-id: { generate: "{{ name | slug }}" }
-schema:
-  type: object
-  required: [name]
-  properties:
-    name:
-      type: string
-      description: The person's name. Its slug is the id, and `@me` resolves against it — so it must agree with `git config user.name`, or an assignee query comes back empty with no error.
-    description:
-      type: string
-      description: Who this person is, in one line.
-    email:
-      type: string
-      format: email
-      description: Their email address.
-order: 140
-list_fields: [name, last-modified, email]
-icon: badge
-group: system