dreamteamer 0.6.0 → 0.6.2

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "dreamteamer",
-	"version": "0.6.0",
+	"version": "0.6.2",
 	"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/src/cli.js

@@ -12,6 +12,12 @@ import { deriveEvents } from './events.js';
 import { commitPending } from './commit.js';
 import { Store } from './store.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'];
+
+
 const USAGE = `usage: dreamteamer <command> | dreamteamer <collection> <verb> …
 
 commands:
@@ -230,7 +236,7 @@ export function run(argv) {
 }
 
 function tryGit(cwd, args) {
-	try { return execFileSync('git', args, { cwd }).toString().trim() || null; } catch { return null; }
+	try { return execFileSync('git', args, { cwd, stdio: QUIET }).toString().trim() || null; } catch { return null; }
 }
 
 function watchAndRecompile(ws) {

package/src/commit.js

@@ -6,6 +6,12 @@ import fs from 'node:fs';
 import path from 'node:path';
 import { pathToRecord } from './events.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'];
+
+
 const VERB = { A: 'add', M: 'set', D: 'rm', R: 'rename', '?': 'add' };
 
 /** Record directories to watch, grouped by owning repo. System-stored collections are excluded:
@@ -31,7 +37,7 @@ function scopeByRepo(descriptors, only) {
  *  is NOT a refusal condition — committing dirty records is this verb's entire job. */
 function inProgress(cwd) {
 	let gitDir;
-	try { gitDir = execFileSync('git', ['rev-parse', '--absolute-git-dir'], { cwd }).toString().trim(); }
+	try { gitDir = execFileSync('git', ['rev-parse', '--absolute-git-dir'], { cwd, stdio: QUIET }).toString().trim(); }
 	catch { return 'not a git repository'; }
 	for (const [marker, label] of [['MERGE_HEAD', 'merge'], ['rebase-merge', 'rebase'], ['rebase-apply', 'rebase'], ['CHERRY_PICK_HEAD', 'cherry-pick'], ['REVERT_HEAD', 'revert']]) {
 		if (fs.existsSync(path.join(gitDir, marker))) return `a ${label} is in progress`;
@@ -42,7 +48,7 @@ function inProgress(cwd) {
 /** A commit on a detached HEAD is reachable only by sha. Worth saying out loud before making one;
  *  not worth refusing over, since it is sometimes exactly what someone means to do. */
 function detached(cwd) {
-	try { return execFileSync('git', ['symbolic-ref', '--quiet', 'HEAD'], { cwd }).toString().trim() === ''; }
+	try { return execFileSync('git', ['symbolic-ref', '--quiet', 'HEAD'], { cwd, stdio: QUIET }).toString().trim() === ''; }
 	catch { return true; }
 }
 
@@ -57,7 +63,10 @@ function sample(root, repo, dirs, descriptors) {
 	// `-uall` is load-bearing: by default porcelain COLLAPSES an untracked directory to a single
 	// `?? data/notes/` entry, which maps to no record — so the first records of a brand-new
 	// collection would be invisible and dt commit would report success having committed nothing.
-	const out = execFileSync('git', ['status', '--porcelain', '-z', '-uall', '--', ...relDirs], { cwd }).toString();
+	// QUIET: the caller (cli `status`) catches a failure here so it can still print the rest of the
+	// report in a non-git folder — but git's own "fatal: not a git repository" was reaching the
+	// terminal anyway, which made a handled case look like a crash.
+	const out = execFileSync('git', ['status', '--porcelain', '-z', '-uall', '--', ...relDirs], { cwd, stdio: QUIET }).toString();
 	const chunks = out.split('\0').filter((c) => c.length > 0);
 	const rows = [];
 	for (let i = 0; i < chunks.length; i++) {

package/src/compile.js

@@ -100,7 +100,8 @@ function bothLayouts(root, kind) {
  * has `data/` — not a layout knob every module would set identically.
  */
 const NON_SOURCE_DIRS = new Set([
-	'node_modules', 'data', 'state', 'media', 'bin', 'src', 'lib', 'scripts', 'studio',
+	'node_modules', 'data', 'state', 'media', 'bin', 'src', 'lib', 'scripts',
+	'ui', 'studio', // the module's UI bundle — 'studio' is the pre-archive name, kept as a fallback
 	'docs', 'dist', 'build', 'test', 'tests', 'coverage', 'system', // 'system': the pre-flatten layout
 ]);
 
@@ -357,23 +358,21 @@ export function compile({ root, pkg }) {
 		}
 	}
 
-	// A module that ships only folders the engine does not recognise compiles ✔ and contributes
-	// NOTHING. Warn; do not fail, since a module that is temporarily source-free is the
-	// operator's business, not the compiler's.
-	for (const source of sources) {
-		if (contributed.has(source.name)) continue;
-		console.warn(`⚠ module "${source.name}" (${rel(source.root)}) contributed no recognised sources — its folder names must match a known kind (${KINDS.join(', ')})`);
-	}
-
 	// ---- stage module UI bundles ---------------------------------------------------
-	// modules ship a PRE-BUILT app.js that registers components/layouts against the studio
+	// modules ship a PRE-BUILT app.js that registers components/layouts against the surface's
 	// registry (design "the UI": components are module code, never records). staged under
-	// .dreamteamer/ui/<module>/app.js; the server serves /ui, the studio imports and calls it.
-	// studio/dist/app.js (a built bundle) wins over studio/app.js (plain-JS, host-provided Vue).
+	// .dreamteamer/ui/<module>/app.js; the VS Code extension reads it off disk (decision 48) and
+	// the legacy server served it at /ui. `dist/app.js` (a built bundle) wins over `app.js`
+	// (plain-JS, host-provided Vue).
+	//
+	// `ui/` is the name — it matches where the bundle STAGES and what it is. `studio/` is the
+	// original name and stays a fallback: the studio it referred to is archived (decisions 51, 93),
+	// so the folder was named after a surface that no longer exists. Both are in NON_SOURCE_DIRS,
+	// so neither trips the unknown-folder gate (decision 179).
 	const uiModules = [];
 	const uiOwners = new Map(); // shortName -> module name, for a readable collision error
 	for (const source of sources) {
-		const cand = ['studio/dist/app.js', 'studio/app.js']
+		const cand = ['ui/dist/app.js', 'ui/app.js', 'studio/dist/app.js', 'studio/app.js']
 			.map((p) => path.join(source.root, p))
 			.find((p) => fs.existsSync(p));
 		if (!cand) continue;
@@ -386,6 +385,18 @@ export function compile({ root, pkg }) {
 		uiOwners.set(shortName, source.name);
 		addEntry(path.join('ui', shortName, 'app.js'), cand);
 		uiModules.push(shortName);
+		// A UI bundle IS a contribution. Counting it here is what keeps the warning below honest —
+		// a module whose whole purpose is a layout used to be told it "contributed no recognised
+		// sources" while its layout was rendering in the app.
+		contributed.add(source.name);
+	}
+
+	// A module that ships only folders the engine does not recognise compiles ✔ and contributes
+	// NOTHING. Warn; do not fail, since a module that is temporarily source-free is the
+	// operator's business, not the compiler's. Runs AFTER UI staging so a UI-only module counts.
+	for (const source of sources) {
+		if (contributed.has(source.name)) continue;
+		console.warn(`⚠ module "${source.name}" (${rel(source.root)}) contributed no recognised sources — its folder names must match a known kind (${KINDS.join(', ')}) or it must ship a UI bundle at ui/app.js`);
 	}
 
 	// ---- collection-templates, for `templates:` merging ----------------------------
@@ -512,29 +523,27 @@ export function compile({ root, pkg }) {
 	}
 
 	// ---- ui-view layout validation --------------------------------------------------
-	// layouts are registered module code; a view naming an unregistered layout fails loudly
-	// naming the registered set (design guardrail: "unknown layout = compile error").
-	// core set = the studio's built-ins; modules declare theirs in package.json
-	// dreamteamer.studio.layouts (the same file their app.js registration lives beside).
-	// KEEP IN SYNC with the UI's `lists.register(...)` calls (dreamteamer-vscode
-	// webview/src/registry/register-defaults.ts). kanban/calendar/map landed there as core Lists in
-	// the 2026-07-27 layouts wave but this set was never widened, so the only way to get a
-	// `layout: kanban` view past compile was for a module to CLAIM the layout it didn't own — which
-	// is what a workspace module was once caught doing, shadowing the core board in the registry (a
-	// module's app.js loads after the built-ins and Map.set wins). Fixed both ends 2026-07-29.
-	const registeredLayouts = new Set(['table', 'cards', 'kanban', 'calendar', 'map']);
-	for (const source of sources) {
-		try {
-			const mpkg = JSON.parse(fs.readFileSync(path.join(source.root, 'package.json'), 'utf8'));
-			for (const l of mpkg.dreamteamer?.studio?.layouts ?? []) registeredLayouts.add(l);
-		} catch { /* root-workspace source without package.json */ }
-	}
+	// ⚠ `layout` is NOT validated here, deliberately. The rule: the engine validates a value if and
+	// only if the ENGINE INTERPRETS it. It interprets filter operators (`matchesFilter`, and the
+	// CLI's `--where`), so a typo'd operator is a real bug it can catch — hence the check below.
+	// It interprets `layout` nowhere: the value is opaque payload forwarded to whichever surface
+	// renders, and only that surface's registry knows which ids exist.
+	//
+	// There used to be an allowlist here, hardcoded to mirror dreamteamer-vscode's
+	// `lists.register(...)` calls in a DIFFERENT REPO. It was wrong both times it was tested:
+	// kanban/calendar/map (2026-07-29) and erd/graph (2026-08-10), each costing an engine edit to
+	// add a UI feature. Worse, it BLOCKED the sanctioned extension path — a module's `app.js` gets
+	// a `registerList({ id, ... })` API, so it can contribute a layout with no engine involvement,
+	// and this check then rejected the very view naming it unless the module also duplicated the id
+	// into a `dreamteamer.studio.layouts` key (zero users, in any repo, ever). Proven 2026-08-11 by
+	// modules/ui-smoke: the layout rendered in the app while compile refused the view.
+	//
+	// The descriptor already documented the correct behaviour — ui-views.collection.yaml: "An
+	// unregistered id degrades visibly rather than erroring" — and the surface already implements
+	// it (presets.ts#resolveRendererEntry falls back to table). Decision 195.
 	for (const [rt, e] of entries) {
 		if (!rt.startsWith('ui-views/')) continue;
 		const view = load(e.bytes.toString('utf8'));
-		if (view?.target === 'list' && view?.layout && !registeredLayouts.has(view.layout)) {
-			fail(`${rt}: layout "${view.layout}" is not registered (registered: ${[...registeredLayouts].sort().join(', ')}).\n  a module registers layouts in its studio app.js AND declares them in package.json under dreamteamer.studio.layouts.`);
-		}
 		// filters are load-bearing (they narrow what the operator SEES) — typo'd operators
 		// fail at compile, not silently at render (review finding 5)
 		const badOps = view?.filter ? [...unknownOperators(view.filter)] : [];

package/src/init.js

@@ -9,6 +9,12 @@ import { slugOrHash } from './template.js';
 import { discoverModules, KINDS } from './compile.js';
 import { Store } from './store.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'];
+
+
 const SKELETON_KINDS = ['collections', 'skills', 'agents', 'commands', 'ui-views'];
 
 const GITIGNORE = `node_modules/
