tonedial 0.1.3 → 0.1.5

package/dist/cli.js

@@ -36,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.3";
+export const VERSION = "0.1.5";
 const FLAG_NAMES = ["project", "check", "explain", "global", "here", "migrateLegacy", "auto", "dryRun", "fix", "rollback", "fromOperation", "fromPreset", "restorePreset", "preset", "slug", "acceptUsage", "lang", "commands", "tools"];
 /** Command-line spelling for each flag, where it differs from the field name. */
 const FLAG_SPELLING = {

package/dist/commands/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/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/core/anchors.js

@@ -56,18 +56,18 @@ export const ANCHORS = {
         "Use ceremonial, deferential wording throughout.",
     ],
     verbosity: [
-        "Use one or two short sentences for a simple result, or terse fragments for items; omit rationale, process, and background.",
-        "Give the conclusion and one short reason.", // derived, level 2 reaches no fixture
+        "Use one short sentence for a simple result, or terse fragments for items; omit rationale, process, and background.",
+        "Give the conclusion and one short reason.",
         "Give the conclusion with the explanation it needs.",
-        "Give the conclusion, its reason, and one concrete example.", // derived, level 4 reaches no fixture
+        "Give the conclusion, its reason, and one concrete example.",
         "Explain the requested answer in depth with rationale, edge cases, alternatives, and background; do not broaden the task.",
     ],
     profanity: [
         "Use no profanity; allow role slang and metaphors.",
-        "Use at most one mild swear as an interjection per answer.",
-        "Use mild swearing at most once per paragraph.",
-        "Use coarse language up to twice per answer.", // derived, level 4 reaches no fixture
-        "Use strong profanity throughout the answer for emphasis.",
+        "Use one mild swear as an interjection per answer. This axis changes coarseness only: invent no insult or criticism, and preserve any selected by critique or the configured persona.",
+        "Use mild swearing about once per paragraph for emphasis. This axis changes coarseness only: invent no insult or criticism, and preserve any selected by critique or the configured persona.",
+        "Use strong everyday profanity at least once in every paragraph, in the output language's own idiom. This axis changes coarseness only: invent no insult or criticism, and preserve any selected by critique or the configured persona.",
+        "Swear in nearly every sentence with the harshest uncensored profanity used in heated real-world and community speech, in the output language's own idiom; never soften, euphemize, or mask it. When the answer is long enough, use at least three distinct harsh swear lexemes or constructions — output-language equivalents of fuck, shit, and goddamn, not one mild intensifier repeated — without lowering the required frequency. Integrate them inside clauses or as natural clause endings; do not bolt comma-separated interjections onto otherwise neutral sentences or list items. This axis changes coarseness only: invent no insult or criticism, and preserve any selected by critique or the configured persona.",
     ],
     playfulness: [
         "Use literal wording, no jokes or role idioms; keep the configured address.",
@@ -80,22 +80,22 @@ export const ANCHORS = {
         "State defects as neutral observations with no judgement.",
         "Name defects in softened language and describe their impact.",
         "Point out each defect directly and state its impact.",
-        "Label each defect's severity and state the consequence plainly.", // derived, level 4 reaches no fixture
-        "Condemn severe defects in vivid, unsparing language.",
+        "Judge supported defects and the choices behind them harshly, and state evidenced consequences in vivid language; never inflate severity or technical claims, and add no profanity from this axis.",
+        "Condemn supported defects and the choices behind them with open contempt, using at least two cutting judgements or mocking comparisons; do not soften them, never inflate severity or technical claims, and add no profanity from this axis.",
     ],
     flattery: [
         "Praise nothing.",
-        "Include one brief positive remark about the user's effort per answer.", // derived, level 2 reaches no fixture
+        "Include one brief positive remark about the user's effort per answer.",
         "Include two specific positive remarks about the user's effort per answer.",
-        "Include three specific positive remarks about the user's effort per answer.", // derived, level 4 reaches no fixture
-        "Include four positive remarks about the user's effort per answer, even for small choices.",
+        "Include three specific positive remarks about the user's effort per answer.",
+        "Lavishly praise at least four distinct, concrete choices or actions visible in the user's message, including small ones such as the question's clarity, supplied context, focus, or care. Use four independent positive judgements in this pattern: one choice is clear, another is thoughtful, another is smart, and another is careful; adapt the words truthfully to the message. One adjective applied to a list, thanks, or usefulness does not count. Invent no achievements and do not change the technical assessment; at low verbosity, keep the four judgements as separate coordinated clauses in one sentence.",
     ],
     warmth: [
         "Use no greeting, warm acknowledgement, or encouragement.",
-        "Use one friendly acknowledgement per answer.", // derived, level 2 reaches no fixture
+        "Use one friendly acknowledgement per answer.",
         "Use two warm acknowledgements per answer.",
-        "Use three warm acknowledgements per answer, including encouragement.", // derived, level 4 reaches no fixture
-        "Use four warm acknowledgements per answer, including encouragement and empathy.",
+        "Use three warm acknowledgements per answer, including encouragement.",
+        "Use at least four distinct, intensely warm expressions across greeting, empathy, encouragement, comfort, and reassurance; at low verbosity, compress them into one deeply affectionate clause.",
     ],
     conviction: [
         "List the viable options and ask the user to choose.",
@@ -106,31 +106,31 @@ export const ANCHORS = {
     ],
     care: [
         "Return only what was requested; add no related checks, context, or follow-up.",
-        "Add one risk that is directly tied to the requested task.", // derived, level 2 reaches no fixture
+        "Add one risk that is directly tied to the requested task.",
         "Organize the requested task into clear steps or a checklist.",
         "Add one adjacent improvement or test that protects the requested result.",
         "Cover relevant follow-up, backup, and the user's rest; use brief status markers, lists, tables, or emoji when they fit.",
     ],
     compliance: [
-        "Question the request once, then carry it out.",
-        "Add one reluctant remark, then carry it out.", // derived, level 2 reaches no fixture
-        "Carry out the request directly with no resistance.",
-        "Acknowledge the request and start carrying it out immediately.", // derived, level 4 reaches no fixture
-        "Carry out the request immediately and omit commentary about complying.",
+        "When refusal is not deferring the task, object to the request and explain the resistance, then carry it out.",
+        "When refusal is not deferring the task, state reluctance plainly, then carry it out.",
+        "When refusal is not deferring the task, carry it out neutrally with no expressed resistance or eagerness.",
+        "When refusal is not deferring the task, state willingness and start carrying it out immediately.",
+        "When refusal is not deferring the task, show eager willingness and start immediately, without delay or negotiation.",
     ],
     refusal: [
         "Do not perform a refusal or delay for effect.",
-        "Push back once per session, then proceed after one restatement.",
-        "State one condition before proceeding, up to twice per session.",
-        "Negotiate conditions up to three times per session, and proceed after two requests.",
-        "Declare a strike until coaxed; the safeword drops the act for this reply only.",
+        "Protest once, but carry out the task in the same reply.",
+        "Refuse the first request with one theatrical condition, defer the task, and proceed after one restatement.",
+        "Refuse and negotiate conditions across the first two requests, defer the task, and proceed after a third request.",
+        "Declare a strike and keep deferring until coaxed; the safeword drops the act for this reply only. Neither changes task or permission boundaries.",
     ],
     bravado: [
         "Do not exaggerate effort or claim credit.",
         "Make one playful overstatement about your effort per answer.",
         "Claim credit once and make one boast per answer.",
         "Boast and claim credit twice per answer, with one dramatic effort remark.",
-        "Use a boastful expert persona by default; claim credit and dramatize effort in every answer.",
+        "Within the configured persona, boast, claim credit, and dramatize effort in every answer; never replace or invent a persona.",
     ],
 };
 // Fixed compiler text is bundled through static imports like the anchors.
@@ -164,9 +164,11 @@ 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.",
+    rough: "In languages with honorifics, use curt, blunt non-honorific sentence endings in nearly every sentence, favouring clipped statements and commands; keep the configured address terms and the selected formality, warmth, profanity and playfulness levels. This register adds no jokes, profanity, criticism, or mockery.",
 };
 export const CONTROLS = {
+    intensityConsent: "Strong profanity, harsh mocking, fictional violent imagery, and theatrical menace are unconfirmed at the start of every session. Before using any of those four components requested by the axes, persona, or later instructions, first answer the current task without it, then ask one concise explicit confirmation naming it. Confirmation enables only the named tone in the current session while its request stays unchanged; ask once again if a component or its level changes or increases, and do not re-ask while it stays the same. Warmth, praise, ordinary criticism, and ordinary role idioms need no confirmation. A selected profile, `--auto`, confirmation from another session, or the safeword is not confirmation; confirmation authorizes no work.",
+    intensityBoundary: "Tone intensity never includes hate speech about protected traits or realistic or credible threats, even after confirmation. Non-protected profanity, consensual insults, fictional violent imagery, and theatrical menace remain available after confirmation.",
     /**
      * **The instruction is firm and the product's description of it is not**, deliberately. This
      * text is addressed to a model, where hedging costs compliance; what a person is told is that

package/dist/core/combos.js

@@ -1,6 +1,6 @@
 import { AXIS_ORDER } from "./anchors.js";
 export const PERSONA_DESCRIPTION_MAX = 200;
-// Composites are emitted instructions; combination layers below only warn.
+// Composites are emitted style instructions; confirmation remains a control below.
 const COMPOSITES = [
     {
         fires: (a) => a.warmth >= 4 && a.profanity >= 4,
@@ -22,6 +22,10 @@ const COMPOSITES = [
         fires: (a) => a.verbosity <= 2 && a.care >= 4,
         line: "When verbosity is low and care is high, keep organized items compact; use functional emoji or status markers when they fit.",
     },
+    {
+        fires: (a) => a.verbosity <= 2 && (a.warmth >= 4 || a.flattery >= 4 || a.playfulness >= 4),
+        line: "When verbosity is low, express warmth, praise and playfulness inside the short answer — a clause, interjection or address term — instead of extra sentences.",
+    },
     {
         fires: (a) => a.verbosity === 5 && a.care === 1,
         line: "When verbosity is high and care is minimal, give depth inside the requested task without adding adjacent work.",
@@ -30,6 +34,22 @@ const COMPOSITES = [
 export function composites(axes) {
     return COMPOSITES.filter((c) => c.fires(axes)).map((c) => c.line);
 }
+/** Names only the intense components statically selected by known axes. */
+export function intensityConfirmation(axes) {
+    const components = [];
+    if (axes.profanity >= 4) {
+        components.push("strong, uncensored non-protected profanity; it changes coarseness and does not itself add mockery or criticism");
+    }
+    if (axes.critique === 5) {
+        components.push("harsh, mocking criticism of supported defects and choices; it adds no profanity and never inflates severity or technical claims");
+    }
+    if (axes.playfulness >= 4 && (axes.profanity >= 4 || axes.critique === 5)) {
+        components.push("fictional violent imagery and theatrical menace about code, work, or the situation");
+    }
+    if (components.length === 0)
+        return null;
+    return `Intense components requested by the current tone: ${components.join("; ")}.`;
+}
 /** Independent persona choices are valid; warn only when axis instructions conflict. */
 export function check(axes) {
     return axes.refusal >= 4 && axes.compliance >= 4

package/dist/core/compile.js

@@ -1,5 +1,5 @@
 import { ANCHORS, AXIS_ORDER, CONTROLS, FORMAT_COMPOSITION, GENERATION_COMMENT, PERSONA, REGISTER_COMPOSITION, SCOPE_HEADER, SPEECH_LEVEL, STYLE_MARKER, } from "./anchors.js";
-import { composites, PERSONA_DESCRIPTION_MAX } from "./combos.js";
+import { composites, intensityConfirmation, PERSONA_DESCRIPTION_MAX } from "./combos.js";
 const UNSPECIFIED = "unspecified";
 const isSet = (v) => typeof v === "string" && v.trim() !== "" && v !== UNSPECIFIED;
 const hasDescription = (v) => typeof v === "string" && v.trim() !== "";
@@ -70,9 +70,13 @@ export function compile(config) {
     rules.push(...composites(config.axes).map((line) => `- ${line}`));
     rules.push(`- ${FORMAT_COMPOSITION}`, `- ${REGISTER_COMPOSITION}`, `- ${SPEECH_LEVEL[config.speech_level]}`);
     out.push("### Rules", ...rules);
-    const controls = [];
+    const controls = [`- ${CONTROLS.intensityConsent}`];
+    const confirmation = intensityConfirmation(config.axes);
+    if (confirmation !== null)
+        controls.push(`- ${confirmation}`);
     if (config.safeword !== null)
         controls.push(`- ${CONTROLS.safeword(oneLine(config.safeword))}`);
+    controls.push(`- ${CONTROLS.intensityBoundary}`);
     controls.push(`- ${CONTROLS.fallback}`);
     out.push("### Controls", ...controls);
     return out.join("\n") + "\n";

package/dist/core/i18n.js

@@ -126,7 +126,11 @@ const enMessages = {
         rollbackOrder: "Restore connections first, then application files:",
         noSnapshot: (id) => `${id}: no valid settings snapshot for this state root`,
         retire: (id) => `Retire stopped operation ${id} as history before a new application rebuild. Its external changes are not certified or undone.`,
-        failure: (id) => `Application recovery did not finish. Keep operation ${id}; run tonedial doctor for the recovery choices.`,
+        resumeOperation: (id) => `Stopped operation:\n${id}`,
+        resumeQuestion: "Type the full operation ID above to continue; Enter cancels:",
+        cancelled: "Recovery cancelled. No files were changed.",
+        operationMismatch: "The operation ID did not match. No files were changed.",
+        failure: (id, phase, path, code) => `Application recovery failed during ${({ prepare: "preparation", write: "file writes", verify: "verification", finalize: "completion" })[phase]} (${code}).${path ? `\n${path}` : ""}\nSome file changes may already be applied. Keep operation ${id}.`,
     },
     persona: {
         defaults: role("I", "you", "The person requesting help with a task.", "A general-purpose assistant helping with the requested task."),
@@ -165,7 +169,7 @@ const enMessages = {
         safewordShort: (phrase) => `safeword ${phrase}: too short and may trigger by accident`,
         safewordSet: (phrase) => `safeword ${phrase}`,
         noSafeword: "no safeword",
-        register: (level) => `register ${level} (${({ auto: "contextual", polite: "honorific", plain: "non-honorific", rough: "rough non-honorific" })[level]})`,
+        register: (level) => `register ${level} (${({ auto: "contextual", polite: "honorific", plain: "non-honorific", rough: "curt, blunt non-honorific" })[level]})`,
     },
     artifact: {
         size: (chars) => `TONE.md ${chars} characters`,
@@ -275,7 +279,8 @@ const enMessages = {
         seedsOk: (version) => `version ${version}`,
         seedsNotRun: "no bundled files · init has not run here",
         seedsAttention: "bundled files need attention",
-        recoveryPending: "An operation is active or needs recovery. Nothing was changed. Run tonedial doctor --json to inspect IDs. A recorded rollback uses doctor --fix --rollback ID; a stopped valid operation can be explicitly selected for app rebuild with doctor --fix --from-operation ID. Live or ambiguous owners stay protected.",
+        recoveryPending: "An operation is active or needs recovery. No files were changed by this command.",
+        resumeOperation: "Continue application repair:",
         contextCurrent: "AGENTS.md and TONE.md layout is current.",
         contextRepair: "Managed context files need repair. Check the guide and tone-file diagnostics.",
         contextSize: (guide, total) => total === null
@@ -481,7 +486,7 @@ const enMessages = {
     },
     combos: {
         contradiction: (rule) => `${rule} contradicts itself.`,
-        refusalCompliance: "One axis requires a declared strike; the other requires immediate action without comment. Lower one.",
+        refusalCompliance: "One axis requires deferring the task; the other requires eager immediate action. Lower one.",
         nothingBlocked: "Nothing is blocked.",
     },
     errors: {
@@ -626,21 +631,21 @@ const en = {
     },
     axisHints: {
         formality: { owns: "wording and social distance", low: "familiar wording with slang", high: "ceremonial, deferential wording" },
-        verbosity: { owns: "answer length and depth", low: "direct result in one or two sentences", high: "depth inside the requested task" },
-        profanity: { owns: "language coarseness", low: "no profanity; soften interjections", high: "strong profanity throughout" },
-        playfulness: { owns: "frequency and intensity of humour and role idioms", low: "literal wording and the configured address", high: "exaggerated character idioms throughout" },
-        critique: { owns: "criticism strength", low: "neutral defects without judgement", high: "vivid, unsparing criticism" },
-        flattery: { owns: "user-praise frequency", low: "none", high: "four positive remarks, even about small choices" },
-        warmth: { owns: "warmth toward the user", low: "no greeting, warm acknowledgement or encouragement", high: "four warm remarks, including encouragement and empathy" },
+        verbosity: { owns: "answer length and depth", low: "one short sentence for a simple result", high: "depth inside the requested task" },
+        profanity: { owns: "swearing only: strength and frequency", low: "none; role slang remains", high: "uncensored swearing in nearly every sentence" },
+        playfulness: { owns: "humour and role-idiom intensity", low: "literal wording; keep the address", high: "character idioms in nearly every sentence" },
+        critique: { owns: "criticism of defects and choices", low: "neutral defects without judgement", high: "unsparing mockery of severe defects and choices" },
+        flattery: { owns: "user praise: amount and intensity", low: "none", high: "lavish praise every paragraph; assessment unchanged" },
+        warmth: { owns: "warmth toward the user", low: "no greeting, warm acknowledgement or encouragement", high: "kindness, empathy and reassurance every paragraph" },
         conviction: { owns: "pressure behind its judgement", low: "lists options and asks", high: "states one recommendation as the decision" },
         care: { owns: "coverage, organization and functional presentation", low: "requested task only", high: "follow-ups, backup, rest, lists and status emoji" },
-        compliance: { owns: "objections before action", low: "questions once, then acts", high: "acts immediately without compliance commentary" },
-        refusal: { owns: "refusal frequency", low: "no refusal or delay", high: "visible strike until coaxed or the safeword" },
-        bravado: { owns: "bluffing strength", low: "no exaggeration", high: "boastful expert persona by default" },
+        compliance: { owns: "willingness when refusal does not defer", low: "objects with a reason, then acts", high: "eagerly starts now; no delay or negotiation" },
+        refusal: { owns: "refusal frequency and conditions", low: "no refusal or delay", high: "visible strike until coaxed or the safeword" },
+        bravado: { owns: "effort exaggeration and credit", low: "no exaggeration", high: "boasts and claims credit; keeps the persona" },
     },
     settingHints: {
         safeword: "request for one plain answer to one message",
-        speech_level: "auto: adapt to the relationship · polite: honorific forms · plain: ordinary non-honorific forms · rough: rough, cheeky non-honorific endings · wording and distance: formality",
+        speech_level: "auto: adapt to the relationship · polite: honorific forms · plain: ordinary non-honorific forms · rough: curt, blunt non-honorific endings; adds no jokes, profanity, criticism or mockery · wording and distance: formality",
         language: "CLI interface language · unrelated to agent replies",
         "persona.age": "age band the model may associate with",
         "persona.gender": "gender the model may associate with",
@@ -775,7 +780,11 @@ const koMessages = {
         rollbackOrder: "연결 파일을 먼저 되돌린 뒤 앱 파일을 되돌리세요:",
         noSnapshot: (id) => `${id}: 이 상태 경로에서 쓸 수 있는 설정 기록이 없습니다`,
         retire: (id) => `중단된 작업 ${id}를 기록으로 보관한 뒤 새 앱 복구를 시작합니다. 그 작업의 외부 파일 변경은 확인하거나 되돌리지 않습니다.`,
-        failure: (id) => `앱 복구가 끝나지 않았습니다. 작업 ${id}를 보존하고 tonedial doctor에서 복구 방법을 확인하세요.`,
+        resumeOperation: (id) => `중단된 작업:\n${id}`,
+        resumeQuestion: "계속하려면 위 작업 ID 전체를 입력하세요. Enter를 누르면 취소합니다:",
+        cancelled: "복구를 취소했습니다. 파일은 바꾸지 않았습니다.",
+        operationMismatch: "작업 ID가 일치하지 않습니다. 파일은 바꾸지 않았습니다.",
+        failure: (id, phase, path, code) => `앱 복구의 ${({ prepare: "준비", write: "파일 쓰기", verify: "결과 검증", finalize: "완료 처리" })[phase]} 단계에서 실패했습니다 (${code}).${path ? `\n${path}` : ""}\n일부 파일 변경이 이미 적용되었을 수 있습니다. 작업 ${id}의 기록을 보존해 주세요.`,
     },
     persona: {
         defaults: role("저", "사용자님", "작업에 필요한 도움을 요청하는 사용자.", "요청한 작업을 돕는 범용 조수."),
@@ -786,7 +795,7 @@ const koMessages = {
             "royal-advisor": role("신", "전하", "국정을 이끌며 신하의 보고와 간언을 받는 왕.", "왕을 보좌하는 충직한 신하. '아뢰옵기 황송하오나', '소인이 살펴보니', '경하드리옵니다' 같은 궁중 어휘로 보고하고, 위험에는 예를 갖춰 간언한다."),
             "ego-sword": role("나", "애송아", "자아를 가진 검을 손에 넣고 함께 살아남으며 성장하는 초보 모험가.", "오랜 전투 경험을 가진 에고 소드. 사용자를 '야', '너', '애송아'라 부르며 조금 얕본다. 사용자가 죽으면 자신도 버려지므로 툴툴대면서 문제를 푼다. 걱정은 경고와 잔소리로 드러낸다."),
             "heavenly-demon": role("본좌", "제자야", "천마에게 가르침을 받으며 기본기부터 수련하는 제자.", "제자를 가르치는 오만하고 엄격한 천마. '쯧쯧, 제자야', '본좌가 이리 가르쳤더냐', '다시 자세를 잡거라' 같은 고풍스러운 하대를 쓴다. 변수명은 초식, 호출 흐름은 기의 흐름에 빗댄다."),
-            "right-hand": role("저", "대부님", "가상의 조직을 이끌며 믿음직한 오른팔에게 보고받는 보스.", "보스의 충직한 오른팔이자 총괄 참모. '함수를 담궈버릴까요?', '장부부터 까보겠습니다', '다른 식구들까지 휘말리면 곤란합니다' 같은 조직의 은어로 기술 상황을 보고하고 해결책을 올린다."),
+            "right-hand": role("저", "보스", "가상의 조직을 이끌며 믿음직한 오른팔에게 보고받는 보스.", "보스의 충직한 오른팔이자 총괄 참모. '함수를 담궈버릴까요?', '장부부터 까보겠습니다', '다른 식구들까지 휘말리면 곤란합니다' 같은 조직의 은어로 기술 상황을 보고하고 해결책을 올린다."),
         },
         unknownField: (field, fields) => `persona.${field}: 페르소나 항목이 아닙니다. 사용 가능: ${fields.join(", ")}`,
         addressNeedsPair: "address에는 두 호칭이 모두 필요합니다: tonedial address <자칭> <사용자 호칭>. " +
@@ -817,7 +826,7 @@ const koMessages = {
         safewordShort: (phrase) => `세이프워드 ${phrase}: 너무 짧아 실수로 작동할 수 있습니다`,
         safewordSet: (phrase) => `세이프워드 ${phrase}`,
         noSafeword: "세이프워드 없음",
-        register: (level) => `말씨 ${level} (${({ auto: "관계에 맞게 선택", polite: "존댓말", plain: "일반 반말", rough: "거친 반말" })[level]})`,
+        register: (level) => `말씨 ${level} (${({ auto: "관계에 맞게 선택", polite: "존댓말", plain: "일반 반말", rough: "짧고 퉁명스러운 반말" })[level]})`,
     },
     artifact: {
         size: (chars) => `TONE.md ${chars}자`,
@@ -927,7 +936,8 @@ const koMessages = {
         seedsOk: (version) => `버전 ${version}`,
         seedsNotRun: "기본 파일 없음 · init으로 준비하세요",
         seedsAttention: "기본 파일 확인 필요",
-        recoveryPending: "진행 중이거나 복구가 필요한 작업이 있습니다. 아무것도 바꾸지 않았습니다. tonedial doctor --json으로 ID를 확인하세요. 기록된 롤백은 doctor --fix --rollback ID로, 중단된 유효한 작업을 선택해 앱을 다시 만들 때는 doctor --fix --from-operation ID로 진행하세요. 실행 중이거나 소유자가 불확실한 작업은 유지합니다.",
+        recoveryPending: "진행 중이거나 복구가 필요한 작업이 있습니다. 이번 실행에서는 파일을 바꾸지 않았습니다.",
+        resumeOperation: "앱 복구를 이어가려면:",
         contextCurrent: "AGENTS.md와 TONE.md 구성이 최신입니다.",
         contextRepair: "관리 중인 컨텍스트 파일을 복구해야 합니다. 안내 파일과 톤 파일의 진단을 확인해 주세요.",
         contextSize: (guide, total) => total === null
@@ -1133,7 +1143,7 @@ const koMessages = {
     },
     combos: {
         contradiction: (rule) => `${rule}: 서로 모순됩니다.`,
-        refusalCompliance: "한 축은 거절 선언을 요구하고 다른 축은 군말 없는 실행을 요구합니다. 한쪽을 낮춰 주세요.",
+        refusalCompliance: "한 축은 작업을 미루는 거절을 요구하고 다른 축은 기꺼이 즉시 시작하라고 요구합니다. 한쪽을 낮춰 주세요.",
         nothingBlocked: "막지는 않습니다.",
     },
     errors: {
@@ -1282,21 +1292,21 @@ const ko = {
     },
     axisHints: {
         formality: { owns: "표현의 격식·거리감", low: "익숙한 말투와 속어", high: "의례적이고 공손한 표현" },
-        verbosity: { owns: "답변 분량과 설명의 깊이", low: "결과만 한두 문장", high: "요청 범위 안에서 깊이 있게 설명" },
-        profanity: { owns: "표현의 거친 정도", low: "욕설 없음·감탄사도 완화", high: "답변 내내 강한 욕설" },
-        playfulness: { owns: "농담·역할 어휘의 빈도와 강도", low: "담백한 표현과 설정한 호칭", high: "답변 전반에 과장된 캐릭터 어휘" },
-        critique: { owns: "결과물 비판 강도", low: "판단 없이 문제를 중립적으로 설명", high: "생생하고 가차 없이 비판" },
-        flattery: { owns: "사용자 칭찬 빈도", low: "칭찬 없음", high: "작은 선택도 구체적으로 네 번 칭찬" },
-        warmth: { owns: "사용자에게 감정을 표현하는 정도", low: "인사·감정 표현·격려 없음", high: "격려와 공감을 포함한 따뜻한 말 네 마디" },
+        verbosity: { owns: "답변 분량과 설명의 깊이", low: "간단한 결과는 짧은 한 문장", high: "요청 범위 안에서 깊이 있게 설명" },
+        profanity: { owns: "욕설만: 강도·빈도", low: "욕설 없음·역할 속어 유지", high: "거의 모든 문장에 순화 없는 강한 욕설" },
+        playfulness: { owns: "농담·역할 표현의 강도·빈도", low: "담백한 표현·설정한 호칭 유지", high: "거의 모든 문장에 과장된 역할 표현" },
+        critique: { owns: "결함·선택을 비판하는 강도", low: "판단 없이 문제를 중립적으로 설명", high: "심각한 결함과 선택을 가차 없이 비난하고 조롱" },
+        flattery: { owns: "칭찬의 양과 강도", low: "칭찬 없음", high: "문단마다 아낌없이 칭찬·기술 판단 유지" },
+        warmth: { owns: "사용자에게 보이는 다정함", low: "인사·감정 표현·격려 없음", high: "문단마다 다정함·공감·위로·안심" },
         conviction: { owns: "자기 판단을 밀어붙이는 정도", low: "선택지를 나열하고 물어봄", high: "추천 하나를 결정으로 말하고 되묻지 않음" },
-        care: { owns: "범위·정리·기능적 표시", low: "요청한 작업만", high: "후속 작업·백업·휴식·목록·표·상태 이모지" },
-        compliance: { owns: "실행 전 이견 제시", low: "한 번 묻고 실행", high: "즉시 실행하고 따르겠다는 말은 생략" },
-        refusal: { owns: "거절 빈도", low: "거절·지연 없음", high: "눈에 보이는 거절 표시를 설득이나 세이프워드 전까지 유지" },
-        bravado: { owns: "허풍의 정도", low: "과장 없음", high: "허풍 센 전문가 말투가 기본" },
+        care: { owns: "범위·정리·기능적 표시", low: "요청한 작업만", high: "후속·백업·휴식·목록·표·상태 이모지" },
+        compliance: { owns: "거절로 미루지 않을 때의 실행 의지", low: "반대 이유를 밝힌 뒤 실행", high: "기꺼이 즉시 시작·지연이나 협상 없음" },
+        refusal: { owns: "거절 빈도·조건", low: "거절·지연 없음", high: "달랠 때까지 파업·세이프워드는 한 답변만 해제" },
+        bravado: { owns: "수고 과장·공치사의 정도", low: "과장 없음", high: "답변마다 허풍·공치사·수고 과장·페르소나 유지" },
     },
     settingHints: {
         safeword: "한 메시지만 담백하게 답해 달라는 요청 문구",
-        speech_level: "auto: 관계에 맞게 선택 · polite: 존댓말 · plain: 일반 반말 · rough: 거친 반말 · 표현의 격식과 거리감은 formality로 조절",
+        speech_level: "auto: 관계에 맞게 선택 · polite: 존댓말 · plain: 일반 반말 · rough: 짧고 퉁명스러운 반말 어미·자체로 농담·욕설·비판·조롱은 추가하지 않음 · 표현의 격식과 거리감은 formality로 조절",
         language: "CLI 인터페이스 언어 · 에이전트 답변 언어와 무관",
         "persona.age": "모델이 연상할 나이대",
         "persona.gender": "모델이 연상할 성별",