tonedial 0.1.1 → 0.1.3

package/dist/cli.js

@@ -1,14 +1,15 @@
 // Argument parsing, dispatch, and human/JSON output.
 import { parseArgs } from "node:util";
 import { isAbsolute } from "node:path";
-import { ConfigError, isConfigV2, nearest } from "./core/config.js";
+import { ConfigError, SETTING_KEYS, isConfigV2, nearest } from "./core/config.js";
+import { AXIS_ORDER } from "./core/anchors.js";
 import { compile } from "./core/compile.js";
 import { toCompileInput } from "./core/resolve.js";
 import { inspectContextLayout } from "./core/seeds.js";
 import { OperationError } from "./core/operations.js";
 import { RegionError } from "./wiring/region.js";
 import { connectionScopeFlag, installShape, resolveAgentPaths, resolvePaths } from "./core/paths.js";
-import { messages } from "./core/i18n.js";
+import { catalogue, configLanguage, detectLanguage, messages } from "./core/i18n.js";
 import { isColourMode, palette } from "./ui/style.js";
 import { cells, maxCells, resolveBudget, wrap } from "./ui/width.js";
 import { interactive } from "./ui/prompt.js";
@@ -22,6 +23,7 @@ import { runSave } from "./commands/save.js";
 import { runCreate } from "./commands/create.js";
 import { runAddress, runPersona, runSet, runReset } from "./commands/set.js";
 import { runShow } from "./commands/show.js";
+import { runGet, settingHelp } from "./commands/get.js";
 import { runUse } from "./commands/use.js";
 import { runDoctor } from "./commands/doctor.js";
 import { runEject } from "./commands/eject.js";
