tonedial 0.1.4 → 0.1.6

package/dist/cli.js

@@ -36,13 +36,14 @@ 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.4";
-const FLAG_NAMES = ["project", "check", "explain", "global", "here", "migrateLegacy", "auto", "dryRun", "fix", "rollback", "fromOperation", "fromPreset", "restorePreset", "preset", "slug", "acceptUsage", "lang", "commands", "tools"];
+export const VERSION = "0.1.6";
+const FLAG_NAMES = ["project", "check", "explain", "global", "here", "migrateLegacy", "auto", "dryRun", "fix", "rollback", "quarantineOperation", "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 = {
     project: "project", check: "check", explain: "explain",
     global: "global", auto: "auto", dryRun: "dry-run", fix: "fix", lang: "lang", commands: "commands",
     tools: "tools", rollback: "rollback", here: "here", migrateLegacy: "migrate-legacy",
+    quarantineOperation: "quarantine-operation",
     fromOperation: "from-operation", fromPreset: "from-preset", restorePreset: "restore-preset",
     preset: "preset", slug: "slug", acceptUsage: "accept-usage",
 };
@@ -68,7 +69,7 @@ const COMMANDS = {
     unwire: { run: runUnwire, flags: ["global", "here", "project", "auto", "dryRun"], max: 1 },
     init: { run: runInit, flags: ["global", "here", "project", "migrateLegacy", "auto", "dryRun", "lang", "commands", "tools"], max: 0, context: "setup" },
     // Doctor checks mutation permission after its recovery-first diagnosis, even with bad config.
-    doctor: { run: runDoctor, flags: ["global", "here", "project", "auto", "dryRun", "fix", "rollback", "fromOperation", "fromPreset", "restorePreset", "tools"], max: 0 },
+    doctor: { run: runDoctor, flags: ["global", "here", "project", "auto", "dryRun", "fix", "rollback", "quarantineOperation", "fromOperation", "fromPreset", "restorePreset", "tools"], max: 0 },
     eject: { run: runEject, flags: ["global", "here", "project", "auto", "dryRun"], max: 0 },
 };
 const CONNECTION_COMMANDS = ["init", "wire", "doctor", "unwire", "eject"];
