tonedial 0.1.0 → 0.1.2

package/dist/commands/set.js

@@ -1,20 +1,20 @@
-// `set`, `reset`, and `address`. One action: change state, then recompile, so the two cannot
+// `set`, `reset`, `address` and `persona`. Change state and recompile in one action, so they cannot
 // drift apart.
 //
 // Warnings never block. A user is entitled to a combination that reads badly, and the tool's
 // job is to say so. Every selected level remains unchanged, including contradictions.
 import { AXIS_DEFAULT, AXIS_ORDER, riskyAxes } from "../core/anchors.js";
 import { check as checkCombos, PERSONA_DESCRIPTION_MAX } from "../core/combos.js";
-import { AGE_BANDS, GENDERS, NOTE_MAX, SPEECH_LEVELS, ConfigError, SETTING_KEYS, isAxis, nearest, nearestAxis, serializeConfig, } from "../core/config.js";
+import { AGE_BANDS, GENDERS, SPEECH_LEVELS, ConfigError, SETTING_KEYS, isAxis, nearest, nearestAxis, serializeConfig, } from "../core/config.js";
 import { toCompileInput } from "../core/resolve.js";
 import { LANGUAGES, catalogue, isLanguage } from "../core/i18n.js";
 import { presetSettings, resolvePreset } from "../core/presets.js";
 import { dial } from "../ui/dial.js";
-import { budget, combination, humanText, riskWarnings } from "../ui/format.js";
-import { interactive } from "../ui/prompt.js";
+import { artifactSize, combination, humanText, riskWarnings } from "../ui/format.js";
+import { guardTerminal, interactive } from "../ui/prompt.js";
 import { createInterface } from "node:readline/promises";
 import { cells, padEnd, truncate, wrap } from "../ui/width.js";
