simt-dev 0.7.0 → 0.7.1

package/src/measure/session.mjs

@@ -8,6 +8,7 @@
 import { readFile } from 'node:fs/promises';
 import { resolve } from 'node:path';
 
+import { CLI } from '../name.mjs';
 import { tokens } from './context.mjs';
 
 const RULE_PATH_RE =
@@ -53,14 +54,14 @@ export async function measureSession(transcriptPath) {
     return {
       ok: false,
       error: '--session requires a local transcript path',
-      remedy: 'pass a local JSONL or JSON transcript path: simt tokens --session <path>',
+      remedy: `pass a local JSONL or JSON transcript path: ${CLI} tokens --session <path>`,
     };
   }
   if (/^[a-z][a-z0-9+.-]*:\/\//i.test(transcriptPath.trim())) {
     return {
       ok: false,
       error: `${transcriptPath}: remote URLs are refused; session transcripts are read locally only (ADR-075)`,
-      remedy: 'pass a local file path on this machine: simt tokens --session ./session.jsonl',
+      remedy: `pass a local file path on this machine: ${CLI} tokens --session ./session.jsonl`,
     };
   }
 

package/src/node-version.mjs

@@ -0,0 +1,37 @@
+// The runtime floor, in one place both entry points read (review 0003 Q54).
+//
+// `package.json` declares `engines.node` and `pyproject.toml` declares a python
+// version; both are advisory to the installer, so an older runtime reached the CLI
+// and failed somewhere inside it — a syntax error, a missing API — instead of the one
+// sentence that says what to install. This module is deliberately tiny and has no
+// imports: the bootstrap that calls it must not load the tool that cannot run.
+
+/** The oldest Node this package runs on. Mirrors `package.json` `engines.node`. */
+export const MIN_NODE = '22.20.0';
+
+/**
+ * Whether `current` is at least `minimum`, compared component by component.
+ *
+ * A string compare is wrong ("9.0.0" > "22.20.0"), and `process.versions.node` may
+ * carry a pre-release suffix that `Number()` would turn into NaN, so the numeric
+ * prefix of each component is what counts.
+ *
+ * @param {string} current a version such as `22.20.0` or `23.1.0-rc.1`
+ * @param {string} [minimum]
+ * @returns {boolean}
+ */
+export function satisfiesMinimum(current, minimum = MIN_NODE) {
+  const parse = (value) =>
+    String(value)
+      .split('.')
+      .map((part) => Number.parseInt(part, 10))
+      .map((part) => (Number.isFinite(part) ? part : 0));
+  const have = parse(current);
+  const want = parse(minimum);
+  for (let i = 0; i < Math.max(have.length, want.length); i += 1) {
+    const a = have[i] ?? 0;
+    const b = want[i] ?? 0;
+    if (a !== b) return a > b;
+  }
+  return true;
+}

package/src/output/index.mjs

