simt-dev 0.2.1 → 0.3.0

package/src/commands/init.mjs

@@ -20,7 +20,7 @@ import { promisify } from 'node:util';
 import { mkdir, readFile, symlink, writeFile } from 'node:fs/promises';
 import { dirname, join } from 'node:path';
 
-import { EXIT, emit, fail, isJson, note } from '../output/index.mjs';
+import { EXIT, emit, emitJson, fail, isJson, note } from '../output/index.mjs';
 import { fingerprint } from '../resolve/fingerprint.mjs';
 import { rulePaths, scanDocument, summarise } from '../projection/conflicts.mjs';
 import { MANIFEST, buildManifest, manifestPath, readManifest, writeManifest, planGates } from '../projection/manifest.mjs';
@@ -219,7 +219,7 @@ export async function initCommand(positional, flags) {
     payload.ok = false;
     payload.blockedBy = 'surface-problem';
     for (const p of surfaceProblems) note(`PROBLEM  ${p}`);
-    if (isJson(flags)) emit(`${JSON.stringify(payload, null, 2)}\n`);
+    if (isJson(flags)) emitJson(payload);
     return fail(
       `${surfaceProblems.length} surface(s) cannot be resolved (${surfaceProblems[0]})`,
       EXIT.FAIL,
@@ -234,7 +234,7 @@ export async function initCommand(positional, flags) {
     payload.ok = false;
     payload.blockedBy = 'mdc-problem';
     for (const p of mdcProblems) note(`PROBLEM  ${p}`);
-    if (isJson(flags)) emit(`${JSON.stringify(payload, null, 2)}\n`);
+    if (isJson(flags)) emitJson(payload);
     return fail(
       `${mdcProblems.length} canonical .mdc rule(s) cannot be projected (${mdcProblems[0]})`,
       EXIT.FAIL,
@@ -249,7 +249,7 @@ export async function initCommand(positional, flags) {
     payload.ok = false;
     payload.blockedBy = 'conflict';
     if (isJson(flags)) {
-      emit(`${JSON.stringify(payload, null, 2)}\n`);
+      emitJson(payload);
     } else {
       emit(render(payload, manifest, { npm, version }));
       note('');
@@ -271,7 +271,7 @@ export async function initCommand(positional, flags) {
   if (malformed.length > 0) {
     payload.ok = false;
     payload.blockedBy = 'malformed-region';
-    if (isJson(flags)) emit(`${JSON.stringify(payload, null, 2)}\n`);
+    if (isJson(flags)) emitJson(payload);
     else emit(render(payload, manifest, { npm, version }));
     return fail(
       `${malformed.length} target(s) have a malformed generated region (${malformed[0].file}: ${malformed[0].reason})`,
@@ -282,7 +282,7 @@ export async function initCommand(positional, flags) {
 
   // Step 4/5: report everything, then make changes only when told to.
   if (isJson(flags)) {
-    if (!apply) emit(`${JSON.stringify(payload, null, 2)}\n`);
+    if (!apply) emitJson(payload);
   } else {
     emit(render(payload, manifest, { npm, version }));
   }
@@ -443,7 +443,7 @@ export async function initCommand(positional, flags) {
   }
   payload.written = true;
 
-  if (isJson(flags)) emit(`${JSON.stringify(payload, null, 2)}\n`);
+  if (isJson(flags)) emitJson(payload);
 
   note('');
   note(`next     ${CLI} sync --yes, then ${CLI} check in CI. Commit when you are happy with the diff.`);
@@ -608,8 +608,12 @@ function render(payload, manifest, { npm = true, version } = {}) {
     // on it would understate the edit the reader is approving. A baseline is the
     // opposite case to AGENTS.md in the one way that matters here — it is placed FIRST,
     // so the repo's own settings below it keep winning (ADR-025).
+    // A nested `apps/web/AGENTS.md` is the same kind of target as the root's, so the
+    // test is the suffix and not the exact path: a monorepo's package region holds
+    // hand-written content too, and describing it as a generated rule file would be
+    // the wrong contract for a reader who has prose above the markers.
     const caption =
-      target.file === PRIMARY_TARGET
+      target.file.endsWith(PRIMARY_TARGET)
         ? 'hand-written content outside the markers is never modified'
         : target.kind === 'baseline'
           ? 'a region placed first, so your own settings below it still win (ADR-025)'

package/src/commands/mcp.mjs

@@ -13,9 +13,9 @@ import { readFile } from 'node:fs/promises';
 import { fileURLToPath } from 'node:url';
 import { dirname, join } from 'node:path';
 
-import { EXIT, emit, fail, isJson } from '../output/index.mjs';
+import { EXIT, emit, emitJson, fail, isJson } from '../output/index.mjs';
 import { TOOLS } from '../mcp/tools.mjs';
-import { PROTOCOL_VERSION, serve } from '../mcp/server.mjs';
+import { PROTOCOL_VERSION, SUPPORTED_VERSIONS, serve } from '../mcp/server.mjs';
 import { CLI } from '../name.mjs';
 
 export async function mcpCommand(positional, flags) {
@@ -23,12 +23,27 @@ export async function mcpCommand(positional, flags) {
 
   if (flags.list === true) {
     if (isJson(flags)) {
-      emit(`${JSON.stringify({ ok: true, protocolVersion: PROTOCOL_VERSION, version, tools: TOOLS.map(({ name, description, inputSchema }) => ({ name, description, inputSchema })) }, null, 2)}\n`);
+      emitJson({
+        ok: true,
+        protocolVersion: PROTOCOL_VERSION,
+        protocolVersions: SUPPORTED_VERSIONS,
+        version,
+        // The output schema and the read-only annotation travel with the tool here too:
+        // a reader listing the surface should see the same contract a call returns,
+        // rather than discovering the shape by making one.
+        tools: TOOLS.map(({ name, description, inputSchema, outputSchema, annotations }) => ({
+          name,
+          description,
+          inputSchema,
+          ...(outputSchema ? { outputSchema } : {}),
+          annotations,
+        })),
+      });
       return EXIT.OK;
     }
     emit(
       [
-        `simt-dev ${version} - MCP surface over stdio (protocol ${PROTOCOL_VERSION})`,
+        `simt-dev ${version} - MCP surface over stdio (protocols ${SUPPORTED_VERSIONS.join(', ')})`,
         '',
         `${TOOLS.length} read-only tools:`,
         ...TOOLS.map((t) => `  ${t.name.padEnd(16)} ${t.description.split('.')[0]}`),
@@ -44,7 +59,7 @@ export async function mcpCommand(positional, flags) {
   }
 
   try {
-    return await serve(TOOLS, { version });
+    return await serve(TOOLS, { packageVersion: version });
   } catch (error) {
     return fail(`mcp transport failed: ${error.message}`, EXIT.FAIL, `run: ${CLI} mcp --list to check the surface loads`);
   }

package/src/commands/plan.mjs

@@ -0,0 +1,99 @@
+import { EXIT, emit, emitJson, fail, isJson, writeMode } from '../output/index.mjs';
+import { formatCounts, planDone, planNext, planStatus } from '../plan/index.mjs';
+import { CLI } from '../name.mjs';
+
+// Preview unless --yes, and --dry-run wins even then. A tracker row marked done
+// for a commit that was never written is a claim the next reader will believe.
+
+export async function planCommand(sub, args, flags) {
+  const root = flags.root ?? process.cwd();
+  if (sub === 'status') return runStatus(root, flags);
+  if (sub === 'next') return runNext(root, args[0] ?? null, flags);
+  if (sub === 'done') {
+    if (!args[0]) return fail('plan done needs a slice id', EXIT.USAGE, `run: ${CLI} plan next`);
+    return runDone(root, args[0], args[1] ?? null, flags);
+  }
+  if (!sub) {
+    return fail('plan needs a subcommand', EXIT.USAGE, `run: ${CLI} plan status  |  ${CLI} plan next  |  ${CLI} plan done <id>`);
+  }
+  return fail(`unknown plan subcommand ${sub}`, EXIT.USAGE, `run: ${CLI} plan status`);
+}
+
+async function runStatus(root, flags) {
+  const result = await planStatus(root);
+  if (result.error) return fail(result.error, EXIT.USAGE, result.remedy);
+  if (isJson(flags)) {
+    emitJson({ ok: true, command: 'plan status', ...result });
+    return EXIT.OK;
+  }
+  const lines = [`repo     ${root}`, `template ${result.template}`, `dirs     ${result.directories.join(', ')}`];
+  if (result.documents.length === 0) lines.push(`(no tracker in ${result.directories.join(' or ')})`);
+  for (const doc of result.documents) {
+    lines.push(`${doc.name}  slices=${doc.slices}  ${formatCounts(doc.counts, result.stateOrder)}`);
+  }
+  lines.push('', `total    ${formatCounts(result.totals, result.stateOrder) || '-'}`);
+  lines.push(`ready    ${result.ready}`);
+  emit(lines.join('\n'), { maxBytes: flags.maxBytes ?? 0 });
+  return EXIT.OK;
+}
+
+async function runNext(root, id, flags) {
+  const result = await planNext(root, id);
+  if (result.error) return fail(result.error, EXIT.USAGE, result.remedy);
+  if (isJson(flags)) {
+    emitJson({ ok: true, command: 'plan next', ...result });
+    return EXIT.OK;
+  }
+  if (!result.next) {
+    const lines = [`repo     ${root}`, result.reason];
+    if (result.blocked?.length) {
+      lines.push('', 'blocked:');
+      for (const row of result.blocked) {
+        const unknown = row.unknownDependencies.length ? `  unknown: ${row.unknownDependencies.join(', ')}` : '';
+        lines.push(`  ${row.id}  ${row.doc}  depends on: ${row.dependsOn || '(none)'}${unknown}`);
+      }
+    }
+    emit(lines.join('\n'), { maxBytes: flags.maxBytes ?? 0 });
+    return EXIT.OK;
+  }
+  const next = result.next;
+  const head = [
+    `repo     ${root}`,
+    `slice    ${next.id}  ${next.doc}`,
+    `state    ${next.state}`,
+    `depends  ${next.dependsOn || '(none)'}`,
+    `bytes    ${next.sectionBytes}`,
+    '',
+    next.section || '(no section for this id)',
+  ];
+  emit(head.join('\n'), { maxBytes: flags.maxBytes ?? 0 });
+  return EXIT.OK;
+}
+
+async function runDone(root, id, sha, flags) {
+  const mode = writeMode(flags);
+  const result = await planDone(root, id, {
+    sha,
+    test: flags.test ?? null,
+    state: flags.state ?? null,
+    dryRun: !mode.apply,
+  });
+  if (result.error) return fail(result.error, EXIT.USAGE, result.remedy);
+  if (isJson(flags)) {
+    emitJson({ ok: true, command: 'plan done', ...result });
+    return EXIT.OK;
+  }
+  const lines = [`repo     ${root}`];
+  if (result.dryRun) {
+    lines.push(`dry-run  ${result.id}  ${result.doc}  line ${result.line}`);
+    lines.push(result.wouldChange ? `would    ${result.from} -> ${result.to}` : `state    ${result.from}`);
+    if (result.remedy) lines.push(`apply    ${result.remedy}`);
+  } else {
+    lines.push(`changed  ${result.changed ? 'yes' : 'no'}  ${result.id}  ${result.doc}  line ${result.line}`);
+    lines.push(result.from === result.to ? `state    ${result.to}` : `state    ${result.from} -> ${result.to}`);
+  }
+  if (result.evidenceRecorded) lines.push(`evidence ${result.sha}${result.test ? `  test: ${result.test}` : ''}`);
+  else if (result.evidenceNote) lines.push(`note     ${result.evidenceNote}`);
+  emit(lines.join('\n'), { maxBytes: flags.maxBytes ?? 0 });
+  return EXIT.OK;
+}

package/src/commands/rules.mjs

@@ -14,7 +14,7 @@
 // one, because "this rule has no decision behind it" is exactly the fact a
 // reviewer needs and exactly the fact an empty output would hide.
 
-import { EXIT, emit, fail, isJson } from '../output/index.mjs';
+import { EXIT, emit, emitJson, fail, isJson } from '../output/index.mjs';
 import { loadRules, select } from '../projection/project.mjs';
 import { loadMdcRules } from '../projection/mdc.mjs';
 import { fingerprint } from '../resolve/fingerprint.mjs';
@@ -92,30 +92,25 @@ export async function listCommand(args, flags) {
   const selection = root ? await selectionFor(rules, root) : null;
 
   if (isJson(flags)) {
-    emit(
-      `${JSON.stringify(
-        {
-          ok: broken.length === 0,
-          command: 'rules list',
-          root,
-          rules: sorted(rules).map((r) => ({
-            id: r.id,
-            title: r.title,
-            origin: r.origin,
-            source: r.source,
-            applies: r.applies,
-            fallback: r.fallback,
-            bytes: r.bytes,
-            error: r.error,
-            adrs: citations(r.body),
-            selected: selection ? selection.selected.has(r.id) : null,
-          })),
-          notes: selection?.notes ?? [],
-        },
-        null,
-        2,
-      )}\n`,
-      { maxBytes: flags.maxBytes ?? 0 },
+    emitJson(
+      {
+                ok: broken.length === 0,
+                command: 'rules list',
+                root,
+                rules: sorted(rules).map((r) => ({
+                  id: r.id,
+                  title: r.title,
+                  origin: r.origin,
+                  source: r.source,
+                  applies: r.applies,
+                  fallback: r.fallback,
+                  bytes: r.bytes,
+                  error: r.error,
+                  adrs: citations(r.body),
+                  selected: selection ? selection.selected.has(r.id) : null,
+                })),
+                notes: selection?.notes ?? [],
+              },
     );
     return broken.length === 0 ? EXIT.OK : EXIT.FAIL;
   }
@@ -188,7 +183,7 @@ export async function showCommand(args, flags) {
 
   const adrs = citations(rule.body);
   if (isJson(flags)) {
-    emit(`${JSON.stringify({ ok: !rule.error, ...rule, adrs }, null, 2)}\n`, { maxBytes: flags.maxBytes ?? 0 });
+    emitJson({ ok: !rule.error, ...rule, adrs }, { maxBytes: flags.maxBytes ?? 0 });
     return rule.error ? EXIT.FAIL : EXIT.OK;
   }
 
@@ -238,21 +233,16 @@ async function ruleDirection(id, rules, decisions, flags, broken) {
   const index = byId(decisions);
 
   if (isJson(flags)) {
-    emit(
-      `${JSON.stringify(
-        {
-          ok: true,
-          command: 'rules why',
-          rule: rule.id,
-          source: rule.source,
-          origin: rule.origin,
-          adrs: cited.map((c) => index.get(c) ?? { id: c, missing: true }),
-          uncited: cited.length === 0,
-        },
-        null,
-        2,
-      )}\n`,
-      { maxBytes: flags.maxBytes ?? 0 },
+    emitJson(
+      {
+                ok: true,
+                command: 'rules why',
+                rule: rule.id,
+                source: rule.source,
+                origin: rule.origin,
+                adrs: cited.map((c) => index.get(c) ?? { id: c, missing: true }),
+                uncited: cited.length === 0,
+              },
     );
     return EXIT.OK;
   }
@@ -313,22 +303,17 @@ async function adrDirection(adr, rules, decisions, flags) {
     // effective ruling is carried alongside rather than instead: the record asked about
     // is still named, and what is in force is named separately.
     const replacement = d.supersededBy ? decisions.find((x) => x.id === d.supersededBy) : null;
-    emit(
-      `${JSON.stringify(
-        {
-          ok: true,
-          command: 'rules why',
-          adr: d,
-          supersededBy: replacement ? { id: replacement.id, title: replacement.title } : null,
-          inForce: replacement
-            ? { id: replacement.id, status: replacement.status, summary: replacement.summary }
-            : { id: d.id, status: d.status, summary: d.summary },
-          rules: restates.map((r) => r.id),
-        },
-        null,
-        2,
-      )}\n`,
-      { maxBytes: flags.maxBytes ?? 0 },
+    emitJson(
+      {
+                ok: true,
+                command: 'rules why',
+                adr: d,
+                supersededBy: replacement ? { id: replacement.id, title: replacement.title } : null,
+                inForce: replacement
+                  ? { id: replacement.id, status: replacement.status, summary: replacement.summary }
+                  : { id: d.id, status: d.status, summary: d.summary },
+                rules: restates.map((r) => r.id),
+              },
     );
     return EXIT.OK;
   }

package/src/commands/skills.mjs

@@ -97,24 +97,19 @@ export async function indexCommand(args, flags) {
   const workspace = await workspaceLine(flags);
 
   if (isJson(flags)) {
-    emit(
-      `${JSON.stringify(
-        {
-          ok: true,
-          workspace,
-          skills: registry.skills.map((s) => ({
-            name: s.name,
-            summary: s.summary,
-            capabilities: s.capabilities,
-            stack: s.stack,
-            bytes: s.bytes,
-            deferred: Boolean(s.deferred),
-          })),
-        },
-        null,
-        2,
-      )}\n`,
-      { maxBytes: flags.maxBytes ?? 0 },
+    emitJson(
+      {
+                ok: true,
+                workspace,
+                skills: registry.skills.map((s) => ({
+                  name: s.name,
+                  summary: s.summary,
+                  capabilities: s.capabilities,
+                  stack: s.stack,
+                  bytes: s.bytes,
+                  deferred: Boolean(s.deferred),
+                })),
+              },
     );
     return EXIT.OK;
   }
@@ -168,20 +163,15 @@ async function emitAll(registry, repoStack, flags, warning) {
   const inline = usable.filter((s) => !s.deferred);
 
   if (isJson(flags)) {
-    emit(
-      `${JSON.stringify(
-        {
-          ok: true,
-          all: true,
-          repoStack,
-          inline: inline.map((s) => s.name),
-          deferred: deferred.map((s) => s.name),
-          ...(warning ? { warning } : {}),
-        },
-        null,
-        2,
-      )}\n`,
-      { maxBytes: flags.maxBytes ?? 0 },
+    emitJson(
+      {
+                ok: true,
+                all: true,
+                repoStack,
+                inline: inline.map((s) => s.name),
+                deferred: deferred.map((s) => s.name),
+                ...(warning ? { warning } : {}),
+              },
     );
     return EXIT.OK;
   }
@@ -217,7 +207,10 @@ export async function findCommand(args, flags) {
     .sort((a, b) => b.score - a.score || a.skill.name.localeCompare(b.skill.name));
 
   if (isJson(flags)) {
-    emit(`${JSON.stringify({ ok: true, query, workspace, results: results.map((r) => ({ name: r.skill.name, score: r.score, reasons: r.reasons })) }, null, 2)}\n`, { maxBytes: flags.maxBytes ?? 0 });
+    emitJson(
+      { ok: true, query, workspace, results: results.map((r) => ({ name: r.skill.name, score: r.score, reasons: r.reasons })) },
+      { maxBytes: flags.maxBytes ?? 0 },
+    );
     return EXIT.OK;
   }
 
@@ -275,24 +268,19 @@ export async function briefCommand(args, flags) {
       // is what `warning` carries. Failing here would tell a caller the tool
       // broke when in fact it is telling them their query was.
       if (flags.all) return emitAll(registry, repoStack, flags, warning);
-      emit(
-        `${JSON.stringify(
-          {
-            ok: true,
-            repo: { root, stack: repoStack },
-            workspace,
-            task: null,
-            budget,
-            resolved: [],
-            deferred: [],
-            excluded: [],
-            warning,
-          },
-          null,
-          2,
-        )}\n`,
-        { maxBytes: flags.maxBytes ?? 0 },
-      );
+      emitJson(
+        {
+                    ok: true,
+                    repo: { root, stack: repoStack },
+                    workspace,
+                    task: null,
+                    budget,
+                    resolved: [],
+                    deferred: [],
+                    excluded: [],
+                    warning,
+                  },
+    );
       return EXIT.OK;
     }
     emit(
@@ -333,22 +321,17 @@ export async function briefCommand(args, flags) {
   const lines = [];
 
   if (isJson(flags)) {
-    emit(
-      `${JSON.stringify(
-        {
-          ok: true,
-          repo: { root, stack: repoStack },
-          workspace,
-          task: flags.task ?? null,
-          budget,
-          resolved: picked.map((e) => ({ name: e.skill.name, bytes: e.skill.bytes, why: [...e.reasons, ...[...e.via].map((v) => `requires:${v}`)] })),
-          deferred: deferred.map((e) => ({ name: e.skill.name, bytes: e.skill.bytes })),
-          excluded: excluded.filter((e) => !closureNames.has(e.skill.name)).map((e) => ({ name: e.skill.name, reason: e.reason })),
-        },
-        null,
-        2,
-      )}\n`,
-      { maxBytes: flags.maxBytes ?? 0 },
+    emitJson(
+      {
+                ok: true,
+                repo: { root, stack: repoStack },
+                workspace,
+                task: flags.task ?? null,
+                budget,
+                resolved: picked.map((e) => ({ name: e.skill.name, bytes: e.skill.bytes, why: [...e.reasons, ...[...e.via].map((v) => `requires:${v}`)] })),
+                deferred: deferred.map((e) => ({ name: e.skill.name, bytes: e.skill.bytes })),
+                excluded: excluded.filter((e) => !closureNames.has(e.skill.name)).map((e) => ({ name: e.skill.name, reason: e.reason })),
+              },
     );
     return EXIT.OK;
   }
@@ -470,10 +453,7 @@ export async function showCommand(args, flags) {
   const body = await sourcePath(skill, workspaceRoot, root);
   const bodyFrom = body === null ? 'none' : body.startsWith(`${root}/`) ? 'repo' : 'workspace';
   if (isJson(flags)) {
-    emit(
-      `${JSON.stringify({ ok: true, ...skill, workspace, body, bodyFrom }, null, 2)}\n`,
-      { maxBytes: flags.maxBytes ?? 0 },
-    );
+    emitJson({ ok: true, ...skill, workspace, body, bodyFrom }, { maxBytes: flags.maxBytes ?? 0 });
     return EXIT.OK;
   }
   emit(
@@ -640,27 +620,22 @@ export async function evalCommand(positional, flags) {
   const okRun = unknown.length === 0 && score.clean;
 
   if (isJson(flags)) {
-    emit(
-      `${JSON.stringify(
-        {
-          ok: okRun,
-          command: 'skills eval',
-          corpus: corpusPath,
-          registry: path,
-          cases: score.cases.map((c) => ({
-            name: c.name,
-            selected: c.selected,
-            missing: c.missing,
-            unexpected: c.unexpected,
-          })),
-          unknownSkills: unknown,
-          precision: score.precision,
-          recall: score.recall,
-        },
-        null,
-        2,
-      )}\n`,
-      { maxBytes: flags.maxBytes ?? 0 },
+    emitJson(
+      {
+                ok: okRun,
+                command: 'skills eval',
+                corpus: corpusPath,
+                registry: path,
+                cases: score.cases.map((c) => ({
+                  name: c.name,
+                  selected: c.selected,
+                  missing: c.missing,
+                  unexpected: c.unexpected,
+                })),
+                unknownSkills: unknown,
+                precision: score.precision,
+                recall: score.recall,
+              },
     );
     return okRun ? EXIT.OK : EXIT.FAIL;
   }

package/src/commands/skillsinstall.mjs

@@ -24,7 +24,7 @@ import { cp, mkdir, readFile, stat, writeFile } from 'node:fs/promises';
 import { existsSync } from 'node:fs';
 import { dirname, join } from 'node:path';
 
-import { EXIT, emit, fail, isJson, note, writeMode } from '../output/index.mjs';
+import { EXIT, emit, emitJson, fail, isJson, note, writeMode } from '../output/index.mjs';
 import { loadRegistry, measureSkill } from '../graph/load.mjs';
 import { fingerprint } from '../resolve/fingerprint.mjs';
 import { readCapability } from '../hooks/capability.mjs';
@@ -35,6 +35,7 @@ import { nearMatches } from '../resolve/near.mjs';
 import { resolveWorkspace, WORKSPACE_REMEDY } from '../workspace.mjs';
 import { CLI } from '../name.mjs';
 import { MANIFEST_FILE } from '../name.mjs';
+import { nameProblems } from '../graph/spec.mjs';
 
 /**
  * Where skills live in this repo. The estate already has a convention - a
@@ -112,6 +113,20 @@ export async function installCommand(args, flags) {
   }
 
   const dir = skillsDir(root, await dirEntries(root));
+  // The Agent Skills specification requires `name` to equal the directory it lives in,
+  // and the directory is named after the skill. So a name that breaks the naming rules
+  // cannot be installed at all: the client resolves by name, finds a directory the name
+  // does not match, and never reads the body this command just copied. Refused here,
+  // before anything is written, with the rule broken - because the alternative is a
+  // successful install that no client can load.
+  const broken = nameProblems(name);
+  if (broken !== null) {
+    return fail(
+      `${name}: ${broken}`,
+      EXIT.REGISTRY,
+      `rename it in ${skill.source ?? 'the registry'} to lowercase letters, digits and single hyphens, then install again`,
+    );
+  }
   const dest = join(root, dir, name);
   const inplace = await samePath(src, dest);
   const action = inplace ? 'in-place' : await compare(dest, src, measured.flat, name);
@@ -147,7 +162,7 @@ export async function installCommand(args, flags) {
   // combination a script writes. The payload is now emitted once, at the end,
   // after the write it describes.
   const report = () => {
-    if (isJson(flags)) emit(`${JSON.stringify(payload, null, 2)}\n`, { maxBytes: flags.maxBytes ?? 0 });
+    if (isJson(flags)) emitJson(payload);
   };
   const mode = writeMode(flags);