@@ -34,7 +36,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.3";
 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 = {
@@ -47,6 +49,7 @@ const FLAG_SPELLING = {
 /** Each command declares its accepted flags and positional limit; null means unlimited. */
 const COMMANDS = {
     set: { run: runSet, flags: [], max: null, context: "state" },
+    get: { run: runGet, flags: [], max: 1 },
     test: { run: runTest, flags: ["project", "dryRun", "preset", "acceptUsage"], max: 1 },
     address: { run: runAddress, flags: [], max: 2, context: "state" },
     persona: { run: runPersona, flags: [], max: 2, context: "state" },
@@ -77,7 +80,8 @@ export const COMMAND_NAMES = Object.keys(COMMANDS);
 /** Intent groups share one command inventory between compact and full help. */
 const COMMAND_GROUPS = [
     ["tone", [
-            ["set", "set <axis>=<level> …"],
+            ["set", "set <key>=<value> …"],
+            ["get", "get [key]"],
             ["address", "address [self user]"],
             ["persona", "persona [agent user]"],
             ["reset", "reset [axis]"],
@@ -108,6 +112,7 @@ const COMMAND_GROUPS = [
 const COMMAND_SYNTAX = COMMAND_GROUPS.flatMap(([, rows]) => rows);
 const COMMAND_EXAMPLES = {
     set: ["tonedial set", "tonedial set warmth=5 critique=4", "tonedial set persona.agent=reviewer"],
+    get: ["tonedial get", "tonedial get language", "tonedial get speech_level --json"],
     test: ["tonedial test codex --dry-run", "tonedial test claude --project .", "tonedial test codex --preset my-tone --accept-usage"],
     address: ['tonedial address "assistant" "friend"'],
     persona: ["tonedial persona", 'tonedial persona "Fictional reviewer" "Developer"'],
@@ -216,7 +221,8 @@ function compactUsage(t, ui) {
     ].join("\n");
 }
 /** One command's syntax and only the flags that can affect that command. */
-function commandUsage(name, t, ui) {
+function commandUsage(name, copy, ui) {
+    const t = copy.cli;
     const command = COMMANDS[name];
     const syntax = COMMAND_SYNTAX.find(([key]) => key === name)?.[1] ?? name;
     const flagKeys = [
@@ -231,6 +237,7 @@ function commandUsage(name, t, ui) {
         return [syntax, t.help.flags[key]];
     });
     const width = Math.max(...flags.map(([flag]) => cells(flag)));
+    const keyWidth = Math.max(...[...AXIS_ORDER, ...SETTING_KEYS].map(key => maxCells(key)));
     return [
         ui.bold(`tonedial ${syntax}`),
         "",
@@ -241,6 +248,12 @@ function commandUsage(name, t, ui) {
         "",
         ui.bold(t.help.examples),
         ...COMMAND_EXAMPLES[name].map(example => `  ${ui.accent(example)}`),
+        ...(["get", "set"].includes(name) ? [
+            "", ui.bold(t.artifact.whatEachAxisObserves),
+            ...helpRows(AXIS_ORDER.map(key => [key, settingHelp(key, copy).join(" · ")]), keyWidth, ui),
+            "", ui.bold(t.artifact.whatElseIsSettable),
+            ...helpRows(SETTING_KEYS.map(key => [key, settingHelp(key, copy).join(" · ")]), keyWidth, ui),
+        ] : []),
     ].join("\n");
 }
 /**
@@ -319,7 +332,8 @@ export async function run(argv, env = process.env, cwd = process.cwd(), isTTY =
     // Resolved before the mode is validated, so the message about a bad `--color` is itself
     // painted the way the rest of this invocation would have been.
     const configPath = resolvePaths(env).config;
-    const say = messages(configPath, env);
+    const copy = catalogue(configLanguage(configPath) ?? detectLanguage(env));
+    const say = copy.cli;
     const colour = String(parsed.values.color);
     const mode = isColourMode(colour) ? colour : "auto";
     // The line budget is settled here beside the colour, because it is the same kind of decision:
@@ -353,7 +367,7 @@ export async function run(argv, env = process.env, cwd = process.cwd(), isTTY =
         if (!Object.hasOwn(COMMANDS, name)) {
             return fail(asJson, say.errors.notACommand(asJson ? name : humanText(name), COMMAND_NAMES, nearest(name, COMMAND_NAMES)), 2, uiErr);
         }
-        process.stdout.write(`${commandUsage(name, say, ui)}\n`);
+        process.stdout.write(`${commandUsage(name, copy, ui)}\n`);
         return 0;
     }
     // npx supplies no durable bare command for generated controls. Help and version stay available.
@@ -503,7 +517,7 @@ function fail(asJson, message, code, ui) {
     }
     else {
         // A standalone path is a copy target, not prose to split into unusable fragments.
-        const lines = message.split("\n").flatMap((line) => isAbsolute(line) || /^(?:tonedial|npm|curl) /.test(line) ? [humanText(line)] : wrap(humanText(line), ui.width));
+        const lines = message.split("\n").flatMap((line) => isAbsolute(line) || /^(?:tonedial|curl) |^npm (?:install|uninstall|update) -|^https?:\/\//.test(line) ? [humanText(line)] : wrap(humanText(line), ui.width));
         process.stderr.write(lines.map((line) => ui.error(line)).join("\n") + "\n");
     }
     return code;

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/get.js

@@ -0,0 +1,41 @@
+// Read active settings without compiling, repairing, or interpreting stored text.
+import { isAxis, AGE_BANDS, GENDERS, ConfigError, nearest, settingValues } from "../core/config.js";
+import { LANGUAGES, catalogue, detectLanguage, isLanguage } from "../core/i18n.js";
+import { humanText } from "../ui/format.js";
+import { maxCells, padEnd, wrap } from "../ui/width.js";
+import { planConfig } from "./compile.js";
+/** The same descriptions and allowed tokens serve key reads and command help. */
+export function settingHelp(key, copy) {
+    if (isAxis(key)) {
+        const hint = copy.axisHints[key];
+        return [hint.owns, `1–5 · 1 ${hint.low} · 5 ${hint.high}`];
+    }
+    const choices = key === "language" ? LANGUAGES : key === "persona.age" ? AGE_BANDS : key === "persona.gender" ? GENDERS : null;
+    return [copy.settingHints[key], ...(choices ? [choices.join(" | ")] : [])];
+}
+export function runGet(ctx, args) {
+    const { change, config } = planConfig(ctx);
+    if (change.before === null)
+        throw new ConfigError(ctx.t.test.missingConfig);
+    const all = settingValues(config);
+    const [requested] = args;
+    if (requested !== undefined && !Object.hasOwn(all, requested)) {
+        throw new ConfigError(ctx.t.axis.notSettable(ctx.asJson ? requested : humanText(requested), nearest(requested, Object.keys(all))));
+    }
+    const values = requested === undefined ? all : { [requested]: all[requested] };
+    const column = Math.max(...Object.keys(values).map(key => maxCells(key)));
+    const budget = ctx.ui.width - column - 4;
+    const lines = Object.entries(values).flatMap(([key, value]) => {
+        const text = value === null ? "—" : humanText(String(value));
+        if (budget < 12)
+            return [`  ${ctx.ui.accent(key)}`, ...wrap(text, ctx.ui.width - 4).map(line => `    ${line}`)];
+        const [first, ...rest] = wrap(text, budget);
+        return [`  ${ctx.ui.accent(padEnd(key, column))}  ${first ?? ""}`,
+            ...rest.map(line => `${" ".repeat(column + 4)}${line}`)];
+    });
+    if (requested !== undefined) {
+        const copy = catalogue(isLanguage(config.language) ? config.language : detectLanguage(ctx.env));
+        lines.push("", ...settingHelp(requested, copy).flatMap(hint => wrap(hint, ctx.ui.width - 2).map(line => `  ${ctx.ui.dim(line)}`)));
+    }
+    return { lines, json: { values } };
+}

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

@@ -60,7 +60,7 @@ export async function savePreset(ctx, displayName, state, options = {}) {
             [address?.self_ref ? ctx.t.persona.callsItself(humanText(address.self_ref)) : "",
                 address?.user_ref ? ctx.t.persona.callsYou(humanText(address.user_ref)) : ""].filter(Boolean).join(" · "),
             ...["user", "agent"].map((field) => `${ctx.t.persona.descriptionFull(field, humanText(config.persona[field] ?? ""))} (${ctx.t.create.descriptionCount([...(config.persona[field] ?? "")].length, PERSONA_DESCRIPTION_MAX)})`),
-            `${(config.safeword ? ctx.t.settings.safewordSet(humanText(config.safeword)) : ctx.t.settings.noSafeword).split(" — ")[0]} · ${ctx.t.settings.register(config.speech_level)}`,
+            `${config.safeword ? ctx.t.settings.safewordSet(humanText(config.safeword)) : ctx.t.settings.noSafeword} · ${ctx.t.settings.register(config.speech_level)}`,
         ];
         for (const detail of details.filter(Boolean))
             review.push(...wrap(detail, ctx.ui.width - 2).map((line) => `  ${line}`));
@@ -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, settingValues, } 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 = "—";
 /**
@@ -184,33 +157,19 @@ function movementLines(moves, ctx, axes) {
  * Returns `undefined` for a key this tool does not have, which `assign` then rejects by name.
  */
 function readKey(config, key, t) {
-    if (key === "safeword")
-        return config.safeword ?? UNSET;
-    if (key === "speech_level")
-        return config.speech_level;
-    if (key === "language")
-        return config.language;
-    if (key.startsWith("persona.")) {
-        const field = key.slice("persona.".length);
-        if (field === "age")
-            return config.persona.age ?? UNSET;
-        if (field === "gender")
-            return config.persona.gender ?? UNSET;
-        if (field === "self_ref")
-            return config.persona.address?.self_ref ?? UNSET;
-        if (field === "user_ref")
-            return config.persona.address?.user_ref ?? UNSET;
-        if (field === "note") {
-            const note = config.persona.note;
-            return note ? t.persona.noteChars([...note].length) : UNSET;
-        }
-        if (field === "user" || field === "agent") {
-            const description = config.persona[field];
-            return description ? t.persona.descriptionChars(field, [...description].length) : UNSET;
-        }
+    const values = settingValues(config);
+    if (!Object.hasOwn(values, key))
         return undefined;
+    const value = values[key];
+    if (value === null)
+        return UNSET;
+    if (typeof value === "string") {
+        if (key === "persona.note")
+            return t.persona.noteChars([...value].length);
+        if (key === "persona.user" || key === "persona.agent")
+            return t.persona.descriptionChars(key.slice("persona.".length), [...value].length);
     }
-    return isAxis(key) ? String(config.axes[key]) : undefined;
+    return String(value);
 }
 /**
  * Assign each pair, and record the movement each one actually made.
@@ -221,16 +180,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 +195,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 +229,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.