tonedial 0.1.2 → 0.1.4

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.2";
+export const VERSION = "0.1.4";
 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/doctor.js

@@ -515,11 +515,34 @@ async function doctorReport(ctx, showRollbackCommands = true, showCodexAction =
         operations: inspected.journals.map(({ operationId, state }) => ({ operationId, state })),
     };
     if (inspected.lock.state !== "none" || inspected.journals.some(({ state }) => state === "pending" || state === "invalid")) {
+        const owner = inspected.lock.owner;
+        const blocking = inspected.journals.filter(({ state }) => state === "pending" || state === "invalid");
+        const shown = ctx.flags.verbose ? inspected.journals : inspected.journals.filter(({ operationId, state }) => state === "pending" || state === "invalid" || operationId === owner?.operationId);
+        const lines = [
+            ...wrap(ctx.t.doctor.recoveryPending, ctx.ui.width - 2).map(line => `  ${ctx.ui.warn(line)}`),
+            ...shown.map(({ operationId, state }) => `  ${operationId}  ${ctx.t.doctor.operationState[state]}`),
+        ];
+        if (owner !== null && !shown.some(({ operationId }) => operationId === owner.operationId))
+            lines.push(`  ${owner.operationId}`);
+        if (inspected.lock.state === "live" || inspected.lock.state === "unknown" || inspected.lock.state === "invalid") {
+            lines.push(...wrap(ctx.t.doctor.rollbackStatus[inspected.lock.state === "live" ? "busy" : "unresolved"], ctx.ui.width - 2)
+                .map(line => `  ${line}`));
+        }
+        else if (inspected.lock.state === "dead" && owner?.kind === "mutation") {
+            const entry = inspected.journals.find(({ operationId }) => operationId === owner.operationId);
+            if (entry?.journal && entry.journal.owner.nonce === owner.nonce) {
+                const selection = inspectRollback(ctx.paths, owner.operationId);
+                if (entry.state === "pending" && !selection.synthetic && blocking.every(({ operationId, journal }) => operationId === owner.operationId && journal !== null)) {
+                    lines.push("", `  ${ctx.t.doctor.resumeOperation}`, ...nextStep(repairCommand(ctx, `doctor --fix --from-operation ${owner.operationId}`), ctx.ui).slice(1));
+                }
+                if (showRollbackCommands && previewRollback(ctx.paths, owner.operationId, ctx.t).status === "ready") {
+                    lines.push("", ...receiptLines(ctx.t.recovery.rollback(owner.operationId), ctx.ui.width - 2).map(line => `  ${line}`));
+                }
+            }
+        }
+        lines.push(...nextStep(`${repairCommand(ctx, "doctor")} --json`, ctx.ui));
         return {
-            lines: [
-                ...wrap(ctx.t.doctor.recoveryPending, ctx.ui.width - 2).map((line) => `  ${ctx.ui.warn(line)}`),
-                ...recovery.operations.map(({ operationId, state }) => `  ${operationId}  ${ctx.t.doctor.operationState[state]}`),
-            ],
+            lines,
             // The damaged config is deliberately not parsed here. `operation` is the only safe context
             // fact to expose until the owner-selected rollback or recovery has completed.
             json: {

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

@@ -8,7 +8,7 @@ import { compile } from "../core/compile.js";
 import { toCompileInput } from "../core/resolve.js";
 import { isLanguage, LANGUAGES } from "../core/i18n.js";
 import { recoverLegacyTone } from "../core/legacy-tone.js";
-import { exportAliasesState, stateOverlapsInstructions } from "../core/paths.js";
+import { connectionScopeFlag, exportAliasesState, stateOverlapsInstructions } from "../core/paths.js";
 import { applyPreset, matchesPreset, assertPresetSelection, BUNDLED, customPresetDir, inspectPresetLibrary, parsePreset, PRESET_MAX_BYTES, resolvePreset, serializePreset, SLUG_PATTERN, } from "../core/presets.js";
 import { contextArtifactTargets, generatedSeedSelection, planGeneratedSeedRebuild, seedFiles, SEED_VERSION, } from "../core/seeds.js";
 import { inspectOperations, readJournal, retireOperationForAppRebuild, } from "../core/operations.js";
@@ -254,9 +254,14 @@ export async function runAppRebuild(ctx) {
             else if (!ctx.flags.auto && ctx.canPrompt) {
                 const input = createInterface({ input: process.stdin, output: process.stdout });
                 try {
-                    process.stdout.write(`  ${t.doctor.recoveryPending}\n  ${owner.operationId}\n`);
-                    if ((await input.question("  > ")).trim() !== owner.operationId)
-                        throw new ConfigError(t.doctor.recoveryPending);
+                    const operation = t.recovery.resumeOperation(owner.operationId).split("\n").flatMap(line => line === owner.operationId ? [line] : wrap(line, ctx.ui.width - 2));
+                    process.stdout.write(`${operation.map(line => `  ${line}`).join("\n")}\n`);
+                    const question = wrap(t.recovery.resumeQuestion, ctx.ui.width - 3).map(line => `  ${line}`).join("\n");
+                    const answer = (await input.question(`${question} `)).trim();
+                    if (answer === "")
+                        throw new ConfigError(t.recovery.cancelled);
+                    if (answer !== owner.operationId)
+                        throw new ConfigError(t.recovery.operationMismatch);
                     retirementId = owner.operationId;
                 }
                 finally {
@@ -394,6 +399,8 @@ export async function runAppRebuild(ctx) {
     }
     const seedsSelection = generatedSeedSelection(ctx.paths, config, ctx.flags.tools !== null && ctx.flags.tools !== "none", t);
     const seeds = planGeneratedSeedRebuild(ctx.paths, config.managedSeeds, seedsSelection, t);
+    const generatedSeeds = seedFiles(ctx.paths, seedsSelection);
+    const rewrittenGenerated = new Set(generatedSeeds.filter(seed => seeds.operationActions.some(({ action }) => action.path === seed.path || (object(action.after)?.type === "directory" && seed.path.startsWith(`${action.path}${sep}`)))).map(seed => seed.path));
     checks.push(...seeds.checks);
     config.managedSeeds = seeds.records;
     config.seedVersion = SEED_VERSION;
@@ -457,40 +464,54 @@ export async function runAppRebuild(ctx) {
         auto: ctx.flags.auto, dryRun: ctx.flags.dryRun, verbose: ctx.flags.verbose, ui: ctx.ui, t,
         heading: t.recovery.heading,
         interactive: () => ctx.canPrompt, ...(ctx.canPrompt ? {} : { out: () => { } }),
-        recoveryPresentation: { lines: presentation, failureMessage: t.recovery.failure },
+        recoveryPresentation: { lines: presentation,
+            failureMessage: (id, phase, path, code) => `${t.recovery.failure(id, phase, path, code)}\ntonedial doctor ${connectionScopeFlag(ctx.agent)} --json` },
         verify: () => {
+            let verificationPath = ctx.paths.config;
+            const mismatch = () => new ConfigError(t.recovery.sourceInvalid, { cause: { code: "VERIFY_MISMATCH", path: verificationPath } });
             try {
                 const repaired = parseConfig(capturedText(captureRawEntry(ctx.paths.config, t, { within: ctx.paths.root })) ?? "", t);
                 if (!isConfigV2(repaired) || serializeConfig(repaired, t) !== serializeConfig(config, t))
-                    throw new ConfigError(t.recovery.sourceInvalid);
-                for (const seed of seedFiles(ctx.paths, seedsSelection)) {
+                    throw mismatch();
+                for (const seed of generatedSeeds) {
+                    verificationPath = seed.path;
                     const now = captureRawEntry(seed.path, t, { within: ctx.paths.root });
                     if (capturedText(now) !== seed.contents)
-                        throw new ConfigError(t.recovery.sourceInvalid);
+                        throw mismatch();
                 }
-                for (const target of artifacts)
+                for (const target of artifacts) {
+                    verificationPath = target.path;
                     if (capturedText(captureRawEntry(target.path, t, { within: ctx.paths.root })) !== artifact)
-                        throw new ConfigError(t.recovery.sourceInvalid);
+                        throw mismatch();
+                }
+                verificationPath = ctx.paths.tone;
                 if (capturedText(captureRawEntry(ctx.paths.tone, t, { within: ctx.paths.root })) !== artifact)
-                    throw new ConfigError(t.recovery.sourceInvalid);
+                    throw mismatch();
                 for (const entry of library.entries) {
                     for (const before of entry.selectionReads) {
-                        if (before.path === restoredPreset?.capture.path)
+                        // Rewritten generated entries were checked against their new bytes above.
+                        if (before.path === restoredPreset?.capture.path || rewrittenGenerated.has(before.path))
                             continue;
+                        verificationPath = before.path;
                         const now = captureRawEntry(before.path, t, { within: ctx.paths.root, maxBytes: PRESET_MAX_BYTES });
                         if (now.type !== before.type || now.identity !== before.identity || now.mode !== before.mode ||
                             (now.bytes === null ? before.bytes !== null : before.bytes === null || !now.bytes.equals(before.bytes))) {
-                            throw new ConfigError(t.recovery.sourceInvalid);
+                            throw mismatch();
                         }
                     }
                 }
                 for (const slug of [...copies, ...(restoredPreset ? [restoredPreset.slug] : [])]) {
+                    verificationPath = slug === restoredPreset?.slug ? restoredPreset.capture.path
+                        : library.recoveryCopies.find(copy => copy.preset.slug === slug).path;
                     if (resolvePreset(ctx.paths.presets, slug, t) === null)
-                        throw new ConfigError(t.recovery.sourceInvalid);
+                        throw mismatch();
                 }
             }
-            catch {
-                throw new ConfigError(t.recovery.sourceInvalid);
+            catch (cause) {
+                if (cause instanceof ConfigError && cause.cause?.code === "VERIFY_MISMATCH")
+                    throw cause;
+                const code = cause !== null && typeof cause === "object" && "code" in cause ? cause.code : undefined;
+                throw new ConfigError(t.recovery.sourceInvalid, { cause: { code, path: verificationPath, cause } });
             }
         },
     };

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}`));

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, 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";
@@ -157,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.

package/dist/commands/show.js

@@ -5,7 +5,7 @@ import { isAbsolute } from "node:path";
 import { stripVTControlCharacters } from "node:util";
 import { AXIS_DEFAULT, AXIS_GROUP, AXIS_KIND, AXIS_RISK_FROM, riskyAxes } from "../core/anchors.js";
 import { check as checkCombos, PERSONA_DESCRIPTION_MAX } from "../core/combos.js";
-import { ConfigError, isConfigV2 } from "../core/config.js";
+import { ConfigError, isConfigV2, settingValues } from "../core/config.js";
 import { compile, measure } from "../core/compile.js";
 import { withPreset, matchesPreset, inspectPresetLibrary, resolvePreset } from "../core/presets.js";
 import { toCompileInput } from "../core/resolve.js";
@@ -31,6 +31,7 @@ export function runShow(ctx, args) {
     }
     const shown = preview ? withPreset(config, preview) : config;
     const axes = shown.axes;
+    const values = settingValues(shown);
     const input = toCompileInput(shown);
     const artifact = compile(input);
     const size = measure(artifact);
@@ -63,33 +64,37 @@ export function runShow(ctx, args) {
         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);
+    const { "persona.age": age, "persona.gender": gender, "persona.note": note, "persona.self_ref": selfRef, "persona.user_ref": userRef, "persona.user": user, "persona.agent": agent } = values;
+    const personaSet = Boolean(age || gender || note || selfRef || userRef || user || agent);
     const gauges = [gaugeHeader(ui, ctx.t), ...gaugeBlock(axes, ui)];
     const gaugeWidth = Math.max(...gauges.map((line) => maxCells(stripVTControlCharacters(line))));
     const detailWidth = ui.terminal && ui.width >= 119 ? ui.width - gaugeWidth - 4 : ui.width - 2;
     const details = [ui.bold(ctx.t.artifact.settingsHeading)];
     if (personaSet) {
         const bits = [
-            p.age ? humanText(p.age) : null,
-            p.gender ? humanText(p.gender) : null,
-            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.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,
+            age ? humanText(age) : null,
+            gender ? humanText(gender) : null,
+            selfRef ? ctx.t.persona.callsItself(humanText(selfRef)) : null,
+            userRef ? ctx.t.persona.callsYou(humanText(userRef)) : null,
+            note ? ctx.t.persona.noteChars([...note].length) : null,
+            user && agent ? ctx.t.persona.descriptionCounts([...user].length, [...agent].length, PERSONA_DESCRIPTION_MAX) : null,
+            user && !agent ? ctx.t.persona.descriptionChars("user", [...user].length) : null,
+            agent && !user ? ctx.t.persona.descriptionChars("agent", [...agent].length) : null,
         ].filter(Boolean);
         if (bits.length)
             for (const folded of wrap(bits.join(" · "), detailWidth))
                 details.push(ui.dim(folded));
-        for (const [field, value] of [["agent", p.agent], ["user", p.user]]) {
+        for (const [field, value] of [["agent", agent], ["user", user]]) {
             if (value === null)
                 continue;
             for (const folded of wrap(ctx.t.persona.descriptionFull(field, humanText(value)), detailWidth)) {
                 details.push(ui.dim(folded));
             }
         }
+        if (note !== null) {
+            for (const folded of wrap(ctx.t.persona.descriptionFull("note", humanText(note)), detailWidth))
+                details.push(ui.dim(folded));
+        }
     }
     // Folded rather than laid out: the safeword is user text of unbounded length, so this row
     // can always exceed the budget and no amount of shortening the fixed words prevents it.
@@ -97,7 +102,7 @@ export function runShow(ctx, args) {
         ? [...new Set(Object.values(config.wiring.registrations).map((record) => `${record.target} (${record.scope})`))]
         : Object.keys(config.wiring);
     for (const text of [
-        stateRow(shown, ctx.t), ctx.t.artifact.displaySettings(config.language),
+        stateRow(values, ctx.t), ctx.t.artifact.displaySettings(values.language),
         ctx.t.artifact.connectionRecords(records.map(humanText)),
     ])
         for (const folded of wrap(text, detailWidth))
@@ -170,10 +175,10 @@ export function runShow(ctx, args) {
             riskAxes: riskyAxes(axes),
             riskThresholds: AXIS_RISK_FROM,
             persona: shown.persona,
-            safeword: shown.safeword,
-            speech_level: shown.speech_level,
+            safeword: values.safeword,
+            speech_level: values.speech_level,
             // Interface language never changes the compiled tone.
-            language: config.language,
+            language: values.language,
             chars: size.chars,
             artifact: { exists: artifactOnDisk },
         },
@@ -197,9 +202,9 @@ function titleRow(name, sizeLabel, ctx) {
  * Safeword and register on one row. Plain text, because it is folded before it is
  * painted and an escape sequence measures as characters while occupying no cell.
  */
-function stateRow(config, t) {
-    const safeword = config.safeword ? t.settings.safewordSet(humanText(config.safeword)).split(" — ")[0] : t.settings.noSafeword.split(" — ")[0];
-    return `${safeword} · ${t.settings.register(config.speech_level)}`;
+function stateRow(values, t) {
+    const safeword = values.safeword ? t.settings.safewordSet(humanText(values.safeword)) : t.settings.noSafeword;
+    return `${safeword} · ${t.settings.register(values.speech_level)}`;
 }
 // Presence alone establishes neither current contents nor native loading.
 function artifactExists(ctx) {

package/dist/core/anchors.js

@@ -164,6 +164,7 @@ export const SPEECH_LEVEL = {
     auto: "In languages with honorifics, choose address forms for the current relationship and scene; keep them consistent within each reply.",
     polite: "In languages with honorifics, use polite address forms even with familiar wording.",
     plain: "In languages with honorifics, use plain address forms even with formal wording.",
+    rough: "In languages with honorifics, use rough, cheeky non-honorific sentence endings; keep the configured address terms and the selected formality, warmth, profanity and playfulness levels.",
 };
 export const CONTROLS = {
     /**

package/dist/core/compile.js

@@ -35,8 +35,8 @@ function validate(config) {
             throw new RangeError(`axis ${axis} is ${level}, not a level 1 to 5`);
         }
     }
-    if (!(config.speech_level in SPEECH_LEVEL)) {
-        throw new RangeError(`speech_level is ${config.speech_level}, not auto, polite, or plain`);
+    if (!Object.hasOwn(SPEECH_LEVEL, config.speech_level)) {
+        throw new RangeError(`speech_level is ${config.speech_level}, not auto, polite, plain, or rough`);
     }
     if (config.persona !== null) {
         for (const field of ["user", "agent"]) {

package/dist/core/config.js

@@ -10,7 +10,7 @@ export const CONFIG_SCHEMA = 2;
 export const LEGACY_CONFIG_SCHEMA = 1;
 export const AGE_BANDS = ["unspecified", "teens", "20s", "30s", "40s", "50s+"];
 export const GENDERS = ["unspecified", "masculine", "feminine", "neutral"];
-export const SPEECH_LEVELS = ["auto", "polite", "plain"];
+export const SPEECH_LEVELS = ["auto", "polite", "plain", "rough"];
 export const WIRING_SCOPES = ["global", "project"];
 export const RESOURCE_KINDS = ["hook", "skill", "shell", "reader", "command"];
 export const RESOURCE_TYPES = ["file", "directory", "symlink"];
@@ -853,20 +853,32 @@ export const isAxis = (name) => AXIS_ORDER.includes(name);
 /**
  * Everything `set <key>=<value>` takes that is not an axis.
  *
- * Two consumers: the did-you-mean match in `set`, and the order `show --explain` renders the
- * per-language descriptions in. It does not drive `assign` or `readKey` — each of those branches
- * carries its own parsing and its own refusal.
+ * Shared by key discovery, setting reads, and the did-you-mean match in `set`.
+ * Assignment retains its own validation.
  *
- * Only one drift direction is caught. A key listed here with no branch in `assign` fails the
- * test that drives every entry through `set`. A branch added to `assign` and never listed here
- * is invisible: it would not appear in `--explain` and `nearest` would not suggest it, and
- * nothing fails. Closing that needs `assign` to be a table rather than a chain of `if`s.
+ * Command tests exercise this inventory through both setting and reading values.
  */
 export const SETTING_KEYS = [
     "safeword", "speech_level", "language",
     "persona.age", "persona.gender", "persona.self_ref", "persona.user_ref", "persona.note",
     "persona.user", "persona.agent",
 ];
+/** Current editable values, without presentation labels or internal ownership metadata. */
+export function settingValues(config) {
+    return {
+        ...Object.fromEntries(AXIS_ORDER.map(axis => [axis, config.axes[axis]])),
+        safeword: config.safeword,
+        speech_level: config.speech_level,
+        language: config.language,
+        "persona.age": config.persona.age,
+        "persona.gender": config.persona.gender,
+        "persona.self_ref": config.persona.address?.self_ref ?? null,
+        "persona.user_ref": config.persona.address?.user_ref ?? null,
+        "persona.note": config.persona.note,
+        "persona.user": config.persona.user,
+        "persona.agent": config.persona.agent,
+    };
+}
 /** Levenshtein-lite: enough to say "did you mean critique?" and no more. */
 export function nearest(name, candidates) {
     const distance = (a, b) => {