@vincentt-xr/cli 0.6.0 → 0.8.0

package/dist/cli/args.d.ts

@@ -13,7 +13,14 @@ export declare function isHelpInvocation(args: string[]): boolean;
  * skip a publish the creator asked for. Anywhere else it stays an unknown flag.
  */
 export declare function isVersionInvocation(args: string[]): boolean;
-/** Flags that stand alone; every other `--flag` consumes the next argument. */
+/**
+ * Flags that stand alone; every other `--flag` consumes the next argument.
+ *
+ * A boolean flag missing from this set silently eats the argument after it. For
+ * `vincentt assets add --download lib_7f3a…` that would swallow the asset id and
+ * leave the command with nothing to resolve, so every new boolean belongs here at
+ * the moment it is introduced.
+ */
 export declare const BOOLEAN_FLAGS: Set<string>;
 export declare function refusedFlag(args: string[]): string | undefined;
 /**

package/dist/cli/args.js

@@ -17,7 +17,14 @@ export function isHelpInvocation(args) {
 export function isVersionInvocation(args) {
     return args[0] === "--version" || args[0] === "-v";
 }
-/** Flags that stand alone; every other `--flag` consumes the next argument. */
+/**
+ * Flags that stand alone; every other `--flag` consumes the next argument.
+ *
+ * A boolean flag missing from this set silently eats the argument after it. For
+ * `vincentt assets add --download lib_7f3a…` that would swallow the asset id and
+ * leave the command with nothing to resolve, so every new boolean belongs here at
+ * the moment it is introduced.
+ */
 export const BOOLEAN_FLAGS = new Set([
     "--force",
     "--preview",
@@ -29,9 +36,11 @@ export const BOOLEAN_FLAGS = new Set([
     "--restart",
     "--no-qr",
     "--verbose",
+    "--send",
     "--no-install",
     "--allow-custom-api",
     "--yes",
+    "--download",
     "--help",
     "-h",
 ]);

package/dist/cli/index.js

@@ -18,7 +18,7 @@ import { runPkceLogin } from "../login/pkceLogin.js";
 import { httpAuthBackend } from "../login/authBackend.js";
 import { loginCommand } from "../login/loginCommand.js";
 import { ensureLoggedIn } from "../login/ensure.js";
-import { clearMachineToken, loadMachineConfig, locateProjectBinding, resolveConfig, MACHINE_CONFIG_PATH, } from "../shared/config.js";
+import { clearMachineToken, loadMachineConfig, locateProjectBinding, resolveConfig, writeDxEnablement, MACHINE_CONFIG_PATH, } from "../shared/config.js";
 import { getMe, ProjectUnreachableError } from "../lib/backend.js";
 import { initCommand } from "../lib/initCommand.js";
 import { linkCommand, printUnreachable, unlinkCommand } from "../lib/projects.js";
@@ -36,7 +36,12 @@ import { renderTerminalQr, shouldRenderQr } from "../preview/qr.js";
 import { PreviewConflictError, PreviewRateLimitedError } from "../preview/api.js";
 import { fetchNext, readCursor, writeCursor } from "../lib/feedback.js";
 import { record as recordInvocation } from "../dx/journal.js";
-import { runDx } from "../dx/command.js";
+import { dxDisableCommand, dxEnableCommand, dxSendCommand, parseDxOptions, runDx, } from "../dx/command.js";
+import { DX_UNATTENDED_SUNSET, loadEnablement } from "../dx/enablement.js";
+import { journalEnabled, journalPath, readJournal } from "../dx/journal.js";
+import { postReport } from "../dx/send.js";
+import { nudgeFor } from "../dx/nudge.js";
+import { verbOf } from "../dx/skeleton.js";
 import { isHelpInvocation, isVersionInvocation, positionalArgs, refusedFlag, } from "./args.js";
 // The console origin serves /cli-auth (the browser target for `vincentt login`). VINCENTT_
 // CONSOLE_URL overrides for dev/dogfood; VINCENTT_EDITOR_URL is honored as a legacy alias.
@@ -576,6 +581,151 @@ async function version() {
     for (const line of renderVersion(report))
         console.log(line);
 }
+// ---- dx ---------------------------------------------------------------------
+async function dx() {
+    const options = parseDxOptions(argv);
+    const now = Date.now();
+    // Both descriptors, matching publish and init. stdin alone let
+    // `vincentt dx --send --yes > out.txt` through — a redirected stdout is
+    // precisely the case where nobody reads what was disclosed.
+    const interactive = () => Boolean(process.stdin.isTTY && process.stdout.isTTY);
+    if (options.enable || options.disable) {
+        const deps = {
+            print: (l) => console.log(l),
+            now: () => now,
+            interactive,
+            confirm: (q) => stdinConfirm()(`  ${q} [y/N] `, false),
+            // `enable` does NOT require being signed in. --send refuses without a PAT
+            // regardless, so a config holding only enablement keys is inert; and
+            // ordering the two verbs ("you must log in before you may state a
+            // preference") would be a rule with no safety behind it.
+            save: async (next) => {
+                await writeDxEnablement(next);
+            },
+        };
+        process.exitCode = options.enable
+            ? await dxEnableCommand(deps, DX_UNATTENDED_SUNSET)
+            : await dxDisableCommand(deps);
+        return;
+    }
+    // Read strictly and independently of auth: a truncated config must disable the
+    // relaxation, not throw through it.
+    const enablement = await loadEnablement(now);
+    if (!options.send) {
+        process.exitCode = runDx(argv, (l) => console.log(l), () => enablement);
+        return;
+    }
+    // `--send` is the one path out of this machine, so it resolves auth the way
+    // every other authed verb does and refuses rather than guessing.
+    process.exitCode = await dxSendCommand({
+        entries: readJournal,
+        print: (l) => console.log(l),
+        now: () => now,
+        enabled: () => journalEnabled(),
+        path: journalPath,
+        cliVersion,
+        auth: async () => {
+            // resolveConfig THROWS when there is no PAT, and its message is written
+            // for a verb that cannot proceed at all. Sending a DX report is
+            // optional, so a signed-out creator gets one plain line from
+            // dxSendCommand instead of a config-file stack trace.
+            try {
+                const cfg = await resolveConfig(projectDir(), {
+                    allowCustomApi: has("--allow-custom-api"),
+                });
+                return cfg.pat ? { apiUrl: cfg.apiUrl, pat: cfg.pat } : undefined;
+            }
+            catch {
+                return undefined;
+            }
+        },
+        post: (apiUrl, pat, report) => postReport(apiUrl, pat, report),
+        confirm: (q) => stdinConfirm()(`${q} [y/N] `, false),
+        interactive,
+        enablement: () => enablement,
+    }, options);
+}
+// ---- assets (f5) ------------------------------------------------------------
+/**
+ * `vincentt assets <search|show|add>` — the CLI's FIRST nested subcommand group,
+ * so this is one `case` with an inner switch rather than a new flat verb.
+ *
+ * The whole group is gated on being signed in, and every screen it prints goes to
+ * STDERR: under `--json` stdout must carry only the JSON document, so an agent
+ * piping stdout into a parser never gets a mixed stream.
+ */
+async function assets() {
+    const sub = positional(1);
+    if (sub === undefined) {
+        console.error("Usage: vincentt assets <search|show|add> [options]");
+        process.exitCode = 1;
+        return;
+    }
+    if (sub !== "search" && sub !== "show" && sub !== "add") {
+        console.error(`Unknown assets command: ${sub}`);
+        console.error("Usage: vincentt assets <search|show|add> [options]");
+        process.exitCode = 1;
+        return;
+    }
+    const { httpLibraryClient } = await import("../library/client.js");
+    const { assetsAdd, assetsSearch, assetsShow } = await import("../library/assetsCommand.js");
+    const cwd = projectDir();
+    let cfg;
+    try {
+        cfg = await resolveConfig(cwd, {
+            allowCustomApi: has("--allow-custom-api"),
+            warn: (l) => console.error(l),
+        });
+    }
+    catch {
+        // Not signed in — the exit-4 screen, because we did not answer. The library is
+        // a platform call, and the creator's PROJECT is unaffected either way.
+        const { unreachableLines } = await import("../library/render.js");
+        for (const l of unreachableLines("auth", "vincentt assets search \"<what you want>\"")) {
+            console.error(l);
+        }
+        process.exitCode = 4;
+        return;
+    }
+    const deps = {
+        out: (l) => console.log(l),
+        err: (l) => console.error(l),
+        client: httpLibraryClient(cfg),
+        cwd,
+    };
+    const json = has("--json");
+    if (sub === "search") {
+        // The query is the bare argument after `search`; the remaining positionals are
+        // ignored rather than concatenated, so a quoting mistake fails loudly.
+        const query = positional(2);
+        if (query === undefined) {
+            console.error('Usage: vincentt assets search "<query>" [--kind prop|frame] [--limit N]');
+            process.exitCode = 1;
+            return;
+        }
+        process.exitCode = await assetsSearch(deps, {
+            query,
+            kind: flag("--kind"),
+            render: flag("--render"),
+            palette: flag("--palette"),
+            limit: flag("--limit"),
+            json,
+        });
+        return;
+    }
+    const ids = positionalArgs(argv).slice(2);
+    if (sub === "show") {
+        process.exitCode = await assetsShow(deps, { ids, json });
+        return;
+    }
+    process.exitCode = await assetsAdd(deps, {
+        ids,
+        json,
+        download: has("--download"),
+        force: has("--force"),
+        dir: flag("--dir"),
+    });
+}
 // ---- servers ----------------------------------------------------------------
 async function relay() {
     const { startRelay } = await import("../relay/server.js");
@@ -623,6 +773,15 @@ function usage() {
         `                       --tester t1 filters to one tester (one tab, across\n` +
         `                       its refreshes). --viewer <label> filters to a single\n` +
         `                       connection; one tab opens several.\n\n` +
+        `Asset library\n` +
+        `  assets search "<query>"   Find curated assets   [--kind prop|frame]\n` +
+        `                              [--render 3d-clay] [--palette sage] [--limit 20] [--json]\n` +
+        `  assets show <id> [<id>…]  Everything known about an asset            [--json]\n` +
+        `  assets add <id> [<id>…]   Print the URLs to reference from your source\n` +
+        `                              Writes nothing. [--download [--dir <path>] [--force]]\n` +
+        `                              [--json]\n` +
+        `                              Ids look like lib_7f3a2c67d4e5b6a7; search returns\n` +
+        `                              them. Reference only ids the tool returned.\n\n` +
         `Reverse channel\n` +
         `  feedback --wait    Block for the next phone annotation, print it, exit\n` +
         `  feedback --watch   Stream annotations as they arrive\n\n` +
@@ -631,7 +790,14 @@ function usage() {
         `Meta\n` +
         `  version            CLI version, and the API this machine resolves to\n` +
         `  dx                 Where this dev loop fought you  [--days <n>] [--json]\n` +
-        `                       Reads a local journal of your own runs. Never sent.\n\n` +
+        `                       Reads a local journal of your own runs. Local by default.\n` +
+        `                       --send reports the findings to the Vincentt team; it\n` +
+        `                       shows the exact payload and asks first. [--note <text>]\n` +
+        `  dx enable          Allow reports to be sent from this machine without asking.\n` +
+        `                       Asks you to confirm in your terminal. Stays on until you\n` +
+        `                       disable it, and is shown on \`vincentt dx\` and\n` +
+        `                       \`vincentt version\` while on.\n` +
+        `  dx disable         Turn that off again.\n\n` +
         `Common options: --dir <path> (project dir, default cwd)\n` +
         `                --allow-custom-api  honor a binding's apiUrl override\n`);
 }
@@ -679,9 +845,10 @@ async function main() {
             return feedback();
         case "relay":
             return relay();
+        case "assets":
+            return assets();
         case "dx":
-            process.exitCode = runDx(argv, (l) => console.log(l));
-            return;
+            return dx();
         default:
             // Flow L30: rolling back and taking an address offline are console
             // actions, and a bare "unknown command" here would be the product failing
@@ -708,6 +875,24 @@ function journal(exitCode, error) {
         exitCode,
         error,
     });
+    // The hint goes out AFTER the run it is about, so it reads as a footnote to
+    // what just happened rather than a warning about what is about to. Never on
+    // `dx` itself — telling someone reading the friction report that they could
+    // read the friction report is noise.
+    if (verbOf(argv) === "dx")
+        return;
+    try {
+        // STDERR, not stdout. This is human narration appended after EVERY verb, so on
+        // any `--json` invocation it would land inside the document an agent is piping
+        // into a parser and corrupt it. Whether that happened was down to the nudge's
+        // own timing heuristic, which makes it the worst kind of intermittent: green in
+        // a test run, broken on a creator's machine a week later.
+        for (const l of nudgeFor(readJournal(), Date.now()))
+            console.error(l);
+    }
+    catch {
+        // A hint that can break a publish is not worth having.
+    }
 }
 main()
     .then(() => {

package/dist/dx/command.d.ts

@@ -1,17 +1,107 @@
+import type { Enablement } from "./enablement.js";
 import type { JournalEntry } from "./journal.js";
+import type { WireReport } from "./send.js";
 export interface DxDeps {
     entries: () => JournalEntry[];
     print: (line: string) => void;
     now: () => number;
     enabled: () => boolean;
     path: () => string;
+    /**
+     * Durable unattended-send state. Optional so the many callers that only read
+     * the journal need not resolve it; absent reads as not enabled.
+     */
+    enablement?: () => Enablement;
 }
 export interface DxOptions {
     /** Only consider runs from the last N days. */
     days: number;
     json: boolean;
+    /** Send the findings to the Vincentt team. Never implied by anything else. */
+    send: boolean;
+    /** Skip the confirmation prompt. Only meaningful with --send. */
+    yes: boolean;
+    /** The creator's own words about the friction, carried with the report. */
+    note?: string;
+    /** `vincentt dx enable` — a positional subcommand, not a flag. */
+    enable: boolean;
+    /** `vincentt dx disable` — a positional subcommand, not a flag. */
+    disable: boolean;
 }
 export declare function parseDxOptions(args: string[]): DxOptions;
 export declare function dxCommand(deps: DxDeps, options: DxOptions): number;
 /** Wire the command to the real journal. */
-export declare function runDx(args: string[], print: (line: string) => void): number;
+export declare function runDx(args: string[], print: (line: string) => void, enablement?: () => Enablement): number;
+export interface DxEnableDeps {
+    print: (line: string) => void;
+    now: () => number;
+    /** stdin.isTTY && stdout.isTTY. Evidence of an interactive session, not proof of a human. */
+    interactive: () => boolean;
+    /** Ask once. Returns false to abort. */
+    confirm: (question: string) => Promise<boolean>;
+    /**
+     * Persist the grant, or clear it when given undefined. NEVER called on a
+     * refusal path — `enable` that refuses must not touch the file at all.
+     */
+    save: (next: {
+        at: string;
+    } | undefined) => Promise<void>;
+}
+/**
+ * `vincentt dx enable` — grant this machine durable permission to send DX reports
+ * without asking first.
+ *
+ * The TTY requirement is a SPEED BUMP, NOT A BOUNDARY, and is written down as
+ * such so a later reader does not build on a guarantee that is not there. It
+ * stops the reflex — an agent that meets a prompt, infers there must be a way
+ * past it, and tries the obvious thing. It does not stop a caller that allocates
+ * a PTY or writes config.json directly.
+ *
+ * The refusal path writes NOTHING. Not "writes the same bytes back" — nothing at
+ * all: this file holds the PAT, and a refusal that round-trips the config through
+ * a write can lose the credential if it dies mid-write.
+ */
+export declare function dxEnableCommand(deps: DxEnableDeps, sunset: number): Promise<number>;
+/**
+ * `vincentt dx disable` — the obvious opposite command.
+ *
+ * Clears BOTH keys. Leaving the timestamp behind would make a later re-enable
+ * report its age from the first grant, which is the kind of thing that ships
+ * wrong and is never noticed. Needs no terminal and no confirmation: turning a
+ * capability OFF is always safe to do, and requiring a TTY here would strand a
+ * creator who wanted to revoke from a script.
+ */
+export declare function dxDisableCommand(deps: DxEnableDeps): Promise<number>;
+export interface DxSendDeps extends DxDeps {
+    /** Resolved API host + PAT. Absent when the creator is not signed in. */
+    auth: () => Promise<{
+        apiUrl: string;
+        pat: string;
+    } | undefined>;
+    post: (apiUrl: string, pat: string, report: WireReport) => Promise<{
+        ref: string;
+        findings: number;
+        expiresAt: string;
+    }>;
+    /** Ask before sending. Returns false to abort. */
+    confirm: (question: string) => Promise<boolean>;
+    cliVersion: () => string;
+    /**
+     * stdin.isTTY && stdout.isTTY. Evidence of an INTERACTIVE SESSION, not proof of
+     * a human: an agent harness that allocates a PTY passes this with nobody
+     * present. The enabled path below is the honest one; this arm gates
+     * convenience, not authorization.
+     */
+    interactive: () => boolean;
+    /** Durable unattended-send state, read strictly. Absent reads as not enabled. */
+    enablement?: () => Enablement;
+}
+/**
+ * `vincentt dx --send`.
+ *
+ * The order is the consent model and is not an implementation detail: find the
+ * friction, BUILD the payload, SHOW it in full, ask, and only then send. A
+ * creator who cannot see what leaves their machine before it leaves has not
+ * agreed to anything.
+ */
+export declare function dxSendCommand(deps: DxSendDeps, options: DxOptions): Promise<number>;

package/dist/dx/command.js

@@ -1,12 +1,26 @@
 import { findClusters, rankClusters } from "./clusters.js";
+import { enablementLine } from "./enablement.js";
 import { journalEnabled, journalPath, readJournal } from "./journal.js";
+import { buildReport, renderPayload } from "./send.js";
 const DEFAULT_DAYS = 7;
 export function parseDxOptions(args) {
     const i = args.indexOf("--days");
     const raw = i !== -1 ? Number(args[i + 1]) : NaN;
+    const n = args.indexOf("--note");
+    const note = n !== -1 ? args[n + 1] : undefined;
+    // Positional, and read only from the slot right after the verb: `--note enable`
+    // is a note, not a subcommand. Deliberately NOT flags — a flag form
+    // (`--enable`) would be one more thing an agent can append to a command it is
+    // already running, which is the shape this whole gate exists to refuse.
+    const sub = args[0] === "dx" ? args[1] : args[0];
     return {
         days: Number.isFinite(raw) && raw > 0 ? raw : DEFAULT_DAYS,
         json: args.includes("--json"),
+        send: args.includes("--send"),
+        yes: args.includes("--yes"),
+        note: note !== undefined && !note.startsWith("-") ? note : undefined,
+        enable: sub === "enable",
+        disable: sub === "disable",
     };
 }
 function withinDays(entries, days, now) {
@@ -54,8 +68,20 @@ export function dxCommand(deps, options) {
     }
     const entries = withinDays(all, options.days, deps.now());
     const clusters = rankClusters(findClusters(entries));
+    const enablement = deps.enablement?.() ?? { enabled: false };
     if (options.json) {
-        deps.print(JSON.stringify({ window: `${options.days}d`, runs: entries.length, clusters }, null, 2));
+        // The JSON object carries enablement as FIELDS because --json is the path an
+        // AGENT reads, and an agent that can send unattended should be able to see
+        // that it can.
+        deps.print(JSON.stringify({
+            window: `${options.days}d`,
+            runs: entries.length,
+            clusters,
+            dxSendEnabled: enablement.enabled,
+            ...(enablement.enabled && enablement.at !== undefined
+                ? { dxSendEnabledAt: enablement.at }
+                : {}),
+        }, null, 2));
         return 0;
     }
     deps.print(`${entries.length} runs in the last ${options.days} days.`);
@@ -81,15 +107,200 @@ export function dxCommand(deps, options) {
     // and a claim only made on some runs is one a reader cannot rely on.
     deps.print("");
     deps.print(`Journal: ${deps.path()} (local only, never sent)`);
+    // Beside it, and ONLY when enabled. Enablement is durable and has no expiry, so
+    // this line is the mitigation rather than a status decoration; printing an
+    // `off` counterpart on every run is how it would get skimmed past.
+    const line = enablementLine(enablement, deps.now());
+    if (line !== undefined)
+        deps.print(line);
     return 0;
 }
 /** Wire the command to the real journal. */
-export function runDx(args, print) {
+export function runDx(args, print, enablement = () => ({ enabled: false })) {
     return dxCommand({
         entries: readJournal,
         print,
         now: () => Date.now(),
         enabled: () => journalEnabled(),
         path: journalPath,
+        enablement,
     }, parseDxOptions(args));
 }
+/** A date a human can read, for the sunset refusal. */
+function sunsetDate(sunset) {
+    return new Date(sunset).toISOString().slice(0, 10);
+}
+/**
+ * `vincentt dx enable` — grant this machine durable permission to send DX reports
+ * without asking first.
+ *
+ * The TTY requirement is a SPEED BUMP, NOT A BOUNDARY, and is written down as
+ * such so a later reader does not build on a guarantee that is not there. It
+ * stops the reflex — an agent that meets a prompt, infers there must be a way
+ * past it, and tries the obvious thing. It does not stop a caller that allocates
+ * a PTY or writes config.json directly.
+ *
+ * The refusal path writes NOTHING. Not "writes the same bytes back" — nothing at
+ * all: this file holds the PAT, and a refusal that round-trips the config through
+ * a write can lose the credential if it dies mid-write.
+ */
+export async function dxEnableCommand(deps, sunset) {
+    if (deps.now() >= sunset) {
+        deps.print("");
+        deps.print(`  Unattended DX submission ended on ${sunsetDate(sunset)} and can no longer be enabled.`);
+        deps.print("  Reports can still be sent from your own terminal.");
+        deps.print("");
+        return 1;
+    }
+    if (!deps.interactive()) {
+        deps.print("");
+        deps.print("  Enabling unattended sending needs a terminal to ask in, and this");
+        deps.print("  session has none. Nothing was changed.");
+        deps.print("");
+        deps.print("  Run `vincentt dx enable` yourself, in your own terminal.");
+        deps.print("");
+        return 1;
+    }
+    // What is being granted, INCLUDING the note risk. The note is the part a
+    // creator does not picture: enablement is what lets an agent compose prose they
+    // have not read and put it on the wire.
+    deps.print("");
+    deps.print("  Unattended DX submission");
+    deps.print("");
+    deps.print("  Your agent will be able to send friction reports from this machine without");
+    deps.print("  asking you first. A report includes a note, which is sent exactly as written.");
+    deps.print("  An agent may compose a note you have not read.");
+    deps.print("");
+    deps.print("  This stays on until you run `vincentt dx disable`.");
+    deps.print("");
+    if (!(await deps.confirm("Enable on this machine?"))) {
+        deps.print("");
+        deps.print("  Not enabled.");
+        deps.print("");
+        return 0;
+    }
+    // Written on every enable, so the age reports from the LATEST grant rather than
+    // the first — a re-enable is a fresh decision and dates from when it was made.
+    await deps.save({ at: new Date(deps.now()).toISOString() });
+    deps.print("");
+    deps.print("  Enabled. Reports may now be sent without a prompt.");
+    deps.print("");
+    return 0;
+}
+/**
+ * `vincentt dx disable` — the obvious opposite command.
+ *
+ * Clears BOTH keys. Leaving the timestamp behind would make a later re-enable
+ * report its age from the first grant, which is the kind of thing that ships
+ * wrong and is never noticed. Needs no terminal and no confirmation: turning a
+ * capability OFF is always safe to do, and requiring a TTY here would strand a
+ * creator who wanted to revoke from a script.
+ */
+export async function dxDisableCommand(deps) {
+    await deps.save(undefined);
+    deps.print("");
+    deps.print("  Unattended sending is off. Reports need your confirmation again.");
+    deps.print("");
+    return 0;
+}
+/**
+ * `vincentt dx --send`.
+ *
+ * The order is the consent model and is not an implementation detail: find the
+ * friction, BUILD the payload, SHOW it in full, ask, and only then send. A
+ * creator who cannot see what leaves their machine before it leaves has not
+ * agreed to anything.
+ */
+export async function dxSendCommand(deps, options) {
+    if (!deps.enabled()) {
+        deps.print("The DX journal is off (VINCENTT_DX_JOURNAL=0). There is nothing to send.");
+        return 0;
+    }
+    const entries = withinDays(deps.entries(), options.days, deps.now());
+    const clusters = rankClusters(findClusters(entries));
+    if (clusters.length === 0) {
+        // Nothing to report is a result, not a failure. Sending an empty report
+        // would cost the creator a round trip to tell us nothing.
+        deps.print(`No friction detected in the last ${options.days} days — nothing to send.`);
+        return 0;
+    }
+    // SENDING requires either an interactive session or durable enablement — the
+    // gate is on --send, not on --yes.
+    //
+    // The nudge prints into an agent's transcript, and an agent that reads it has
+    // every incentive to act: it just failed four times. Its reflex for an
+    // interactive prompt is to add --yes. That path ends with the AGENT deciding
+    // to transmit, supplying the note, and the human seeing the payload scroll
+    // past in a transcript they may not be reading — which is not the opt-in this
+    // feature is built around.
+    //
+    // The gate used to sit on --yes, on the premise that the bare path was safe
+    // because "the prompt reads EOF under a pipe and fails closed". That premise
+    // was false: an empty pipe abandoned the promise rather than refusing, and a
+    // pipe carrying a line answered it — `echo y | vincentt dx --send` transmitted
+    // with no terminal and no human. --yes was never the boundary; --send is, so
+    // the check sits on the act being authorized rather than on a flag that only
+    // modifies how it is confirmed.
+    //
+    // The second arm is the SUPPORTED unattended path: a person, at a terminal,
+    // ran `vincentt dx enable` on this machine. That is a prior deliberate act
+    // rather than a per-send answer, which is what makes it consent at all.
+    const enablement = deps.enablement?.() ?? { enabled: false };
+    const interactive = deps.interactive();
+    if (!interactive && !enablement.enabled) {
+        // This refusal NAMES the enabling command. A refusal is an answer to a
+        // command the caller typed, which makes it SOLICITED output — the
+        // prohibition is on UNBIDDEN output instructing a caller (the nudge names
+        // neither `enable` nor `--send`, and still must not). A refusal naming
+        // nothing satisfies the letter of that rule and leaves a human at exit 1
+        // with no path forward, for no security gain: guessability was never the
+        // threat.
+        deps.print("Sending a report needs your confirmation, and this session has no terminal");
+        deps.print("to ask in. Run `vincentt dx enable` yourself to allow reports from this");
+        deps.print("machine, or run `vincentt dx --send` in your own terminal.");
+        return 1;
+    }
+    const auth = await deps.auth();
+    if (auth === undefined) {
+        deps.print("Not signed in. Run `vincentt login` to send a report.");
+        return 1;
+    }
+    const report = buildReport(clusters, deps.cliVersion(), options.note);
+    // Above the payload, on the unattended path only: name that this is enabled,
+    // how old the grant is, and that nothing is going to ask.
+    const unattended = !interactive && enablement.enabled;
+    if (unattended) {
+        const line = enablementLine(enablement, deps.now());
+        if (line !== undefined) {
+            deps.print("");
+            deps.print(`${line}. Not asking.`);
+        }
+    }
+    // renderPayload runs on EVERY path, including the unattended one. This is
+    // DISCLOSURE, NOT CONSENT: on the attended path it is what the creator answers
+    // to; unattended it is a forensic artifact that answers "what did we send"
+    // after the fact. Worth its one print, and not to be cited as carrying the
+    // weight the question used to. Only the ASK is ever skipped, never the SHOW.
+    for (const l of renderPayload(report))
+        deps.print(l);
+    deps.print("");
+    // The enabled machine does not ask. --yes still means only "skip the question"
+    // and is inert without one of the two arms above.
+    if (!unattended && !options.yes && !(await deps.confirm("Send this report?"))) {
+        deps.print("Not sent.");
+        return 0;
+    }
+    try {
+        const res = await deps.post(auth.apiUrl, auth.pat, report);
+        deps.print("");
+        deps.print(`✓ Reported — ${res.findings} ${res.findings === 1 ? "finding" : "findings"}, ref ${res.ref}`);
+        deps.print(`  Kept until ${res.expiresAt}, then deleted.`);
+        deps.print("  Your journal stays on this machine.");
+        return 0;
+    }
+    catch (err) {
+        deps.print("");
+        deps.print(`✗ ${err instanceof Error ? err.message : String(err)}`);
+        return 1;
+    }
+}