dreamteamer 0.12.1 → 0.13.0

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "dreamteamer",
-	"version": "0.12.1",
+	"version": "0.13.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

@@ -75,7 +75,11 @@ and deliberately nothing else — including nothing about people. There is no `u
   from git's own status letters), and a multi-record commit says what it swept.
 - **one commit per REPO.** a module can own its records (`owns-data` in its package.json), and git
   has no cross-repo commit — so a rename whose inbound refs live in another repo is TWO commits.
-  `dt commit` prints both. `dt commit <collection> …` scopes it; `--dry-run` shows the set first.
+  `dt commit` prints both. `--dry-run` shows the set first.
+- **scope the commit to what YOU wrote: `dt commit <collection>/<id>`.** any number of targets, each
+  either a whole `<collection>` or one record — bare `dt commit` publishes everything pending, and
+  `dt commit <collection>` publishes every dirty record under it *whoever wrote it*, which is the
+  same sweep as the blanket add below when a second session shares the tree.
 - **never `git add -A`, `git add .`, or `git commit -a`.** stage explicit paths. more than one agent
   can be working in a tree, and a blanket add silently commits whatever another session has
   uncommitted right now — under your subject, leaving `git status` clean and the damage invisible.

package/src/cli.js

@@ -100,7 +100,10 @@ workspace verbs:
               [--since <sha|YYYY-MM-DD>] (default: the last commit) [--json]
   commit      publish records already written to disk: samples git status over every
               collection's record dirs, one commit PER REPO, subject composed from the
-              status letters. [<collection> …] to scope, [-m <subject>], [--dry-run]
+              status letters. Scope it with any number of targets, each either a whole
+              <collection> or one <collection>/<id> — the record form is what keeps a
+              concurrent session's pending records out of your commit.
+              [<collection>|<collection>/<id> …] [-m <subject>] [--dry-run] [--json]
   help        this text
 `;
 
@@ -206,7 +209,9 @@ export function run(argv) {
 				const store = new Store(ws);
 				const mi = rest.indexOf('-m');
 				const message = mi > -1 ? rest[mi + 1] : undefined;
-				// bare args are collection names — minus the token `-m` consumed as its subject
+				// bare args are TARGETS — a whole collection or a `<collection>/<id>` reference,
+				// told apart in commit.js against the declared collections — minus the token `-m`
+				// consumed as its subject
 				const only = rest.filter((a, i) => !a.startsWith('-') && (mi === -1 || i !== mi + 1));
 				const results = commitPending(store, { only, message, dryRun: rest.includes('--dry-run') });
 				if (rest.includes('--json')) { emit(JSON.stringify(results, null, 2)); process.exit(0); }

package/src/commit.js

@@ -5,6 +5,7 @@ import { execFileSync } from 'node:child_process';
 import fs from 'node:fs';
 import path from 'node:path';
 import { pathToRecord } from './events.js';
+import { splitRef } from './ref.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
@@ -14,6 +15,28 @@ const QUIET = ['ignore', 'pipe', 'ignore'];
 
 const VERB = { A: 'add', M: 'set', D: 'rm', R: 'rename', '?': 'add' };
 
+/** What the caller asked to publish. A target is EITHER a collection name or a `<collection>/<id>`
+ *  reference — the same either-shape `move` and `commands` accept, and after 0.12.0 the shape every
+ *  other verb's target has. Which one it is cannot be guessed from the string (an id may contain
+ *  slashes and so may a namespaced collection name), so it is decided against the DECLARED
+ *  collections: a key of `descriptors` is a collection, anything else goes to splitRef — which
+ *  throws, naming the known collections, rather than letting a typo mean "no scope".
+ *
+ *  Returns `scope` (collections to sample, so the git pathspec stays as narrow as it was), `whole`
+ *  (collections asked for entire) and `records` (ref → {collection, id}). */
+function parseTargets(descriptors, only) {
+	const scope = new Set();
+	const whole = new Set();
+	const records = new Map();
+	for (const target of only) {
+		if (descriptors.has(target)) { whole.add(target); scope.add(target); continue; }
+		const { collection, id } = splitRef(descriptors, target);
+		records.set(`${collection}/${id}`, { collection, id });
+		scope.add(collection);
+	}
+	return { scoped: only.length > 0, scope: [...scope], whole, records };
+}
+
 /** Record directories to watch, grouped by owning repo. System-stored collections are excluded:
  *  they live in the gitignored runtime and their sources are module files — the same exclusion
  *  pathToRecord already applies. */
@@ -97,11 +120,44 @@ export function composeSubject(rows) {
 	return `dreamteamer: ${rows.length} changes across ${collections.join(', ')}`;
 }
 
+/** A requested reference that matched no pending row is one of two very different things: a record
+ *  that is already published (nothing to do, and fine) or a MISTYPED id — which must not pass as
+ *  "nothing pending", the one report that looks like success. Only the store can tell them apart,
+ *  and it is only asked in this branch: a pending DELETION matched a row above, so a record whose
+ *  file is legitimately gone never reaches here. */
+function assertResolvable(store, records, matched) {
+	for (const [ref, { collection, id }] of records) {
+		if (matched.has(ref) || store.ids(collection).has(id)) continue;
+		throw new Error(`${ref}: no such record — nothing pending under that reference`);
+	}
+}
+
 export function commitPending(store, { only = [], message, dryRun = false } = {}) {
-	const byRepo = scopeByRepo(store.descriptors, only);
-	const results = [];
+	// Targets are resolved BEFORE anything is committed, so one bad target in a list of good ones
+	// leaves the whole tree untouched rather than committing a prefix of what was asked for.
+	const targets = parseTargets(store.descriptors, only);
+	const byRepo = scopeByRepo(store.descriptors, targets.scope);
+	// ⚠ Sample every repo FIRST, then check the references, then commit. The unknown-reference test
+	// below can only be answered once every repo has been sampled — a record lives in exactly one
+	// repo, and which one is not known in advance.
+	const sampled = [];
+	const matched = new Set();
 	for (const [repo, dirs] of byRepo) {
 		const { cwd, rows } = sample(store.root, repo, dirs, store.descriptors);
+		// The SAMPLER is deliberately left alone — it is what makes a hand-edited record
+		// indistinguishable from one the store wrote. Narrowing happens here, on the sampled rows,
+		// so `dt commit <collection>/<id>` publishes that record and leaves a sibling written by
+		// another session exactly as pending as it found it.
+		const wanted = !targets.scoped ? rows : rows.filter((r) => {
+			const ref = `${r.collection}/${r.id}`;
+			if (targets.records.has(ref)) { matched.add(ref); return true; }
+			return targets.whole.has(r.collection);
+		});
+		sampled.push({ repo, cwd, rows: wanted });
+	}
+	assertResolvable(store, targets.records, matched);
+	const results = [];
+	for (const { repo, cwd, rows } of sampled) {
 		if (!rows.length) continue;
 		const blocked = inProgress(cwd);
 		if (blocked) { results.push({ repo, rows, blocked }); continue; }