tonedial 0.1.1 → 0.1.3

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))
@@ -148,13 +153,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 {
@@ -174,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 },
         },
@@ -201,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/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)),
         ],
     };
 }

package/dist/commands/wire.js

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

package/dist/core/anchors.js

@@ -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/combos.js

@@ -30,45 +30,13 @@ const COMPOSITES = [
 export function composites(axes) {
     return COMPOSITES.filter((c) => c.fires(axes)).map((c) => c.line);
 }
-// Address heuristics intentionally cover Korean only; other free-form terms stay unclassified.
-// Widen only with a per-language address lexicon.
-const INFORMAL_SELF = /^(나|내|형|누나|오빠|언니)$/;
-const DEFERENTIAL_USER = /(님)$/;
-export function check(axes, persona, speechLevel) {
-    const w = [];
-    const add = (layer, rule, id) => w.push({ layer, rule, id });
-    if (axes.refusal >= 4 && axes.compliance >= 4) {
-        add("forbidden", "refusal≥4 × compliance≥4", "refusalCompliance");
-    }
-    if (persona) {
-        const selfRef = persona.address?.self_ref ?? null;
-        const userRef = persona.address?.user_ref ?? null;
-        if (axes.formality === 5 && selfRef && INFORMAL_SELF.test(selfRef)) {
-            add("awkward", "formality 5 × informal self_ref", "formalSelfRef");
-        }
-        if (axes.formality <= 2 && speechLevel === "plain" && userRef && DEFERENTIAL_USER.test(userRef)) {
-            add("awkward", "formality≤2 × deferential user_ref", "casualUserRef");
-        }
-        if (persona.age === "teens" && axes.formality === 5) {
-            add("awkward", "age: teens × formality 5", "teensFormal");
-        }
-        if (persona.age === "50s+" && selfRef && INFORMAL_SELF.test(selfRef)) {
-            add("awkward", "age: 50s+ with a junior self_ref", "seniorJuniorSelfRef");
-        }
-        // The spec's eighth awkward rule — `age` contradicting the relative age implied by
-        // `address` — is **not implemented**. It needs a kinship lexicon that maps 형 or 누나 to a
-        // relative age, in a design that takes address terms as free-form text in any language.
-        // Recorded rather than dropped: the rule is right and the input it needs does not exist.
-        // Measured, not predicted: across five `terse-operator` runs the configured address never
-        // surfaced once, because a maximally terse reply has no natural slot for a vocative.
-        // The user is told rather than obeyed, since the alternative is forcing unnatural output.
-        if ((selfRef || userRef) && (axes.warmth <= 2 || axes.verbosity <= 2)) {
-            add("ineffective", "address set while warmth≤2 or verbosity≤2", "addressUnlikely");
-        }
-    }
-    return w;
+/** Independent persona choices are valid; warn only when axis instructions conflict. */
+export function check(axes) {
+    return axes.refusal >= 4 && axes.compliance >= 4
+        ? [{ layer: "forbidden", rule: "refusal≥4 × compliance≥4", id: "refusalCompliance" }]
+        : [];
 }
-/** The axes a preset moves off their default. Sparsity is 5±2 of these. */
+/** The axes a preset moves off their default; custom profiles have no count restriction. */
 export function nonDefaultAxes(axes, defaults) {
     // Walks AXIS_ORDER rather than Object.keys: map iteration order follows the JSON file, and a
     // hand-edited config carrying a stray key would otherwise be reported as a non-default axis.

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,8 +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 NOTE_MAX = 200;
+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"];
@@ -854,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) => {