tonedial 0.1.0 → 0.1.2

package/dist/cli.js

@@ -20,7 +20,7 @@ import { runEdit } from "./commands/edit.js";
 import { runUpdate } from "./commands/update.js";
 import { runSave } from "./commands/save.js";
 import { runCreate } from "./commands/create.js";
-import { runAddress, runSet, runReset } from "./commands/set.js";
+import { runAddress, runPersona, runSet, runReset } from "./commands/set.js";
 import { runShow } from "./commands/show.js";
 import { runUse } from "./commands/use.js";
 import { runDoctor } from "./commands/doctor.js";
@@ -34,7 +34,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.0";
+export const VERSION = "0.1.2";
 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 = {
@@ -49,6 +49,7 @@ const COMMANDS = {
     set: { run: runSet, flags: [], max: null, context: "state" },
     test: { run: runTest, flags: ["project", "dryRun", "preset", "acceptUsage"], max: 1 },
     address: { run: runAddress, flags: [], max: 2, context: "state" },
+    persona: { run: runPersona, flags: [], max: 2, context: "state" },
     reset: { run: runReset, flags: [], max: 1, context: "state" },
     show: { run: runShow, flags: ["explain"], max: 1 },
     create: { run: runCreate, flags: ["slug", "auto", "dryRun"], max: null, context: "state" },
@@ -78,6 +79,7 @@ const COMMAND_GROUPS = [
     ["tone", [
             ["set", "set <axis>=<level> …"],
             ["address", "address [self user]"],
+            ["persona", "persona [agent user]"],
             ["reset", "reset [axis]"],
             ["show", "show [slug]"],
             ["test", "test [claude|codex]"],
@@ -108,6 +110,7 @@ const COMMAND_EXAMPLES = {
     set: ["tonedial set", "tonedial set warmth=5 critique=4", "tonedial set persona.agent=reviewer"],
     test: ["tonedial test codex --dry-run", "tonedial test claude --project .", "tonedial test codex --preset my-tone --accept-usage"],
     address: ['tonedial address "assistant" "friend"'],
+    persona: ["tonedial persona", 'tonedial persona "Fictional reviewer" "Developer"'],
     reset: ["tonedial reset", "tonedial reset warmth"],
     show: ["tonedial show", "tonedial show --explain"],
     create: ["tonedial create", 'tonedial create "Jarvis" --slug jarvis care=3 --auto'],

package/dist/commands/compile.js

@@ -4,7 +4,7 @@ import { compile, measure } from "../core/compile.js";
 import { ConfigError, defaultConfig, parseConfig } from "../core/config.js";
 import { toCompileInput } from "../core/resolve.js";
 import { contextArtifactTargets } from "../core/seeds.js";
-import { budget, humanText, nextStep, num } from "../ui/format.js";
+import { artifactSize, humanText, nextStep } from "../ui/format.js";
 import { wrap } from "../ui/width.js";
 import { confirm } from "../ui/prompt.js";
 import { captureRawEntry, gate, planChange, rawReadChange } from "../wiring/apply.js";
@@ -60,15 +60,6 @@ export async function applyPlanned(ctx, changes, finalChanges = [], review = fal
     }
     return result;
 }
-export function sizeWarning(size, t) {
-    // It warns and never fails: a user is entitled to switch every axis on, and a budget that
-    // refuses to compile is a different product.
-    if (size.overCap)
-        return [t.artifact.overCap(num(size.chars), num(size.cap))];
-    if (size.overTarget)
-        return [t.artifact.overTarget(num(size.chars), num(size.target))];
-    return [];
-}
 export async function runCompile(ctx) {
     const check = ctx.flags.check;
     const { change: configChange, config } = planConfig(ctx);
@@ -113,10 +104,10 @@ export async function runCompile(ctx) {
         lines: [
             ...wrap(status, ctx.ui.width - 2).map(line => `  ${ctx.ui.bold((!check || current ? ctx.ui.success : ctx.ui.warn)(line))}`),
             `  ${humanText(ctx.paths.tone)}`,
-            `  ${size.overCap ? ctx.ui.error(budget(size, ctx.t)) : ctx.ui.dim(budget(size, ctx.t))}`,
+            `  ${ctx.ui.dim(artifactSize(size, ctx.t))}`,
             ...nextStep(check && !current ? "tonedial compile" : "tonedial show", ctx.ui),
         ],
         json: { path: ctx.paths.tone, agentsPath: ctx.paths.agents, written: !check, ...size },
-        warnings: sizeWarning(size, ctx.t),
+        warnings: [],
     };
 }

package/dist/commands/create.js

@@ -11,7 +11,7 @@ import { guardTerminal } from "../ui/prompt.js";
 import { wrap } from "../ui/width.js";
 import { planConfig } from "./compile.js";
 import { savePreset } from "./save.js";
-import { applyAssignments } from "./set.js";
+import { applyAssignments, settingsWarnings } from "./set.js";
 export async function runCreate(ctx, args) {
     try {
         const state = planConfig(ctx);
@@ -23,7 +23,7 @@ export async function runCreate(ctx, args) {
         config.persona.agent ??= defaults.agent;
         let displayName = args[0]?.trim() ?? "";
         let slug = ctx.flags.slug ?? undefined;
-        const warnings = applyAssignments(config, args.slice(1), ctx.t, ctx.asJson).warnings;
+        applyAssignments(config, args.slice(1), ctx.t, ctx.asJson);
         if (ctx.canPrompt && !ctx.flags.auto && !ctx.flags.dryRun) {
             const release = guardTerminal();
             const rl = createInterface({ input: process.stdin, output: process.stdout });
@@ -60,10 +60,9 @@ export async function runCreate(ctx, args) {
                         const chosen = await ask(label, value);
                         try {
                             const candidate = structuredClone(config);
-                            const applied = applyAssignments(candidate, [`${key}=${chosen}`], ctx.t, false);
+                            applyAssignments(candidate, [`${key}=${chosen}`], ctx.t, false);
                             serializeConfig(candidate, ctx.t);
                             Object.assign(config, candidate);
-                            warnings.push(...applied.warnings);
                             if (key === "persona.user" || key === "persona.agent") {
                                 process.stdout.write(`  ${ctx.t.create.descriptionCount([...chosen].length, PERSONA_DESCRIPTION_MAX)}\n`);
                             }
@@ -97,9 +96,10 @@ export async function runCreate(ctx, args) {
         return {
             ...result,
             json: { ...result.json, ...(result.json.created === true ? { config: toCompileInput(config) } : {}) },
-            warnings: [...new Set([...warnings, ...(result.warnings ?? []), ...riskWarnings(config.axes, ctx.t),
-                    ...checkCombos(config.axes, config.persona, config.speech_level).map((notice) => combination(notice, ctx.t)),
-                    ctx.t.notice.modelExpectation])],
+            warnings: result.json.created === true ? [
+                ...settingsWarnings(config, ctx.t, ctx.asJson), ...riskWarnings(config.axes, ctx.t),
+                ...checkCombos(config.axes).map((notice) => combination(notice, ctx.t)),
+            ] : [],
         };
     }
     catch (cause) {

package/dist/commands/doctor.js

@@ -7,7 +7,7 @@ import { runRebuildNative } from "./wire.js";
 import { compile, measure } from "../core/compile.js";
 import { ConfigError, defaultConfig, isConfigV2, parseConfig } from "../core/config.js";
 import { inspectOperations, inspectRollback } from "../core/operations.js";
-import { join } from "node:path";
+import { join, relative } from "node:path";
 import { AGENT_TOOLS, CONTEXT_ARTIFACT_FILENAME, CONTEXT_GUIDE_FILENAME, UPDATE_COMMAND, connectionScopeFlag, onPath, readerPath, resolveAgentPaths, shimScript, installShape, canonicalDestination, shellQuote } from "../core/paths.js";
 import { SKILL_NAME } from "../core/skill.js";
 import { GUIDE_FORMAT_MARKER } from "../core/reader.js";
@@ -15,7 +15,7 @@ import { inspect as inspectSkill, skillPath } from "../wiring/skill.js";
 import { candidateRcPaths, pathLineState, rcPath, withPathLine } from "../wiring/shell.js";
 import { SEED_VERSION, inspectContextLayout, inspectSeeds, recordedSeedSelection, } from "../core/seeds.js";
 import { toCompileInput } from "../core/resolve.js";
-import { budget, humanText, nextStep, receiptLines, recoveryRollbackLines, section } from "../ui/format.js";
+import { artifactSize, humanText, nextStep, receiptLines, recoveryRollbackLines, section } from "../ui/format.js";
 import { wrap } from "../ui/width.js";
 import { applyRollback, assertFresh, planChange, previewRollback } from "../wiring/apply.js";
 import { confirm } from "../ui/prompt.js";
@@ -585,7 +585,7 @@ async function doctorReport(ctx, showRollbackCommands = true, showCodexAction =
         checks.push(onDisk === null
             ? { name: "TONE.md", state: "problem", detail: ctx.t.doctor.toneNotWritten, repair: "tonedial compile" }
             : onDisk === expected
-                ? { name: "TONE.md", state: "ok", detail: budget(measure(expected), ctx.t) }
+                ? { name: "TONE.md", state: "ok", detail: artifactSize(measure(expected), ctx.t) }
                 : {
                     name: "TONE.md",
                     state: "problem",
@@ -681,9 +681,11 @@ async function doctorReport(ctx, showRollbackCommands = true, showCodexAction =
     const appHealthy = diagnosis.layout.kind === "current" && diagnosis.layout.cause === "none" && seeds.every(({ state }) => state === "current");
     const lines = [
         `  ${ctx.ui.bold((appHealthy ? ctx.ui.success : ctx.ui.warn)(ctx.t.doctor.applicationHealth(appHealthy)))}`,
-        ...section(ctx.t.doctor.connectionsHeading, ctx.ui),
-        ...wrap(ctx.t.doctor.connectionHealth(nativeAttention), ctx.ui.width - 2).map((line) => `  ${nativeAttention ? ctx.ui.warn(line) : line}`),
-        ...wrap(ctx.t.doctor.hookSettingScope, ctx.ui.width - 2).map(line => `  ${line}`),
+        ...(integrations.length || nativeAttention ? [
+            ...section(ctx.t.doctor.connectionsHeading, ctx.ui),
+            ...wrap(ctx.t.doctor.connectionHealth(nativeAttention), ctx.ui.width - 2).map((line) => `  ${nativeAttention ? ctx.ui.warn(line) : line}`),
+            ...wrap(ctx.t.doctor.hookSettingScope, ctx.ui.width - 2).map(line => `  ${line}`),
+        ] : []),
         ...section(ctx.t.doctor.checksHeading, ctx.ui),
         ...renderCheckBlocks(shownChecks, ctx.flags.verbose ? [] : hookSettings, integrations, ctx),
         // A repair receipt presents its new IDs once in native→app order. Standalone diagnosis
@@ -753,8 +755,7 @@ async function runRollback(ctx, operationId) {
  * The seeds in home against the ones this package carries.
  *
  * An npm update replaces the code and never touches `~/.tonedial/`, so a corrected anchor would
- * otherwise never reach an existing user. Re-running `init` is the update path, and this is
- * what tells someone there is a reason to.
+ * otherwise never reach an existing user. `doctor --fix` refreshes generated application files.
  */
 function seedCheck(ctx, config, seeds) {
     // Zero means `init` never ran, which `use` and `wire` reach on their own and which nothing is
@@ -771,7 +772,7 @@ function seedCheck(ctx, config, seeds) {
             state: "problem",
             detail: ctx.t.doctor.seedsAttention,
             files: stale.map(({ seed, state }) => ({ path: seed.path, reason: state })),
-            ...(stale.every(({ state }) => state === "missing" || state === "stale") ? { repair: repairCommand(ctx, "init") } : {}),
+            ...(stale.every(({ state }) => state === "missing" || state === "stale") ? { repair: repairCommand(ctx, "doctor --fix") } : {}),
         };
 }
 /** Whether the skill is linked, copied, someone else's, or simply not installed. */
@@ -1050,15 +1051,23 @@ function elsewhereReport(rows, ctx) {
 }
 function report(check, ctx) {
     const paint = check.state === "problem" ? ctx.ui.error : check.state === "ok" ? ctx.ui.success : ctx.ui.dim;
-    const head = `  ${paint(MARK[check.state])} ${ctx.ui.bold(humanText(check.name))}`;
+    const head = `  ${paint(MARK[check.state])} ${ctx.ui.bold(humanText(check.name === "seeds" ? ctx.t.doctor.seedsHeading : check.name))}`;
     // Keep the marker and check name together, then give every detail a stable four-cell hanging
     // indent. A fixed name column made a narrow doctor report spend most of its width on padding.
-    const body = (check.humanDetail ?? [check.detail]).flatMap(detail => detail.split("\n"))
+    const body = (check.files?.length ? [] : check.humanDetail ?? [check.detail]).flatMap(detail => detail.split("\n"))
         .flatMap(line => receiptLines(humanText(line), ctx.ui.width - 6));
     const lines = [head, ...body.map((line) => `    ${check.state === "ok" ? ctx.ui.dim(line) : line}`)];
-    for (const file of check.files ?? []) {
-        lines.push(...wrap(ctx.t.doctor.seedReason[file.reason], ctx.ui.width - 6).map((line) => `    ${line}`));
-        lines.push(`    ${humanText(file.path)}`);
+    if (check.files?.length) {
+        lines.push(`    ${humanText(ctx.paths.root)}`);
+        for (const reason of ["missing", "stale", "modified", "foreign", "unreadable"]) {
+            const files = check.files.filter(file => file.reason === reason);
+            if (!files.length)
+                continue;
+            lines.push(...wrap(ctx.t.doctor.seedReason[reason], ctx.ui.width - 6).map(line => `    ${line}`));
+            for (const file of files) {
+                lines.push(...wrap(humanText(relative(ctx.paths.root, file.path)), ctx.ui.width - 8).map(line => `      ${line}`));
+            }
+        }
     }
     if (check.repair)
         lines.push(...nextStep(check.repair, ctx.ui));
@@ -1092,7 +1101,5 @@ function unconnectedReport(settings, ctx) {
     return [
         `  ${ctx.ui.dim(MARK.note)} ${ctx.ui.bold(ctx.t.doctor.hookGroupHeading)}`,
         ...wrap(ctx.t.doctor.hookGroupUnknown(tools), ctx.ui.width - 4).map(line => `    ${line}`),
-        ...wrap(ctx.t.doctor.hookGroupMissing, ctx.ui.width - 4).map(line => `    ${line}`),
-        ...wrap(ctx.t.doctor.hookGroupAction, ctx.ui.width - 4).map(line => `    ${line}`),
     ];
 }

package/dist/commands/edit.js

@@ -6,11 +6,12 @@ import { tmpdir } from "node:os";
 import { isDeepStrictEqual } from "node:util";
 import { CONFIG_SCHEMA, ConfigError, parseConfig, serializeConfig } from "../core/config.js";
 import { BUNDLED, SLUG_PATTERN, matchesPreset, withPreset, assertPresetSelection, customPresetDir, inspectPresetLibrary, parsePreset, preparePresetWrite, resolvePreset, } from "../core/presets.js";
-import { applyPlanned, planArtifact, planConfig, sizeWarning } from "./compile.js";
+import { applyPlanned, planArtifact, planConfig } from "./compile.js";
 import { check as checkCombos } from "../core/combos.js";
-import { combination, humanText, riskWarnings } from "../ui/format.js";
+import { artifactSize, combination, humanText, riskWarnings } from "../ui/format.js";
 import { captureRawEntry, planChange, rawReadChange, rawReadCheck } from "../wiring/apply.js";
 import { emptyWiring } from "../wiring/ownership.js";
+import { settingsWarnings } from "./set.js";
 /**
  * The editor to hand the file to. `$VISUAL` wins over `$EDITOR` by long convention — a user
  * who sets both means the first for interactive work, which this is.
@@ -116,11 +117,11 @@ export async function runEdit(ctx, args) {
             }
             const { change: toneChange, size } = planArtifact(ctx, config);
             await commit([toneChange], [{ ...baseline, after }]);
-            lines.push(`  ${(size.overCap ? ctx.ui.error : ctx.ui.success)(ctx.t.artifact.recompiled(size.chars, size.cap))}`);
+            lines.push(`  ${ctx.ui.dim(artifactSize(size, ctx.t))}`);
             return {
                 lines,
                 json: { path: target.path, editor: editor[0], opened: true, changed: true, chars: size.chars },
-                warnings: stateWarnings(ctx, config, size),
+                warnings: stateWarnings(ctx, config),
             };
         }
         // **Refused, not dropped.** `parsePreset` returns the slug it was handed and ignores the one
@@ -189,8 +190,8 @@ export async function runEdit(ctx, args) {
                 const { change: toneChange, size } = planArtifact(ctx, config);
                 const finalConfig = { ...configRead.change, after: serializeConfig(config, ctx.t) };
                 await commit([configRead.change, presetChange, toneChange], [finalConfig]);
-                lines.push(`  ${(size.overCap ? ctx.ui.error : ctx.ui.success)(ctx.t.artifact.recompiled(size.chars, size.cap))}`);
-                warnings.push(...stateWarnings(ctx, config, size));
+                lines.push(`  ${ctx.ui.dim(artifactSize(size, ctx.t))}`);
+                warnings.push(...stateWarnings(ctx, config));
             }
             else {
                 await commit([configRead.change, presetChange]);
@@ -226,13 +227,11 @@ export async function runEdit(ctx, args) {
     }
 }
 /** The notices every other state-changing command emits, through the same owners they use. */
-function stateWarnings(ctx, config, size) {
-    const p = config.persona;
+function stateWarnings(ctx, config) {
     return [
-        ...checkCombos(config.axes, p, config.speech_level).map((w) => combination(w, ctx.t)),
-        ...(p.age || p.gender || p.note || p.address || p.user || p.agent ? [ctx.t.notice.personaUnanchored] : []),
+        ...checkCombos(config.axes).map((w) => combination(w, ctx.t)),
+        ...settingsWarnings(config, ctx.t, ctx.asJson),
         ...riskWarnings(config.axes, ctx.t),
-        ...sizeWarning(size, ctx.t),
     ];
 }
 /**

package/dist/commands/init.js

@@ -13,7 +13,7 @@ import { BUNDLED, localizedPreset, matchesPreset, withPreset } from "../core/pre
 import { SEED_VERSION, inspectContextLayout, planSeedChanges } from "../core/seeds.js";
 import { inspectOperations } from "../core/operations.js";
 import { SKILL_NAME, TONE_COMMAND_MD, TONE_COMMAND_VERSION } from "../core/skill.js";
-import { budget, humanText, nativeSetup, receiptLines, recoveryRollbackLines, riskWarnings, section } from "../ui/format.js";
+import { artifactSize, humanText, nativeSetup, receiptLines, recoveryRollbackLines, riskWarnings, section } from "../ui/format.js";
 import { riskyAxes } from "../core/anchors.js";
 import { padEnd, wrap } from "../ui/width.js";
 import { gate, planChange } from "../wiring/apply.js";
@@ -204,7 +204,7 @@ export async function runInit(entry, _args) {
         addReceipt(ctx.t.artifact.generated, ctx.ui.success);
     }
     if (ctx.flags.verbose) {
-        lines.push(`  ${ctx.ui.dim(budget(size, ctx.t))}`);
+        lines.push(`  ${ctx.ui.dim(artifactSize(size, ctx.t))}`);
         // The seed list grows with every bundled preset, so it folds like any other sentence.
         addReceipt(ctx.t.wiring.seeded(seeds.labels));
         if (skills.length) {
@@ -219,11 +219,10 @@ export async function runInit(entry, _args) {
             addReceipt(message);
         }
     }
-    lines.push("");
-    addReceipt(copy.init.risk, ctx.ui.warn);
-    addReceipt(ctx.t.notice.modelExpectation);
-    for (const notice of riskWarnings(config.axes, ctx.t))
-        addReceipt(notice, ctx.ui.risk);
+    if (applied) {
+        for (const notice of riskWarnings(config.axes, ctx.t))
+            addReceipt(notice, ctx.ui.risk);
+    }
     lines.push("");
     // Skills and controls invoke bare tonedial, so command reachability needs its own hint.
     if (onPath("tonedial", ctx.env) === null) {
@@ -298,10 +297,6 @@ async function rebuildExisting(entry) {
     const resultHeading = ctx.canPrompt && !ctx.flags.auto && !ctx.flags.dryRun
         ? section(copy.init.resultHeading, ctx.ui) : [];
     const app = await runAppRebuild(ctx);
-    const riskIntro = [
-        ...receiptLines(copy.init.risk, ctx.ui.width - 2).map(line => `  ${ctx.ui.warn(line)}`),
-        ...receiptLines(ctx.t.notice.modelExpectation, ctx.ui.width - 2).map(line => `  ${line}`),
-    ];
     if (ctx.flags.dryRun) {
         const answers = await ask(ctx, copy, false, selection);
         const tools = selection ?? answers.tools;
@@ -309,7 +304,7 @@ async function rebuildExisting(entry) {
             throw new ConfigError(ctx.t.errors.commandsNeedClaude);
         const native = await runRebuildNative({ ...ctx, flags: { ...ctx.flags, tools: tools.length ? tools.join(",") : "none" } }, app.legacy, app.proposedConfig);
         return {
-            lines: [...(ctx.canPrompt ? [] : introduction), ...app.lines, ...native.lines, ...riskIntro],
+            lines: [...(ctx.canPrompt ? [] : introduction), ...app.lines, ...native.lines],
             json: { ...app.json, agentRoot: ctx.agent.root, live: ctx.agent.live,
                 scope: ctx.agent.live ? "global" : "project", scopeExplicit, language: app.proposedConfig.language,
                 seedVersion: SEED_VERSION, tools, native: native.json,
@@ -320,7 +315,7 @@ async function rebuildExisting(entry) {
         };
     }
     if (app.rebuiltConfig === null)
-        return { ...app, lines: [...(ctx.canPrompt ? [] : introduction), ...resultHeading, ...app.lines, ...riskIntro] };
+        return { ...app, lines: [...(ctx.canPrompt ? [] : introduction), ...resultHeading, ...app.lines] };
     const answers = await ask(ctx, copy, false, selection);
     const tools = selection ?? answers.tools;
     if (ctx.flags.commands && !tools.includes("claude"))
@@ -331,7 +326,6 @@ async function rebuildExisting(entry) {
     const after = codexHandoff(scoped, native.json.applied === true || native.json.reason === "nothing", codexConfigured);
     return {
         lines: [...(ctx.canPrompt ? [] : introduction), ...resultHeading, ...app.lines, ...native.lines,
-            ...riskIntro,
             ...recoveryRollbackLines(ctx.t, app.json.operationId, native.json.operationId)],
         ...(after ? { after } : {}),
         json: {

package/dist/commands/save.js

@@ -2,10 +2,10 @@
 import { AXIS_DEFAULT, AXIS_ORDER } from "../core/anchors.js";
 import { ConfigError, serializeConfig } from "../core/config.js";
 import { BUNDLED, PRESET_SCHEMA, SLUG_PATTERN, preparePresetWrite, presetSettings, resolvePreset, slugify } from "../core/presets.js";
-import { budget, humanText, nextStep } from "../ui/format.js";
+import { artifactSize, humanText, nextStep } from "../ui/format.js";
 import { cells, truncate, wrap } from "../ui/width.js";
 import { PERSONA_DESCRIPTION_MAX } from "../core/combos.js";
-import { applyPlanned, planArtifact, planConfig, sizeWarning } from "./compile.js";
+import { applyPlanned, planArtifact, planConfig } from "./compile.js";
 import { planChange, rawReadChange, rawReadCheck } from "../wiring/apply.js";
 /** Only the axes that moved. Every axis is still emitted; sparsity is storage, not compilation. */
 function movedValues(axes) {
@@ -73,27 +73,19 @@ export async function savePreset(ctx, displayName, state, options = {}) {
         };
     const count = Object.keys(values).length;
     const countLabel = ctx.t.preset.nonDefault(count);
-    const warnings = [...sizeWarning(size, ctx.t)];
-    if (replaced)
-        warnings.push(ctx.t.preset.replaced(slug));
-    // Sparsity survives on one reason after the omit-defaults rule fell: fewer extremes mean
-    // fewer internal collisions. It is guidance, so it warns and never blocks.
-    if (count < 3 || count > 7) {
-        warnings.push(ctx.t.preset.sparsity(slug, count));
-    }
     return {
         // Truncated, not folded. A display name has no length cap, and folding one across two lines
         // makes the slug beside it harder to read than losing the tail does.
         lines: [
             ...(options.create ? result.lines : []),
-            `  ${ctx.ui.success(ctx.ui.bold(ctx.t.preset.savedTarget(slug)))}`,
+            ...wrap(replaced ? ctx.t.preset.replaced(slug) : ctx.t.preset.savedTarget(slug), ctx.ui.width - 2)
+                .map((line) => `  ${ctx.ui.success(ctx.ui.bold(line))}`),
             `  ${truncate(humanText(displayName), Math.max(1, ctx.ui.width - cells(`    ${countLabel}`)))}  ${ctx.ui.dim(countLabel)}`,
             `  ${ctx.t.artifact.generated}`,
-            ...(ctx.flags.verbose ? [`  ${ctx.ui.dim(budget(size, ctx.t))}`] : []),
+            ...(ctx.flags.verbose ? [`  ${ctx.ui.dim(artifactSize(size, ctx.t))}`] : []),
             ...nextStep("tonedial list", ctx.ui),
         ],
         json: { slug, displayName, values, settings: preset.settings, nonDefaultAxes: count, replaced, chars: size.chars,
             ...(options.create ? { created: true, diff: result.diff, operationId: result.operationId } : {}) },
-        warnings,
     };
 }