simt-dev 0.7.0 → 0.8.0

package/src/commands/shared.mjs

@@ -29,6 +29,7 @@ import {
 } from '../projection/shared.mjs';
 import { buildManifest, declaredShared, manifestPath, manifestText, readManifest, writeManifest } from '../projection/manifest.mjs';
 import { desiredRegion } from '../projection/rules.mjs';
+import { plainNumber } from '../util/fs.mjs';
 
 /**
  * Everything `plan` and `install` both need, computed once.
@@ -76,9 +77,9 @@ async function gather(flags) {
  */
 function divergentNote(d, total) {
   if (d.reason === 'coverage') {
-    return `${d.id}  carried by ${plain(d.roots.length)} of ${plain(total)} repositories, so each region keeps its own`;
+    return `${d.id}  carried by ${plainNumber(d.roots.length)} of ${plainNumber(total)} repositories, so each region keeps its own`;
   }
-  return `${d.id}  rendered differently in ${plain(d.roots.length)} repositories, so each region keeps its own`;
+  return `${d.id}  rendered differently in ${plainNumber(d.roots.length)} repositories, so each region keeps its own`;
 }
 
 /** Why a selected rule cannot leave any region, in the words its reason deserves. */
@@ -98,7 +99,7 @@ function excludedNote({ id, why }) {
 function capNote(target, bytes) {
   if (target.path === null || target.cap === null || bytes <= target.cap.bytes) return null;
   return [
-    `${target.surface}  ${plain(bytes)} B exceeds the ${plain(target.cap.bytes)} B it allows for ${target.cap.appliesTo}`,
+    `${target.surface}  ${plainNumber(bytes)} B exceeds the ${plainNumber(target.cap.bytes)} B it allows for ${target.cap.appliesTo}`,
     `  ${target.cap.why}`,
     `  the rules above that limit are not read; move rules this workspace does not share back into each region, or drop the shared copy for this surface`,
   ].join('\n');
@@ -157,10 +158,10 @@ export async function sharedPlanCommand(_args, flags) {
   }
 
   const lines = [
-    `shared   ${target.root}  ${plain(roots.length)} repositories  (${target.source})`,
-    `rules    ${plain(shared.length)} of ${plain(candidates)} ids carried once  ${plain(bytes)} B`,
+    `shared   ${target.root}  ${plainNumber(roots.length)} repositories  (${target.source})`,
+    `rules    ${plainNumber(shared.length)} of ${plainNumber(candidates)} ids carried once  ${plainNumber(bytes)} B`,
   ];
-  for (const r of shared) lines.push(`  ${r.id}  ${r.priority ?? 'unclassified'}  ${plain(Buffer.byteLength(r.rendered))} B  ${r.source}`);
+  for (const r of shared) lines.push(`  ${r.id}  ${r.priority ?? 'unclassified'}  ${plainNumber(Buffer.byteLength(r.rendered))} B  ${r.source}`);
   if (divergent.length > 0) {
     // Named, not summarised: a reader who expected a python rule here and did not get it
     // is owed the reason, and "divergent: 2" is not a reason.
@@ -171,9 +172,9 @@ export async function sharedPlanCommand(_args, flags) {
     lines.push(`left in every region  ${excluded.length} rule(s) no root can hand over:`);
     for (const e of excluded) lines.push(`  ${excludedNote(e)}`);
   }
-  lines.push(`saves    ${plain(save)} B across ${plain(roots.length)} regions`);
+  lines.push(`saves    ${plainNumber(save)} B across ${plainNumber(roots.length)} regions`);
   for (const r of rows) {
-    lines.push(`  ${r.name}  ${plain(r.bytes)} B  ${r.mode}  ${r.rules.length > 0 ? r.rules.join(', ') : '(carries nothing extra)'}`);
+    lines.push(`  ${r.name}  ${plainNumber(r.bytes)} B  ${r.mode}  ${r.rules.length > 0 ? r.rules.join(', ') : '(carries nothing extra)'}`);
   }
   lines.push('writes');
   for (const t of targets) {
@@ -189,7 +190,7 @@ export async function sharedPlanCommand(_args, flags) {
     if (over !== null) lines.push(`warn     ${over}`);
   }
   lines.push(`nothing written; re-run with: ${CLI} shared install --yes`);
-  emit(lines.join('\n'), { maxBytes: flags.maxBytes ?? 0 });
+  emit(lines.join('\n'));
   return EXIT.OK;
 }
 
@@ -297,7 +298,7 @@ export async function sharedInstallCommand(_args, flags) {
     }
     emit(
       [
-        `shared   ${plain(shared.length)} rule(s), ${plain(Buffer.byteLength(sharedBody(shared)))} B`,
+        `shared   ${plainNumber(shared.length)} rule(s), ${plainNumber(Buffer.byteLength(sharedBody(shared)))} B`,
         ...states.map((s) =>
           s.path === null
             ? `  paste     ${s.surface}  no user-level file is recorded for it`
@@ -306,7 +307,6 @@ export async function sharedInstallCommand(_args, flags) {
         `manifest ${manifests.map((m) => `${m.action}:${basename(m.root)}`).join(' ')}`,
         dryRun ? 'dry-run  nothing written' : `nothing written; re-run with: ${CLI} shared install --yes`,
       ].join('\n'),
-      { maxBytes: flags.maxBytes ?? 0 },
     );
     // After the report: the report says what, the diff shows it (R50).
     emitDiffs(diffs, flags);
@@ -327,8 +327,8 @@ export async function sharedInstallCommand(_args, flags) {
   }
 
   const lines = [
-    `shared   installed for ${plain(roots.length)} repositories`,
-    `rules    ${plain(shared.length)} carried once  ${shared.map((r) => r.id).join(', ')}`,
+    `shared   installed for ${plainNumber(roots.length)} repositories`,
+    `rules    ${plainNumber(shared.length)} carried once  ${shared.map((r) => r.id).join(', ')}`,
   ];
   for (const w of written) {
     // `inject`'s word for a file with no region in it is "added"; the word for a file
@@ -354,7 +354,7 @@ export async function sharedInstallCommand(_args, flags) {
     if (over !== null) lines.push(`warn     ${over}`);
   }
   lines.push(`verify   ${CLI} doctor  reports the copy as current, and ${CLI} tokens --repos --root . reports what is left`);
-  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);
   return EXIT.OK;
@@ -418,11 +418,6 @@ function describeShared(state, targets) {
   return `${targets.length} user-level file(s) carry every rule this repository handed over`;
 }
 
-/** `1234567`, never `1,234,567`: two machines must print the same bytes (ADR-013). */
-function plain(n) {
-  return String(n);
-}
-
 /** The directory name, for a line that has to name several repositories at once. */
 function basename(path) {
   return path.split('/').filter(Boolean).pop() ?? path;

package/src/commands/skills.mjs

@@ -10,6 +10,7 @@
 // black box.
 
 import { readFile, realpath } from 'node:fs/promises';
+import { repoContext } from '../context.mjs';
 import { join } from 'node:path';
 import { existsSync } from 'node:fs';
 
@@ -19,11 +20,14 @@ import { bodyFile, sourcePath } from '../resolve/body.mjs';
 import { unknownSkills, scoreCorpus } from '../resolve/eval.mjs';
 import { PACKAGE_ROOT, resolveWorkspace, WORKSPACE_REMEDY } from '../workspace.mjs';
 import { fingerprint } from '../resolve/fingerprint.mjs';
-import { tokenize, rankSkills, closure, selectWithinBudget, resolveAlias, scoreSkill, selectionVerdict, stackCompatible } from '../resolve/resolve.mjs';
+import { rankSkills, closure, selectWithinBudget, resolveAlias, scoreSkill, selectionVerdict, stackCompatible } from '../resolve/resolve.mjs';
+import { tokenize } from '../text/tokens.mjs';
 import { localSkillNodes } from '../resolve/local.mjs';
 import { nearMatches } from '../resolve/near.mjs';
 import { CLI } from '../name.mjs';
 import { parsePathList } from '../argv.mjs';
+import { commandRoot } from '../repo-root.mjs';
+import { gitText } from '../sys/git.mjs';
 
 export { parsePathList };
 
@@ -32,11 +36,8 @@ const DEFAULT_BUDGET = 20480;
 /** git status paths, so path signals come from the real diff. */
 export async function dirtyPaths(root) {
   try {
-    const { execFile } = await import('node:child_process');
-    const { promisify } = await import('node:util');
-    const run = promisify(execFile);
-    const { stdout } = await run('git', ['-C', root, 'status', '--porcelain=v1'], { maxBuffer: 8 << 20 });
-    return stdout
+    const stdout = await gitText(root, ['status', '--porcelain=v1'], { maxBuffer: 8 << 20 });
+    return (stdout ?? '')
       .split('\n')
       .filter(Boolean)
       .map((line) => line.slice(3).trim())
@@ -82,11 +83,11 @@ async function skillsRegistry(args) {
  * costs a fingerprint plus a directory scan, so it runs only when the registry did
  * not answer.
  */
-async function findSkill(registry, root, name, verb) {
+async function findSkill(registry, root, name, verb, ctx) {
   if (!name) skillsFailure(`${verb} needs a skill name`, `usage: ${CLI} skills ${verb} <name>`, EXIT.USAGE);
   const skill = registry.skills.find((s) => s.name === name);
   if (skill) return skill;
-  const repoStack = (await fingerprint(root)).signals;
+  const repoStack = (await ctx.fingerprint()).signals;
   const local = (await localSkillNodes(root, registry, repoStack)).find((s) => s.name === name);
   if (local) return local;
   const near = nearMatches(name, registry.skills.map((s) => s.name));
@@ -114,7 +115,10 @@ function skillFacts(skill) {
 /** Tier 1: the selection the task resolves to, with the text packet's display sets. */
 export async function skillsBriefFacts(root, args = {}) {
   const registry = await skillsRegistry(args);
-  const repo = await fingerprint(root);
+  // One context per call: a second question about the same repository inside this
+  // command costs nothing (review 0003 Q67).
+  const ctx = args.ctx ?? repoContext(root);
+  const repo = await ctx.fingerprint();
   const { note: workspace, root: workspaceRoot } = await announceWorkspace(args);
   const repoStack = repo.signals;
   const paths = args.paths ? parsePathList(args.paths) : await dirtyPaths(root);
@@ -246,7 +250,7 @@ export async function skillsFindFacts(root, query, args = {}) {
     ...registry.skills
       .map((skill) => ({ skill, ...scoreSkill(skill, context) }))
       .filter((r) => selectionVerdict(r.evidence, r.reasons) === null),
-    ...(await localSkillNodes(root, registry, (await fingerprint(root)).signals))
+    ...(await localSkillNodes(root, registry, (await (args.ctx ?? repoContext(root)).fingerprint()).signals))
       .map((skill) => ({ skill, ...scoreSkill(skill, context) }))
       .filter((r) => r.score > 0),
   ].sort((a, b) => b.score - a.score || a.skill.name.localeCompare(b.skill.name));
@@ -259,7 +263,7 @@ export async function skillsFindFacts(root, query, args = {}) {
 /** Tier 2: one skill body and the metadata needed to judge it. */
 export async function skillsShowFacts(root, name, args = {}) {
   const registry = await skillsRegistry(args);
-  const skill = await findSkill(registry, root, name, 'show');
+  const skill = await findSkill(registry, root, name, 'show', args.ctx ?? repoContext(root));
   const { note: workspace, root: workspaceRoot } = await announceWorkspace(args);
   // The repo is a location for a declared source too, so `show` reads a body the
   // caller already has instead of reporting the body missing.
@@ -287,8 +291,9 @@ export async function skillsShowFacts(root, name, args = {}) {
 /** The signal chain for one skill in one repository. */
 export async function skillsWhyFacts(root, name, args = {}) {
   const registry = await skillsRegistry(args);
-  const skill = await findSkill(registry, root, name, 'why');
-  const repo = await fingerprint(root);
+  const ctx = args.ctx ?? repoContext(root);
+  const skill = await findSkill(registry, root, name, 'why', ctx);
+  const repo = await ctx.fingerprint();
   const paths = args.paths ? parsePathList(args.paths) : await dirtyPaths(root);
   const tokens = tokenize(args.task ?? '');
   const { score, reasons } = scoreSkill(skill, { repoStack: repo.signals, taskTokens: tokens, paths });
@@ -386,7 +391,6 @@ export async function indexCommand(args, flags) {
       '',
       `deferred entries return a pointer, not a body. Fetch one with: ${CLI} skills show <name>`,
     ].join('\n'),
-    { maxBytes: flags.maxBytes ?? 0 },
   );
   return EXIT.OK;
 }
@@ -429,14 +433,14 @@ async function emitAllFacts(facts, flags) {
   if (deferred.length > 0) {
     lines.push('', `DEFERRED ${deferred.length}: ${deferred.map((s) => s.name).join(', ')}`);
   }
-  emit(lines.join('\n'), { maxBytes: flags.maxBytes ?? 0 });
+  emit(lines.join('\n'));
   return EXIT.OK;
 }
 
 // --- find ---------------------------------------------------------------------
 
 export async function findCommand(args, flags) {
-  const root = flags.root ?? process.cwd();
+  const root = commandRoot(flags);
   let facts;
   try {
     facts = await skillsFindFacts(root, args.join(' '), flags);
@@ -449,7 +453,6 @@ export async function findCommand(args, flags) {
   if (isJson(flags)) {
     emitJson(
       { ok: true, query, workspace, results },
-      { maxBytes: flags.maxBytes ?? 0 },
     );
     return EXIT.OK;
   }
@@ -469,17 +472,17 @@ export async function findCommand(args, flags) {
           `${r.name.padEnd(26)} ${kb(r.bytes).padStart(7)}  ${r.reasons.join(' ')}`,
       ),
     ].join('\n'),
-    { maxBytes: flags.maxBytes ?? 0 },
   );
   return EXIT.OK;
 }
 
 // --- brief: tier 1 ------------------------------------------------------------
 export async function briefCommand(args, flags) {
-  const root = flags.root ?? process.cwd();
+  const root = commandRoot(flags);
+  const ctx = repoContext(root);
   let facts;
   try {
-    facts = await skillsBriefFacts(root, flags);
+    facts = await skillsBriefFacts(root, { ...flags, ctx });
   } catch (error) {
     return fail(error.message, error.exitCode ?? EXIT.FAIL, error.remedy);
   }
@@ -498,21 +501,20 @@ export async function briefCommand(args, flags) {
   }
 
   if (facts.warning) {
-    const repo = await fingerprint(root);
+    const repo = await ctx.fingerprint();
     emit(
       [
         `repo ${root.split('/').pop()} (${repoLine(repo)})`,
         '',
         facts.warning,
       ].join('\n'),
-      { maxBytes: flags.maxBytes ?? 0 },
     );
     return EXIT.OK;
   }
 
   const { shown, shownDeferred, shownUsed, pointerOnly, excludedEntries, workspace, workspaceRoot, budget } = facts;
   const lines = [];
-  const repo = await fingerprint(root);
+  const repo = await ctx.fingerprint();
 
   lines.push(
     `RESOLVED ${shown.length} skills, ${kb(shownUsed)}${flags.all || shownUsed <= budget ? '' : ' (budget capped)'} - repo ${root.split('/').pop()} (${repoLine(repo)})`,
@@ -533,7 +535,7 @@ export async function briefCommand(args, flags) {
       lines.push('', `NOT SELECTED ${hidden.length}`, '', `  notes: ${CLI} skills why <name> | ${CLI} skills show <name>`);
     }
     lines.push('', 'OVERRIDE  --skill <name> | --budget <bytes> | --all | --paths <globs>');
-    emit(lines.join('\n'), { maxBytes: flags.maxBytes ?? 0 });
+    emit(lines.join('\n'));
     return EXIT.OK;
   }
 
@@ -578,14 +580,14 @@ export async function briefCommand(args, flags) {
   }
 
   lines.push('', 'OVERRIDE  --skill <name> | --budget <bytes> | --all | --paths <globs>');
-  emit(lines.join('\n'), { maxBytes: flags.maxBytes ?? 0 });
+  emit(lines.join('\n'));
   return EXIT.OK;
 }
 
 // --- show: tier 2 -------------------------------------------------------------
 
 export async function showCommand(args, flags) {
-  const root = flags.root ?? process.cwd();
+  const root = commandRoot(flags);
   let facts;
   try {
     facts = await skillsShowFacts(root, args[0], flags);
@@ -595,7 +597,7 @@ export async function showCommand(args, flags) {
   const { skill, workspace, body, bodyFrom, bodyText } = facts;
   const source = skill.sources?.find((s) => s.role === 'canonical') ?? skill.sources?.[0];
   if (isJson(flags)) {
-    emitJson({ ok: true, ...skill, workspace, body, bodyFrom, bodyText }, { maxBytes: flags.maxBytes ?? 0 });
+    emitJson({ ok: true, ...skill, workspace, body, bodyFrom, bodyText });
     return EXIT.OK;
   }
   emit(
@@ -618,7 +620,6 @@ export async function showCommand(args, flags) {
     ]
       .filter((l) => l !== null)
       .join('\n'),
-    { maxBytes: flags.maxBytes ?? 0 },
   );
   return EXIT.OK;
 }
@@ -626,7 +627,7 @@ export async function showCommand(args, flags) {
 // --- why ----------------------------------------------------------------------
 
 export async function whyCommand(args, flags) {
-  const root = flags.root ?? process.cwd();
+  const root = commandRoot(flags);
   let facts;
   try {
     facts = await skillsWhyFacts(root, args[0], flags);
@@ -641,7 +642,7 @@ export async function whyCommand(args, flags) {
   // to scrape: a skill that can never be selected in this repo is a decision, not
   // a line of output.
   if (isJson(flags)) {
-    emitJson({ ok: true, command: 'skills why', ...facts }, { maxBytes: flags.maxBytes ?? 0 });
+    emitJson({ ok: true, command: 'skills why', ...facts });
     return EXIT.OK;
   }
 
@@ -667,7 +668,7 @@ export async function whyCommand(args, flags) {
   if (facts.variantOf) lines.push('', `variant-of      ${facts.variantOf} (sibling group, one body per stack)`);
   if (facts.requires?.length > 0) lines.push(`requires        ${facts.requires.join(', ')}`);
 
-  emit(lines.join('\n'), { maxBytes: flags.maxBytes ?? 0 });
+  emit(lines.join('\n'));
   return EXIT.OK;
 }
 
@@ -773,7 +774,7 @@ export async function evalCommand(positional, flags) {
   }
 
   lines.push('', okRun ? 'OK the resolver meets the gold corpus' : 'REGRESSION: the resolver no longer meets the gold corpus');
-  emit(lines.join('\n'), { maxBytes: flags.maxBytes ?? 0 });
+  emit(lines.join('\n'));
   return okRun ? EXIT.OK : EXIT.FAIL;
 }
 

package/src/commands/skillscompile.mjs

@@ -14,14 +14,15 @@ import {
   evaluateSkillTriggers,
   proposeSkillDescription,
 } from '../graph/compile.mjs';
-import { loadRunRecords } from '../bench/report.mjs';
-import { extractPatchFiles } from '../bench/grade.mjs';
-import { resolveVaultDir } from '../bench/mine.mjs';
+import { loadRunRecords } from '../measure/records.mjs';
+import { extractPatchFiles } from '../testing/patches.mjs';
+import { resolveVaultDir } from '../testing/vault.mjs';
 import { locateSource, sourceHeldLocally } from '../resolve/source.mjs';
 import { nearMatches } from '../resolve/near.mjs';
 import { resolveWorkspace, WORKSPACE_REMEDY } from '../workspace.mjs';
 import { CLI } from '../name.mjs';
 import { LOCAL_DIR } from '../state.mjs';
+import { commandRoot } from '../repo-root.mjs';
 
 async function readSkillRawText(skill, workspaceRoot, root) {
   const canonical = skill.sources?.find((s) => s.role === 'canonical') ?? skill.sources?.[0];
@@ -68,7 +69,7 @@ export async function compileCommand(args, flags) {
   const { registry, errors, ok } = await loadRegistry(null, flags);
   if (!ok) return fail(errors[0], EXIT.REGISTRY, WORKSPACE_REMEDY);
 
-  const root = resolve(flags.root ?? process.cwd());
+  const root = resolve(commandRoot(flags));
   const ws = await resolveWorkspace(flags);
   const targetName = args[0] ?? null;
 
@@ -117,7 +118,6 @@ export async function compileCommand(args, flags) {
           splitPlan: s.splitPlan,
         })),
       },
-      { maxBytes: flags.maxBytes ?? 0 },
     );
     return EXIT.OK;
   }
@@ -150,7 +150,7 @@ export async function compileCommand(args, flags) {
     }
   }
 
-  emit(lines.join('\n'), { maxBytes: flags.maxBytes ?? 0 });
+  emit(lines.join('\n'));
   return EXIT.OK;
 }
 
@@ -223,7 +223,6 @@ async function runSingleSkillCompile(skill, registry, { root, workspaceRoot, fla
           : null,
         proposal,
       },
-      { maxBytes: flags.maxBytes ?? 0 },
     );
     return EXIT.OK;
   }
@@ -246,7 +245,7 @@ async function runSingleSkillCompile(skill, registry, { root, workspaceRoot, fla
     }
   }
 
-  emit(lines.join('\n'), { maxBytes: flags.maxBytes ?? 0 });
+  emit(lines.join('\n'));
   if (!mode.apply) {
     note(`note    dry-run  nothing written; apply with: ${CLI} skills compile ${skill.name} --yes`);
   }

package/src/commands/skillsinstall.mjs

@@ -38,6 +38,8 @@ import { resolveWorkspace, WORKSPACE_REMEDY } from '../workspace.mjs';
 import { CLI } from '../name.mjs';
 import { MANIFEST_FILE } from '../name.mjs';
 import { nameProblems } from '../graph/spec.mjs';
+import { commandRoot } from '../repo-root.mjs';
+import { parseFrontmatter } from '../text/frontmatter.mjs';
 
 /**
  * Where skills live in this repo. The estate already has a convention - a
@@ -82,7 +84,7 @@ export async function installCommand(args, flags) {
   const ws = await resolveWorkspace(flags);
   if (ws.error) return fail(`workspace config: ${ws.error}`, EXIT.CONFIG, 'fix the JSON, or remove the file');
 
-  const root = flags.root ?? process.cwd();
+  const root = commandRoot(flags);
   const repo = await fingerprint(root);
   const pick = await chooseSource(skill, repo.signals, flags, { root, workspaceRoot: ws.root });
   if (pick.error) return fail(pick.error, EXIT.USAGE, pick.remedy);
@@ -210,7 +212,6 @@ export async function installCommand(args, flags) {
       ]
         .filter((l) => l !== null)
         .join('\n'),
-      { maxBytes: flags.maxBytes ?? 0 },
     );
   }
 
@@ -498,13 +499,13 @@ async function dirEntries(root) {
  */
 export async function wrapFlat(src, name) {
   const text = await readFile(src, 'utf8');
-  const fm = /^---\n([\s\S]*?)\n---\n?/.exec(text);
-  if (!fm) return `---\nname: ${name}\n---\n\n${text.trim()}\n`;
-  const keys = fm[1]
+  const { front, block } = parseFrontmatter(text);
+  if (front === null) return `---\nname: ${name}\n---\n\n${text.trim()}\n`;
+  const keys = front
     .split('\n')
     .filter((l) => !/^name:/.test(l))
     .join('\n');
-  return `---\nname: ${name}\n${keys}\n---\n\n${text.slice(fm[0].length).trim()}\n`;
+  return `---\nname: ${name}\n${keys}\n---\n\n${text.slice(block.length).trim()}\n`;
 }
 
 async function fileSha(path) {