@@ -137,6 +143,7 @@ export function install({ root, pkg }) {
 	const names = Object.keys(map);
 	if (!names.length) { console.log('✔ no git-modules declared — nothing to restore'); return 0; }
 	fs.mkdirSync(path.join(root, 'git_modules'), { recursive: true });
+	const unreachable = [];
 	for (const name of names) {
 		const { url, ref = 'main' } = map[name];
 		const dest = path.join(root, 'git_modules', name);
@@ -148,10 +155,24 @@ export function install({ root, pkg }) {
 			continue;
 		}
 		console.log(`… cloning ${url} → git_modules/${name} (${ref})`);
-		execFileSync('git', ['clone', '--branch', ref, url, dest], { stdio: 'inherit' });
+		try {
+			execFileSync('git', ['clone', '--branch', ref, url, dest], { stdio: 'inherit' });
+		} catch {
+			// one unreachable clone must not abandon the rest. the lockfile is a map of PRIVATE
+			// repos as often as public ones, so "the current credentials cannot see this one" is
+			// ordinary — a fresh machine, a collaborator, a cloud sandbox. aborting there left a
+			// half-restored workspace and named only the first failure.
+			fs.rmSync(dest, { recursive: true, force: true }); // git leaves the partial dir behind
+			unreachable.push(name);
+			console.warn(`⚠ git_modules/${name}: clone failed — skipped (${url})`);
+			continue;
+		}
 		buildClone(dest, name);
 	}
-	return 0;
+	// non-zero, because the workspace is NOT what the lockfile describes: modules are missing and
+	// `check` will report references into them as unknown collections.
+	if (unreachable.length) console.error(`✖ ${unreachable.length} module(s) could not be cloned: ${unreachable.join(', ')}`);
+	return unreachable.length ? 1 : 0;
 }
 
 // dreamteamer update [<name>] — pull each lockfile-declared git_modules clone forward