-import { applyPlanned, planArtifact, planConfig, sizeWarning } from "./compile.js";
+import { applyPlanned, planArtifact, planConfig } from "./compile.js";
 /** A raw number is bucketed on write; the stored and compiled value is always the band. */
 function bucketAge(value, t, asJson) {
     if (AGE_BANDS.includes(value))
@@ -31,36 +31,15 @@ function bucketAge(value, t, asJson) {
 }
 /** The settable persona keys, in the order `set --help` and the error message list them. */
 const PERSONA_FIELDS = ["age", "gender", "self_ref", "user_ref", "note", "user", "agent"];
-const OBSERVABLE_WORDS = {
-    formal: "formality", polite: "formality", casual: "formality",
-    brief: "verbosity", concise: "verbosity", verbose: "verbosity", short: "verbosity",
-    swear: "profanity", profan: "profanity",
-    joke: "playfulness", funny: "playfulness", humour: "playfulness", humor: "playfulness",
-    harsh: "critique", critic: "critique", blunt: "critique",
-    praise: "flattery", compliment: "flattery", flatter: "flattery",
-    warm: "warmth", kind: "warmth", empath: "warmth",
-    opinion: "conviction", decisive: "conviction",
-    thorough: "care", proactive: "care",
-    obedient: "compliance", grumble: "compliance",
-    refuse: "refusal", boast: "bravado", brag: "bravado",
-};
-/** The note is a content channel, so `set` says what an axis would own better. It never edits. */
-function noteWarnings(note, t) {
-    const out = [];
-    if ([...note].length > NOTE_MAX) {
-        out.push(t.persona.noteOverCap([...note].length, NOTE_MAX));
-    }
-    const lower = note.toLowerCase();
-    const named = [...new Set(Object.entries(OBSERVABLE_WORDS)
-            .filter(([word]) => lower.includes(word))
-            .map(([, axis]) => axis))];
-    if (named.length) {
-        out.push(t.persona.noteNamesAxis(named));
+/** Report limitations in the final settings, never superseded interview answers. */
+export function settingsWarnings(config, t, asJson) {
+    const warnings = [];
+    if (config.safeword && [...config.safeword].length < 4) {
+        warnings.push(t.settings.safewordShort(asJson ? config.safeword : humanText(config.safeword)));
     }
-    return out;
+    return warnings;
 }
 function assign(config, key, value, t, asJson) {
-    const warnings = [];
     if (key === "guards") {
         throw new ConfigError(t.settings.guardsRetired);
     }
@@ -70,23 +49,20 @@ function assign(config, key, value, t, asJson) {
     if (key === "safeword") {
         const phrase = value.trim();
         config.safeword = phrase === "" ? null : phrase;
-        if (config.safeword && [...config.safeword].length < 4) {
-            warnings.push(t.settings.safewordShort(asJson ? config.safeword : humanText(config.safeword)));
-        }
-        return warnings;
+        return;
     }
     if (key === "speech_level") {
         if (!SPEECH_LEVELS.includes(value)) {
             throw new ConfigError(t.settings.speechLevel(SPEECH_LEVELS));
         }
         config.speech_level = value;
-        return warnings;
+        return;
     }
     if (key === "language") {
         if (!isLanguage(value))
             throw new ConfigError(t.errors.languageUnsupported(asJson ? value : humanText(value), LANGUAGES));
         config.language = value;
-        return warnings;
+        return;
     }
     if (key.startsWith("persona.")) {
         const field = key.slice("persona.".length);
@@ -109,8 +85,6 @@ function assign(config, key, value, t, asJson) {
                 break;
             case "note":
                 config.persona.note = empty ? null : value;
-                if (!empty)
-                    warnings.push(...noteWarnings(value, t));
                 break;
             case "user":
             case "agent": {
@@ -132,7 +106,7 @@ function assign(config, key, value, t, asJson) {
                 // first. An axis error already states its range; this one owed the same.
                 throw new ConfigError(t.persona.unknownField(asJson ? field : humanText(field), PERSONA_FIELDS));
         }
-        return warnings;
+        return;
     }
     if (key.startsWith("subagent.")) {
         throw new ConfigError(t.axis.subagentUnsupported);
@@ -154,10 +128,9 @@ function assign(config, key, value, t, asJson) {
         config.axes[key] = level;
         config.unsaved = true;
     }
-    return warnings;
 }
 function comboWarnings(config, t) {
-    return checkCombos(config.axes, config.persona, config.speech_level).map((w) => combination(w, t));
+    return checkCombos(config.axes).map((w) => combination(w, t));
 }
 const UNSET = "—";
 /**
@@ -221,16 +194,12 @@ function readKey(config, key, t) {
  */
 function applyPairs(config, pairs, t, asJson) {
     const settingsBefore = JSON.stringify(presetSettings(config));
-    const warnings = [];
     const changed = [];
     const moves = [];
-    let personaTouched = false;
     for (const [key, value] of pairs) {
         const before = readKey(config, key, t);
-        warnings.push(...assign(config, key, value, t, asJson));
+        assign(config, key, value, t, asJson);
         changed.push(key);
-        if (key.startsWith("persona.") && value.trim() !== "")
-            personaTouched = true;
         const after = readKey(config, key, t);
         // Only a real move. `set formality=3` on an axis already at 3 was reporting `3 → 3`, which
         // is the misleading `from` this line exists to prevent.
@@ -240,9 +209,7 @@ function applyPairs(config, pairs, t, asJson) {
     }
     if (settingsBefore !== JSON.stringify(presetSettings(config)))
         config.unsaved = true;
-    if (personaTouched)
-        warnings.push(t.notice.personaUnanchored);
-    return { warnings, changed, moves };
+    return { warnings: settingsWarnings(config, t, asJson), changed, moves };
 }
 /** The same assignments and validation for direct tuning and preset creation. */
 export function applyAssignments(config, args, t, asJson) {
@@ -264,7 +231,7 @@ async function commit(ctx, configChange, config, applied) {
             `  ${ctx.ui.bold(finalConfig.before === finalConfig.after ? ctx.t.axis.settingsUnchanged : ctx.ui.success(ctx.t.axis.settingsSaved))}`,
             ...movementLines(applied.moves, ctx, config.axes),
             `  ${ctx.ui.success(toneChange.before === toneChange.after ? ctx.t.artifact.current : ctx.t.artifact.generated)}`,
-            ...(ctx.flags.verbose ? [`  ${ctx.ui.dim(budget(size, ctx.t))}`] : []),
+            ...(ctx.flags.verbose ? [`  ${ctx.ui.dim(artifactSize(size, ctx.t))}`] : []),
         ],
         json: {
             changed: applied.changed,
@@ -272,22 +239,18 @@ async function commit(ctx, configChange, config, applied) {
             config: toCompileInput(config),
             chars: size.chars,
         },
-        warnings: [...applied.warnings, ...riskWarnings(config.axes, ctx.t), ...comboWarnings(config, ctx.t), ...sizeWarning(size, ctx.t)],
+        warnings: [...applied.warnings, ...riskWarnings(config.axes, ctx.t), ...comboWarnings(config, ctx.t)],
     };
 }
 export async function runSet(ctx, args) {
-    let result;
     if (!args.length) {
         if (!ctx.canPrompt || !interactive()) {
             throw new ConfigError(ctx.t.axis.needsArgument);
         }
-        result = await runDial(ctx);
+        return runDial(ctx);
     }
-    else {
-        const { change: configChange, config } = planConfig(ctx);
-        result = await commit(ctx, configChange, config, applyAssignments(config, args, ctx.t, ctx.asJson));
-    }
-    return { ...result, warnings: [...(result.warnings ?? []), ctx.t.notice.modelExpectation] };
+    const { change: configChange, config } = planConfig(ctx);
+    return commit(ctx, configChange, config, applyAssignments(config, args, ctx.t, ctx.asJson));
 }
 /**
  * `tonedial address` — the two terms, and nothing else.
@@ -313,6 +276,66 @@ export async function runAddress(ctx, args) {
     ];
     return commit(ctx, configChange, config, applyPairs(config, pairs, ctx.t, ctx.asJson));
 }
+/** Agent first, user second, like address's self/user pair. Apply only after both validate. */
+export async function runPersona(ctx, args) {
+    const { change: configChange, config } = planConfig(ctx);
+    try {
+        const roles = args.length === 0 ? await askRoles(ctx, config) : args;
+        if (roles.length !== 2)
+            throw new ConfigError(ctx.t.persona.rolesNeedsPair);
+        return commit(ctx, configChange, config, applyPairs(config, [
+            ["persona.agent", roles[0]], ["persona.user", roles[1]],
+        ], ctx.t, ctx.asJson));
+    }
+    catch (cause) {
+        if (!(cause instanceof Error) || cause.code !== "ABORT_ERR")
+            throw cause;
+        return { lines: [`  ${ctx.t.axis.nothingChanged}`], json: { changed: [], moves: [], cancelled: true }, after: async () => 130 };
+    }
+}
+async function askRoles(ctx, config) {
+    if (!ctx.canPrompt || !interactive())
+        throw new ConfigError(ctx.t.persona.rolesNeedsPair);
+    const release = guardTerminal();
+    const rl = createInterface({ input: process.stdin, output: process.stdout });
+    try {
+        for (const line of wrap(ctx.t.persona.rolesIntroduction, ctx.ui.width - 2))
+            process.stdout.write(`  ${line}\n`);
+        const roles = [];
+        for (const field of ["agent", "user"]) {
+            const current = config.persona[field] ?? "";
+            for (;;) {
+                process.stdout.write("\n");
+                for (const line of wrap(`${ctx.t.create[field]}${current ? `: ${humanText(current)}` : ""}`, ctx.ui.width - 2)) {
+                    process.stdout.write(`  ${line}\n`);
+                }
+                const answer = (await rl.question("  > ")).trim();
+                const chosen = answer === '""' ? "" : answer || current;
+                try {
+                    assign(structuredClone(config), `persona.${field}`, chosen, ctx.t, false);
+                    roles.push(chosen);
+                    process.stdout.write(`  ${ctx.t.create.descriptionCount([...chosen].length, PERSONA_DESCRIPTION_MAX)}\n`);
+                    break;
+                }
+                catch (cause) {
+                    if (!(cause instanceof ConfigError))
+                        throw cause;
+                    for (const line of wrap(humanText(cause.message), ctx.ui.width - 2))
+                        process.stdout.write(`  ${ctx.ui.warn(line)}\n`);
+                }
+            }
+        }
+        return roles;
+    }
+    finally {
+        try {
+            rl.close();
+        }
+        finally {
+            release();
+        }
+    }
+}
 /**
  * The two questions, on a terminal.
  *
@@ -398,9 +421,9 @@ export async function runReset(ctx, args) {
                         : `  ${ctx.ui.bold(axis)} ${ctx.ui.dim(String(before))} ${ctx.ui.dim("→")} ${ctx.ui.bold(ctx.ui.accent(String(AXIS_DEFAULT[axis])))}`]
                 : wrap(ctx.t.axis.resetAll, ctx.ui.width - 2).map(line => `  ${ctx.ui.bold(ctx.ui.success(line))}`)),
             `  ${ctx.ui.success(toneChange.before === toneChange.after ? ctx.t.artifact.current : ctx.t.artifact.generated)}`,
-            ...(ctx.flags.verbose ? [`  ${ctx.ui.dim(budget(size, ctx.t))}`] : []),
+            ...(ctx.flags.verbose ? [`  ${ctx.ui.dim(artifactSize(size, ctx.t))}`] : []),
         ],
         json: { reset: axis ?? "all", chars: size.chars },
-        warnings: [...riskWarnings(config.axes, ctx.t), ...comboWarnings(config, ctx.t), ...sizeWarning(size, ctx.t)],
+        warnings: [...riskWarnings(config.axes, ctx.t), ...comboWarnings(config, ctx.t)],
     };
 }

package/dist/commands/show.js

@@ -12,8 +12,8 @@ import { toCompileInput } from "../core/resolve.js";
 import { inspectContextLayout } from "../core/seeds.js";
 import { catalogue, isLanguage } from "../core/i18n.js";
 import { explainBlock, gaugeBlock, gaugeHeader } from "../ui/gauge.js";
-import { planConfig, sizeWarning } from "./compile.js";
-import { budget as budgetLine, combination, humanText, nextStep, riskWarnings } from "../ui/format.js";
+import { planConfig } from "./compile.js";
+import { artifactSize, combination, humanText, nextStep, riskWarnings } from "../ui/format.js";
 import { maxCells, truncate, wrap } from "../ui/width.js";
 import { inspectContextConsumers } from "../wiring/targets.js";
 export function runShow(ctx, args) {
@@ -48,20 +48,20 @@ export function runShow(ctx, args) {
         ? "tonedial save"
         : 'tonedial save "My Tone"';
     const lines = [];
-    const budget = budgetLine(size, ctx.t);
+    const sizeLabel = artifactSize(size, ctx.t);
     // A display name has no length cap, so the title is the one row that can be pushed past the
     // budget by state alone. Truncating keeps the size at the right margin where it is read.
     const prefix = "ToneDial · show · ";
-    const nameBudget = ctx.ui.width - maxCells(budget) - maxCells(status) - maxCells(prefix) - 4;
+    const nameBudget = ctx.ui.width - maxCells(sizeLabel) - maxCells(status) - maxCells(prefix) - 4;
     if (nameBudget >= 2) {
-        lines.push(titleRow(prefix + truncate(humanText(activeName), nameBudget) + status, budget, size.overCap, ctx));
+        lines.push(titleRow(prefix + truncate(humanText(activeName), nameBudget) + status, sizeLabel, ctx));
     }
     else {
         const title = prefix + truncate(humanText(activeName), Math.max(2, ui.width - maxCells(status) - maxCells(prefix) - 2)) + status;
         for (const folded of wrap(title, ui.width - 2))
             lines.push(`  ${ui.bold(folded)}`);
-        for (const folded of wrap(budget, ui.width - 2))
-            lines.push(`  ${(size.overCap ? ui.error : ui.dim)(folded)}`);
+        for (const folded of wrap(sizeLabel, ui.width - 2))
+            lines.push(`  ${ui.dim(folded)}`);
     }
     const p = shown.persona;
     const personaSet = Boolean(p.age || p.gender || p.note || p.address || p.user || p.agent);
@@ -76,20 +76,18 @@ export function runShow(ctx, args) {
             p.address?.self_ref ? ctx.t.persona.callsItself(humanText(p.address.self_ref)) : null,
             p.address?.user_ref ? ctx.t.persona.callsYou(humanText(p.address.user_ref)) : null,
             p.note ? ctx.t.persona.noteChars([...p.note].length) : null,
-            p.user && p.agent && !ctx.flags.verbose ? ctx.t.persona.descriptionCounts([...p.user].length, [...p.agent].length, PERSONA_DESCRIPTION_MAX) : null,
-            p.user && !p.agent && !ctx.flags.verbose ? ctx.t.persona.descriptionChars("user", [...p.user].length) : null,
-            p.agent && !p.user && !ctx.flags.verbose ? ctx.t.persona.descriptionChars("agent", [...p.agent].length) : null,
+            p.user && p.agent ? ctx.t.persona.descriptionCounts([...p.user].length, [...p.agent].length, PERSONA_DESCRIPTION_MAX) : null,
+            p.user && !p.agent ? ctx.t.persona.descriptionChars("user", [...p.user].length) : null,
+            p.agent && !p.user ? ctx.t.persona.descriptionChars("agent", [...p.agent].length) : null,
         ].filter(Boolean);
         if (bits.length)
             for (const folded of wrap(bits.join(" · "), detailWidth))
                 details.push(ui.dim(folded));
-        if (ctx.flags.verbose) {
-            for (const [field, value] of [["user", p.user], ["agent", p.agent]]) {
-                if (value === null)
-                    continue;
-                for (const folded of wrap(ctx.t.persona.descriptionFull(field, humanText(value)), detailWidth)) {
-                    details.push(ui.dim(folded));
-                }
+        for (const [field, value] of [["agent", p.agent], ["user", p.user]]) {
+            if (value === null)
+                continue;
+            for (const folded of wrap(ctx.t.persona.descriptionFull(field, humanText(value)), detailWidth)) {
+                details.push(ui.dim(folded));
             }
         }
     }
@@ -145,22 +143,16 @@ export function runShow(ctx, args) {
         }
     }
     else {
-        // Keep the short legend and action together so a one-row persona still fits 80×24.
+        // Keep the short legend and save action together after the settings.
         const legend = ctx.t.artifact.movedFromDefault + (needsSave ? ` · ${ctx.t.preset.changesNotSaved}` : "");
         const [first, ...rest] = wrap(legend, ui.width - 4);
         lines.push(`  ${ui.accent("*")} ${ui.dim(first)}`, ...rest.map((line) => `    ${ui.dim(line)}`), ...nextStep(preview ? `tonedial use ${preview.slug}` : needsSave ? saveCommand : "tonedial show --explain", ui).slice(1));
     }
-    const combinations = checkCombos(axes, shown.persona, shown.speech_level);
+    const combinations = checkCombos(axes);
     const warnings = combinations.map((w) => combination(w, ctx.t));
-    if (personaSet) {
-        warnings.push(ctx.t.notice.personaUnanchored);
-    }
     warnings.push(...riskWarnings(axes, ctx.t));
-    warnings.push(ctx.t.notice.modelExpectation);
     if (activeConflict && preview === null)
         warnings.push(ctx.t.preset.activeConflict(config.preset));
-    // Through the same owner every other command uses, rather than a sentence composed here.
-    warnings.push(...sizeWarning(size, ctx.t));
     return {
         lines,
         json: {
@@ -183,7 +175,6 @@ export function runShow(ctx, args) {
             // Interface language never changes the compiled tone.
             language: config.language,
             chars: size.chars,
-            cap: size.cap,
             artifact: { exists: artifactOnDisk },
         },
         warnings,
@@ -194,14 +185,13 @@ export function runShow(ctx, args) {
  * while both fit — on anything narrower they fall back to a single space rather than pushing
  * the line past its budget. Right alignment is worth having and never worth an overflow.
  */
-function titleRow(name, budget, overCap, ctx) {
-    const paint = overCap ? ctx.ui.error : ctx.ui.dim;
+function titleRow(name, sizeLabel, ctx) {
     // Measured pessimistically. A display name is user text and may hold ambiguous-width
     // characters, so a gap sized by the narrow measure is a gap that overflows on the terminals
     // this contract exists for.
-    const used = maxCells(name) + maxCells(budget) + 2;
+    const used = maxCells(name) + maxCells(sizeLabel) + 2;
     const gap = used <= ctx.ui.width ? " ".repeat(ctx.ui.width - used) : " ";
-    return `  ${ctx.ui.bold(name)}${gap}${paint(budget)}`;
+    return `  ${ctx.ui.bold(name)}${gap}${ctx.ui.dim(sizeLabel)}`;
 }
 /**
  * Safeword and register on one row. Plain text, because it is folded before it is

package/dist/commands/transfer.js

@@ -141,6 +141,5 @@ export async function runImport(ctx, args) {
             ...nextStep(`tonedial show ${slug}`, ctx.ui),
         ],
         json: { slug, displayName: preset.displayName, replaced: existed, source },
-        warnings: existed ? [ctx.t.preset.replaced(slug)] : [],
     };
 }

package/dist/commands/update.js

@@ -1,13 +1,13 @@
-// Update curl installations, guide npm updates, and report generated-state freshness.
+// Update through the installation owner and report application-state work separately.
 import { VERSION } from "../cli.js";
 import { closeSync, constants, fstatSync, lstatSync, openSync, readSync } from "node:fs";
 import { TextDecoder } from "node:util";
 import { ConfigError, parseConfig } from "../core/config.js";
-import { AGENT_TOOLS, UPDATE_COMMAND, installShape } from "../core/paths.js";
-import { REGISTRY, downloadRelease, haveTar, installRelease, installedVersion, latestRelease } from "../core/selfupdate.js";
+import { AGENT_TOOLS, UPDATE_COMMAND, installShape, shellQuote } from "../core/paths.js";
+import { REGISTRY, downloadRelease, haveTar, inspectNpmInstall, installRelease, installedVersion, latestRelease, updateNpmInstall } from "../core/selfupdate.js";
 import { confirm } from "../ui/prompt.js";
 import { SEED_VERSION, inspectSeeds, recordedSeedSelection } from "../core/seeds.js";
-import { humanText } from "../ui/format.js";
+import { humanText, receiptLines } from "../ui/format.js";
 import { urlIdentity } from "../core/net.js";
 /** A damaged state file must not disable package guidance or reveal its parser excerpt. */
 function updateConfig(ctx) {
@@ -84,16 +84,40 @@ export async function runUpdate(ctx) {
             stateIssue = "unreadable";
         }
     }
-    const lines = [
-        `  ${ctx.ui.bold(ctx.t.update.running(VERSION))}`,
-        `  ${ctx.ui.dim(ctx.t.update.installedBy(shape))}`,
-        "",
-    ];
-    // npm is told, not driven. Spawning a package manager to update a package it owns is a
-    // different act from replacing a directory this tool put there itself.
+    const lines = [`  ${ctx.ui.bold(ctx.t.update.running(VERSION))}`, ""];
+    const preview = () => {
+        if (!ctx.asJson) {
+            process.stdout.write(`${lines.join("\n")}\n`);
+            lines.length = 0;
+        }
+    };
     let replaced = null;
+    let installed = null;
+    let outcome;
     if (shape !== "curl") {
-        lines.push(`  ${ctx.t.update.onlyCurl(shape)}`, `  ${ctx.t.update.toUpdate}`, `    ${ctx.ui.accent(command)}`);
+        if (ctx.flags.dryRun) {
+            outcome = "dry-run";
+            lines.push(`  ${ctx.t.update.toUpdate}`, `    ${ctx.ui.accent(command)}`, `  ${ctx.t.wiring.dryRun}`);
+        }
+        else if (!ctx.flags.auto && !ctx.canPrompt) {
+            outcome = "approval-required";
+            lines.push(`  ${ctx.t.update.toUpdate}`, `    ${ctx.ui.accent(command)}`, ...receiptLines(ctx.t.update.needsApproval, ctx.ui.width - 2).map(line => `  ${line}`));
+        }
+        else {
+            const target = inspectNpmInstall(ctx.env, ctx.t);
+            lines.push(`  ${ctx.t.update.toUpdate}`, `    ${ctx.ui.accent(`${command} --prefix "${shellQuote(humanText(target.prefix))}"`)}`);
+            preview();
+            if (ctx.flags.auto || (await confirm(ctx.t.update.npmQuestion)) === "yes") {
+                installed = updateNpmInstall(target, ctx.env, ctx.t);
+                replaced = installed === target.version ? null : installed;
+                outcome = replaced === null ? "unchanged" : "updated";
+                lines.push(`  ${ctx.ui.success(ctx.t.update.npmComplete(installed))}`);
+            }
+            else {
+                outcome = "declined";
+                lines.push(`  ${ctx.t.update.declined}`);
+            }
+        }
     }
     else {
         // Before the network, like `install.sh` checks its tools before it fetches anything.
@@ -104,29 +128,38 @@ export async function runUpdate(ctx) {
         if (release.version === VERSION) {
             // Nothing downloaded. The common case is an install that is already current, and paying
             // for the whole package to be told so is a cost with nothing on the other side of it.
+            installed = VERSION;
+            outcome = "unchanged";
             lines.push(`  ${ctx.ui.success(ctx.t.update.already(release.version))}`);
         }
         else if (ctx.flags.dryRun) {
-            lines.push(`  ${ctx.ui.warn(ctx.t.update.wouldReplace(humanText(ctx.paths.lib), humanText(release.version)))}`);
+            outcome = "dry-run";
+            lines.push(`  ${ctx.t.update.wouldReplace(humanText(ctx.paths.lib), humanText(release.version))}`);
         }
         else if (!ctx.flags.auto && !ctx.canPrompt) {
             // JSON never asks, including on a terminal. Explicit --auto supplies approval through
             // the same branch as human output; absent approval, report the existing no-install result.
-            lines.push(`  ${ctx.ui.warn(ctx.t.update.needsApproval)}`);
-        }
-        else if (ctx.flags.auto || (await confirm(ctx.t.update.question(release.version))) === "yes") {
-            const tarball = await downloadRelease(release, ctx.t);
-            lines.push(`  ${ctx.ui.accent(ctx.t.update.found(release.version, tarball.byteLength))}`);
-            installRelease(ctx.paths, tarball, ctx.t);
-            // **What landed, not what was claimed.** The registry's `version` is metadata; a stub or
-            // a mistake serving one number and a different tarball made `update` report a version it
-            // had not installed — and, because the no-op check compares that metadata against this
-            // process's own constant, swap again on every run forever.
-            replaced = installedVersion(ctx.paths) ?? release.version;
-            lines.push(`  ${ctx.ui.success(ctx.ui.bold(ctx.t.update.replaced(replaced)))}`);
+            outcome = "approval-required";
+            lines.push(...receiptLines(ctx.t.update.needsApproval, ctx.ui.width - 2).map(line => `  ${line}`));
         }
         else {
-            lines.push(`  ${ctx.t.update.declined}`);
+            lines.push(`  ${ctx.t.update.wouldReplace(humanText(ctx.paths.lib), humanText(release.version))}`);
+            preview();
+            if (ctx.flags.auto || (await confirm(ctx.t.update.question(release.version))) === "yes") {
+                const tarball = await downloadRelease(release, ctx.t);
+                lines.push(`  ${ctx.ui.accent(ctx.t.update.found(release.version, tarball.byteLength))}`);
+                installRelease(ctx.paths, tarball, ctx.t);
+                installed = installedVersion(ctx.paths);
+                if (installed === null)
+                    throw new ConfigError(ctx.t.update.versionUnknown);
+                replaced = installed;
+                outcome = "updated";
+                lines.push(`  ${ctx.ui.success(ctx.ui.bold(ctx.t.update.replaced(installed)))}`);
+            }
+            else {
+                outcome = "declined";
+                lines.push(`  ${ctx.t.update.declined}`);
+            }
         }
     }
     const warnings = [];
@@ -134,20 +167,33 @@ export async function runUpdate(ctx) {
     // `seedFiles` are constants in the copy that has just been replaced, so a release that moved
     // the anchors would be reported against the old ones — which is the exact gap this command
     // exists to close. Say the one thing that is still true and stop measuring.
-    if (replaced !== null || config === null || config.seedVersion === 0 || stateIssue !== null || (stale && stale.length > 0)) {
-        lines.push("", `  ${ctx.t.update.thenRefresh}`, `    ${ctx.ui.accent("tonedial doctor --fix")}`);
-    }
-    if (replaced === null && config?.seedVersion === 0) {
-        warnings.push(ctx.t.update.neverInitialised);
-    }
-    else if (replaced === null && stale && stale.length > 0) {
-        // Second, and phrased as a second step: replacing the package is not the whole update, and
-        // a user who stops at the first line is the one who ends up running new code on old anchors.
-        for (const { seed, state } of stale) {
-            if (state !== "current")
-                warnings.push(`${ctx.t.doctor.seedReason[state]}\n${seed.path}`);
+    const inspectable = replaced === null ? stale ?? [] : [];
+    const routine = inspectable.filter(({ state }) => state === "missing" || state === "stale");
+    const problems = inspectable.filter(({ state }) => state !== "missing" && state !== "stale");
+    const fresh = stateIssue === "missing" && ![ctx.paths.agents, ctx.paths.tone, ctx.paths.presets, ctx.paths.skill].some(path => {
+        try {
+            return lstatSync(path, { throwIfNoEntry: false }) !== undefined;
+        }
+        catch {
+            return true;
+        }
+    });
+    if (stateIssue !== null && !fresh)
+        warnings.push(ctx.t.update.stateIssue[stateIssue]);
+    if (routine.length)
+        lines.push("", `  ${ctx.t.update.refreshFiles(routine.length)}`);
+    if (problems.length) {
+        lines.push("", `  ${ctx.t.wiring.stateRoot}`, `  ${humanText(ctx.paths.root)}`);
+        for (const reason of ["modified", "foreign", "unreadable"]) {
+            const group = problems.filter(({ state }) => state === reason);
+            if (group.length)
+                warnings.push([ctx.t.doctor.seedReason[reason], ...group.map(({ seed }) => seed.label)].join("\n"));
         }
     }
+    const stateRecoveryRequired = !fresh && (stateIssue !== null || config?.seedVersion === 0 || inspectable.length > 0 || replaced !== null);
+    const recoveryCommand = fresh ? "tonedial init" : problems.length ? "tonedial doctor" : "tonedial doctor --fix";
+    if (fresh || stateRecoveryRequired)
+        lines.push("", `  ${fresh ? ctx.t.update.setupNeeded : problems.length ? ctx.t.update.reviewState : ctx.t.update.thenRefresh}`, `    ${ctx.ui.accent(recoveryCommand)}`);
     return {
         lines,
         json: {
@@ -155,17 +201,18 @@ export async function runUpdate(ctx) {
             shape,
             command,
             replaced,
+            installedVersion: installed,
+            outcome,
             seedVersion: config?.seedVersion ?? null,
             stateIssue,
-            stateRecoveryRequired: stateIssue !== null || config?.seedVersion === 0 || (stale?.length ?? 0) > 0 || replaced !== null,
-            recoveryCommand: "tonedial doctor --fix",
+            stateRecoveryRequired,
+            recoveryCommand,
             // Null after a swap: this process is the old package, and reporting its constants as the
             // installed ones would be a claim it cannot make.
             packageSeedVersion: replaced === null ? SEED_VERSION : null,
             staleSeeds: replaced === null ? (stale?.map(({ seed }) => seed.label) ?? null) : null,
             seedIssues: replaced === null ? (stale?.map(({ seed, state }) => ({ path: seed.path, reason: state })) ?? null) : null,
-            // Named for what it is. On npm this command asks nothing of the network, so a consumer
-            // must not read silence here as "you are up to date".
+            // npm owns registry/cache resolution; only the curl branch observes remote metadata.
             checkedRemote: shape === "curl",
         },
         warnings,

package/dist/commands/use.js

@@ -6,9 +6,9 @@ import { ConfigError, serializeConfig } from "../core/config.js";
 import { exportAliasesState, projectTonePath } from "../core/paths.js";
 import { check as checkCombos } from "../core/combos.js";
 import { withPreset, assertPresetSelection, inspectPresetLibrary, resolvePreset } from "../core/presets.js";
-import { applyPlanned, planArtifact, planConfig, sizeWarning } from "./compile.js";
+import { applyPlanned, planArtifact, planConfig } from "./compile.js";
 import { planChange, rawReadCheck } from "../wiring/apply.js";
-import { budget, combination, humanText, nextStep } from "../ui/format.js";
+import { artifactSize, combination, humanText, nextStep } from "../ui/format.js";
 import { truncate, wrap } from "../ui/width.js";
 /**
  * How much of a preset's name this screen shows. `list` and `show` already truncate; this line
@@ -65,16 +65,16 @@ export async function runUse(ctx, args) {
         risk: ctx.t.notice.risk,
         roleplay: config.axes.playfulness >= 4 ? ctx.t.notice.roleplay : null,
     };
-    const notices = [notice.safeword, ...(notice.riskAxes ? [notice.riskAxes] : []), notice.risk];
+    const notices = [notice.safeword, ...(notice.riskAxes ? [notice.riskAxes] : [])];
     const lines = [
         ...wrap(ctx.t.preset.active(truncate(humanText(preset.displayName), ui.width - 12)), ui.width - 2)
             .map((line) => `  ${ui.success(ui.bold(line))}`),
         `  ${ctx.t.artifact.generated}`,
-        ...(ctx.flags.verbose ? [`  ${ui.dim(budget(size, ctx.t))}`] : []),
+        ...(ctx.flags.verbose ? [`  ${ui.dim(artifactSize(size, ctx.t))}`] : []),
         // Folded here rather than at the printer: `lines` are laid out by the command that built
         // them, and a printer that reflowed them would break every column in the gauge block.
         "",
-        ...notices.flatMap((n) => wrap(humanText(n), ui.width - 2).map((folded) => `  ${n === notice.riskAxes ? ui.risk(folded) : n === notice.risk ? ui.warn(folded) : folded}`)),
+        ...notices.flatMap((n) => wrap(humanText(n), ui.width - 2).map((folded) => `  ${n === notice.riskAxes ? ui.risk(folded) : folded}`)),
         ...project,
         ...nextStep("tonedial show", ui),
     ];
@@ -93,9 +93,7 @@ export async function runUse(ctx, args) {
             project: projectPath,
         },
         warnings: [
-            ...(notice.roleplay ? [notice.roleplay] : []),
-            ...checkCombos(config.axes, config.persona, config.speech_level).map((w) => combination(w, ctx.t)),
-            ...sizeWarning(size, ctx.t),
+            ...checkCombos(config.axes).map((w) => combination(w, ctx.t)),
         ],
     };
 }

package/dist/commands/wire.js

@@ -453,7 +453,7 @@ function summary(ctx, reason, tools, action = "connect") {
         return receiptLines(action === "disconnect" ? ctx.t.wiring.alreadyDisconnected(named) : ctx.t.wiring.alreadyMatch(named), ctx.ui.width - 2)
             .map((line) => `  ${ctx.ui.bold(line)}`);
     if (reason === "dry-run")
-        return [`  ${ctx.ui.warn(ctx.t.wiring.dryRun)}`];
+        return [`  ${ctx.ui.dim(ctx.t.wiring.dryRun)}`];
     if (reason === "declined")
         return [`  ${ctx.t.wiring.declined}`];
     return [

package/dist/core/anchors.js

@@ -182,6 +182,3 @@ export const CONTROLS = {
   that message still goes through its normal checks.`,
     fallback: "If the user asks to change the tone, use the `tonedial` CLI (`tonedial --help`).",
 };
-/** The compiled artifact's budget, in Unicode code points across the whole file. */
-export const TARGET_CHARS = 1800;
-export const CAP_CHARS = 2700;