tonedial 0.1.1 → 0.1.2

package/dist/cli.js

@@ -34,7 +34,7 @@ export const JSON_SCHEMA = 3;
  * run time is the one thing that breaks all three binary packagers at once. A test asserts this
  * equals the manifest, which is the cheap half of the trade.
  */
-export const VERSION = "0.1.1";
+export const VERSION = "0.1.2";
 const FLAG_NAMES = ["project", "check", "explain", "global", "here", "migrateLegacy", "auto", "dryRun", "fix", "rollback", "fromOperation", "fromPreset", "restorePreset", "preset", "slug", "acceptUsage", "lang", "commands", "tools"];
 /** Command-line spelling for each flag, where it differs from the field name. */
 const FLAG_SPELLING = {

package/dist/commands/create.js

@@ -11,7 +11,7 @@ import { guardTerminal } from "../ui/prompt.js";
 import { wrap } from "../ui/width.js";
 import { planConfig } from "./compile.js";
 import { savePreset } from "./save.js";
-import { applyAssignments } from "./set.js";
+import { applyAssignments, settingsWarnings } from "./set.js";
 export async function runCreate(ctx, args) {
     try {
         const state = planConfig(ctx);
@@ -23,7 +23,7 @@ export async function runCreate(ctx, args) {
         config.persona.agent ??= defaults.agent;
         let displayName = args[0]?.trim() ?? "";
         let slug = ctx.flags.slug ?? undefined;
-        const warnings = applyAssignments(config, args.slice(1), ctx.t, ctx.asJson).warnings;
+        applyAssignments(config, args.slice(1), ctx.t, ctx.asJson);
         if (ctx.canPrompt && !ctx.flags.auto && !ctx.flags.dryRun) {
             const release = guardTerminal();
             const rl = createInterface({ input: process.stdin, output: process.stdout });
@@ -60,10 +60,9 @@ export async function runCreate(ctx, args) {
                         const chosen = await ask(label, value);
                         try {
                             const candidate = structuredClone(config);
-                            const applied = applyAssignments(candidate, [`${key}=${chosen}`], ctx.t, false);
+                            applyAssignments(candidate, [`${key}=${chosen}`], ctx.t, false);
                             serializeConfig(candidate, ctx.t);
                             Object.assign(config, candidate);
-                            warnings.push(...applied.warnings);
                             if (key === "persona.user" || key === "persona.agent") {
                                 process.stdout.write(`  ${ctx.t.create.descriptionCount([...chosen].length, PERSONA_DESCRIPTION_MAX)}\n`);
                             }
@@ -97,9 +96,10 @@ export async function runCreate(ctx, args) {
         return {
             ...result,
             json: { ...result.json, ...(result.json.created === true ? { config: toCompileInput(config) } : {}) },
-            warnings: [...new Set([...warnings, ...(result.warnings ?? []), ...riskWarnings(config.axes, ctx.t),
-                    ...checkCombos(config.axes, config.persona, config.speech_level).map((notice) => combination(notice, ctx.t)),
-                    ctx.t.notice.modelExpectation])],
+            warnings: result.json.created === true ? [
+                ...settingsWarnings(config, ctx.t, ctx.asJson), ...riskWarnings(config.axes, ctx.t),
+                ...checkCombos(config.axes).map((notice) => combination(notice, ctx.t)),
+            ] : [],
         };
     }
     catch (cause) {

package/dist/commands/doctor.js

@@ -7,7 +7,7 @@ import { runRebuildNative } from "./wire.js";
 import { compile, measure } from "../core/compile.js";
 import { ConfigError, defaultConfig, isConfigV2, parseConfig } from "../core/config.js";
 import { inspectOperations, inspectRollback } from "../core/operations.js";
-import { join } from "node:path";
+import { join, relative } from "node:path";
 import { AGENT_TOOLS, CONTEXT_ARTIFACT_FILENAME, CONTEXT_GUIDE_FILENAME, UPDATE_COMMAND, connectionScopeFlag, onPath, readerPath, resolveAgentPaths, shimScript, installShape, canonicalDestination, shellQuote } from "../core/paths.js";
 import { SKILL_NAME } from "../core/skill.js";
 import { GUIDE_FORMAT_MARKER } from "../core/reader.js";
@@ -681,9 +681,11 @@ async function doctorReport(ctx, showRollbackCommands = true, showCodexAction =
     const appHealthy = diagnosis.layout.kind === "current" && diagnosis.layout.cause === "none" && seeds.every(({ state }) => state === "current");
     const lines = [
         `  ${ctx.ui.bold((appHealthy ? ctx.ui.success : ctx.ui.warn)(ctx.t.doctor.applicationHealth(appHealthy)))}`,
-        ...section(ctx.t.doctor.connectionsHeading, ctx.ui),
-        ...wrap(ctx.t.doctor.connectionHealth(nativeAttention), ctx.ui.width - 2).map((line) => `  ${nativeAttention ? ctx.ui.warn(line) : line}`),
-        ...wrap(ctx.t.doctor.hookSettingScope, ctx.ui.width - 2).map(line => `  ${line}`),
+        ...(integrations.length || nativeAttention ? [
+            ...section(ctx.t.doctor.connectionsHeading, ctx.ui),
+            ...wrap(ctx.t.doctor.connectionHealth(nativeAttention), ctx.ui.width - 2).map((line) => `  ${nativeAttention ? ctx.ui.warn(line) : line}`),
+            ...wrap(ctx.t.doctor.hookSettingScope, ctx.ui.width - 2).map(line => `  ${line}`),
+        ] : []),
         ...section(ctx.t.doctor.checksHeading, ctx.ui),
         ...renderCheckBlocks(shownChecks, ctx.flags.verbose ? [] : hookSettings, integrations, ctx),
         // A repair receipt presents its new IDs once in native→app order. Standalone diagnosis
@@ -753,8 +755,7 @@ async function runRollback(ctx, operationId) {
  * The seeds in home against the ones this package carries.
  *
  * An npm update replaces the code and never touches `~/.tonedial/`, so a corrected anchor would
- * otherwise never reach an existing user. Re-running `init` is the update path, and this is
- * what tells someone there is a reason to.
+ * otherwise never reach an existing user. `doctor --fix` refreshes generated application files.
  */
 function seedCheck(ctx, config, seeds) {
     // Zero means `init` never ran, which `use` and `wire` reach on their own and which nothing is
@@ -771,7 +772,7 @@ function seedCheck(ctx, config, seeds) {
             state: "problem",
             detail: ctx.t.doctor.seedsAttention,
             files: stale.map(({ seed, state }) => ({ path: seed.path, reason: state })),
-            ...(stale.every(({ state }) => state === "missing" || state === "stale") ? { repair: repairCommand(ctx, "init") } : {}),
+            ...(stale.every(({ state }) => state === "missing" || state === "stale") ? { repair: repairCommand(ctx, "doctor --fix") } : {}),
         };
 }
 /** Whether the skill is linked, copied, someone else's, or simply not installed. */
@@ -1050,15 +1051,23 @@ function elsewhereReport(rows, ctx) {
 }
 function report(check, ctx) {
     const paint = check.state === "problem" ? ctx.ui.error : check.state === "ok" ? ctx.ui.success : ctx.ui.dim;
-    const head = `  ${paint(MARK[check.state])} ${ctx.ui.bold(humanText(check.name))}`;
+    const head = `  ${paint(MARK[check.state])} ${ctx.ui.bold(humanText(check.name === "seeds" ? ctx.t.doctor.seedsHeading : check.name))}`;
     // Keep the marker and check name together, then give every detail a stable four-cell hanging
     // indent. A fixed name column made a narrow doctor report spend most of its width on padding.
-    const body = (check.humanDetail ?? [check.detail]).flatMap(detail => detail.split("\n"))
+    const body = (check.files?.length ? [] : check.humanDetail ?? [check.detail]).flatMap(detail => detail.split("\n"))
         .flatMap(line => receiptLines(humanText(line), ctx.ui.width - 6));
     const lines = [head, ...body.map((line) => `    ${check.state === "ok" ? ctx.ui.dim(line) : line}`)];
-    for (const file of check.files ?? []) {
-        lines.push(...wrap(ctx.t.doctor.seedReason[file.reason], ctx.ui.width - 6).map((line) => `    ${line}`));
-        lines.push(`    ${humanText(file.path)}`);
+    if (check.files?.length) {
+        lines.push(`    ${humanText(ctx.paths.root)}`);
+        for (const reason of ["missing", "stale", "modified", "foreign", "unreadable"]) {
+            const files = check.files.filter(file => file.reason === reason);
+            if (!files.length)
+                continue;
+            lines.push(...wrap(ctx.t.doctor.seedReason[reason], ctx.ui.width - 6).map(line => `    ${line}`));
+            for (const file of files) {
+                lines.push(...wrap(humanText(relative(ctx.paths.root, file.path)), ctx.ui.width - 8).map(line => `      ${line}`));
+            }
+        }
     }
     if (check.repair)
         lines.push(...nextStep(check.repair, ctx.ui));
@@ -1092,7 +1101,5 @@ function unconnectedReport(settings, ctx) {
     return [
         `  ${ctx.ui.dim(MARK.note)} ${ctx.ui.bold(ctx.t.doctor.hookGroupHeading)}`,
         ...wrap(ctx.t.doctor.hookGroupUnknown(tools), ctx.ui.width - 4).map(line => `    ${line}`),
-        ...wrap(ctx.t.doctor.hookGroupMissing, ctx.ui.width - 4).map(line => `    ${line}`),
-        ...wrap(ctx.t.doctor.hookGroupAction, ctx.ui.width - 4).map(line => `    ${line}`),
     ];
 }

package/dist/commands/edit.js

@@ -11,6 +11,7 @@ import { check as checkCombos } from "../core/combos.js";
 import { artifactSize, combination, humanText, riskWarnings } from "../ui/format.js";
 import { captureRawEntry, planChange, rawReadChange, rawReadCheck } from "../wiring/apply.js";
 import { emptyWiring } from "../wiring/ownership.js";
+import { settingsWarnings } from "./set.js";
 /**
  * The editor to hand the file to. `$VISUAL` wins over `$EDITOR` by long convention — a user
  * who sets both means the first for interactive work, which this is.
@@ -227,10 +228,9 @@ export async function runEdit(ctx, args) {
 }
 /** The notices every other state-changing command emits, through the same owners they use. */
 function stateWarnings(ctx, config) {
-    const p = config.persona;
     return [
-        ...checkCombos(config.axes, p, config.speech_level).map((w) => combination(w, ctx.t)),
-        ...(p.age || p.gender || p.note || p.address || p.user || p.agent ? [ctx.t.notice.personaUnanchored] : []),
+        ...checkCombos(config.axes).map((w) => combination(w, ctx.t)),
+        ...settingsWarnings(config, ctx.t, ctx.asJson),
         ...riskWarnings(config.axes, ctx.t),
     ];
 }

package/dist/commands/init.js

@@ -219,11 +219,10 @@ export async function runInit(entry, _args) {
             addReceipt(message);
         }
     }
-    lines.push("");
-    addReceipt(copy.init.risk, ctx.ui.warn);
-    addReceipt(ctx.t.notice.modelExpectation);
-    for (const notice of riskWarnings(config.axes, ctx.t))
-        addReceipt(notice, ctx.ui.risk);
+    if (applied) {
+        for (const notice of riskWarnings(config.axes, ctx.t))
+            addReceipt(notice, ctx.ui.risk);
+    }
     lines.push("");
     // Skills and controls invoke bare tonedial, so command reachability needs its own hint.
     if (onPath("tonedial", ctx.env) === null) {
@@ -298,10 +297,6 @@ async function rebuildExisting(entry) {
     const resultHeading = ctx.canPrompt && !ctx.flags.auto && !ctx.flags.dryRun
         ? section(copy.init.resultHeading, ctx.ui) : [];
     const app = await runAppRebuild(ctx);
-    const riskIntro = [
-        ...receiptLines(copy.init.risk, ctx.ui.width - 2).map(line => `  ${ctx.ui.warn(line)}`),
-        ...receiptLines(ctx.t.notice.modelExpectation, ctx.ui.width - 2).map(line => `  ${line}`),
-    ];
     if (ctx.flags.dryRun) {
         const answers = await ask(ctx, copy, false, selection);
         const tools = selection ?? answers.tools;
@@ -309,7 +304,7 @@ async function rebuildExisting(entry) {
             throw new ConfigError(ctx.t.errors.commandsNeedClaude);
         const native = await runRebuildNative({ ...ctx, flags: { ...ctx.flags, tools: tools.length ? tools.join(",") : "none" } }, app.legacy, app.proposedConfig);
         return {
-            lines: [...(ctx.canPrompt ? [] : introduction), ...app.lines, ...native.lines, ...riskIntro],
+            lines: [...(ctx.canPrompt ? [] : introduction), ...app.lines, ...native.lines],
             json: { ...app.json, agentRoot: ctx.agent.root, live: ctx.agent.live,
                 scope: ctx.agent.live ? "global" : "project", scopeExplicit, language: app.proposedConfig.language,
                 seedVersion: SEED_VERSION, tools, native: native.json,
@@ -320,7 +315,7 @@ async function rebuildExisting(entry) {
         };
     }
     if (app.rebuiltConfig === null)
-        return { ...app, lines: [...(ctx.canPrompt ? [] : introduction), ...resultHeading, ...app.lines, ...riskIntro] };
+        return { ...app, lines: [...(ctx.canPrompt ? [] : introduction), ...resultHeading, ...app.lines] };
     const answers = await ask(ctx, copy, false, selection);
     const tools = selection ?? answers.tools;
     if (ctx.flags.commands && !tools.includes("claude"))
@@ -331,7 +326,6 @@ async function rebuildExisting(entry) {
     const after = codexHandoff(scoped, native.json.applied === true || native.json.reason === "nothing", codexConfigured);
     return {
         lines: [...(ctx.canPrompt ? [] : introduction), ...resultHeading, ...app.lines, ...native.lines,
-            ...riskIntro,
             ...recoveryRollbackLines(ctx.t, app.json.operationId, native.json.operationId)],
         ...(after ? { after } : {}),
         json: {

package/dist/commands/save.js

@@ -73,20 +73,13 @@ export async function savePreset(ctx, displayName, state, options = {}) {
         };
     const count = Object.keys(values).length;
     const countLabel = ctx.t.preset.nonDefault(count);
-    const warnings = [];
-    if (replaced)
-        warnings.push(ctx.t.preset.replaced(slug));
-    // Sparsity survives on one reason after the omit-defaults rule fell: fewer extremes mean
-    // fewer internal collisions. It is guidance, so it warns and never blocks.
-    if (count < 3 || count > 7) {
-        warnings.push(ctx.t.preset.sparsity(slug, count));
-    }
     return {
         // Truncated, not folded. A display name has no length cap, and folding one across two lines
         // makes the slug beside it harder to read than losing the tail does.
         lines: [
             ...(options.create ? result.lines : []),
-            `  ${ctx.ui.success(ctx.ui.bold(ctx.t.preset.savedTarget(slug)))}`,
+            ...wrap(replaced ? ctx.t.preset.replaced(slug) : ctx.t.preset.savedTarget(slug), ctx.ui.width - 2)
+                .map((line) => `  ${ctx.ui.success(ctx.ui.bold(line))}`),
             `  ${truncate(humanText(displayName), Math.max(1, ctx.ui.width - cells(`    ${countLabel}`)))}  ${ctx.ui.dim(countLabel)}`,
             `  ${ctx.t.artifact.generated}`,
             ...(ctx.flags.verbose ? [`  ${ctx.ui.dim(artifactSize(size, ctx.t))}`] : []),
@@ -94,6 +87,5 @@ export async function savePreset(ctx, displayName, state, options = {}) {
         ],
         json: { slug, displayName, values, settings: preset.settings, nonDefaultAxes: count, replaced, chars: size.chars,
             ...(options.create ? { created: true, diff: result.diff, operationId: result.operationId } : {}) },
-        warnings,
     };
 }

package/dist/commands/set.js

@@ -5,7 +5,7 @@
 // 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";
@@ -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) {
@@ -276,18 +243,14 @@ async function commit(ctx, configChange, config, applied) {
     };
 }
 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.

package/dist/commands/show.js

@@ -148,13 +148,9 @@ export function runShow(ctx, args) {
         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));
     return {

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

@@ -65,7 +65,7 @@ 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))}`),
@@ -74,7 +74,7 @@ export async function runUse(ctx, args) {
         // 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,8 +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)),
+            ...checkCombos(config.axes).map((w) => combination(w, ctx.t)),
         ],
     };
 }