simt-dev 0.7.0 → 0.7.1

package/src/commands/sync.mjs

@@ -19,7 +19,8 @@
 import { mkdir, readFile, stat, symlink, unlink } from 'node:fs/promises';
 import { dirname, join, resolve, sep } from 'node:path';
 import { EXIT, emit, emitJson, fail, isJson, note, writeMode } from '../output/index.mjs';
-import { plan, checkTargets, checkTarget, provenanceDigest, loadRules, select, pointerTargets, pointerState } from '../projection/project.mjs';
+import { repoContext } from '../context.mjs';
+import { plan, checkTargets, checkTarget, select, pointerTargets, pointerState } from '../projection/project.mjs';
 import { fingerprint } from '../resolve/fingerprint.mjs';
 import { manifestDrift, readManifest, unrunnableGates, buildManifest, writeManifest, withGenerated, manifestText, manifestPath } from '../projection/manifest.mjs';
 import { diffField, emitDiffs, readBefore } from '../diff.mjs';
@@ -34,6 +35,7 @@ import { computeLock, readLock } from '../projection/lock.mjs';
 import { runDeclaredChecks } from '../kernel/checks.mjs';
 import { decisionsCutoff, decisionsDir } from '../decisions/dir.mjs';
 import { lintDecisions } from '../memory/decide.mjs';
