dreamteamer 0.22.0 → 0.24.0

package/README.md

@@ -111,6 +111,19 @@ node_modules/<name>/   # published package
 Precedence runs top to bottom, so a local copy shadows a published one — which is how you develop a
 module and use it in the same workspace at the same time.
 
+A published package or a git clone may carry **several** modules: when its root has a `modules/`
+folder, each `modules/<name>/` with a `dreamteamer` key in its `package.json` is a module on that
+channel, and the root itself is never compiled. One `npm install` then delivers a whole family, and the
+workspace keeps what it wants — a bare module name in `dreamteamer.disable` drops a module before
+compile looks at it (an entry with a slash, `<module>/<entity>`, still disables one entity):
+
+```json
+"dreamteamer": { "disable": ["recordings", "introspection"] }
+```
+
+Disabling a module another one declares in `dependencies` is refused, naming what is present. The
+workspace's own `modules/*` never nest.
+
 Sources live **flat at a module root** — `modules/crm/skills/`, beside `package.json` — and a folder
 at a module root that isn't a known kind is a compile error rather than a silent skip.
 

package/package.json

@@ -1,7 +1,7 @@
 {
 	"name": "dreamteamer",
-	"version": "0.22.0",
-	"description": "A workspace compiler for coding agents \u2014 schema-validated records as plain files over git, compiled into every harness",
+	"version": "0.24.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>",
 	"homepage": "https://github.com/dreamteamer/dreamteamer#readme",

package/src/cli.js

@@ -165,6 +165,7 @@ Every verb that MOVES records or CLEARS values takes --dry-run and prints its pl
 
 workspace verbs:
   init        write the workspace skeleton into the current directory (never compiles)
+              [--harnesses claude-code,codex,pi,gemini-cli,cursor,notebooklm]
   --version   print the engine version (works anywhere)
   install     make THIS checkout ready — the engine, .env (linked from the primary when this is a
               worktree), declared local assets, git modules, compile, and a declared postinstall.

package/src/compile.js

@@ -523,33 +523,51 @@ export const locationOf = (source, wsRoot) =>
 export function discoverModules(root, pkg) {
 	const byName = new Map(); // name -> {name, root, channel}
 	const shadows = []; // {name, winner, loser} — channels
+	// A BARE `dreamteamer.disable` entry names a whole module; `<module>/<entity>` names one entity and
+	// is applied per source at compile time. The bare form is what lets a workspace take a PACKAGE of
+	// modules and keep only the ones it wants — a disabled module is simply never discovered, so every
+	// caller (compile, status, install) sees the same set.
+	const disabledModules = new Set((pkg?.dreamteamer?.disable ?? []).filter((d) => typeof d === 'string' && !d.includes('/')));
+	const disabledHits = new Set();
 	const tryAdd = (name, srcRoot, channel) => {
+		if (disabledModules.has(name)) { disabledHits.add(name); return; }
 		const existing = byName.get(name);
 		if (existing) { shadows.push({ name, winner: existing.channel, loser: channel }); return; }
 		byName.set(name, { name, root: srcRoot, channel });
 	};
-	const scanDir = (dir, channel) => {
+	const readPkg = (dir) => {
+		try {
+			const mpkg = JSON.parse(fs.readFileSync(path.join(dir, 'package.json'), 'utf8'));
+			return 'dreamteamer' in mpkg ? mpkg : null;
+		} catch { return null; } // no package.json, or unparseable — not a module
+	};
+	// A PACKAGE OF MODULES: a dependency or a git clone whose root carries `modules/` bundles several
+	// modules — its sub-modules are the modules, and the root itself is never compiled. One
+	// `npm install` (or one clone) then delivers a whole family, and `disable` cherry-picks from it.
+	// Inline `modules/*` never nest: a `modules/` folder at an inline module root stays the
+	// unknown-folder compile error it always was, because the workspace's own tree has no reason to
+	// bundle.
+	const scanDir = (dir, channel, unpack) => {
 		if (!fs.existsSync(dir)) return;
 		for (const name of fs.readdirSync(dir).sort()) {
 			const srcRoot = path.join(dir, name);
-			const pkgPath = path.join(srcRoot, 'package.json');
-			if (!fs.existsSync(pkgPath)) continue;
-			try {
-				const mpkg = JSON.parse(fs.readFileSync(pkgPath, 'utf8'));
-				if ('dreamteamer' in mpkg) tryAdd(mpkg.name ?? name, srcRoot, channel);
-			} catch { /* unparseable package.json — skip */ }
+			const mpkg = readPkg(srcRoot);
+			if (mpkg) (unpack ? tryAddOrUnpack : tryAdd)(mpkg.name ?? name, srcRoot, channel);
 		}
 	};
-	scanDir(path.join(root, 'modules'), 'inline');
-	scanDir(path.join(root, 'git_modules'), 'git');
+	const tryAddOrUnpack = (name, srcRoot, channel) => {
+		const bundle = path.join(srcRoot, 'modules');
+		if (fs.existsSync(bundle) && fs.statSync(bundle).isDirectory()) { scanDir(bundle, channel, false); return; }
+		tryAdd(name, srcRoot, channel);
+	};
+	scanDir(path.join(root, 'modules'), 'inline', false);
+	scanDir(path.join(root, 'git_modules'), 'git', true);
 	for (const dep of Object.keys({ ...pkg.dependencies, ...pkg.devDependencies }).sort()) {
 		const srcRoot = path.join(root, 'node_modules', dep);
-		try {
-			const mpkg = JSON.parse(fs.readFileSync(path.join(srcRoot, 'package.json'), 'utf8'));
-			if ('dreamteamer' in mpkg) tryAdd(mpkg.name ?? dep, srcRoot, 'npm');
-		} catch { /* dep not installed or no package.json — skip */ }
+		const mpkg = readPkg(srcRoot);
+		if (mpkg) tryAddOrUnpack(mpkg.name ?? dep, srcRoot, 'npm');
 	}
-	return { modules: [...byName.values()], shadows };
+	return { modules: [...byName.values()], shadows, disabledModules: [...disabledHits] };
 }
 
 // ---- module-owned data ----------------------------------------------------------
@@ -629,7 +647,7 @@ export function compile({ root, pkg }) {
 	};
 
 	// ---- discover sources: channel modules then the workspace's own -----------------
-	const { modules: discovered, shadows } = discoverModules(root, pkg);
+	const { modules: discovered, shadows, disabledModules } = discoverModules(root, pkg);
 	for (const s of shadows) console.warn(shadowWarning(s));
 	const sources = [...discovered];
 	// workspace-owned sources: either at the root (classic layout) or in the designated
@@ -809,7 +827,7 @@ export function compile({ root, pkg }) {
 	const dataOwners = dataOwningModules(sources, fail, rel);
 
 	const disabled = new Set(config.disable ?? []);
-	const disabledHits = new Set();
+	const disabledHits = new Set(disabledModules); // bare entries were applied at discovery
 
 	/** entries: runtime-relative path -> { sources: [workspace-relative], bytes } */
 	const entries = new Map();

package/src/harnesses.js

@@ -14,7 +14,7 @@ import fs from 'node:fs';
 import path from 'node:path';
 import { load, dump } from './yaml.js';
 
-export const KNOWN_HARNESSES = ['claude-code', 'codex', 'pi', 'gemini-cli', 'cursor'];
+export const KNOWN_HARNESSES = ['claude-code', 'codex', 'pi', 'gemini-cli', 'cursor', 'notebooklm'];
 
 export const STAMP = '<!-- generated by dreamteamer compile — do not edit; source of truth lives in modules/<module>/<kind>/ -->';
 
@@ -99,6 +99,14 @@ export function runHarnessAdapters({ root, entries, harnesses, prevManifest, sou
 		summary.push('cursor → .cursor/rules/dreamteamer.mdc');
 	}
 
+	// ---- notebooklm: NOTEBOOKLM.md carries the notebook's CONFIGURATION ---------------
+	// Not an orientation block: NotebookLM does not read a context file and has no skills. What it
+	// needs is a persona to paste, a response length to pick, and the limits that decide how the
+	// workspace has to be cut up — and all three go stale as collections come and go, which is why
+	// this is generated on compile rather than written once by hand.
+	block('NOTEBOOKLM.md', on('notebooklm') ? notebooklmBlock(entries, version) : null);
+	if (on('notebooklm')) summary.push('notebooklm → NOTEBOOKLM.md block');
+
 	// ---- prune: anything WE stamped that this compile didn't produce ------------------
 	const current = new Set(outputs);
 	for (const dir of ['.claude/skills', '.claude/agents', '.claude/commands', '.agents/skills', '.cursor/rules']) {
@@ -119,6 +127,94 @@ export function runHarnessAdapters({ root, entries, harnesses, prevManifest, sou
 	return { outputs, blocks, summary };
 }
 
+/** Sources a notebook holds, per plan — Google's published table, read 2026-09. Stated here because
+ *  the number decides the SHAPE of the export: a workspace with more collections than the plan has
+ *  slots has to be narrowed or packed, and that is a decision the operator makes before running
+ *  anything. */
+const NOTEBOOK_PLANS = [
+	['standard', 50, 50], ['plus', 100, 200], ['pro', 300, 500], ['ultra', 600, 2500],
+];
+
+/** The notebook's configuration, generated: what to paste as custom instructions, which settings to
+ *  pick, and the limits that bind. Derived from the compiled DESCRIPTORS only — never from `data/`,
+ *  for the same reason the orientation block carries no record counts: this lands in a committed file
+ *  and a count would re-dirty it on every write. */
+function notebooklmBlock(entries, version) {
+	const index = buildCollectionsIndex(entries);
+	const modules = buildModulesIndex(entries);
+	const data = index.filter((c) => !c.system);
+	const withheldCollections = data.filter((c) => c.sensitive).map((c) => c.name);
+	const withheldFields = data.flatMap((c) => c.sensitiveFields.map((f) => `${c.name}.${f}`));
+	const exported = data.filter((c) => !c.sensitive);
+
+	// grouped by module from the COLLECTIONS index, which carries each collection's owning module —
+	// `buildModulesIndex` deliberately reports skills, commands and bin, not collections
+	const title = new Map(modules.map((m) => [m.id, m.title]));
+	const byModule = new Map();
+	for (const c of data) {
+		const k = c.module || '';
+		if (!byModule.has(k)) byModule.set(k, []);
+		byModule.get(k).push(c.name);
+	}
+	const brief = [...byModule]
+		.sort((a, b) => (title.get(a[0]) || a[0]).localeCompare(title.get(b[0]) || b[0]))
+		.map(([mod, names]) => `- ${title.get(mod) || mod || 'the workspace'}: ${names.sort().map((c) => (withheldCollections.includes(c) ? `${c} (withheld)` : c)).join(', ')}`);
+
+	const persona = [
+		'You are the reference desk for this workspace. Every source is ONE COLLECTION of it, and every row or section is one record. Answer only from the sources.',
+		'',
+		'A record is cited as `<collection>/<id>`. A field holding a reference contains exactly that form, so `leads.company = companies/acme` means the record `acme` in the `companies` source — follow those links across sources rather than guessing. A source whose name ends `--01`, `--02` is one collection split across files purely for size; treat the parts as one collection.',
+		'',
+		'What this workspace keeps, by module:',
+		...brief,
+		'',
+		withheldCollections.length || withheldFields.length
+			? `Deliberately NOT here: ${[...withheldCollections.map((c) => `the whole collection ${c}`), ...withheldFields].join('; ')}. If asked about them, say they were withheld from the export rather than inferring.`
+			: 'Nothing has been withheld from this export.',
+		'',
+		'Ground every claim in a record and name it. When the question is a table question — which rows match, what is overdue, everything about one company — read down the column and give the matching records, not a summary. When the sources do not hold the answer, say so plainly: "this workspace does not record that" is a useful answer.',
+	].join('\n');
+
+	const lines = [
+		'NOTEBOOKLM — the configuration for a notebook over this workspace. NotebookLM reads no context',
+		'file and runs no skills, so unlike the other harnesses nothing here is injected: it is applied,',
+		`once per notebook, and re-pasted when the schema changes. Regenerated by every \`dreamteamer compile\` (engine ${version}).`,
+		'',
+		'## settings',
+		'',
+		'| setting | value | why |',
+		'|---|---|---|',
+		'| response length | **longer** | records are terse; the useful answer quotes several and says which |',
+		'| chat mode | **do not set one** | `--mode` REPLACES the persona — see the warning below |',
+		'',
+		'```bash',
+		'notebooklm configure -n <notebook-id> --response-length longer \\',
+		'  --persona "$(sed -n \'/^## custom instructions/,/^## limits/p\' NOTEBOOKLM.md | sed \'1,2d;$d\')"',
+		'```',
+		'',
+		'⚠ **`configure` REPLACES the whole configuration on every call, and passing `--mode` with a persona silently discards the persona.** Measured: `--persona … --response-length longer --mode default` answers `{mode: "default", configured: true}` at exit 0, with the persona and the response length gone; the identical call without `--mode` returns both. There is also no read-only inspection — a bare `configure`, the obvious way to check the current settings, CLEARS them. So send every setting you want in ONE call, never `--mode` alongside a persona, and keep the persona in a file rather than only in the notebook.',
+		'',
+		'## custom instructions',
+		'',
+		persona,
+		'',
+		'## limits',
+		'',
+		'| plan | sources per notebook | chats per day |',
+		'|---|---|---|',
+		...NOTEBOOK_PLANS.map(([n, s, c]) => `| ${n} | ${s} | ${c} |`),
+		'',
+		`This workspace exports **${exported.length} collections**${withheldCollections.length ? ` (${withheldCollections.length} withheld)` : ''}, so one source per collection needs a plan with at least that many slots — before any collection is split.`,
+		'',
+		'- **Per source:** 500,000 words or 200 MB, per Google. ⚠ A CSV source fails well below that: measured on a large private workspace, files at or under 805,081 bytes indexed and files at or above 881,828 bytes did not, so 700,000 bytes is the working ceiling.',
+		'- **Persona:** 10,000 characters. The block above is generated to stay inside it; adding to it by hand can push it over, and `configure` refuses the whole call rather than truncating.',
+		'- **Auto-sync follows native Google Docs, Sheets and Slides only.** An uploaded file — CSV, PDF, Markdown — is a SNAPSHOT: re-export means re-adding those sources.',
+		'- ⚠ **`source add` reports success whether or not the file indexes.** Read `source list --json` back and require `type` to be the format you uploaded; a source that failed reads `type: unknown, status: error` with no message anywhere.',
+		'- ⚠ **An answer is real only with non-blank text AND at least one reference.** Exit 0 with an empty answer is a real outcome, reached by scoping a broad question with `-s`.',
+	];
+	return lines.join('\n');
+}
+
 // skill id → description one-liners from each SKILL.md's frontmatter; the orientation
 // block carries this index so harnesses without native skill discovery still get triggers.
 function buildSkillsIndex(entries) {
@@ -156,6 +252,10 @@ function buildCollectionsIndex(entries) {
 			description: flat(d.description),
 			useWhen: flat(d.use_when),
 			module: d.module ?? '',
+			// the sensitivity marks, so a generated persona can NAME what it was not given —
+			// "withheld" is a better answer than "I don't know"
+			sensitive: d.sensitive === true,
+			sensitiveFields: Object.entries(d.schema?.properties ?? {}).filter(([, p]) => p?.['x-sensitive'] === true).map(([k]) => k),
 			write: writeLine(d.schema),
 		});
 	}

package/src/land.js

@@ -43,12 +43,19 @@ export const LAND_LOCK = 'dreamteamer-land.lock';
  * compile never touches one: matching on the basename would let a nested file that happens to carry
  * a copied block be resolved `--ours` and discarded silently (ruling R32).
  *
+ * ⚠ THIS LIST DRIFTS THE MOMENT A HARNESS IS ADDED ON A DIFFERENT BRANCH, and it did:
+ * `NOTEBOOKLM.md` was written by a harness developed in parallel with `land`, so neither branch's
+ * suite could see the gap and both were green. Landed together, `dt land` classified a conflict in
+ * that file as `other` — a foreign file that ABORTS the landing — instead of a managed block it can
+ * simply regenerate. The unit test below derives this list from `harnesses.js` itself for exactly
+ * this reason, and it is what caught it; keep it that way rather than asserting a literal.
+ *
  * ⚠ `.cursor/rules/dreamteamer.mdc` is deliberately NOT here (ruling R33). Cursor's output is a
  * WHOLE generated file — frontmatter, body and STAMP, no begin/end markers (harnesses.js:97) — so
  * there is no block to take `--ours` on, and `init` gitignores `.cursor/` anyway. A conflict there
  * is an ordinary non-records conflict and aborts the landing like any other.
  */
-export const MANAGED_FILES = ['CLAUDE.md', 'AGENTS.md', 'GEMINI.md'];
+export const MANAGED_FILES = ['CLAUDE.md', 'AGENTS.md', 'GEMINI.md', 'NOTEBOOKLM.md'];
 
 /** Does compile write a managed block into this exact path? Task C's per-commit loop asks too. */
 export const isManaged = (filePath) => MANAGED_FILES.includes(filePath);