dreamteamer 0.25.1 → 0.26.0

package/bin/dreamteamer.js

@@ -12,6 +12,34 @@ import { pathToFileURL, fileURLToPath } from 'node:url';
 const MODULE_SEGMENTS = new Set(['node_modules', 'git_modules', 'modules']);
 
 const self = fileURLToPath(import.meta.url);
+
+// `--vault <path>` — operate on ANOTHER workspace without leaving this one. Consumed HERE, before
+// anything else resolves, because every verb downstream answers "which workspace am I in" from
+// process.cwd(): changing the directory once IS the whole implementation, and it also points the
+// dev-clone walk below at the TARGET's git_modules rather than the caller's.
+//
+// ⚠ It is spliced out of process.argv, not just out of the slice handed to run(): the dev-clone
+// branch re-enters this same file, and a flag left in place would be applied a SECOND time — the
+// path resolving against the already-changed directory, i.e. at the wrong workspace, silently.
+//
+// The path resolves against the INVOKING directory, which is where the caller typed it. Every other
+// relative path in the command then resolves against the target — the same rule a `cd` would give.
+const vaultAt = process.argv.indexOf('--vault', 2);
+if (vaultAt !== -1) {
+	const target = process.argv[vaultAt + 1];
+	if (!target || target.startsWith('-')) {
+		console.error('\u2716 --vault needs a path to a workspace, e.g. `--vault ../another-workspace`');
+		process.exit(1);
+	}
+	const resolved = path.resolve(process.cwd(), target);
+	if (!fs.existsSync(resolved)) {
+		console.error(`\u2716 --vault ${target} \u2014 no such directory (resolved to ${resolved})`);
+		process.exit(1);
+	}
+	process.chdir(resolved);
+	process.argv.splice(vaultAt, 2);
+}
+
 const devBin = findDevClone(process.cwd());
 // `realpath`, NOT `path.resolve`: resolve is pure string math and does not follow symlinks, so a
 // workspace whose git_modules/dreamteamer is a SYMLINK to the engine it is already running (the

package/package.json

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

package/skills/using-dreamteamer/SKILL.md

@@ -71,6 +71,22 @@ on: **validation is hard** (unknown fields included; an invalid write is rejecte
 with no partial state), and **a write does not commit** — `dt commit` publishes, scoped
 (`references/records.md`).
 
+## one session, several workspaces
+
+a harness can be pointed at more than one workspace at a time. when it is, it loads skills, commands
+and agents from ALL of them and the workspace INSTRUCTIONS from the PRIMARY one only — measured:
+zero instruction blocks from the others across every session on record. so the schema in context is
+the primary workspace's, whoever shipped the skill you are reading.
+
+- **start a session in the workspace it is about.** it is the only thing that loads that workspace's
+  instructions, and it settles name collisions in its favour.
+- **to touch another workspace from here, `--vault <path>` — not `cd`.** the flag resolves the
+  target's schema, validates and commits there, and leaves the working directory alone; a `cd`
+  outlives the command.
+- **every record write prints the workspace it landed in** — `✔ <workspace> · <path>`. a write to
+  the wrong workspace passes validation, because the collection usually exists in both, so that line
+  is what distinguishes them.
+
 ## two acts, one map
 
 Act one is **working with data** — the records themselves. Act two is **modeling the workspace**

package/src/cli.js

@@ -35,6 +35,10 @@ const QUIET = ['ignore', 'pipe', 'ignore'];
 
 export const USAGE = `usage: dreamteamer <verb> [<target>] [flags]
 
+  --vault <path>   run against another workspace. The path resolves from the directory you typed it
+                   in; every other path in the command resolves inside the target. The working
+                   directory is unchanged.
+
 record verbs (hard validation — invalid writes are rejected before disk).
 A <target> is either a collection name or a <collection>/<id> reference; the reference splits at
 the longest DECLARED collection prefix, so finance/transactions/2026/03/coffee is ONE argument:
@@ -269,6 +273,16 @@ const FIELD_VERBS = ['add-field', 'set-field', 'rm-field', 'rename-field'];
 // misspelling — `dt commit --dryrun` COMMITTED, because `rest.includes('--dry-run')` is false for a
 // flag nobody typed correctly. The record/system/field verbs are checked in `collections-cli.js`,
 // beside the parser they share; these nine have no shared parser, so the table is here.
+// Flags consumed BEFORE dispatch, in bin/dreamteamer.js, so no verb ever sees them. They are real
+// and honoured; they are simply honoured earlier than VERB_FLAGS/WORKSPACE_FLAGS can express.
+//
+// ⚠ Listing one here EXEMPTS it from the "documented flags are accepted by some verb" guard, which
+// exists because 0.19.0 shipped a flag that was documented and silently swallowed. The exemption is
+// only safe while the behaviour is pinned somewhere else: `--vault` is covered end-to-end in
+// test/integration/cross-workspace-targeting.test.js. A global flag with no such file is the exact
+// defect that guard was written to catch \u2014 add the coverage, not the entry.
+export const GLOBAL_FLAGS = ['vault'];
+
 export const WORKSPACE_FLAGS = {
 	init: ['name', 'data-path', 'harnesses', 'workspace-module'], update: [],
 	install: ['clone', 'dry-run', 'json', 'link-env', 'all', 'hook', 'print-adapters'],

package/src/collections-cli.js

@@ -118,6 +118,14 @@ export function collectionCommand(ws, collection, verb, args) {
 
 	const d = store.descriptor(collection);
 
+	// Every record write says WHICH workspace it landed in. `--vault` is OPTIONAL and a bare command
+	// resolves from the working directory, so the one thing the flag cannot do is tell you when you
+	// forgot it \u2014 this can, for the price of one word, with no state and nothing refused. A write
+	// aimed at one workspace and landed in another becomes visible on the very next line of output
+	// instead of never: on a machine holding several workspaces most collection NAMES are shared while
+	// their fields are not, so the misplaced write succeeds and reports success.
+	const at = ws.pkg?.name ? `${ws.pkg.name} \u00b7 ` : '';
+
 	switch (verb) {
 		case 'list': {
 			const { rows, narrowed } = narrowRows(store, d, collection, flags);
@@ -167,7 +175,7 @@ export function collectionCommand(ws, collection, verb, args) {
 				const id = need(pos, 0, 'id');
 				if (!flags.from) throw new Error(`"${collection}" is a \`codec: file\` collection — pass --from <path> with the file to import`);
 				const { id: written, file } = store.addFile(collection, id, flags.from, { force: !!flags.force });