+import { commandRoot } from '../repo-root.mjs';
 
 /** Findings `sync` reports and does not fail on.
  *
@@ -123,7 +125,7 @@ export const CHECK_NON_BLOCKING = new Set([
 ]);
 
 export async function syncCommand(positional, flags) {
-  const root = flags.root ?? positional[0] ?? process.cwd();
+  const root = commandRoot(flags, positional);
   const checkOnly = flags.check === true;
   const mode = writeMode(flags);
 
@@ -409,7 +411,7 @@ export async function syncCommand(positional, flags) {
           : `would write ${changed.length + pointersAdded.length + (manifestChanged ? 1 : 0)} file(s); apply with: ${CLI} sync --yes`,
       );
     }
-    emit(lines.join('\n'), { maxBytes: flags.maxBytes ?? 0 });
+    emit(lines.join('\n'));
     // After the report: the report says what, the diff shows it (R50).
     emitDiffs(diffs, flags);
   }
@@ -544,8 +546,9 @@ async function gateCwdFindings(root, manifest) {
 // reports 77. The command below renders these facts for terminals; the tool
 // returns them as JSON. The CLI keeps its field names; the tool adopts them.
 export async function checkRepo(root, opts = {}) {
-  const findings = await checkTargets(root, opts);
-  const rules = await loadRules(root);
+  const ctx = opts.ctx ?? repoContext(root);
+  const findings = await checkTargets(root, { ...opts, ctx });
+  const rules = await ctx.rules();
 
   // A rule file with no id would be projected without a traceable source, so it
   // is a gate failure rather than a warning: `rules why` could not resolve it.
@@ -568,7 +571,7 @@ export async function checkRepo(root, opts = {}) {
   // A declared gate this repo cannot run fails closed on every commit once hooks are
   // installed. Reported here rather than left to `hooks status`, so the repo is red
   // before anyone installs anything rather than after.
-  const { manifest, exists } = await readManifest(root);
+  const { manifest, exists } = await ctx.manifest();
   // The gates slot, counted — not just reported — so the line can print run/total.
   // A cwd finding names a declared gate that will not run, so it counts with the
   // unrunnable; an unknown-gate-cwd names no declared gate, so it does not.
@@ -603,14 +606,14 @@ export async function checkRepo(root, opts = {}) {
     // hand either: the next `init` puts simt-dev's own bytes back and the formatter
     // takes them away again. Reporting it here is what stops that being a surprise
     // discovered at upgrade time.
-    const { stack } = await fingerprint(root);
-    const drift = await manifestDrift(root, stack, await provenanceDigest());
+    const { stack } = await ctx.fingerprint();
+    const drift = await manifestDrift(root, stack, await ctx.digest());
     if (drift) findings.push(drift);
   }
   if (opts.frozen) findings.push(...(await frozenFindings(root, opts)));
   // The checkers a selected rule declared (ADR-088). They read the rule source,
   // not the folded region, so a line that left the prompt is still the line that runs.
-  const fp = await fingerprint(root);
+  const fp = await ctx.fingerprint();
   const { selected } = select(rules.filter((r) => r.error === null), fp.stack ?? [], fp.facts ?? []);
   findings.push(...(await runDeclaredChecks(root, selected, manifest ?? null)));
 
@@ -652,7 +655,7 @@ export async function checkRepo(root, opts = {}) {
 }
 
 export async function checkCommand(positional, flags) {
-  const root = flags.root ?? positional[0] ?? process.cwd();
+  const root = commandRoot(flags, positional);
   const { ok, findings } = await checkRepo(root, flags);
   const payload = {
     ok,
@@ -678,7 +681,6 @@ export async function checkCommand(positional, flags) {
         return f.remedy ? [head, `${' '.repeat(11)}remedy: ${f.remedy}`] : [head];
       })
       .join('\n'),
-    { maxBytes: flags.maxBytes ?? 0 },
   );
   return ok ? EXIT.OK : EXIT.FAIL;
 }

package/src/commands/tests.mjs

@@ -10,11 +10,12 @@ import { readFile } from 'node:fs/promises';
 import { join } from 'node:path';
 import { promisify } from 'node:util';
 
-import { EXIT, emit, emitJson, fail, isJson } from '../output/index.mjs';
+import { EXIT, emit, emitJson, fail, isJson, present } from '../output/index.mjs';
 import { CLI } from '../name.mjs';
 import { isTestPath } from '../bench/mine.mjs';
 import { blobTexts, isIndexStale, langOf, readEdges, readFiles, reindex } from '../index/store.mjs';
 import { HISTORY, importsOf, parseCoverage, testEdges, testsFor } from '../index/tests.mjs';
+import { commandRoot } from '../repo-root.mjs';
 
 const exec = promisify(execFile);
 
@@ -31,7 +32,7 @@ const COVERAGE_PATHS = [
 
 export async function testsCommand(args, flags) {
   if (args.length > 1) return fail(`unknown tests argument ${args[1]}`, EXIT.USAGE, `run: ${CLI} tests [path]`);
-  const root = flags.root ?? process.cwd();
+  const root = commandRoot(flags);
   const loaded = await loadFiles(root);
   if (loaded.error) return loaded.error;
   const { files } = loaded;
@@ -58,11 +59,11 @@ export async function testsCommand(args, flags) {
   const tests = testsFor(target, edges, { cochange: flags.cochange === true });
   const payload = { ok: true, command: 'tests', root, path: target, tests };
   if (isJson(flags)) {
-    emitJson(payload, { pretty: flags.pretty === true, maxBytes: flags.maxBytes ?? 0 });
+    emitJson(payload);
     return EXIT.OK;
   }
   const lines = [`tests    ${tests.length}`, ...tests];
-  emit(lines.join('\n'), { maxBytes: flags.maxBytes ?? 0 });
+  emit(lines.join('\n'));
   return EXIT.OK;
 }
 
@@ -74,11 +75,7 @@ function summarise(root, flags, edges) {
     else if (edge.kind === 'cochange') cochange += 1;
   }
   const payload = { ok: true, command: 'tests', root, test, cochange };
-  if (isJson(flags)) {
-    emitJson(payload, { pretty: flags.pretty === true, maxBytes: flags.maxBytes ?? 0 });
-    return EXIT.OK;
-  }
-  emit(`test      ${test}\ncochange  ${cochange}`, { maxBytes: flags.maxBytes ?? 0 });
+  present(payload, () => `test      ${test}\ncochange  ${cochange}`, flags);
   return EXIT.OK;
 }
 

package/src/commands/tokens.mjs

@@ -73,7 +73,7 @@ export async function tokensCommand(positional, flags) {
       `tool output ${plain(session.toolOutput.bytes)} B  ~${plain(session.toolOutput.tokens)} tokens  (${plain(session.toolOutput.share)}%)`,
       `total       ${plain(session.total.bytes)} B  ~${plain(session.total.tokens)} tokens`,
     ];
-    emit(lines.join('\n'), { maxBytes: flags.maxBytes ?? 0 });
+    emit(lines.join('\n'));
     return EXIT.OK;
   }
 
@@ -193,6 +193,6 @@ export async function tokensCommand(positional, flags) {
     `mcp      tools/list ${plain(mcp.bytes)} B of ${plain(mcp.tools)} tools  (the same for every repository, so it is not in any total)`,
   );
 
-  emit(lines.join('\n'), { maxBytes: flags.maxBytes ?? 0 });
+  emit(lines.join('\n'));
   return EXIT.OK;
 }

package/src/commands/undo.mjs

@@ -11,24 +11,21 @@
 // the rest around a hand edit would silently merge two authors' intentions.
 // Like every other writer this command previews without `--yes`.
 
-import { EXIT, emit, emitJson, isJson, writeMode } from '../output/index.mjs';
+import { EXIT, emit, emitJson, isJson, writeMode, present } from '../output/index.mjs';
 import { CLI } from '../name.mjs';
 import { beforeText, entryLabel, listJournalSets, readGitValue, readJournalSet, undoLastJournalSet } from '../journal.mjs';
 import { diffField, emitDiffs, readBefore } from '../diff.mjs';
 import { join } from 'node:path';
 import { invalidateCheckCache } from '../status.mjs';
+import { commandRoot } from '../repo-root.mjs';
 
 export async function undoCommand(positional, flags) {
-  const root = flags.root ?? positional[0] ?? process.cwd();
+  const root = commandRoot(flags, positional);
   const mode = writeMode(flags);
 
   const [id] = await listJournalSets(root);
   if (!id) {
-    if (isJson(flags)) {
-      emitJson({ ok: true, command: 'undo', root, set: null, restored: [], dryRun: !mode.apply });
-      return EXIT.OK;
-    }
-    emit('nothing to undo: no journaled writes', { maxBytes: flags.maxBytes ?? 0 });
+    present({ ok: true, command: 'undo', root, set: null, restored: [], dryRun: !mode.apply }, () => 'nothing to undo: no journaled writes', flags);
     return EXIT.OK;
   }
 
@@ -64,7 +61,6 @@ export async function undoCommand(positional, flags) {
         '',
         `would restore ${files} file(s)${keys > 0 ? ` and ${keys} git config key(s)` : ''}; apply with: ${CLI} undo --yes`,
       ].join('\n'),
-      { maxBytes: flags.maxBytes ?? 0 },
     );
     // After the report: the report says what, the diff shows it (R50).
     emitDiffs(diffs, flags);
@@ -73,11 +69,7 @@ export async function undoCommand(positional, flags) {
 
   const result = await undoLastJournalSet(root);
   if (result.empty) {
-    if (isJson(flags)) {
-      emitJson({ ok: true, command: 'undo', root, set: null, restored: [] });
-      return EXIT.OK;
-    }
-    emit('nothing to undo: no journaled writes', { maxBytes: flags.maxBytes ?? 0 });
+    present({ ok: true, command: 'undo', root, set: null, restored: [] }, () => 'nothing to undo: no journaled writes', flags);
     return EXIT.OK;
   }
   if (result.refused) {
@@ -92,7 +84,6 @@ export async function undoCommand(positional, flags) {
         '',
         'nothing was restored; re-run the writing command or merge by hand, then undo again',
       ].join('\n'),
-      { maxBytes: flags.maxBytes ?? 0 },
     );
     return EXIT.FAIL;
   }
@@ -106,7 +97,6 @@ export async function undoCommand(positional, flags) {
   }
   emit(
     [`undone    ${result.set}`, ...result.restored.map((p) => `restored  ${p}`)].join('\n'),
-    { maxBytes: flags.maxBytes ?? 0 },
   );
   // After the report: the report says what, the diff shows it (R50).
   emitDiffs(diffs, flags);

package/src/commands/upgrade.mjs

@@ -216,8 +216,12 @@ export async function upgradeCommand(positional, flags) {
     }
   }
 
+  // One verdict, stated once. `ok` used to be `skipped === 0`, so a workspace with a
+  // repo that never adopted answered ok:false and exited 0: the document and the process
+  // disagreed, and a caller had no way to tell which one was the answer (review 0003 Q65).
+  const code = exitFor(plans, failed);
   const payload = {
-    ok: summary.skipped === 0 && failed.length === 0,
+    ok: code === EXIT.OK,
     command: 'upgrade',
     root,
     shape: found.shape,
@@ -232,7 +236,7 @@ export async function upgradeCommand(positional, flags) {
 
   if (isJson(flags)) {
     emitJson(payload);
-    return exitFor(plans, failed);
+    return code;
   }
 
   emit(render(plans, summary, { root, shape: found.shape, source: target.source, sha, applied, failed }));
@@ -256,7 +260,7 @@ export async function upgradeCommand(positional, flags) {
   } else {
     note('note     every consumer already runs this simt-dev');
   }
-  return exitFor(plans, failed);
+  return code;
 }
 
 /**

package/src/commands/why.mjs

@@ -11,8 +11,9 @@ import { join } from 'node:path';
 import { promisify } from 'node:util';
 
 import { EXIT, emit, emitJson, fail, isJson } from '../output/index.mjs';
-import { CLI, MANIFEST_FILE } from '../name.mjs';
+import { CLI } from '../name.mjs';
 import { FORMATTABLE, GATES } from '../hooks/gates.mjs';
+import { loadManifest } from '../manifest/schema.mjs';
 import { decisionsDir } from '../decisions/dir.mjs';
 import {
   decisionHits,
@@ -24,6 +25,7 @@ import {
 } from '../index/govern.mjs';
 import { splitFrontmatter } from '../memory/decide.mjs';
 import { listPromotedLessons } from '../memory/lessons.mjs';
+import { commandRoot } from '../repo-root.mjs';
 
 const exec = promisify(execFile);
 
@@ -31,7 +33,7 @@ const RULE_DIRS = ['rules', 'rules/stacks', 'rules/mdc', '.simt/profiles'];
 
 export async function whyCommand(args, flags, commands = []) {
   if (args.length > 1) return fail(`unknown why argument ${args[1]}`, EXIT.USAGE, `run: ${CLI} why [path]`);
-  const root = flags.root ?? process.cwd();
+  const root = commandRoot(flags);
   const listed = await tracked(root);
   if (listed.error) return listed.error;
   const files = new Set(listed.files);
@@ -45,22 +47,22 @@ export async function whyCommand(args, flags, commands = []) {
   const items = sortHits([...hits, ...scopeHits(target, corpus)]);
   const payload = { ok: true, command: 'why', root, path: target, items };
   if (isJson(flags)) {
-    emitJson(payload, { pretty: flags.pretty === true, maxBytes: flags.maxBytes ?? 0 });
+    emitJson(payload);
     return EXIT.OK;
   }
   const lines = items.map((item) => `${item.kind.padEnd(10)}${item.id}  ${item.detail}`);
-  emit(lines.length > 0 ? lines.join('\n') : 'none', { maxBytes: flags.maxBytes ?? 0 });
+  emit(lines.length > 0 ? lines.join('\n') : 'none');
   return EXIT.OK;
 }
 
 function reportUnresolved(root, flags, unresolved) {
   const payload = { ok: true, command: 'why', root, unresolved };
   if (isJson(flags)) {
-    emitJson(payload, { pretty: flags.pretty === true, maxBytes: flags.maxBytes ?? 0 });
+    emitJson(payload);
     return EXIT.OK;
   }
   const lines = unresolved.map((item) => `UNRESOLVED-AFFECTS  ${item.token}  ${item.id}`);
-  emit([`unresolved  ${unresolved.length}`, ...lines].join('\n'), { maxBytes: flags.maxBytes ?? 0 });
+  emit([`unresolved  ${unresolved.length}`, ...lines].join('\n'));
   return EXIT.OK;
 }
 
@@ -172,8 +174,7 @@ export async function lessonScopes(root) {
 
 async function gateCommands(root) {
   try {
-    const parsed = JSON.parse(await readFile(join(root, MANIFEST_FILE), 'utf8'));
-    const commands = parsed?.gates?.commands;
+    const commands = (await loadManifest(root)).manifest?.gates?.commands;
     return commands && typeof commands === 'object' ? commands : {};
   } catch {
     return {};

package/src/compare/row.mjs

@@ -21,7 +21,6 @@ import { checkTargets, PRIMARY_TARGET } from '../projection/project.mjs';
 import { manifestDrift, readManifest } from '../projection/manifest.mjs';
 import { loadRules, select } from '../projection/rules.mjs';
 import { resolvePacks } from '../packs.mjs';
-import { knownGates } from '../hooks/resolve.mjs';
 import { fingerprint } from '../resolve/fingerprint.mjs';
 import { readHooksState, wantsShim } from './hooksstate.mjs';
 import { CLI } from '../name.mjs';
@@ -421,4 +420,3 @@ export function summarise(rows, extra = {}) {
   };
 }
 
-export { knownGates };

package/src/context.mjs

@@ -0,0 +1,64 @@
+// The per-run memo a command reads its repository through (review 0003 Q67).
+//
+// `check` did the same work twice in one run: `fingerprint(root)` at two sites, a
+// manifest read that `manifestDrift` repeated, and a rules load that every consumer
+// paid for again. Each fingerprint spawns `git ls-files` and walks the tree once per
+// glob fact, so the second call was never cheap - it was invisible.
+//
+// The cache lives for one command, not for the process. `bench` writes manifests and
+// rewrites trees mid-run; a process-lifetime memo would hand a benchmark the answer
+// for a repository it had just changed, which is the one way a cache can be worse
+// than no cache. A caller that wants a fresh answer makes a fresh context.
+//
+// A rejected computation is not cached: a transient failure (a git lock, a permission
+// error) should not become the answer for the rest of the run, and every one of these
+// readers is safe to retry.
+
+import { fingerprint } from './resolve/fingerprint.mjs';
+import { readManifest } from './projection/manifest.mjs';
+import { loadRules, provenanceDigest } from './projection/rules.mjs';
+
+/**
+ * One repository, read once per question.
+ *
+ * Each accessor is a promise, and two calls with the same key share it rather than
+ * racing: the first caller to ask starts the work, and everyone else awaits it.
+ *
+ * @param {string} root the repository this context answers for
+ */
+export function repoContext(root) {
+  const cache = new Map();
+  const counts = { hits: 0, misses: 0 };
+
+  const once = (key, compute) => {
+    if (cache.has(key)) {
+      counts.hits += 1;
+      return cache.get(key);
+    }
+    counts.misses += 1;
+    const pending = Promise.resolve()
+      .then(compute)
+      .catch((error) => {
+        // Not cached, or one failed read would answer every later caller.
+        cache.delete(key);
+        throw error;
+      });
+    cache.set(key, pending);
+    return pending;
+  };
+
+  return {
+    root,
+    /** What the cache did, for a test or a measurement - never printed by a command. */
+    get stats() {
+      return { ...counts, entries: cache.size };
+    },
+    fingerprint: () => once('fingerprint', () => fingerprint(root)),
+    // The legacy shape, because that is what the commands print: `error` is the
+    // unreadable-file case and every caller already renders it. Memoising the loader's
+    // `problems` array here instead gave doctor `undefined` where it tests for null.
+    manifest: () => once('manifest', () => readManifest(root)),
+    rules: () => once('rules', () => loadRules(root)),
+    digest: () => once('digest', () => provenanceDigest()),
+  };
+}

