omgbase 0.4.0 → 0.4.1

package/dist/src/cmd/log.js

@@ -1,6 +1,6 @@
 import { parseArgs } from "node:util";
 import { changesSince } from "@omgbase/core";
-import { CliUsageError, truncationFooter, EXIT_OK, renderHelp } from "../output.js";
+import { CliUsageError, truncationFooter, EXIT_OK, emitMachine, renderHelp } from "../output.js";
 import { remoteCall } from "./_remote.js";
 // `omg log` (11 §5.5) — changes_since, one digest summary per line. Relative
 // --since (24h/7d) is resolved to a literal ISO timestamp client-side, then to
@@ -23,9 +23,12 @@ function relativeToIso(since) {
         const ms = unit === "h" ? 3600e3 : unit === "d" ? 86400e3 : unit === "w" ? 7 * 86400e3 : 30 * 86400e3;
         return new Date(Date.now() - n * ms).toISOString();
     }
-    // Absolute timestamp: pass through (Date normalizes).
+    // Absolute timestamp: pass through (Date normalizes). Anything else is the
+    // user's mistake, not "the epoch" (spec/cli §6 `log`).
     const t = Date.parse(since);
-    return Number.isNaN(t) ? new Date(0).toISOString() : new Date(t).toISOString();
+    if (Number.isNaN(t))
+        throw new CliUsageError(`bad --since '${since}' (use a relative age like 24h or 7d, or an ISO timestamp)`);
+    return new Date(t).toISOString();
 }
 async function runLog(cli, args) {
     const { values } = parseArgs({
@@ -76,21 +79,8 @@ async function runLog(cli, args) {
             opts.origin = values.origin;
         result = changesSince(ws.store, repo.repoId, opts);
     }
-    if (cli.flags.mode === "json") {
-        cli.io.out(JSON.stringify(result));
-        return EXIT_OK;
-    }
-    if (cli.flags.mode === "jsonl") {
-        for (const d of result.digests)
-            cli.io.out(JSON.stringify(d));
-        if (result.truncated)
-            truncationFooter(cli.io, cli.style, result.cursor);
-        return EXIT_OK;
-    }
-    if (cli.flags.mode === "ids") {
-        for (const d of result.digests)
-            cli.io.out(d.commit);
-        return EXIT_OK;
+    if (cli.flags.mode !== "human") {
+        return emitMachine(cli, result, { items: result.digests, ids: result.digests.map((d) => d.commit), cursor: result.truncated ? result.cursor : null });
     }
     const { style, io } = cli;
     if (result.digests.length === 0) {

package/dist/src/cmd/ls.js

@@ -1,7 +1,7 @@
 import { parseArgs } from "node:util";
 import { docsList } from "@omgbase/core";
 import { columns } from "../render.js";
-import { EXIT_OK, renderHelp } from "../output.js";
+import { EXIT_OK, emitMachine, renderHelp } from "../output.js";
 import { remoteCall } from "./_remote.js";
 // `omg ls [glob]` (11 §5.2) — live documents: path, block count, last-commit
 // time. glob is a simple prefix/suffix match on the path (SQL LIKE with * → %).
@@ -39,20 +39,8 @@ async function runLs(cli, args) {
         cursor = page.truncated ? page.cursor : null;
     } while (cursor);
     cli.capture?.(rows); // shell: docs become the addressable frame (ref = path)
-    if (cli.flags.mode === "ids") {
-        for (const r of rows)
-            cli.io.out(r.path);
-        return EXIT_OK;
-    }
-    if (cli.flags.mode === "json") {
-        cli.io.out(JSON.stringify(rows));
-        return EXIT_OK;
-    }
-    if (cli.flags.mode === "jsonl") {
-        for (const r of rows)
-            cli.io.out(JSON.stringify(r));
-        return EXIT_OK;
-    }
+    if (cli.flags.mode !== "human")
+        return emitMachine(cli, rows, { items: rows, ids: rows.map((r) => r.path) });
     const { style, io } = cli;
     if (rows.length === 0) {
         io.err(style.dim("  no documents"));

package/dist/src/cmd/mcp.js

@@ -1,6 +1,7 @@
 import { parseArgs } from "node:util";
-import { serveStdio, Watcher, WatchLease, watchLeaseLive, freshnessSweep, awaitReady, WATCH_READY_PATIENCE_MS, EmbedDrainer, EngineError, pinClock, sequentialMinter, setIdMinter } from "@omgbase/core";
-import { CliUsageError, EngineErrorLike, EXIT_OK, renderHelp } from "../output.js";
+import { serveStdio, Watcher, WatchLease, watchLeaseLive, freshnessSweep, awaitReady, WATCH_READY_PATIENCE_MS, EmbedDrainer, EngineError } from "@omgbase/core";
+import { EngineErrorLike, EXIT_OK, renderHelp } from "../output.js";
+import { installSpecSeams } from "../seams.js";
 import { loadEmbedding } from "./_embed.js";
 import { openRepoSource } from "./_source.js";
 // `omg mcp [--no-watch]` (11 §5.8) — MCP server on stdio; the host owns the
@@ -11,38 +12,18 @@ import { openRepoSource } from "./_source.js";
 // CRITICAL: on stdio, stdout is the MCP protocol channel. Nothing may write to
 // stdout here — every diagnostic goes to stderr (cli.io.err).
 /**
- * The two conformance seams of spec/surface §7.1, read from the environment
- * BEFORE the workspace opens (so no id is minted and no timestamp read without
- * them). For conformance runs only — never set in production:
- *
- *   OMGBASE_SPEC_MINTER=sequential   the fixture minter of spec/store §2.2 for
- *                                    the whole process (`d_0, d_1, …`, each
- *                                    prefix from 0); any other value is a
- *                                    startup error
- *   OMGBASE_SPEC_CLOCK=<RFC 3339>    "now" is that instant for the whole
- *                                    process: every commit a tool stamps, every
- *                                    `ts` reported as current
- *
- * Both are announced on stderr (stdout is the protocol channel).
+ * Announce the two conformance seams of spec/surface §7.1 on stderr (stdout is
+ * the protocol channel). They are installed for every verb at the entry point
+ * (`seams.ts`, spec/cli §2.6) — `mcp` only reports them, so a conformance run
+ * is visibly not a production one.
  */
-function installSpecSeams(cli) {
-    const minter = process.env.OMGBASE_SPEC_MINTER;
-    if (minter !== undefined && minter !== "") {
-        if (minter !== "sequential") {
-            throw new CliUsageError(`OMGBASE_SPEC_MINTER=${JSON.stringify(minter)}: the only value is "sequential" (spec/surface §7.1)`, "unset it, or set OMGBASE_SPEC_MINTER=sequential for a conformance run");
-        }
-        setIdMinter(sequentialMinter());
+function announceSpecSeams(cli) {
+    const seams = installSpecSeams();
+    if (seams.minter) {
         cli.io.err(cli.style.dim("[mcp] spec seam: sequential id minter (OMGBASE_SPEC_MINTER=sequential) — conformance run, not for production"));
     }
-    const clock = process.env.OMGBASE_SPEC_CLOCK;
-    if (clock !== undefined && clock !== "") {
-        try {
-            pinClock(clock);
-        }
-        catch {
-            throw new CliUsageError(`OMGBASE_SPEC_CLOCK=${JSON.stringify(clock)}: not an RFC 3339 instant (spec/surface §7.1)`, "e.g. OMGBASE_SPEC_CLOCK=2026-09-27T00:00:00.000Z");
-        }
-        cli.io.err(cli.style.dim(`[mcp] spec seam: clock pinned to ${new Date().toISOString()} (OMGBASE_SPEC_CLOCK) — conformance run, not for production`));
+    if (seams.clock !== null) {
+        cli.io.err(cli.style.dim(`[mcp] spec seam: clock pinned to ${seams.clock} (OMGBASE_SPEC_CLOCK) — conformance run, not for production`));
     }
 }
 async function runMcp(cli, args) {
@@ -64,7 +45,7 @@ async function runMcp(cli, args) {
             notes: [`host config: {"command": "${cli.prog}", "args": ["mcp", "-C", "/path/to/notes"]}`],
         });
     }
-    installSpecSeams(cli);
+    announceSpecSeams(cli);
     // The host launches us from its own cwd, so a missing workspace here almost
     // always means the host config lacks `-C <dir>` — say so, rather than the
     // generic "run init" hint (which would create an empty workspace in the wrong place).

package/dist/src/cmd/mutate.js

@@ -13,6 +13,20 @@ function block(cli, ws, repoId, ref) {
         throw new EngineErrorLike("block_missing", `not a block: ${ref}`);
     return r.blockId;
 }
+// `done` addresses task blocks only (spec/cli §6): any other live block type is
+// a type_mismatch before an op is built — the macro itself would record a no-op
+// `edited` commit (its `attrs.checked` only rewrites a task's marker).
+function taskBlock(ws, ref, blockId) {
+    const row = ws.store.db
+        .prepare("SELECT type FROM blocks WHERE block_id = ? AND deleted_commit IS NULL")
+        .get(blockId);
+    if (!row)
+        throw new EngineErrorLike("block_missing", `not a block: ${ref}`);
+    if (row.type !== "task") {
+        throw new EngineErrorLike("type_mismatch", `not a task: ${ref} is a ${row.type}`, { data: { block: blockId, type: row.type } });
+    }
+    return blockId;
+}
 function rawHashOf(ws, blockId) {
     const row = ws.store.db
         .prepare("SELECT lower(hex(raw_hash)) h FROM blocks WHERE block_id = ? AND deleted_commit IS NULL")
@@ -87,7 +101,7 @@ async function runInsert(cli, args) {
     }
     const to = positionals[0];
     if (!to)
-        throw new CliUsageError("insert requires a <to> parent (block id, or a heading id for section append)");
+        throw new CliUsageError("insert requires a <to> parent (a container block id, or a doc id/path for the top level)");
     const markdown = readContent(content);
     // The destination-parent CAS (spec/mutate §1.2) rides as the op-level expect.
     const expect = values.expect ? { expect: { parent_children_hash: values.expect } } : {};
@@ -238,7 +252,7 @@ async function runDone(cli, args) {
         return runOpsRemote(cli, "tasks_complete", { blocks: refs, ...(values.undo ? { checked: false } : {}) });
     const ws = cli.workspace();
     const repo = cli.repo(ws);
-    const blocks = refs.map((r) => block(cli, ws, repo.repoId, r));
+    const blocks = refs.map((r) => taskBlock(ws, r, block(cli, ws, repo.repoId, r)));
     const ops = values.undo
         ? blocks.map((b) => ({ op: "update", block: b, attrs: { checked: false }, expect: pinned(ws, b) }))
         : tasksComplete(ws.store, blocks);
@@ -301,7 +315,14 @@ async function runSplit(cli, args) {
         throw new CliUsageError("split requires a <block>");
     if (!values.at)
         throw new CliUsageError("split requires --at n[,n…]");
-    const at = values.at.split(",").map((s) => Number(s.trim()));
+    // Offsets are integers (spec/mutate §2.5); anything else is a usage error
+    // here, not a NaN that reaches the kernel.
+    const at = values.at.split(",").map((s) => {
+        const n = Number(s.trim());
+        if (s.trim() === "" || !Number.isInteger(n))
+            throw new CliUsageError(`bad --at '${values.at}' (offsets must be integers: n[,n…])`);
+        return n;
+    });
     if (cli.flags.server)
         return runOpsRemote(cli, "blocks_split", { block: ref, at });
     const ws = cli.workspace();

package/dist/src/cmd/node.js

@@ -28,8 +28,12 @@ async function runNode(cli, args) {
         });
     }
     if (sub === "set") {
-        parseArgs({ args: rest, allowPositionals: true, options: { actor: { type: "string" } } });
-        const [nodeId, prop, ...valueParts] = rest.filter((a) => !a.startsWith("--"));
+        // The value is every positional after <prop>, joined by a space; --actor
+        // (an option WITH a value) is taken out by the parser, never by a prefix
+        // filter — that filter used to leave the actor's value inside the property
+        // value (`checked "true human:spec"`), which the task editor read as false.
+        const { values, positionals } = parseArgs({ args: rest, allowPositionals: true, options: { actor: { type: "string" } } });
+        const [nodeId, prop, ...valueParts] = positionals;
         if (!nodeId || !prop || valueParts.length === 0)
             throw new CliUsageError("node set <nodeId> <prop> <value>");
         const value = valueParts.join(" ");
@@ -39,7 +43,7 @@ async function runNode(cli, args) {
         const ws = cli.workspace();
         const repo = cli.repo(ws);
         const ops = nodeSet(ws.store, nodeId, prop, value);
-        return runOps(cli, ws, repo, ops, { reason: `node_set ${prop}` });
+        return runOps(cli, ws, repo, ops, { reason: `node_set ${prop}`, ...(values.actor ? { actor: values.actor } : {}) });
     }
     if (sub === "props") {
         // `props` is a local editability lookup with no remote tool (a niche read).

package/dist/src/cmd/oqx.d.ts

@@ -1,2 +1,12 @@
+import { type OqxResult } from "@omgbase/core";
 import type { Command } from "../commands.js";
+import type { Cli } from "../context.js";
+/**
+ * Render an `OqxResult` in the current mode (shared with `run`). `--json` is the
+ * whole result verbatim (incl. consumer + any scalar), so count/exists round-trip
+ * without special-casing; `--jsonl` streams the hits (or the values, as JSON);
+ * `--ids` the hit ids — a scalar result has neither, so those modes print the
+ * document. The truncation footer prints in every mode but `--json`.
+ */
+export declare function renderOqxResult(cli: Cli, result: OqxResult): number;
 export declare const cmdOqx: Command;

package/dist/src/cmd/oqx.js

@@ -1,7 +1,7 @@
 import { parseArgs } from "node:util";
 import { readFileSync } from "node:fs";
 import { oqxRun, oqxRunAsync, collectSemanticPhrases } from "@omgbase/core";
-import { truncationFooter, EngineErrorLike, EXIT_OK, renderHelp, renderHits } from "../output.js";
+import { truncationFooter, CliUsageError, EngineErrorLike, EXIT_OK, emitMachine, renderHelp, renderHits } from "../output.js";
 import { loadEmbedding } from "./_embed.js";
 import { remoteCall } from "./_remote.js";
 import { readStdin } from "./_mutate.js";
@@ -85,10 +85,8 @@ async function runOqx(cli, args) {
     const source = values.file
         ? (values.file === "-" ? readStdin() : readFileSync(values.file, "utf8"))
         : positionals.join(" ").trim();
-    if (!source) {
-        cli.io.err(cli.style.dim("  usage: query <source>  (or -f file|-)"));
-        return EXIT_OK;
-    }
+    if (!source)
+        throw new CliUsageError("query requires a <source> (or -f file|-)");
     const opts = {};
     if (values.n)
         opts.limit = Number(values.n);
@@ -135,11 +133,24 @@ async function runOqx(cli, args) {
         : result.consumer === "exists" ? result.exists
             : result.consumer === "none" ? result.none
                 : result.values ?? result);
-    // JSON emits the whole result verbatim (incl. consumer + any scalar), so
-    // count/exists round-trip without special-casing.
-    if (cli.flags.mode === "json") {
-        cli.io.out(JSON.stringify(result));
-        return EXIT_OK;
+    return renderOqxResult(cli, result);
+}
+/**
+ * Render an `OqxResult` in the current mode (shared with `run`). `--json` is the
+ * whole result verbatim (incl. consumer + any scalar), so count/exists round-trip
+ * without special-casing; `--jsonl` streams the hits (or the values, as JSON);
+ * `--ids` the hit ids — a scalar result has neither, so those modes print the
+ * document. The truncation footer prints in every mode but `--json`.
+ */
+export function renderOqxResult(cli, result) {
+    const cursor = result.truncated ? result.cursor ?? "" : null;
+    if (cli.flags.mode !== "human") {
+        const list = result.values ?? (result.consumer === "collect" || result.consumer === "first" || result.consumer === "single" ? result.hits : undefined);
+        return emitMachine(cli, result, {
+            ...(list ? { items: list } : {}),
+            ...(list && !result.values ? { ids: result.hits.map((h) => h.id) } : {}),
+            cursor,
+        });
     }
     // Scalar consumers (count/exists/none) have no hits — render the reduction itself.
     if (result.consumer === "count" || result.consumer === "exists" || result.consumer === "none") {
@@ -148,26 +159,12 @@ async function runOqx(cli, args) {
         return EXIT_OK;
     }
     // A `values` projection has no hits — one bare value per line (strings
-    // verbatim, anything else as JSON; `--jsonl` is JSON throughout).
+    // verbatim, anything else as JSON).
     if (result.values) {
         for (const v of result.values)
-            cli.io.out(typeof v === "string" && cli.flags.mode !== "jsonl" ? v : JSON.stringify(v));
-        if (result.truncated)
-            truncationFooter(cli.io, cli.style, result.cursor ?? "");
-        return EXIT_OK;
-    }
-    if (cli.flags.mode === "ids") {
-        for (const h of result.hits)
-            cli.io.out(h.id);
-        if (result.truncated)
-            truncationFooter(cli.io, cli.style, result.cursor ?? "");
-        return EXIT_OK;
-    }
-    if (cli.flags.mode === "jsonl") {
-        for (const h of result.hits)
-            cli.io.out(JSON.stringify(h));
-        if (result.truncated)
-            truncationFooter(cli.io, cli.style, result.cursor ?? "");
+            cli.io.out(typeof v === "string" ? v : JSON.stringify(v));
+        if (cursor !== null)
+            truncationFooter(cli.io, cli.style, cursor);
         return EXIT_OK;
     }
     const { style, io } = cli;

package/dist/src/cmd/outline.js

@@ -1,6 +1,6 @@
 import { parseArgs } from "node:util";
 import { findDoc, docsOutline } from "@omgbase/core";
-import { CliUsageError, EngineErrorLike, truncationFooter, EXIT_OK, renderHelp } from "../output.js";
+import { CliUsageError, EngineErrorLike, truncationFooter, EXIT_OK, emitMachine, renderHelp } from "../output.js";
 import { remoteCall } from "./_remote.js";
 // `omg outline <doc|path>` (alias ol) — the wire format (06 §6). Human output
 // prints the outline text with full block ids inline; --json emits the
@@ -11,7 +11,6 @@ async function runOutline(cli, args) {
         allowPositionals: true,
         options: {
             depth: { type: "string" },
-            section: { type: "string" },
             skeleton: { type: "boolean" },
             help: { type: "boolean" },
         },
@@ -20,10 +19,9 @@ async function runOutline(cli, args) {
         return renderHelp(cli, {
             name: "outline",
             summary: "A document's outline with block ids inline (frozen wire format) — the orientation view",
-            usage: "outline <doc|path> [--depth <n>] [--section <locator>] [--skeleton]",
+            usage: "outline <doc|path> [--depth <n>] [--skeleton]",
             options: [
                 ["--depth <n>", "limit heading depth"],
-                ["--section <locator>", "outline only the section at a locator"],
                 ["--skeleton", "structure only, no text"],
             ],
         });
@@ -57,10 +55,9 @@ async function runOutline(cli, args) {
         result = docsOutline(ws.store, info.docId, opts);
         header = info.path;
     }
-    if (cli.flags.mode !== "human") {
-        cli.io.out(JSON.stringify(result));
-        return EXIT_OK;
-    }
+    // `{ text, truncated }` carries neither a list nor ids: every machine mode is the document.
+    if (cli.flags.mode !== "human")
+        return emitMachine(cli, result, { cursor: result.truncated ? "budget" : null });
     const { render, style, io } = cli;
     io.out(render.wordmark(header));
     io.out(render.rule(40));

package/dist/src/cmd/retarget.js

@@ -1,11 +1,12 @@
 import { parseArgs } from "node:util";
 import { linksRetarget } from "@omgbase/core";
 import { CliUsageError, EXIT_OK, renderHelp } from "../output.js";
-import { runOps } from "./_mutate.js";
+import { runOps, unifiedDiffLines } from "./_mutate.js";
 import { remoteCall } from "./_remote.js";
 // `omg retarget <from> <to> [--scope glob] [--apply]` (11 §5.6) — plan-by-default.
-// Without --apply it runs the dry-run and prints the per-block diffs (the 06 §4
-// "always dry-run first" contract, encoded as the default). --apply commits.
+// Without --apply it runs the dry-run and prints, per hit block, the unified
+// diff of its raw (the same diff every other preview prints — the 06 §4 "always
+// dry-run first" contract, encoded as the default). --apply commits.
 async function runRetarget(cli, args) {
     const { values, positionals } = parseArgs({
         args,
@@ -65,27 +66,11 @@ function renderPlan(cli, from, to, hits) {
     io.err(style.dim(`  plan — ${hits.length} block(s) would change; re-run with --apply to commit`));
     for (const h of hits) {
         io.out(style.id(h.block));
-        for (const line of lineDiff(h.oldRaw, h.newRaw)) {
-            io.out(line.startsWith("+") ? style.ok(line) : line.startsWith("-") ? style.err(line) : style.dim(line));
-        }
+        for (const line of unifiedDiffLines(cli, h.oldRaw, h.newRaw))
+            io.out(line);
         io.out("");
     }
     return EXIT_OK;
 }
-function lineDiff(before, after) {
-    const a = before.split("\n");
-    const b = after.split("\n");
-    const out = [];
-    const max = Math.max(a.length, b.length);
-    for (let i = 0; i < max; i++) {
-        if (a[i] === b[i])
-            continue;
-        if (a[i] !== undefined)
-            out.push(`- ${a[i]}`);
-        if (b[i] !== undefined)
-            out.push(`+ ${b[i]}`);
-    }
-    return out;
-}
 export const cmdRetarget = { name: "retarget", summary: "Rewrite a link target (plan-by-default)", run: (c, a) => runRetarget(c, a) };
 //# sourceMappingURL=retarget.js.map

package/dist/src/cmd/run.js

@@ -1,7 +1,8 @@
 import { parseArgs } from "node:util";
 import { resolveRef, findDoc, loadDocBlocks, blockRaw, oqxRun, oqxRunAsync, collectSemanticPhrases } from "@omgbase/core";
-import { CliUsageError, EngineErrorLike, truncationFooter, EXIT_OK, renderHelp, renderHits } from "../output.js";
+import { CliUsageError, EngineErrorLike, renderHelp } from "../output.js";
 import { loadEmbedding } from "./_embed.js";
+import { renderOqxResult } from "./oqx.js";
 // `omg run <locator|path>` (11 §5.3) — evaluate the first ```omg fence in a doc
 // (or the fence at a block locator) and print its results. The fence body is an
 // OQX source string (the same language `omg query` runs). Strictly read-and-print:
@@ -98,37 +99,9 @@ async function runRun(cli, args) {
     else {
         result = oqxRun(ws.store, repo.repoId, source);
     }
-    if (cli.flags.mode === "json") {
-        cli.io.out(JSON.stringify(result));
-        return EXIT_OK;
-    }
-    if (result.consumer === "count" || result.consumer === "exists" || result.consumer === "none") {
-        cli.io.out(result.consumer === "count" ? String(result.count) : result.consumer === "exists" ? String(result.exists) : String(result.none));
-        return EXIT_OK;
-    }
-    if (result.values) {
-        for (const v of result.values)
-            cli.io.out(typeof v === "string" ? v : JSON.stringify(v));
-        if (result.truncated)
-            truncationFooter(cli.io, cli.style, result.cursor ?? "");
-        return EXIT_OK;
-    }
-    if (cli.flags.mode === "ids") {
-        for (const h of result.hits)
-            cli.io.out(h.id);
-        return EXIT_OK;
-    }
-    const { style, io } = cli;
-    if (result.hits.length === 0) {
-        io.err(style.dim("  no hits"));
-        return EXIT_OK;
-    }
-    // Same renderer as `omg query`: `<id>  <path>` lines, or a column table when
-    // the fence projects (a selected `text` shows as its first line).
-    renderHits(cli, result.hits);
-    if (result.truncated)
-        truncationFooter(io, style, result.cursor ?? "");
-    return EXIT_OK;
+    // Same renderer as `omg query`, in every mode: `<id>  <path>` lines, or a
+    // column table when the fence projects (a selected `text` shows as its first line).
+    return renderOqxResult(cli, result);
 }
 export const cmdRun = { name: "run", summary: "Evaluate an ```omg fence (OQX, inert, read-only)", run: (c, a) => runRun(c, a) };
 //# sourceMappingURL=run.js.map

package/dist/src/cmd/show.js

@@ -1,6 +1,6 @@
 import { parseArgs } from "node:util";
-import { resolveRef, nodesGet, findDoc, docLinks, historyNode, docPropertiesMerged } from "@omgbase/core";
-import { CliUsageError, EngineErrorLike, EXIT_OK, renderHelp } from "../output.js";
+import { resolveRef, nodesGet, docsRead, docLinks, historyNode, docPropertiesMerged } from "@omgbase/core";
+import { CliUsageError, EngineErrorLike, EXIT_OK, emitMachine, renderHelp } from "../output.js";
 import { expandBlockArgs } from "./_mutate.js";
 function showOne(cli, ref, include) {
     const ws = cli.workspace();
@@ -9,11 +9,15 @@ function showOne(cli, ref, include) {
     if (!resolved)
         throw new EngineErrorLike("doc_missing", `no node ${ref}`);
     if (resolved.kind === "document") {
-        const info = findDoc(ws.store, { docId: resolved.docId });
+        // The card reads the merged properties + open edges; `--json` is the
+        // `read_ref` result for a document (`{ kind: "document", ...docs_read }`).
+        const res = docsRead(ws.store, resolved.docId);
+        if (!res)
+            throw new EngineErrorLike("doc_missing", `no document ${ref}`);
         const links = docLinks(ws.store, resolved.docId, { direction: "both" });
         const properties = docPropertiesMerged(ws.store.db, resolved.docId);
-        const payload = { kind: "document", id: info.docId, path: info.path, properties, edges: links };
-        return { payload, render: () => renderDocCard(cli, info.path, properties, links) };
+        const payload = { kind: "document", ...res };
+        return { payload, render: () => renderDocCard(cli, res.path, properties, links) };
     }
     const node = nodesGet(ws.store, resolved.docId, resolved.blockId, { resolution: "full" });
     if (!node)
@@ -47,14 +51,9 @@ function runShow(cli, args) {
     // One ref keeps the single-entity shape (→ @_, frame intact); several become a list.
     const single = cards.length === 1 ? cards[0] : null;
     cli.capture?.(single ? single.payload : cards.map((c) => c.payload));
-    if (cli.flags.mode === "json") {
-        cli.io.out(JSON.stringify(single ? single.payload : cards.map((c) => c.payload)));
-        return EXIT_OK;
-    }
     if (cli.flags.mode !== "human") {
-        for (const c of cards)
-            cli.io.out(JSON.stringify(c.payload));
-        return EXIT_OK;
+        const docs = cards.map((c) => c.payload);
+        return single ? emitMachine(cli, single.payload) : emitMachine(cli, docs, { items: docs });
     }
     for (const c of cards)
         c.render();

package/dist/src/cmd/source.js

@@ -6,7 +6,7 @@ import { createSource, deleteSource, listSources, getSourceByName, attachSourceT
 import { columns } from "../render.js";
 import { drainEmbeddings } from "./_embed.js";
 import { ensureFsAdapter, FS_ADAPTER } from "./_source.js";
-import { CliUsageError, EngineErrorLike, EXIT_OK, renderHelp } from "../output.js";
+import { CliUsageError, EngineErrorLike, EXIT_OK, emitMachine, renderHelp } from "../output.js";
 // `omg source` (ADR-014) — the source registry: where a repo's bytes come from
 // (a filesystem directory today; git/S3/etc. via adapters later). A repo owns
 // identity + history; adding a filesystem source points it at a directory and
@@ -101,14 +101,16 @@ async function runAdd(cli, args) {
     if (getSourceByName(ws.store, sourceName))
         throw new EngineErrorLike("path_taken", `a source named '${sourceName}' already exists`);
     // Consent gate: -y proceeds; a TTY prompts with a live file count; a non-TTY
-    // without -y refuses rather than absorbing the tree silently.
+    // without -y is a usage error (the script forgot the flag; exit 2) rather
+    // than a silent absorption of the tree — or a silent success.
     if (!values.yes) {
+        if (!process.stdin.isTTY || !cli.io.stdoutTTY) {
+            throw new CliUsageError(`refusing without -y (would ingest files under ${shortenHome(abs)})`, "there is no TTY to confirm on; pass -y to consent to the ingest");
+        }
         const { ok } = await confirmIngestWithCount(cli, abs, slug);
-        if (cli.io.stdoutTTY)
-            process.stderr.write("\n");
+        process.stderr.write("\n");
         if (!ok) {
-            const why = !process.stdin.isTTY || !cli.io.stdoutTTY ? `refusing without -y (would ingest files under ${shortenHome(abs)})` : "cancelled";
-            cli.io.err(cli.style.dim(`  ${why}`));
+            cli.io.err(cli.style.dim("  cancelled"));
             return EXIT_OK;
         }
     }
@@ -133,10 +135,8 @@ async function runAdd(cli, args) {
             return confirmTTY(cli, `embed ${pending} block(s) now via ${where}?`);
         },
     });
-    if (cli.flags.mode !== "human") {
-        cli.io.out(JSON.stringify({ repo: slug, repoId, source: sourceName, root: abs, ingested: swept.ingested.length, ...(drained ? { embedded: drained.embedded } : {}) }));
-        return EXIT_OK;
-    }
+    if (cli.flags.mode !== "human")
+        return emitMachine(cli, { repo: slug, repoId, source: sourceName, root: abs, ingested: swept.ingested.length, ...(drained ? { embedded: drained.embedded } : {}) });
     const { render, style, io } = cli;
     io.out(`  ${render.g.diamond} ${style.accent(slug)} ← ${style.path(shortenHome(abs))}  ${style.dim(`${swept.ingested.length} files`)}`);
     if (drained)
@@ -146,23 +146,13 @@ async function runAdd(cli, args) {
 function runList(cli) {
     const ws = cli.workspace();
     const sources = listSources(ws.store).map((s) => ({ ...s, repos: attachedRepoSlugs(cli, ws, s.sourceId) }));
-    if (cli.flags.mode === "json") {
-        cli.io.out(JSON.stringify(sources.map((s) => ({ name: s.name, adapter: s.adapter, config: s.config, repos: s.repos }))));
-        return EXIT_OK;
-    }
-    if (cli.flags.mode === "jsonl") {
-        for (const s of sources)
-            cli.io.out(JSON.stringify({ name: s.name, adapter: s.adapter, config: s.config, repos: s.repos }));
-        return EXIT_OK;
-    }
-    if (cli.flags.mode === "ids") {
-        for (const s of sources)
-            cli.io.out(s.name);
-        return EXIT_OK;
+    if (cli.flags.mode !== "human") {
+        const rows = sources.map((s) => ({ name: s.name, adapter: s.adapter, config: s.config, repos: s.repos }));
+        return emitMachine(cli, rows, { items: rows, ids: rows.map((r) => r.name) });
     }
     const { style, io } = cli;
     if (sources.length === 0) {
-        io.out(style.dim("  no sources registered"));
+        io.err(style.dim("  no sources registered"));
         return EXIT_OK;
     }
     const rows = sources.map((s) => [
@@ -189,10 +179,8 @@ function runAttachDetach(cli, args, verb) {
         attachSourceToRepo(ws.store, repo.repoId, source.sourceId);
     else
         detachSourceFromRepo(ws.store, repo.repoId, source.sourceId);
-    if (cli.flags.mode !== "human") {
-        cli.io.out(JSON.stringify({ source: name, repo: repo.slug, attached: verb === "attach" }));
-        return EXIT_OK;
-    }
+    if (cli.flags.mode !== "human")
+        return emitMachine(cli, { source: name, repo: repo.slug, attached: verb === "attach" });
     cli.io.out(`  ${cli.render.g.ok} ${verb === "attach" ? "attached" : "detached"} ${cli.style.accent(name)} ${verb === "attach" ? "→" : "⇸"} ${cli.style.accent(repo.slug)}`);
     return EXIT_OK;
 }
@@ -206,10 +194,8 @@ function runRm(cli, args) {
     if (!source)
         throw new EngineErrorLike("target_missing", `no source named '${name}'`);
     deleteSource(ws.store, source.sourceId);
-    if (cli.flags.mode !== "human") {
-        cli.io.out(JSON.stringify({ source: name, deleted: true }));
-        return EXIT_OK;
-    }
+    if (cli.flags.mode !== "human")
+        return emitMachine(cli, { source: name, deleted: true });
     cli.io.out(`  ${cli.render.g.ok} deleted source ${cli.style.accent(name)}`);
     return EXIT_OK;
 }