-				flags.json ? emit(JSON.stringify({ id: written, path: rel(ws.root, file) })) : console.log(`✔ ${rel(ws.root, file)}`);
+				flags.json ? emit(JSON.stringify({ id: written, path: rel(ws.root, file) })) : console.log(`✔ ${at}${rel(ws.root, file)}`);
 				return 0;
 			}
 			if (flags.from) throw new Error(`--from imports a file as a record, and "${collection}" is not a \`codec: file\` collection`);
@@ -175,7 +183,7 @@ export function collectionCommand(ws, collection, verb, args) {
 			const { id, file, idFallback } = store.add(collection, fields, { id: flags.id });
 			flags.json
 				? emit(JSON.stringify({ id, path: rel(ws.root, file), ...(idFallback ? { idFallback } : {}) }))
-				: console.log(`✔ ${rel(ws.root, file)}`);
+				: console.log(`✔ ${at}${rel(ws.root, file)}`);
 			// ⚠ SAY IT, EVERY TIME. The id was derived from a hash because the value it is generated
 			// from carries no a-z0-9 — the write succeeded and the record is fine, but the id is
 			// unreadable and unguessable, and nobody finds that out until they try to type it. By
@@ -194,7 +202,7 @@ export function collectionCommand(ws, collection, verb, args) {
 			Object.assign(changes, coerceArrays(d, stripMeta(flags)));
 			if (!Object.keys(changes).length) throw new Error('nothing to set — pass key=value pairs or --key value flags');
 			store.set(collection, id, changes);
-			flags.json ? emit(JSON.stringify({ id })) : console.log('✔ updated');
+			flags.json ? emit(JSON.stringify({ id })) : console.log(`✔ ${at}updated`);
 			return 0;
 		}
 		// Manual ordering. ONE record is written per move — that is the entire feature; a dense
@@ -228,20 +236,20 @@ export function collectionCommand(ws, collection, verb, args) {
 
 			const id = need(pos, 0, 'id');
 			store.set(collection, id, { [field]: placementKey(rows, id, flags, collection) });
-			flags.json ? emit(JSON.stringify({ id })) : console.log('✔ moved');
+			flags.json ? emit(JSON.stringify({ id })) : console.log(`✔ ${at}moved`);
 			return 0;
 		}
 		case 'rm': {
 			const id = need(pos, 0, 'id');
 			if (flags['dry-run']) return dryRunPlan(`rm ${collection}/${id}`, { records: store.ids(collection).has(id) ? 1 : 0, refs: store.findInboundRefs(`${collection}/${id}`).length });
 			const { inboundIgnored } = store.rm(collection, id, { force: !!flags.force });
-			flags.json ? emit(JSON.stringify({ id, removed: true, inboundIgnored })) : console.log(`✔ removed${inboundIgnored ? ` (${inboundIgnored} inbound reference(s) left dangling — run \`dreamteamer check\`)` : ''}`);
+			flags.json ? emit(JSON.stringify({ id, removed: true, inboundIgnored })) : console.log(`✔ ${at}removed${inboundIgnored ? ` (${inboundIgnored} inbound reference(s) left dangling — run \`dreamteamer check\`)` : ''}`);
 			return 0;
 		}
 		case 'rename': {
 			const out = store.rename(collection, need(pos, 0, 'old id'), need(pos, 1, 'new id'));
 			if (flags.json) { emit(JSON.stringify(out)); return 0; }
-			console.log(`✔ renamed ${collection}/${need(pos, 0, 'old id')} → ${collection}/${out.id}`);
+			console.log(`✔ ${at}renamed ${collection}/${need(pos, 0, 'old id')} → ${collection}/${out.id}`);
 			if (out.touched) console.log(`✔ rewrote ${out.rewrites} inbound reference(s) across ${out.touched} file(s)`);
 			return 0;
 		}