package/src/decisions/index-doc.mjs

@@ -0,0 +1,46 @@
+// The decisions index document, rendered from the records (review 0003 Q91).
+//
+// The file was 590 hand-written lines: a table of every ADR kept in step by whoever
+// remembered. It agreed with the records until it did not, and nothing read it, so
+// nothing noticed - the failure the generated rule regions exist to prevent, one
+// directory over. The table is output now: this module renders it, `simt rules
+// decisions --yes` writes it, and test/decisions-index.test.mjs fails on drift.
+//
+// The narrative that trailed the table moved to docs/architecture/history.md: prose a
+// reader consults is not prose a command rewrites.
+
+const HEADER = `# Decisions
+
+Architecture decision records for the SIMT development ecosystem. One canonical home per
+decision; nothing here is duplicated into a repo's \`AGENTS.md\`.
+
+A decision is superseded by writing a new ADR with a higher number and editing the old
+record's status line — never by editing the ruling in place.
+
+This table is generated from the records: \`simt rules decisions --yes\` writes it, and
+\`test/decisions-index.test.mjs\` fails when it drifts. The history behind the numbers is
+in [architecture/history.md](architecture/history.md).
+
+| ADR | Decision | Status |
+|---|---|---|
+`;
+
+/**
+ * The index document, from the records.
+ *
+ * Ordered by number, not by filename: the number IS the order, and a directory listing
+ * is not (`ADR-100` sorts before `ADR-99` as text).
+ *
+ * @param {{id: string, title: string, status: string, file: string}[]} rows
+ * @returns {string}
+ */
+export function renderDecisionsIndex(rows) {
+  const ordered = [...rows].sort((a, b) => number(a.id) - number(b.id));
+  const lines = ordered.map((row) => `| [${number(row.id)}](decisions/${row.file}) | ${row.title} | ${row.status} |`);
+  return `${HEADER}${lines.join('\n')}\n`;
+}
+
+/** `ADR-007` -> `007`, the number the table and the ordering both use. */
+function number(id) {
+  return id.replace(/^ADR-/i, '').padStart(3, '0');
+}