@@ -200,7 +221,7 @@ function buildClone(dest, name) {
 }
 
 function tryGit(cwd, args) {
-	try { return execFileSync('git', args, { cwd }).toString().trim() || null; } catch { return null; }
+	try { return execFileSync('git', args, { cwd, stdio: QUIET }).toString().trim() || null; } catch { return null; }
 }
 
 function appendMissing(file, block) {

package/src/server.js

@@ -16,6 +16,12 @@ 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' } = {}) {
 	const app = express();
 	app.use(express.json({ limit: '10mb' }));
@@ -42,7 +48,7 @@ export function startServer(ws, { port = 8080, host = '127.0.0.1' } = {}) {
 	// 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 }).toString().trim());
+		operatorId = slugOrHash(execFileSync('git', ['config', 'user.name'], { cwd: ws.root, stdio: QUIET }).toString().trim());
 	} catch { /* no git identity — @me filters simply won't narrow */ }
 
 	api.get('/info', (req, res) => {

package/src/store.js

@@ -12,6 +12,12 @@ import { generateId } from './template.js';
 import { parseRecord, parseRecordText, patternRe, fmtAjvError, unknownFields, walk, EXT, assertSafeId } from './records.js';
 import { normalizeRecord } from './temporal.js';
 import { NO_RUNTIME, loadDescriptors, runtimeDir, sourceRoots as compiledSourceRoots } from './runtime.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 class Store {
 	constructor({ root, pkg }) {
 		this.root = root;
@@ -66,7 +72,7 @@ export class Store {
 
 	// current HEAD — one cheap rev-parse per cache check vs a multi-thousand-file walk
 	gitHead() {
-		try { return execFileSync('git', ['rev-parse', 'HEAD'], { cwd: this.root }).toString().trim(); } catch { return 'no-git'; }
+		try { return execFileSync('git', ['rev-parse', 'HEAD'], { cwd: this.root, stdio: QUIET }).toString().trim(); } catch { return 'no-git'; }
 	}
 
 	ids(collection) {
@@ -128,7 +134,7 @@ export class Store {
 		const relPath = path.relative(this.root, file);
 		let previousContent;
 		try {
-			previousContent = execFileSync('git', ['show', `${hash}:${relPath}`], { cwd: this.root }).toString();
+			previousContent = execFileSync('git', ['show', `${hash}:${relPath}`], { cwd: this.root, stdio: QUIET }).toString();
 		} catch {
 			throw new Error(`${collection}/${id}: no content at ${hash} for ${relPath} — nothing was reverted.`);
 		}