@@ -92,7 +92,27 @@ export function writeMode(flags) {
  * Truncation is always announced with an explicit line, never a silent ellipsis:
  * an agent that cannot tell a truncated answer from a complete one will guess.
  */
-export function emit(text, { maxBytes = 0, stream = process.stdout } = {}) {
+/**
+ * Answer one command's result on the surface the caller asked for.
+ *
+ * Every command that has both a document and a text report was choosing between them by
+ * hand, in the same five lines, in more than a dozen files - and a command that chose
+ * slightly differently printed a report where a caller had asked for JSON, which is how a
+ * script gets prose (review 0003 Q63).
+ *
+ * The renderer is a thunk because the surface is decided first: a command asked for JSON
+ * must not pay to render text nobody reads, and a caller cannot forget the branch.
+ */
+export function present(payload, renderText, flags) {
+  if (isJson(flags)) {
+    emitJson(payload);
+    return 'json';
+  }
+  emit(renderText());
+  return 'text';
+}
+
+export function emit(text, { maxBytes = maxBytesDefault, stream = process.stdout } = {}) {
   const body = text.endsWith('\n') ? text : `${text}\n`;
   const bytes = Buffer.byteLength(body);
   if (maxBytes > 0 && bytes > maxBytes) {
@@ -131,6 +151,19 @@ export const SCHEMA_VERSION = 1;
  */
 let prettyDefault = process.stdout.isTTY === true;
 
+// The byte ceiling is one flag with one reader: the envelope. Commands used to pass
+// `flags.maxBytes ?? 0` at seventy-eight call sites, which is seventy-eight chances to pass
+// a different number, or to forget and answer past the ceiling the caller set (review 0003
+// Q65). A ceiling of zero or a value that is not a number is no ceiling, the same way the
+// flag itself is read.
+let maxBytesDefault = 0;
+
+/** Set the byte ceiling every emit and every document inherits, from `--max-bytes`. */
+export function maxBytesLimit(bytes) {
+  const value = Number(bytes);
+  maxBytesDefault = Number.isFinite(value) && value > 0 ? Math.floor(value) : 0;
+}
+
 export function jsonIndentDefault(pretty = process.stdout.isTTY === true) {
   prettyDefault = pretty;
 }
@@ -203,8 +236,83 @@ function fitJsonArrays(payload, maxBytes, pretty) {
   return null;
 }
 
-export function emitJson(value, { stream = process.stdout, pretty = prettyDefault, maxBytes = 0 } = {}) {
-  const payload = withSchemaVersion(value);
+/**
+ * Warnings a run accumulated, carried into the JSON document it prints.
+ *
+ * The same reason stderr is separate from stdout: a caller reading a document cannot
+ * see a note printed beside it. A command that ignored half of what it was asked still
+ * has to succeed or fail the same way, so the note belongs IN the result, and the text
+ * mode keeps the stderr line it already had (review 0003 Q62).
+ */
+let accumulated = [];
+
+// The path the dispatcher resolved. A command should not restate it: the ones that did
+// restated it wrongly (`plugin` printed `plugin claude`, `sync` printed `sync --check`),
+// and a document whose `command` disagrees with the argv that produced it is worse than
+// one with no `command` at all (review 0003 Q65).
+let canonicalCommand = null;
+
+/** Set the command path every JSON document will carry, or clear it with null. */
+export function jsonCommand(path) {
+  canonicalCommand = path ?? null;
+}
+
+// A document cannot name the exit code before the command has returned one. The
+// dispatcher captures what a command emits, then writes it once with the code attached;
+// writing first is how `ok: false` shipped alongside exit 0 (review 0003 Q65).
+let captured = null;
+
+/** Collect documents instead of writing them, so the dispatcher can add the exit code. */
+export function jsonCaptureStart() {
+  captured = [];
+}
+
+/** The captured documents and a reset, or an empty list when nothing was captured. */
+export function jsonCaptureTake() {
+  const docs = captured;
+  captured = null;
+  return docs;
+}
+
+/** Record a warning for the document this run prints. */
+export function warn(message) {
+  accumulated = [...accumulated, message];
+}
+
+/**
+ * Drop what a previous run in this process recorded.
+ *
+ * The collector is per process and a process can dispatch more than once - the MCP
+ * server and the tests both do. Without this, one command's notice appeared in the
+ * next command's document, which parity between the two surfaces caught (review 0003
+ * Q62).
+ */
+export function clearWarnings() {
+  accumulated = [];
+}
+
+/** The warnings this run has recorded, in order. */
+export function warnings() {
+  return accumulated;
+}
+
+export function emitJson(value, { stream = process.stdout, pretty = prettyDefault, maxBytes = maxBytesDefault } = {}) {
+  // `notices`, not `warnings`: `status` already reports a warning COUNT under that key,
+  // and a document cannot mean two things by one name. The collision is named here
+  // rather than bent into either shape (review 0003 Q62).
+  const carried =
+    accumulated.length > 0 && value !== null && typeof value === 'object' && !Array.isArray(value) && value.notices === undefined
+      ? { ...value, notices: accumulated }
+      : value;
+  const stamped =
+    canonicalCommand !== null && carried !== null && typeof carried === 'object' && !Array.isArray(carried)
+      ? { ...carried, command: canonicalCommand }
+      : carried;
+  if (captured !== null) {
+    captured.push({ value: stamped });
+    return true;
+  }
+  const payload = withSchemaVersion(stamped);
   const text = `${stringifyJson(payload, pretty)}\n`;
   // JSON is never byte-truncated: a cut document parses as a lie, and exit 0 calls it
   // true. Arrays shrink with a `truncated` record naming what lost how much, and a

package/src/packs/manage.mjs

@@ -511,6 +511,23 @@ export async function publishPack(dir, { apply = false } = {}) {
     return { pack: linted.pack, ok: false, published: false, skipped: false, planned: [], findings };
   }
 
+  // A preview is a preview. The registry read below is the one network call in this
+  // command, and running it to print a plan made `pack publish` — a preview by default
+  // — a network operation that failed offline without `--yes` (review 0003 Q58).
+  if (!apply) {
+    return {
+      pack: linted.pack,
+      ok: true,
+      published: false,
+      skipped: false,
+      planned: [
+        `npm view ${pkg}@${pack.version}  (check whether it is already live)`,
+        `npm publish  (in ${dir})`,
+      ],
+      findings,
+    };
+  }
+
   // Idempotent, the way the release twin is: a version that is already live is
   // skipped rather than republished, so a re-run after an interruption continues
   // where it stopped.
@@ -534,9 +551,6 @@ export async function publishPack(dir, { apply = false } = {}) {
   }
 
   const planned = [`npm publish  (in ${dir})`];
-  if (!apply) {
-    return { pack: linted.pack, ok: true, published: false, skipped: false, planned, findings };
-  }
   try {
     await exec('npm', ['publish'], { cwd: dir });
   } catch (error) {

package/src/packs.mjs

@@ -72,8 +72,26 @@ export async function packDigest(dir, { exclude = [] } = {}) {
     }
     for (const entry of entries.sort((a, b) => (a.name < b.name ? -1 : 1))) {
       const rel = prefix === '' ? entry.name : `${prefix}/${entry.name}`;
-      if (entry.isDirectory()) await walk(join(d, entry.name), rel);
-      else if (entry.isFile() && !excluded.has(rel)) files.push(rel);
+      if (entry.isDirectory()) {
+        await walk(join(d, entry.name), rel);
+      } else if (entry.isSymbolicLink()) {
+        // A link is not vendored bytes, and the loader follows it: the old walk skipped
+        // links while the projection read through them, so a rule reached by a link was
+        // projected without being covered by the pin (review 0003 Q58). A link to a
+        // file is hashed through its target, because `readFile` below follows it. A link
+        // to a directory is refused: recursing would let a pack's digest describe a tree
+        // it does not carry.
+        const target = await stat(join(d, entry.name)).catch(() => null);
+        if (target?.isDirectory()) {
+          const error = new Error(
+            `${rel} is a symbolic link to a directory; a pack is vendored bytes, and its digest cannot cover a tree it does not carry`,
+          );
+          error.code = 'PACK_SYMLINK';
+          error.path = rel;
+          throw error;
+        }
+        if (!excluded.has(rel)) files.push(rel);
+      } else if (entry.isFile() && !excluded.has(rel)) files.push(rel);
     }
   };
   await walk(dir);

package/src/projection/lock.mjs

@@ -17,6 +17,11 @@ import { LOCK_FILE, LOCK_LEGACY } from '../name.mjs';
 import { desiredRegion, provenanceDigest, LOCAL_PROFILE_DIR } from './rules.mjs';
 import { readManifest } from './manifest.mjs';
 
+/** The lock's own format. Bumped only when a reader must interpret an old file
+ *  differently; an absent field means 1, because every lock written before this
+ *  field existed was written by the only format there has been. */
+const LOCK_VERSION = 1;
+
 /** Manifest keys that change what the region contains. Anything else in the file is
  *  the repository's own notes, and hashing it would make a comment fail the lock. */
 const MANIFEST_KEYS = ['mode', 'budget', 'shared', 'surfaces', 'gates'];
@@ -39,7 +44,7 @@ export async function computeLock(root, flags = {}, manifest = undefined) {
   const outputs = createHash('sha256').update(desired.body).digest('hex');
   const hasVariants =
     variants && typeof variants === 'object' && Object.keys(variants).length > 0;
-  return hasVariants ? { inputs, outputs, variants } : { inputs, outputs };
+  return hasVariants ? { version: LOCK_VERSION, inputs, outputs, variants } : { version: LOCK_VERSION, inputs, outputs };
 }
 
 /**
@@ -71,6 +76,11 @@ export async function readLock(root) {
   if (text === null) return { lock: null, error: null };
   try {
     const lock = JSON.parse(text);
+    // Absent means 1; a version this build does not know is a lock it cannot judge,
+    // and reading it anyway would report drift for a format change.
+    if (lock.version !== undefined && (!Number.isInteger(lock.version) || lock.version < 1)) {
+      return { lock: null, error: 'version must be an integer of at least 1' };
+    }
     if (typeof lock?.inputs !== 'string' || typeof lock?.outputs !== 'string') {
       return { lock: null, error: 'must be an object with inputs and outputs' };
     }

package/src/projection/manifest.mjs

@@ -32,31 +32,17 @@ import { runScript } from '../ecosystem/node-runner.mjs';
 // and the manifest name is used a dozen times below in remedy strings that name this
 // file by name.
 import { MANIFEST_FILE, MANIFEST_LEGACY } from '../name.mjs';
+import { GENERATED_KEYS_OF, KEYS, loadManifest, manifestPath } from '../manifest/schema.mjs';
 import { CLI } from '../name.mjs';
 import { packageVersion } from '../package-version.mjs';
 export const MANIFEST = MANIFEST_FILE;
 
+// Still exported from here because this is where the manifest lived: every caller that
+// resolved its path through this module keeps working, and the implementation moved.
+export { manifestPath };
+
 export { MANIFEST_LEGACY };
 
-/**
- * The manifest a repository has, which is not necessarily the one this tool would write.
- *
- * The file was renamed from `simt-dev.json` to `simt.json`. Every read site used to say
- * `join(root, MANIFEST)` and would have reported an adopted repository as unadopted the
- * day the constant moved - and "no manifest" means "never adopted", which is the answer
- * that offers to re-adopt a repo that is already done. Fourteen repositories carry the
- * old name on disk.
- *
- * So the old name is read as a fallback and the new one is written. `writeManifest`
- * renames rather than creating a second file, which is how the window closes: the first
- * `simt init` or `simt sync` in an adopted repo retires the old name by moving it.
- */
-export async function manifestPath(root) {
-  const next = join(root, MANIFEST);
-  if (existsSync(next)) return next;
-  const previous = join(root, MANIFEST_LEGACY);
-  return existsSync(previous) ? previous : next;
-}
 
 
 /**
@@ -433,7 +419,7 @@ function ecosystemCommands(facts = [], capability = null) {
  */
 export function buildManifest({ root, stack = [], sha, version, existing = null, capability = null, surfaces = undefined, facts = [] }) {
   const gates = defaultGates(stack, facts);
-  const limits = defaultLimits(stack);
+  const limits = defaultLimits();
 
   // A re-init must never silently weaken a repo's own declaration: existing
   // limits and gates win over defaults, and only the projection stamp is refreshed.
@@ -745,7 +731,10 @@ export function declaredShared(manifest) {
   return { level, rules };
 }
 
-export const GENERATED_KEYS = new Set(['$comment', 'projection']);
+// Derived from the table rather than restated: a key this tool writes is a `tool` key
+// marked generated, and a second list here is the drift this module exists to end.
+export const GENERATED_KEYS = GENERATED_KEYS_OF;
+
 
 // The sub-keys of `projection` this tool writes. `projection` is a generated key, but
 // not wholesale: the repository owns sub-keys this writer does not emit (`place` is the
@@ -892,20 +881,17 @@ export function manifestText(manifest) {
   return `${JSON.stringify(manifest, null, 2)}\n`;
 }
 
-/** @returns {{manifest: object|null, exists: boolean, error: string|null}} */
+/**
+ * The manifest in the shape the callers already read, now answered by the one loader
+ * (review 0003 Q69). `error` is the unreadable-file case only: a manifest with a value
+ * the schema cannot use is still a manifest, and refusing it here would turn every
+ * reader into a second validator.
+ *
+ * @returns {Promise<{manifest: object|null, exists: boolean, error: string|null}>}
+ */
 export async function readManifest(root) {
-  const path = await manifestPath(root);
-  let text;
-  try {
-    text = await readFile(path, 'utf8');
-  } catch {
-    return { manifest: null, exists: false, error: null };
-  }
-  try {
-    return { manifest: JSON.parse(text), exists: true, error: null };
-  } catch (error) {
-    return { manifest: null, exists: true, error: `unparseable: ${error.message}` };
-  }
+  const { manifest, exists, problems } = await loadManifest(root);
+  return { manifest, exists, error: exists && manifest === null ? (problems[0] ?? 'unparseable') : null };
 }
 
 export async function writeManifest(root, manifest, journal = null) {

package/src/projection/rules.mjs

@@ -27,10 +27,11 @@ import { dirname, join, resolve } from 'node:path';
 
 import { fingerprint, KNOWN_TAGS } from '../resolve/fingerprint.mjs';
 import { loadMdcRules, renderMdc } from './mdc.mjs';
-import { foldsRules, frontmatterBlock, resolveSurfaces, rulePath, canScope } from './surfaces.mjs';
+import { foldsRules, resolveSurfaces, rulePath, canScope } from './surfaces.mjs';
 import { ruleTargets } from './targets.mjs';
 import { compose } from './markers.mjs';
-import { declaredBudget, declaredShared, manifestPath, readManifest } from './manifest.mjs';
+import { declaredBudget, declaredShared, readManifest } from './manifest.mjs';
+import { loadManifest } from '../manifest/schema.mjs';
 import { commandCard, CARD_LIMIT_BYTES } from '../kernel/card.mjs';
 import { packToBudget } from '../kernel/budget.mjs';
 import { filterInferable, inferableDefect, inferableProofs } from '../kernel/inferability.mjs';
@@ -255,7 +256,7 @@ export function isEligible(rule, signals, optedIn) {
 export async function readDeclared(root) {
   let parsed = {};
   try {
-    parsed = JSON.parse(await readFile(await manifestPath(root), 'utf8')) ?? {};
+    parsed = (await loadManifest(root)).manifest ?? {};
   } catch {
     parsed = {};
   }

package/src/repo-root.mjs

@@ -50,6 +50,25 @@ export function repoRoot(cwd) {
   }
 }
 
+/**
+ * The directory a command works on: `--root`, else the first positional when the command
+ * takes one, else the current directory.
+ *
+ * This precedence is a user-visible contract, not an implementation detail: it decides
+ * which directory `--root .` and a bare positional mean, and thirty-four commands had
+ * their own copy of it. The copies drifted - some resolved the answer, some did not; some
+ * read `args[0]`, some `positional[0]` - so the same argv could name two directories
+ * depending on which command read it (review 0003 Q65).
+ *
+ * The answer is returned verbatim, not resolved: a caller that wants an absolute path
+ * says so, and a command that reports the root it was given still reports what the reader
+ * typed. `repoRoot` answers the different question of which repository that directory
+ * belongs to.
+ */
+export function commandRoot(flags = {}, positional = []) {
+  return flags.root ?? positional[0] ?? process.cwd();
+}
+
 /**
  * Whether git on this repository compares paths case-insensitively, which is
  * the one filesystem fact a path comparison must honour: on a case-insensitive

package/src/resolve/fingerprint.mjs

@@ -19,10 +19,11 @@
 
 import { readdir, readFile, stat } from 'node:fs/promises';
 import { spawn } from 'node:child_process';
-import { basename, join } from 'node:path';
+import { join } from 'node:path';
 
 import { matchesGlob } from './resolve.mjs';
 import { MANIFEST_FILE, MANIFEST_LEGACY } from '../name.mjs';
+import { loadManifest } from '../manifest/schema.mjs';
 
 /** tag -> human-readable marker(s) that imply it. First match wins per tag. */
 const MARKERS = [
@@ -225,6 +226,12 @@ export async function fingerprint(root) {
   }
   const names = new Set(entries);
 
+  // One walk answers every `glob` fact. Each candidate used to walk the tree again, so
+  // a repository with seven globs paid for seven identical walks - the same directories,
+  // in the same order, for the same answer (review 0003 Q67).
+  let nested = null;
+  const nestedPaths = async () => (nested ??= await listNested(root));
+
   for (const [tag, markers] of MARKERS) {
     const hit = markers.find((m) => names.has(m));
     if (hit) {
@@ -249,7 +256,7 @@ export async function fingerprint(root) {
         break;
       }
       if (fact.kind === 'glob') {
-        const hit = (await findNested(root, candidate))[0];
+        const hit = findNestedIn(await nestedPaths(), candidate)[0];
         if (hit) {
           facts.add(fact.name);
           factEvidence[fact.name] ??= hit;
@@ -320,9 +327,9 @@ export async function fingerprint(root) {
     : names.has(MANIFEST_LEGACY)
       ? MANIFEST_LEGACY
       : null;
-  const manifest = manifestName === null
-    ? null
-    : await readManifest(join(root, manifestName));
+  // One reader, so a file that does not parse is a missing declaration rather than an
+  // object whose only key is "error" pretending to be this repo manifest (Q69).
+  const manifest = manifestName === null ? null : (await loadManifest(root)).manifest;
 
   const stackList = [...stack].sort();
   const factList = [...facts].sort();
@@ -339,14 +346,6 @@ export async function fingerprint(root) {
   };
 }
 
-async function readManifest(path) {
-  try {
-    return JSON.parse(await readFile(path, 'utf8'));
-  } catch {
-    return { error: `${basename(path)} unparseable` };
-  }
-}
-
 async function isDir(path) {
   try {
     return (await stat(path)).isDirectory();
@@ -364,7 +363,7 @@ async function isDir(path) {
  * are skipped for the reason the extension sample skips them: detection is not a
  * scan of vendored output.
  */
-async function findNested(root, pattern) {
+async function listNested(root) {
   const found = [];
   const walk = async (dir, prefix, depth) => {
     let items;
@@ -378,7 +377,7 @@ async function findNested(root, pattern) {
       const rel = prefix ? `${prefix}/${item.name}` : item.name;
       if (item.isDirectory()) {
         if (depth < GLOB_DEPTH) await walk(join(dir, item.name), rel, depth + 1);
-      } else if (matchesGlob(rel, pattern)) {
+      } else {
         found.push(rel);
       }
     }
@@ -387,6 +386,11 @@ async function findNested(root, pattern) {
   return found.sort();
 }
 
+/** The paths in the one walk that match a shape. */
+function findNestedIn(paths, pattern) {
+  return paths.filter((rel) => matchesGlob(rel, pattern)).sort();
+}
+
 /**
  * Which extensions this repository is written in.
  *

package/src/review/critic.mjs

@@ -33,6 +33,7 @@ import { digestOf, promptHash, proposalFrontmatter } from '../distill/engine.mjs
 const exec = promisify(execFile);
 
 import { LOCAL_DIR } from '../state.mjs';
+import { commandRoot } from '../repo-root.mjs';
 
 // Locked on-disk beneath machine-local state, like the distilled cache (R38) —
 // proposals keyed by content digest, never projected and never committed.
@@ -216,7 +217,7 @@ export async function reviewTarget(args, flags, { write = true, commands = [] }
   if (args.length > 0) {
     return fail(`unknown review argument ${args[0]}`, EXIT.USAGE, `usage: ${CLI} review [--local]`);
   }
-  const root = resolve(flags.root ?? process.cwd());
+  const root = resolve(commandRoot(flags));
   const listed = await tracked(root);
   if (listed.error) return listed.error;
 

package/src/toolwords.mjs

@@ -23,6 +23,7 @@ import { LESSON_KEYS } from './memory/lessons.mjs';
 import { DECISION_KEYS } from './memory/decide.mjs';
 import { PROMPT_WORDS } from './mcp/prompts.mjs';
 import { AGENT_STEM, SKILL_STEM } from './agents/render.mjs';
+import { CORPUS_KIND } from './bench/corpus.mjs';
 
 /**
  * `simt-` names that belong to this tool and never to a repository.
@@ -50,6 +51,8 @@ export const TOOL_WORDS = new Set([
   AGENT_STEM,
   // The companion skill the agent reads on demand; its stem is the directory name.
   SKILL_STEM,
+  // The kind stamp this tool writes into every sealed bench corpus document it exports.
+  CORPUS_KIND,
 ]);
 
 /**

package/src/workspace.mjs

@@ -38,7 +38,8 @@ export const PACKAGE_ROOT = resolve(HERE, '..');
 // other LOCKED on-disk names, and a second copy here is a name that can drift from the
 // list of names that are allowed to move. Imported as well as re-exported, because a
 // bare `export { X } from` does not bind X here and every use below would fail.
-import { CONFIG_DIR } from './name.mjs';
+import { CONFIG_DIR, MANIFEST_FILE } from './name.mjs';
+import { manifestPath, readManifest } from './projection/manifest.mjs';
 export { CONFIG_DIR };
 export const CONFIG_FILE = 'config.json';
 
@@ -133,14 +134,25 @@ async function looksLikeWorkspace(dir) {
 /**
  * Resolve the workspace.
  *
- * Precedence, highest first: `--workspace`, `SIMT_DEV_WORKSPACE`, the user config file, then the
- * sibling heuristic of this package - and that last one only if it actually contains a git
- * repository.
+ * Precedence, highest first (ADR-119): `--workspace`, the repository's own manifest
+ * declaration, `SIMT_DEV_WORKSPACE` - a value that names a directory is honoured only
+ * where the manifest declares a workspace, because the variable is a pointer INTO a
+ * workspace the repo opted into, not one imposed on a repo that never declared one;
+ * a value that declines is honoured from anywhere, because a decline points at
+ * nothing - the manifest's value, the user config file, then the sibling heuristic
+ * of this package, which is accepted only if it actually contains a git repository.
  *
+ * A relative manifest value resolves against the manifest's directory, not the
+ * process's, so `workspace: ".."` means the same thing from any subdirectory.
+ *
+ * @param {{repoRoot?: string}} [options] `repoRoot` names the repository whose manifest
+ *   declares the workspace; it defaults to `process.cwd()`, which is the repository
+ *   for the way every command is run.
  * @returns {Promise<{root: string|null, source: string, detail: string, searched: string[], error: string|null}>}
  */
 export async function resolveWorkspace(flags = {}, options = {}) {
   const env = options.env ?? process.env;
+  const repoRoot = options.repoRoot ?? process.cwd();
   const searched = configPaths(options);
 
   // The config file is read FIRST, before precedence is applied, and a parse failure
@@ -169,16 +181,49 @@ export async function resolveWorkspace(flags = {}, options = {}) {
     );
   }
 
+  // The repository's own declaration (ADR-119). It is read before the environment
+  // variable because it is what the variable is allowed to point into: a repo that
+  // declared no workspace is a single repo with no workspace, and an environment
+  // variable cannot turn it into a member of a workspace nobody reviewed.
+  const manifest = await readManifest(repoRoot);
+  if (manifest.error) {
+    return {
+      root: null,
+      source: 'repo',
+      detail: await manifestPath(repoRoot),
+      searched,
+      error: manifest.error,
+    };
+  }
+  let repoValue = null;
+  if (manifest.exists && typeof manifest.manifest.workspace === 'string' && manifest.manifest.workspace.trim() !== '') {
+    const off = disabled(manifest.manifest.workspace, 'repo', `${MANIFEST_FILE} workspace`, searched);
+    if (off) return off; // the repo declined; the environment variable cannot enforce one
+    repoValue = manifest.manifest.workspace;
+  }
+
   if (env.SIMT_DEV_WORKSPACE) {
-    return (
-      disabled(env.SIMT_DEV_WORKSPACE, 'env', 'SIMT_DEV_WORKSPACE', searched) ?? {
+    const off = disabled(env.SIMT_DEV_WORKSPACE, 'env', 'SIMT_DEV_WORKSPACE', searched);
+    if (off) return off; // a decline points at nothing, so it needs no declaration to work
+    if (repoValue !== null) {
+      return {
         root: absolute(env.SIMT_DEV_WORKSPACE),
         source: 'env',
         detail: 'SIMT_DEV_WORKSPACE',
         searched,
         error: null,
-      }
-    );
+      };
+    }
+  }
+
+  if (repoValue !== null) {
+    return {
+      root: absolute(repoValue, repoRoot),
+      source: 'repo',
+      detail: `${MANIFEST_FILE} workspace`,
+      searched,
+      error: null,
+    };
   }
 
   if (user.exists && typeof user.config.workspace === 'string' && user.config.workspace.length > 0) {
@@ -245,11 +290,11 @@ export const WORKSPACE_REMEDY = (() => {
   return `--workspace <path>, the SIMT_DEV_WORKSPACE environment variable, or ${where}`;
 })();
 
-function absolute(p) {
+function absolute(p, base = process.cwd()) {
   const expanded = p.startsWith('~/')
     ? join(homedir(), p.slice(2))
     : p;
-  return isAbsolute(expanded) ? expanded : resolve(expanded);
+  return isAbsolute(expanded) ? expanded : resolve(base, expanded);
 }
 
 /**