package/src/diff.mjs

@@ -49,7 +49,7 @@ export async function readBefore(path) {
 export function emitDiffs(pairs, flags) {
   if (isJson(flags)) return;
   const text = renderDiffs(pairs);
-  if (text !== '') emit(text, { maxBytes: flags.maxBytes ?? 0 });
+  if (text !== '') emit(text);
 }
 
 /** The `--diff` bytes for a JSON payload: absent entirely without the flag, so

package/src/distill/distill.mjs

@@ -35,6 +35,7 @@ import {
 
 export const DEFAULT_BUDGET = 2048;
 import { LOCAL_DIR } from '../state.mjs';
+import { commandRoot } from '../repo-root.mjs';
 
 const DISTILL_DIR = join(LOCAL_DIR, 'distilled');
 
@@ -175,7 +176,7 @@ export async function distillTarget(args, flags) {
     );
   }
 
-  const root = resolve(flags.root ?? process.cwd());
+  const root = resolve(commandRoot(flags));
   const source = await resolveTarget(target, root, flags);
   if (source.exit !== undefined) return source.exit;
 
@@ -192,6 +193,16 @@ export async function distillTarget(args, flags) {
   const cached = flags.refresh === true ? null : await readFile(absProposal, 'utf8').catch(() => null);
   if (cached !== null) {
     const fields = parseExistingFrontmatter(cached);
+    let faults = [];
+    if (typeof fields.faults === 'string') {
+      try {
+        const parsedFaults = JSON.parse(fields.faults);
+        if (Array.isArray(parsedFaults)) faults = parsedFaults.map(String);
+      } catch {
+        // A malformed faults line is not a reason to refuse the proposal; the proposal
+        // still says it is unverified, and `--refresh` re-derives the list.
+      }
+    }
     return {
       ok: true,
       command: 'distill',
@@ -201,6 +212,7 @@ export async function distillTarget(args, flags) {
       budget: Number(fields.budget ?? budget),
       citations: countCitations(cached),
       verified: fields.verified !== 'false',
+      faults,
       metric: { note: METRIC_NOTE },
       proposal: { path: relProposal, state: 'cached', bytes: Buffer.byteLength(cached, 'utf8') },
     };
@@ -227,6 +239,7 @@ export async function distillTarget(args, flags) {
       engine: provenance,
       budget,
       verified: faults.length === 0,
+      faults,
     }) + `\n${outcome.body}\n`;
 
   await mkdir(join(root, DISTILL_DIR), { recursive: true });

package/src/distill/engine.mjs

@@ -167,7 +167,7 @@ export function verifyCitations(body, sourceLineCount) {
 }
 
 /** The proposal file's frontmatter. No wall-clock value here: byte-stable (P4). */
-export function proposalFrontmatter({ source, digest, engine, budget, prompt, verified, verdict, advisory }) {
+export function proposalFrontmatter({ source, digest, engine, budget, prompt, verified, verdict, advisory, faults = [] }) {
   return [
     '---',
     `source: ${source}`,
@@ -178,6 +178,10 @@ export function proposalFrontmatter({ source, digest, engine, budget, prompt, ve
     verdict ? `verdict: ${verdict}` : null,
     advisory ? 'advisory: true' : null,
     verified === false ? 'verified: false' : 'verified: true',
+    // The faults belong to the proposal, not only to the report that wrote it: a cached
+    // proposal re-read without them reported `verified:false` and nothing to fix
+    // (review 0003 Q52).
+    Array.isArray(faults) && faults.length > 0 ? `faults: ${JSON.stringify(faults)}` : null,
     'status: proposal',
     '---',
     '',

package/src/graph/load.mjs

@@ -117,7 +117,9 @@ async function defaultRegistry(flags) {
  * failure to resolve is a WARNING, not 38 `ENOENT` lines (ADR-014).
  *
  * Memoised per the inputs that decide the answer: the `--workspace` flag, the
- * `SIMT_DEV_WORKSPACE` environment and the user-config location. A single
+ * `SIMT_DEV_WORKSPACE` environment, the user-config location, and the current
+ * directory, whose manifest declares the workspace the variable may point into
+ * (ADR-119). A single
  * first-call-wins promise served one caller's workspace to every later caller with
  * different flags (Q14) — `skills_index({workspace: ws})` followed by
  * `skills_index({})` answered `ws` twice. Callers with the same inputs still share
@@ -129,6 +131,7 @@ export function workspace(flags = {}) {
     flags?.workspace ?? null,
     process.env.SIMT_DEV_WORKSPACE ?? null,
     process.env.XDG_CONFIG_HOME ?? null,
+    process.cwd(),
   ]);
   if (!workspacePromises.has(key)) workspacePromises.set(key, resolveWorkspace(flags));
   return workspacePromises.get(key);

package/src/hooks/capability.mjs

@@ -21,7 +21,8 @@
 import { constants as fsConstants } from 'node:fs';
 import { access, readdir, readFile, stat } from 'node:fs/promises';
 import { join } from 'node:path';
-import { ECOSYSTEMS, manifestPath } from '../projection/manifest.mjs';
+import { ECOSYSTEMS } from '../projection/manifest.mjs';
+import { loadManifest } from '../manifest/schema.mjs';
 import { resolveNodeRunner } from '../ecosystem/node-runner.mjs';
 
 /** Binaries the shared dispatcher shells out to directly, rather than via a script. */
@@ -170,8 +171,7 @@ export async function readCapability(root) {
   // so the only evidence that can prove it is the declaration itself. A repo with no
   // manifest simply has no declared commands.
   try {
-    const manifest = JSON.parse(await readFile(await manifestPath(root), 'utf8'));
-    capability.commands = declaredCommands(manifest);
+    capability.commands = declaredCommands((await loadManifest(root)).manifest);
   } catch {
     capability.commands = {};
   }