@@ -130,7 +131,8 @@ const COMMAND_EXAMPLES = {
     wire: ["tonedial wire codex --here --dry-run"],
     unwire: ["tonedial unwire codex --here --dry-run"],
     init: ["tonedial init --tools none --global --auto", "tonedial init --tools codex --here"],
-    doctor: ["tonedial doctor", "tonedial doctor --fix --global --tools none --dry-run"],
+    doctor: ["tonedial doctor", "tonedial doctor --fix --global --tools none --dry-run",
+        "tonedial doctor --fix --quarantine-operation ID --global"],
     eject: ["tonedial eject --here --dry-run"],
 };
 const FLAG_SYNTAX = [
@@ -145,6 +147,7 @@ const FLAG_SYNTAX = [
     ["tools", "--tools=LIST"],
     ["fix", "--fix"],
     ["rollback", "--rollback=ID"],
+    ["quarantineOperation", "--quarantine-operation=ID"],
     ["fromOperation", "--from-operation=ID"],
     ["fromPreset", "--from-preset=SLUG"],
     ["restorePreset", "--restore-preset=SLUG"],
@@ -298,6 +301,7 @@ export async function run(argv, env = process.env, cwd = process.cwd(), isTTY =
         "dry-run": { type: "boolean", default: false },
         fix: { type: "boolean", default: false },
         rollback: { type: "string" },
+        "quarantine-operation": { type: "string" },
         "from-operation": { type: "string" },
         "from-preset": { type: "string" },
         "restore-preset": { type: "string" },
@@ -398,6 +402,7 @@ export async function run(argv, env = process.env, cwd = process.cwd(), isTTY =
         dryRun: parsed.values["dry-run"] === true,
         fix: parsed.values.fix === true,
         rollback: typeof parsed.values.rollback === "string" ? parsed.values.rollback : null,
+        quarantineOperation: typeof parsed.values["quarantine-operation"] === "string" ? parsed.values["quarantine-operation"] : null,
         fromOperation: typeof parsed.values["from-operation"] === "string" ? parsed.values["from-operation"] : null,
         fromPreset: typeof parsed.values["from-preset"] === "string" ? parsed.values["from-preset"] : null,
         restorePreset: typeof parsed.values["restore-preset"] === "string" ? parsed.values["restore-preset"] : null,
@@ -424,9 +429,9 @@ export async function run(argv, env = process.env, cwd = process.cwd(), isTTY =
     if (command.max !== null && rest.length > command.max) {
         return fail(asJson, say.errors.tooManyArguments(name, command.max, rest.length), 2, uiErr);
     }
-    if (name === "doctor" && ((!flags.fix && (flags.fromOperation !== null || flags.fromPreset !== null || flags.restorePreset !== null || flags.tools !== null)) ||
+    if (name === "doctor" && ((!flags.fix && (flags.quarantineOperation !== null || flags.fromOperation !== null || flags.fromPreset !== null || flags.restorePreset !== null || flags.tools !== null)) ||
         (flags.restorePreset !== null && flags.fromOperation === null) ||
-        (flags.rollback !== null && (flags.fromOperation !== null || flags.fromPreset !== null || flags.restorePreset !== null || flags.tools !== null)))) {
+        (flags.rollback !== null && (flags.quarantineOperation !== null || flags.fromOperation !== null || flags.fromPreset !== null || flags.restorePreset !== null || flags.tools !== null)))) {
         return fail(asJson, say.recovery.invalidOptions, 2, uiErr);
     }
     try {

package/dist/commands/doctor.js

@@ -472,6 +472,20 @@ export async function runDoctor(ctx, _args) {
     if (!ctx.flags.fix)
         return doctorReport(ctx);
     const app = await runAppRebuild(ctx);
+    if (app.quarantineOnly) {
+        const rollbackLines = app.json.applied === true ? recoveryRollbackLines(ctx.t, app.json.operationId, null) : [];
+        const remaining = Array.isArray(app.json.remainingInvalidOperations)
+            ? app.json.remainingInvalidOperations.filter((id) => typeof id === "string") : [];
+        const next = typeof app.json.next === "string" ? app.json.next : null;
+        return {
+            ...app,
+            lines: [...app.lines, ...rollbackLines, ...(next === null ? [] : [
+                    `  ${ctx.t.recovery.quarantineRemaining(remaining.length)}`, "", `  ${next}`,
+                ])],
+            json: { ...app.json, root: ctx.agent.root, stateRoot: ctx.paths.root, agentRoot: ctx.agent.root,
+                live: ctx.agent.live, fixed: app.json.applied === true, appHealthy: false },
+        };
+    }
     if (ctx.flags.dryRun) {
         const native = await runRebuildNative(ctx, app.legacy, app.proposedConfig);
         return {
@@ -517,10 +531,14 @@ async function doctorReport(ctx, showRollbackCommands = true, showCodexAction =
     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 invalid = blocking.filter(({ state }) => state === "invalid");
+        const quarantineable = inspected.lock.state === "none" && blocking.length === invalid.length && invalid.length > 0;
+        const singleQuarantine = quarantineable && invalid.length === 1;
         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]}`),
+            ...wrap(quarantineable ? ctx.t.doctor.invalidRecoveryPending : ctx.t.doctor.recoveryPending, ctx.ui.width - 2).map(line => `  ${ctx.ui.warn(line)}`),
+            ...shown.filter(({ operationId }) => !singleQuarantine || operationId !== invalid[0].operationId)
+                .map(({ operationId, state }) => `  ${operationId}  ${ctx.t.doctor.operationState[state]}`),
         ];
         if (owner !== null && !shown.some(({ operationId }) => operationId === owner.operationId))
             lines.push(`  ${owner.operationId}`);
@@ -540,7 +558,14 @@ async function doctorReport(ctx, showRollbackCommands = true, showCodexAction =
                 }
             }
         }
-        lines.push(...nextStep(`${repairCommand(ctx, "doctor")} --json`, ctx.ui));
+        if (quarantineable) {
+            lines.push("", ...(singleQuarantine
+                ? wrap(ctx.t.recovery.quarantineCandidate(invalid[0].operationId), ctx.ui.width - 2)
+                : wrap(ctx.t.recovery.quarantineRemaining(invalid.length), ctx.ui.width - 2)).map(line => `  ${line}`), ...nextStep(repairCommand(ctx, `doctor --fix --quarantine-operation ${invalid[0].operationId}`), ctx.ui).slice(1));
+        }
+        else {
+            lines.push(...nextStep(`${repairCommand(ctx, "doctor")} --json`, ctx.ui));
+        }
         return {
             lines,
             // The damaged config is deliberately not parsed here. `operation` is the only safe context

package/dist/commands/init.js

@@ -297,6 +297,9 @@ async function rebuildExisting(entry) {
     const resultHeading = ctx.canPrompt && !ctx.flags.auto && !ctx.flags.dryRun
         ? section(copy.init.resultHeading, ctx.ui) : [];
     const app = await runAppRebuild(ctx);
+    if (app.quarantineOnly) {
+        return { ...app, lines: [...(ctx.canPrompt ? [] : introduction), ...resultHeading, ...app.lines] };
+    }
     if (ctx.flags.dryRun) {
         const answers = await ask(ctx, copy, false, selection);
         const tools = selection ?? answers.tools;

package/dist/commands/rebuild.js

@@ -11,7 +11,7 @@ import { recoverLegacyTone } from "../core/legacy-tone.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";
+import { inspectOperations, readJournal, retireOperationForAppRebuild, serializeOperationQuarantine, } from "../core/operations.js";
 import { assertFresh, captureRawEntry, gate, planEntryRebuild, rawReadCheck, validateFileAction, } from "../wiring/apply.js";
 import { confirm } from "../ui/prompt.js";
 import { wrap } from "../ui/width.js";
@@ -218,13 +218,83 @@ function privateCapture(capture) {
         boundary: capture.boundary, boundaryIdentity: capture.boundaryIdentity,
         parents: capture.parents.map(parent => ({ ...parent })) };
 }
+function planOperationQuarantine(ctx, entry) {
+    const capture = captureRawEntry(entry.path, ctx.t, { within: ctx.paths.root });
+    if (capture.type !== "regular" || capture.bytes === null)
+        throw new ConfigError(ctx.t.recovery.quarantineUnavailable(entry.operationId));
+    return planEntryRebuild(capture, serializeOperationQuarantine(ctx.paths, entry.operationId, capture.bytes), ctx.t, { reason: "quarantine-operation", mode: capture.mode ?? 0o600 }).action;
+}
+async function quarantineOneOperation(ctx, entry, remaining) {
+    const action = planOperationQuarantine(ctx, entry);
+    const presentation = [ctx.t.recovery.quarantine(entry.operationId)]
+        .flatMap(line => wrap(line, ctx.ui.width - 2).map(part => `  ${part}`));
+    const result = await gate([], {
+        paths: ctx.paths, operationActions: [action], retention: { kind: "migration", reason: "app-rebuild" },
+        auto: ctx.flags.auto, dryRun: ctx.flags.dryRun, verbose: ctx.flags.verbose, ui: ctx.ui, t: ctx.t,
+        heading: ctx.t.recovery.heading, interactive: () => ctx.canPrompt, ...(ctx.canPrompt ? {} : { out: () => { } }),
+        recoveryPresentation: { lines: presentation,
+            failureMessage: (id, phase, path, code) => `${ctx.t.recovery.failure(id, phase, path, code)}\ntonedial doctor ${connectionScopeFlag(ctx.agent)} --json` },
+        verify: () => {
+            const state = inspectOperations(ctx.paths).journals.find(({ operationId }) => operationId === entry.operationId)?.state;
+            if (state !== "quarantined")
+                throw new ConfigError(ctx.t.recovery.sourceInvalid);
+        },
+    });
+    const lines = [...result.lines];
+    if (result.reason === "written") {
+        lines.push(`  ${ctx.t.recovery.quarantineComplete(entry.operationId)}`);
+    }
+    else {
+        lines.push(`  ${result.reason === "dry-run" ? ctx.t.wiring.dryRun : ctx.t.wiring.declined}`);
+    }
+    return {
+        lines,
+        json: {
+            appRebuilt: false, applied: result.applied, reason: result.reason, operationId: result.operationId ?? null,
+            root: ctx.paths.root, quarantinedOperation: entry.operationId, remainingInvalidOperations: [...remaining],
+            next: result.applied && remaining.length > 0
+                ? `tonedial doctor --fix --quarantine-operation ${remaining[0]} ${connectionScopeFlag(ctx.agent)}` : null,
+            nativeAttention: false, activationVerified: false, diff: result.diff,
+        },
+        rebuiltConfig: null,
+        proposedConfig: null,
+        legacy: null,
+        quarantineOnly: true,
+    };
+}
 export async function runAppRebuild(ctx) {
     const t = ctx.t;
     const operations = inspectOperations(ctx.paths);
-    const pending = operations.journals.filter(entry => entry.state === "pending" || entry.state === "invalid");
-    const blocked = operations.lock.state !== "none" || pending.length > 0;
-    if (blocked && (operations.lock.state === "live" || operations.lock.state === "unknown" ||
-        pending.some(entry => entry.journal === null) || (!ctx.flags.fromOperation && (ctx.flags.auto || !ctx.canPrompt)))) {
+    const pending = operations.journals.filter(entry => entry.state === "pending");
+    const invalid = operations.journals.filter(entry => entry.state === "invalid");
+    let quarantined = invalid.find(entry => entry.operationId === ctx.flags.quarantineOperation) ?? null;
+    if (ctx.flags.quarantineOperation && quarantined === null)
+        throw new ConfigError(t.recovery.quarantineUnavailable(ctx.flags.quarantineOperation));
+    if (invalid.length > 0 && quarantined === null && operations.lock.state === "none" && pending.length === 0 && invalid.length === 1 &&
+        !ctx.flags.auto && ctx.canPrompt) {
+        const candidate = invalid[0];
+        const input = createInterface({ input: process.stdin, output: process.stdout });
+        try {
+            const notice = t.recovery.quarantineCandidate(candidate.operationId).split("\n").flatMap(line => line === candidate.operationId ? [line] : wrap(line, ctx.ui.width - 2));
+            process.stdout.write(`${notice.map(line => `  ${line}`).join("\n")}\n`);
+            const question = wrap(t.recovery.quarantineQuestion, 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 !== candidate.operationId)
+                throw new ConfigError(t.recovery.operationMismatch);
+            quarantined = candidate;
+        }
+        finally {
+            input.close();
+        }
+    }
+    if (invalid.length > 0 && quarantined === null) {
+        const candidate = invalid[0];
+        const command = `tonedial doctor --fix --quarantine-operation ${candidate.operationId} ${connectionScopeFlag(ctx.agent)}`;
+        throw new ConfigError(t.recovery.quarantineRequired(candidate.operationId, command));
+    }
+    if (quarantined !== null && (operations.lock.state !== "none" || pending.length > 0)) {
         throw new ConfigError(t.doctor.recoveryPending);
     }
     const scopeExplicit = ctx.scopeExplicit ?? (ctx.flags.global || ctx.flags.here === true || ctx.flags.project !== null);
@@ -232,6 +302,14 @@ export async function runAppRebuild(ctx) {
         throw new ConfigError(t.errors.scopeRequired);
     if (ctx.flags.tools !== null)
         parseToolSelection(ctx.flags.tools, true, t);
+    if (quarantined !== null && invalid.length > 1) {
+        return quarantineOneOperation(ctx, quarantined, invalid.filter(entry => entry !== quarantined).map(entry => entry.operationId));
+    }
+    const blocked = operations.lock.state !== "none" || pending.length > 0;
+    if (blocked && (operations.lock.state === "live" || operations.lock.state === "unknown" ||
+        pending.some(entry => entry.journal === null) || (!ctx.flags.fromOperation && (ctx.flags.auto || !ctx.canPrompt)))) {
+        throw new ConfigError(t.doctor.recoveryPending);
+    }
     const configCapture = captureRawEntry(ctx.paths.config, t, { within: ctx.paths.root, maxBytes: CONFIG_MAX_BYTES });
     const selected = ctx.flags.fromOperation ? selectedJournal(ctx, ctx.flags.fromOperation) : null;
     let retirementId = null;
@@ -405,7 +483,11 @@ export async function runAppRebuild(ctx) {
     config.managedSeeds = seeds.records;
     config.seedVersion = SEED_VERSION;
     const artifact = compile(toCompileInput(config));
-    const operationActions = [...seeds.operationActions];
+    let quarantinePlan = null;
+    if (quarantined !== null) {
+        quarantinePlan = planOperationQuarantine(ctx, quarantined);
+    }
+    const operationActions = [...(quarantinePlan ? [quarantinePlan] : []), ...seeds.operationActions];
     for (const target of artifacts) {
         const capture = target.capture ?? captureRawEntry(target.path, t, { within: ctx.paths.root, allowLink: true });
         const plan = planEntryRebuild(capture, artifact, t, { reason: "generated" });
@@ -457,6 +539,7 @@ export async function runAppRebuild(ctx) {
         ...(missingFields.length ? [`  ${t.recovery.missing(missingFields)}`] : []),
         ...(copies.length ? [`  ${t.recovery.copies(copies)}`] : []),
         ...(nativeAttention ? [`  ${t.recovery.nativePending}`] : []),
+        ...(quarantined ? [`  ${t.recovery.quarantine(quarantined.operationId)}`] : []),
         ...(retirementId ? [`  ${t.recovery.retire(retirementId)}`] : []),
     ].flatMap(line => wrap(line.trimStart(), ctx.ui.width - 2).map(part => `  ${part}`));
     const options = {
@@ -484,6 +567,12 @@ export async function runAppRebuild(ctx) {
                     if (capturedText(captureRawEntry(target.path, t, { within: ctx.paths.root })) !== artifact)
                         throw mismatch();
                 }
+                if (quarantined !== null) {
+                    verificationPath = quarantined.path;
+                    const entry = inspectOperations(ctx.paths).journals.find(({ operationId }) => operationId === quarantined.operationId);
+                    if (entry?.state !== "quarantined")
+                        throw mismatch();
+                }
                 verificationPath = ctx.paths.tone;
                 if (capturedText(captureRawEntry(ctx.paths.tone, t, { within: ctx.paths.root })) !== artifact)
                     throw mismatch();
@@ -521,7 +610,7 @@ export async function runAppRebuild(ctx) {
         if (!ctx.flags.auto) {
             process.stdout.write(`${(preview.reason === "nothing" ? [...preview.lines, ...presentation] : preview.lines).join("\n")}\n`);
             if (await confirm(`  ${t.wiring.applyQuestion(preview.diff.length)}`) === "no") {
-                return { lines: [`  ${t.wiring.declined}`], json: { appRebuilt: false, applied: false, reason: "declined", diff: preview.diff }, rebuiltConfig: null, proposedConfig: config, legacy };
+                return { lines: [`  ${t.wiring.declined}`], json: { appRebuilt: false, applied: false, reason: "declined", diff: preview.diff }, rebuiltConfig: null, proposedConfig: config, legacy, quarantineOnly: false };
             }
         }
         const snapshots = [configCapture, ...seeds.reads, ...artifacts.flatMap(target => target.capture === null ? [] : [target.capture]),
@@ -551,12 +640,13 @@ export async function runAppRebuild(ctx) {
         lines.push(...presentation);
     lines.push(`  ${applied ? result.reason === "nothing" ? t.recovery.unchanged : t.recovery.rebuilt : result.reason === "dry-run" ? t.wiring.dryRun : t.wiring.declined}`);
     return {
-        lines, rebuiltConfig: applied ? config : null, proposedConfig: config, legacy,
+        lines, rebuiltConfig: applied ? config : null, proposedConfig: config, legacy, quarantineOnly: false,
         json: {
             appRebuilt: applied, applied: result.applied, reason: result.reason, operationId: result.operationId ?? null,
             root: ctx.paths.root, source, recovered: [...kept], defaulted: [...defaulted], invalid: damagedFields,
             seeded: seeds.labels, chars: [...artifact].length, riskAxes: riskyAxes(config.axes),
             recoveredPresets: copies, restoredPreset: restoredPreset?.slug ?? null, retiredOperation: retirementId,
+            quarantinedOperation: quarantined?.operationId ?? null,
             retiredExternalActions,
             nativeAttention, activationVerified: false, diff: result.diff,
         },

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";