@vincentt-xr/cli 0.7.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",
@@ -33,6 +40,7 @@ export const BOOLEAN_FLAGS = new Set([
     "--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,8 @@ 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 { dxSendCommand, parseDxOptions, 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";
@@ -583,8 +584,35 @@ async function version() {
 // ---- 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));
+        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
@@ -592,7 +620,7 @@ async function dx() {
     process.exitCode = await dxSendCommand({
         entries: readJournal,
         print: (l) => console.log(l),
-        now: () => Date.now(),
+        now: () => now,
         enabled: () => journalEnabled(),
         path: journalPath,
         cliVersion,
@@ -613,9 +641,91 @@ async function dx() {
         },
         post: (apiUrl, pat, report) => postReport(apiUrl, pat, report),
         confirm: (q) => stdinConfirm()(`${q} [y/N] `, false),
-        interactive: () => Boolean(process.stdin.isTTY),
+        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");
@@ -663,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` +
@@ -673,7 +792,12 @@ function usage() {
         `  dx                 Where this dev loop fought you  [--days <n>] [--json]\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\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`);
 }
@@ -721,6 +845,8 @@ async function main() {
             return feedback();
         case "relay":
             return relay();
+        case "assets":
+            return assets();
         case "dx":
             return dx();
         default:
@@ -756,8 +882,13 @@ function journal(exitCode, error) {
     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.log(l);
+            console.error(l);
     }
     catch {
         // A hint that can break a publish is not worth having.

package/dist/dx/command.d.ts

@@ -1,3 +1,4 @@
+import type { Enablement } from "./enablement.js";
 import type { JournalEntry } from "./journal.js";
 import type { WireReport } from "./send.js";
 export interface DxDeps {
@@ -6,6 +7,11 @@ export interface DxDeps {
     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. */
@@ -17,11 +23,55 @@ export interface DxOptions {
     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<{
@@ -36,8 +86,15 @@ export interface DxSendDeps extends DxDeps {
     /** Ask before sending. Returns false to abort. */
     confirm: (question: string) => Promise<boolean>;
     cliVersion: () => string;
-    /** True when stdin is a terminal — i.e. a human is here to answer. */
+    /**
+     * 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`.

package/dist/dx/command.js

@@ -1,4 +1,5 @@
 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;
@@ -7,12 +8,19 @@ export function parseDxOptions(args) {
     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) {
@@ -60,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.`);
@@ -87,18 +107,102 @@ 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`.
  *
@@ -120,7 +224,8 @@ export async function dxSendCommand(deps, options) {
         deps.print(`No friction detected in the last ${options.days} days — nothing to send.`);
         return 0;
     }
-    // --yes REQUIRES a terminal.
+    // 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
@@ -129,13 +234,30 @@ export async function dxSendCommand(deps, options) {
     // past in a transcript they may not be reading — which is not the opt-in this
     // feature is built around.
     //
-    // Without --yes there is no such path: the prompt reads EOF under a pipe and
-    // fails closed. So the gate is narrow on purpose — it closes the one way an
-    // autonomous caller could consent on a creator's behalf, and leaves --yes
-    // working for the human who has read the payload.
-    if (options.yes && !deps.interactive()) {
-        deps.print("Sending a DX report is the creator's call, so --yes needs a terminal.");
-        deps.print("Run `vincentt dx --send` yourself, or drop --yes to be asked.");
+    // 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();
@@ -144,10 +266,27 @@ export async function dxSendCommand(deps, options) {
         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("");
-    if (!options.yes && !(await deps.confirm("Send this report?"))) {
+    // 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;
     }

package/dist/dx/enablement.d.ts

@@ -0,0 +1,51 @@
+/**
+ * The product-lifetime bound on an explicitly internal-beta capability. Past this
+ * date `enable` refuses AND an existing flag stops being honored, so FORGETTING
+ * THIS TURNS THE FEATURE OFF — the safe direction.
+ *
+ * This is deliberately a constant in shipped code rather than a CI test with a
+ * hard-coded date: such a test fires in an uninvolved engineer's lap at a moment
+ * with no context, and the cheapest green is bumping the constant. Reaching this
+ * date is a decision to make (extend, or remove the feature), not a number to
+ * raise.
+ */
+export declare const DX_UNATTENDED_SUNSET: number;
+export interface Enablement {
+    enabled: boolean;
+    /** The raw ISO8601 grant time. Present only when `enabled` is true. */
+    at?: string;
+}
+/**
+ * Decide enablement from an already-parsed config object. Pure, and STRICT:
+ * identity against `true`, never truthiness.
+ *
+ * Truthiness fails OPEN on `"false"`, `"0"`, `{}`, `[]`, `1`, and `"garbage"` —
+ * every one of those is truthy in JavaScript. The worst is `"false"`, which is
+ * what a person hand-editing this file writes when they are trying to turn the
+ * feature OFF; `{}` is what a refactor grouping the two fields produces. A gate
+ * that reads a creator's "off" as "on" is inverted, not merely loose.
+ */
+export declare function readEnablement(cfg: unknown, now: number): Enablement;
+/**
+ * Read enablement from the real machine config.
+ *
+ * Wrapped in its OWN try/catch, independent of the auth read, because
+ * `readJsonIfExists` rethrows everything that is not ENOENT: a truncated
+ * config.json must DISABLE the relaxation, not throw through it and take an
+ * unrelated verb down with it.
+ */
+export declare function loadEnablement(now: number): Promise<Enablement>;
+/** Whole days elapsed, floored, never negative — a clock skew must not print `(-2 days)`. */
+export declare function ageInDays(at: string, now: number): number;
+/** The calendar day of the grant, in UTC. The time of day is noise at this age scale. */
+export declare function grantedOn(at: string): string;
+/**
+ * The one visibility line, in the single pinned shape every human surface uses:
+ *
+ *   Unattended send: ENABLED since 2026-04-01 (145 days)
+ *
+ * Returns undefined when not enabled. Nothing is printed in that case, on
+ * purpose: a line that prints unconditionally is a line readers learn to skip,
+ * which would cost exactly the attention the enabled line needs.
+ */
+export declare function enablementLine(e: Enablement, now: number): string | undefined;