@krtclcdy/tersio 2.23.0 → 2.24.1

package/cli/interactive.js

@@ -1,6 +1,6 @@
 // cli/interactive.ts — TTY layer: readline, Clack spinners, selects, task phases.
 import readline from 'node:readline';
-import { cancel as clackCancel, confirm as clackConfirm, select as clackSelect, spinner as clackSpinner, tasks as clackTasks } from '@clack/prompts';
+import { cancel as clackCancel, confirm as clackConfirm, log as clackLog, select as clackSelect, spinner as clackSpinner, tasks as clackTasks } from '@clack/prompts';
 import { execP } from './common.js';
 const RL = readline.createInterface({ input: process.stdin, output: process.stdout });
 let rlOpen = true;
@@ -67,6 +67,32 @@ async function askInteractiveConfirm(message, initialValue = true) {
     }
     return { status: 'confirmed', value: answer };
 }
+// Confirm a destructive run: a Clack dialog at a terminal, a plain prompt in a
+// pipe or script. False means the user declined or aborted.
+async function confirmDestructive(message) {
+    if (tty()) {
+        closeRL();
+        const answer = await clackConfirm({ message, initialValue: false });
+        if (typeof answer !== 'boolean') {
+            clackCancel('Aborted.');
+            closeRL();
+            return false;
+        }
+        if (!answer) {
+            console.log('Aborted.');
+            closeRL();
+            return false;
+        }
+        return true;
+    }
+    const typed = await ask('\nProceed? [y/N]: ');
+    if (!typed.toLowerCase().startsWith('y')) {
+        console.log('Aborted.');
+        closeRL();
+        return false;
+    }
+    return true;
+}
 // Run collecting work under one TTY-only Clack task. Callers print after the
 // task completes, keeping normal output out of the spinner animation.
 async function runInteractivePhase(title, collect) {
@@ -77,7 +103,41 @@ async function runInteractivePhase(title, collect) {
     await clackTasks([{ title, task: async () => { result = await collect(); } }]);
     return result;
 }
+const TAG_KIND = {
+    fail: 'error', warn: 'warn', hint: 'info', ok: 'success', note: 'message',
+    write: 'step', rm: 'step', migrate: 'step', skip: 'info', 'dry-run': 'info',
+};
+function sayTagged(line) {
+    const m = /^\s*\[([\w-]+)\]\s?([\s\S]*)$/.exec(line);
+    const kind = (m && TAG_KIND[m[1]]) || 'info';
+    if (tty() && m)
+        clackLog[kind](m[2]);
+    else
+        console.log(line);
+}
+// One live-updating task line instead of a spinner per step.
+async function withInteractiveTask(title, work) {
+    if (!tty())
+        return work(() => { });
+    closeRL();
+    let result;
+    const spin = clackSpinner();
+    spin.start(title);
+    try {
+        result = await work((message) => spin.message(message));
+        spin.stop('done');
+    }
+    catch (e) {
+        spin.error(shortSpinnerError(e));
+        throw e;
+    }
+    return result;
+}
+function shortSpinnerError(e) {
+    const msg = e instanceof Error ? e.message : String(e);
+    return (msg.split('\n')[0] || 'failed').slice(0, 120);
+}
 async function execNetwork(label, cmd, args, opts = {}) {
     return withInteractiveSpinner(label, () => execP(cmd, args, opts));
 }
-export { ask, closeRL, tty, withInteractiveSpinner, execNetwork, askInteractiveChoice, askInteractiveConfirm, runInteractivePhase, };
+export { ask, closeRL, tty, withInteractiveSpinner, withInteractiveTask, execNetwork, sayTagged, askInteractiveChoice, askInteractiveConfirm, confirmDestructive, runInteractivePhase, };

package/cli/layer.js

@@ -0,0 +1,22 @@
+// cli/layer.ts — the shared shape of an extension tree.
+import path from 'node:path';
+// Turns a `[dir, label]` table into resolved paths under `extDir`.
+export function layerEntries(extDir, table) {
+    return table.map(([dir, label]) => ({ label, path: path.join(extDir, dir) }));
+}
+// Directory names only, for callers that key off the names alone.
+export function layerDirs(table) {
+    return table.map(([dir]) => dir);
+}
+// A port source sits two levels below extensions/, one level once installed.
+export function rewritePortImports(content) {
+    return content.replace(/from '\.\.\/\.\.\/(shared|lib)\//g, "from '../$1/");
+}
+// What of the layer is on disk.
+export function reportLayer(extDir, tables, exists) {
+    const all = tables.flatMap((table) => layerEntries(extDir, table));
+    return {
+        present: all.filter((entry) => exists(entry.path)),
+        missing: all.filter((entry) => !exists(entry.path)),
+    };
+}

package/cli/manifest.js

@@ -0,0 +1,33 @@
+// Single list of install writes, shared by installer, doctor, and tests.
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+export const EXT_DIR = path.join(path.dirname(fileURLToPath(import.meta.url)), '..', 'extensions');
+/** Every file in the tree, as paths relative to the extensions directory. */
+export const TREE_FILES = [
+    'shared/host.ts',
+    'shared/session-state.ts',
+    'shared/types.ts',
+    'shared/plugin-settings.ts',
+    'shared/usage-ledger.ts',
+    'shared/pricing.ts',
+    'shared/carbon.ts',
+    'lib/utils.ts',
+    'caveman-session/index.ts',
+    'caveman-session/rule.md',
+    'rtk-session/index.ts',
+    'combo-toggle/index.ts',
+    'tersio-commands/index.ts',
+    'ai-addons-updater/index.ts',
+];
+export function sourcePath(relative) {
+    return path.join(EXT_DIR, ...relative.split('/'));
+}
+/** The entries under one directory, as source paths and tree-relative targets. */
+export function filesUnder(dir) {
+    const found = [];
+    for (const file of TREE_FILES) {
+        if (file.startsWith(`${dir}/`))
+            found.push([sourcePath(file), file]);
+    }
+    return found;
+}

package/cli/omp-layer.js

@@ -0,0 +1,51 @@
+// The Oh My Pi layer as data: the extension directories, the RTK wiring and the Ponytail package, named in one place...
+import path from 'node:path';
+import { layerEntries, reportLayer } from './layer.js';
+const INSTALLED_EXTENSIONS = [
+    ['caveman-session', 'caveman session mode'],
+    ['rtk-session', 'rtk session mode'],
+    ['ai-addons-updater', 'add-on updater'],
+    ['combo-toggle', 'combo preset switch'],
+    ['tersio-commands', '/tersio command'],
+    ['shared', 'session bridge, usage and pricing store'],
+    // Read by the add-on updater; the updater itself is removed above.
+    ['lib', 'shared installer and updater helpers'],
+];
+const RETIRED_EXTENSIONS = [
+    // Legacy always-on combo helper; imports shared/session-state.js, so it breaks with a module-not-found warning once the...
+    ['aaa-combo-boot', 'retired combo boot helper'],
+];
+// `rtkBinaryName` is passed in because it is platform-dependent and already resolved by the caller.
+export function ompLayer(home, rtkBinaryName) {
+    const agentDir = path.join(home, '.omp', 'agent');
+    const extDir = path.join(agentDir, 'extensions');
+    const pluginsDir = path.join(home, '.omp', 'plugins');
+    return {
+        extDir,
+        configFile: path.join(agentDir, 'config.yml'),
+        pluginsDir,
+        ponytailPackage: path.join(pluginsDir, 'node_modules', '@dietrichgebert', 'ponytail'),
+        rtkBinary: path.join(home, '.bun', 'bin', rtkBinaryName),
+        rtkExtension: path.join(extDir, 'rtk.ts'),
+        installed: layerEntries(extDir, INSTALLED_EXTENSIONS),
+        retired: layerEntries(extDir, RETIRED_EXTENSIONS),
+    };
+}
+// Every extension directory the layer owns, installed and retired together.
+export function ompExtensionTargets(layer) {
+    return [...layer.installed, ...layer.retired].map((entry) => entry.path);
+}
+export function tersioPluginDir(home) {
+    return path.join(home, '.omp', 'plugins', 'node_modules', '@krtclcdy', 'tersio');
+}
+export function reportOmpLayer(home, exists) {
+    const extDir = path.join(home, '.omp', 'agent', 'extensions');
+    const pluginPath = tersioPluginDir(home);
+    const { present, missing } = reportLayer(extDir, [INSTALLED_EXTENSIONS], exists);
+    return {
+        pluginPath: exists(pluginPath) ? pluginPath : null,
+        extensions: present,
+        missing,
+        installed: exists(pluginPath),
+    };
+}

package/cli/pi-layer.js

@@ -0,0 +1,37 @@
+// cli/pi-layer.ts — the Pi extension layer as data: the five extension directories plus shared/ and lib/.
+import path from 'node:path';
+import { layerDirs, layerEntries, reportLayer } from './layer.js';
+const INSTALLED_EXTENSIONS = [
+    ['caveman-session', 'caveman session mode'],
+    ['rtk-session', 'rtk session mode'],
+    ['ai-addons-updater', 'add-on updater'],
+    ['combo-toggle', 'combo preset switch'],
+    ['tersio-commands', '/tersio command'],
+];
+// Imported by the extension directories but never loaded by Pi itself, so they stay out of the install list and only...
+const MODULE_DIRECTORIES = [
+    ['shared', 'Pi types, session bridge, usage and pricing store'],
+    ['lib', 'shared installer and updater helpers'],
+];
+export const PI_EXTENSION_DIRS = layerDirs(INSTALLED_EXTENSIONS);
+export const PI_MODULE_DIRS = layerDirs(MODULE_DIRECTORIES);
+export function piLayer(home) {
+    const relocated = process.env.PI_CODING_AGENT_DIR;
+    const base = relocated && relocated.trim() !== '' ? relocated : path.join(home, '.pi', 'agent');
+    const extDir = path.join(base, 'extensions');
+    return {
+        extDir,
+        rtkExtension: path.join(extDir, 'rtk.ts'),
+        installed: layerEntries(extDir, INSTALLED_EXTENSIONS),
+        modules: layerEntries(extDir, MODULE_DIRECTORIES),
+    };
+}
+// Every directory the layer owns. Removal walks this list and nothing else.
+export function piExtensionTargets(layer) {
+    return [...layer.installed, ...layer.modules].map((entry) => entry.path);
+}
+// Reports the layer without needing a platform rtk binary name.
+export function reportPiLayer(home, exists) {
+    const { present, missing } = reportLayer(piLayer(home).extDir, [INSTALLED_EXTENSIONS, MODULE_DIRECTORIES], exists);
+    return { extensions: present, missing, installed: present.length > 0 };
+}

package/cli/pi-wiring.js

@@ -0,0 +1,92 @@
+// Install and remove Tersio's Pi extension tree: Pi loads ~/.pi/agent/extensions/<dir>/index.ts through jiti, no build...
+import { promises as fs } from 'node:fs';
+import path from 'node:path';
+import { readTextIfExists } from '../extensions/lib/utils.js';
+import { rewritePortImports } from './layer.js';
+import { piExtensionTargets, piLayer } from './pi-layer.js';
+// `$HOME`-relative form of a path, for output that must stay readable.
+function rel(target, home) {
+    if (!home)
+        return target;
+    const prefix = home.endsWith(path.sep) ? home : `${home}${path.sep}`;
+    return target.startsWith(prefix) ? `~/${target.slice(prefix.length).split(path.sep).join('/')}` : target;
+}
+export function piExtensionDir(home) {
+    return piLayer(home).extDir;
+}
+// Writes only when the content differs, leaving a `.bak` of what it replaced.
+async function writeIfChanged(target, content, options) {
+    const current = await readTextIfExists(target);
+    if (current === content)
+        return false;
+    if (options.dryRun)
+        return true;
+    await fs.mkdir(path.dirname(target), { recursive: true });
+    if (current !== null)
+        await fs.copyFile(target, `${target}.bak`).catch(() => { });
+    await fs.writeFile(target, content, 'utf8');
+    return true;
+}
+async function exists(target) {
+    try {
+        await fs.stat(target);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+// Returns the paths it changed, so a no-op re-run is not counted as work.
+export async function installPiTersio(home, tree, options = {}) {
+    const extDir = piExtensionDir(home);
+    const written = [];
+    for (const [from, to] of tree.sources) {
+        const content = await readTextIfExists(from);
+        if (content === null) {
+            // Named by its path under the extension dir, never by the repo source.
+            if (!options.quiet) {
+                console.log(`  [fail] Pi extension source missing: ${to}`);
+                console.log('  [hint] Reinstall tersio — extensions/pi ships with the CLI');
+            }
+            continue;
+        }
+        if (await writeIfChanged(path.join(extDir, to), rewritePortImports(content), options))
+            written.push(to);
+    }
+    for (const [dir, rule] of tree.rules) {
+        if (rule === null)
+            continue;
+        const target = path.join(dir, 'rule.md');
+        if (await writeIfChanged(path.join(extDir, target), rule, options))
+            written.push(target);
+    }
+    if (written.length > 0 && !options.quiet) {
+        console.log(`  ${options.dryRun ? '[dry-run] would write' : '[write]'} Pi — ${written.length} file(s) under ${rel(extDir, home)}`);
+    }
+    return written;
+}
+// Removes the Pi tree: every directory the layer owns, the `.bak` copies, and the flat module a pre-tree install wrote at...
+export async function removePiTersio(home, options = {}) {
+    let removed = false;
+    for (const target of [...piExtensionTargets(piLayer(home)), path.join(piExtensionDir(home), 'tersio.ts')]) {
+        if (!(await exists(target)))
+            continue;
+        if (!options.quiet) {
+            console.log(`  ${options.dryRun ? '[dry-run] would remove' : '[rm]'} ${rel(target, home)}`);
+        }
+        if (!options.dryRun) {
+            await fs.rm(target, { recursive: true, force: true });
+            await fs.rm(`${target}.bak`, { force: true, recursive: true });
+        }
+        removed = true;
+    }
+    return removed;
+}
+// True when any module of the Pi tree is present.
+export async function piTersioInstalled(home) {
+    for (const entry of piLayer(home).installed) {
+        if (await exists(path.join(entry.path, 'index.ts')))
+            return true;
+    }
+    return false;
+}

package/cli/profile.js

@@ -1,12 +1,13 @@
-// cli/profile.ts — session-start defaults profile (combo/caveman/rtk/ponytail)
-// plus the display-currency default for usage/dashboard reports.
-// Single source for reading/writing the omp plugin settings lock entry.
-// Extracted from cli/install.ts so both install and settings share it.
-import { promises as fs } from 'node:fs';
+// cli/profile.ts — session-start defaults and the display-currency default,
+// stored in ~/.tersio/settings.json. Shared by install and settings.
+import { existsSync, promises as fs } from 'node:fs';
 import path from 'node:path';
-import { CAVEMAN_DEFAULTS, COMBO_PRESET_MODES, OMP_PLUGINS_DIR, PACKAGE_NAME, PONYTAIL_DEFAULTS, verbose, } from './common.js';
+import { CAVEMAN_DEFAULTS, COMBO_PRESET_MODES, PACKAGE_NAME, PONYTAIL_DEFAULTS, verbose, } from './common.js';
+import os from 'node:os';
 import { DEFAULT_CURRENCY, isCurrencyCode } from './currency.js';
 import { readTextIfExists } from '../extensions/lib/utils.js';
+import { tersioSettingsFile } from '../extensions/shared/plugin-settings.js';
+export const BACKUP_SCHEDULES = new Set(['manual', 'daily', 'weekly', 'monthly']);
 function defaultProfile() {
     return {
         comboDefault: 'off',
@@ -14,31 +15,17 @@ function defaultProfile() {
         rtkDefault: false,
         ponytailDefault: 'off',
         currency: DEFAULT_CURRENCY,
+        backupSchedule: 'monthly',
     };
 }
-// Stored profile from the live lock file: update/reinstall runs without flags
-// or prompts must preserve the user's choice, never reset it to off.
+// Seed once from OMP plugin settings so a pre-~/.tersio install keeps its values.
 async function storedProfile() {
     const base = defaultProfile();
-    const raw = await readTextIfExists(path.join(OMP_PLUGINS_DIR, 'omp-plugins.lock.json'));
-    if (!raw)
+    const stored = (await readTextIfExists(tersioSettingsFile())) !== null
+        ? parseStored(await readTextIfExists(tersioSettingsFile()))
+        : parseStored(await readTextIfExists(legacyOmpLockPath()));
+    if (!stored)
         return base;
-    let stored;
-    try {
-        const parsed = JSON.parse(raw);
-        if (!parsed || typeof parsed !== 'object' || !('settings' in parsed))
-            return base;
-        const settings = parsed.settings;
-        if (!settings || typeof settings !== 'object' || !(PACKAGE_NAME in settings))
-            return base;
-        const entry = settings[PACKAGE_NAME];
-        if (!entry || typeof entry !== 'object')
-            return base;
-        stored = entry;
-    }
-    catch {
-        return base;
-    }
     if (typeof stored.comboDefault === 'string' && stored.comboDefault in COMBO_PRESET_MODES)
         base.comboDefault = stored.comboDefault;
     if (typeof stored.cavemanDefault === 'string' && CAVEMAN_DEFAULTS.has(stored.cavemanDefault))
@@ -50,42 +37,55 @@ async function storedProfile() {
     if (typeof stored.currency === 'string' && isCurrencyCode(stored.currency.trim().toUpperCase())) {
         base.currency = stored.currency.trim().toUpperCase();
     }
+    if (typeof stored.backupSchedule === 'string' && BACKUP_SCHEDULES.has(stored.backupSchedule)) {
+        base.backupSchedule = stored.backupSchedule;
+    }
     return base;
 }
-// Persist the profile as omp plugin settings so `omp plugin config get`
-// reflects the choice and the extensions pick it up on session start.
-async function writePluginSettings(profile, options) {
-    const pluginsDir = OMP_PLUGINS_DIR;
-    const lockPath = path.join(pluginsDir, 'omp-plugins.lock.json');
-    let config = {};
-    const existing = await readTextIfExists(lockPath);
-    if (existing) {
-        try {
-            config = JSON.parse(existing);
-        }
-        catch {
-            config = {};
-        }
+function legacyOmpLockPath() {
+    const configHome = process.env.XDG_CONFIG_HOME || path.join(os.homedir(), '.config');
+    return [
+        path.join(os.homedir(), '.omp', 'plugins', 'omp-plugins.lock.json'),
+        path.join(configHome, 'omp', 'plugins', 'omp-plugins.lock.json'),
+    ].find((p) => existsSync(p)) ?? path.join(os.homedir(), '.omp', 'plugins', 'omp-plugins.lock.json');
+}
+function parseStored(raw) {
+    if (!raw)
+        return null;
+    try {
+        const parsed = JSON.parse(raw);
+        if (!parsed || typeof parsed !== 'object')
+            return null;
+        const direct = parsed;
+        const nested = direct.settings?.[PACKAGE_NAME];
+        return (nested ?? direct);
     }
-    config.plugins = config.plugins || {};
-    config.settings = config.settings || {};
-    config.settings[PACKAGE_NAME] = {
-        ...(config.settings[PACKAGE_NAME] || {}),
+    catch {
+        return null;
+    }
+}
+// Persist the profile where every host reads it. `omp plugin config get` no
+// longer reports it; `tersio settings` does.
+async function writePluginSettings(profile, options) {
+    const file = tersioSettingsFile();
+    const values = {
+        ...(parseStored(await readTextIfExists(file)) ?? {}),
         comboDefault: profile.comboDefault,
         comboSetupComplete: true,
         cavemanDefault: profile.cavemanDefault,
         rtkDefault: profile.rtkDefault,
         ponytailDefault: profile.ponytailDefault,
         currency: profile.currency,
+        backupSchedule: profile.backupSchedule,
     };
     if (options.dryRun) {
         if (verbose && !options.quiet)
-            console.log(`  [dry-run] would write plugin settings (${PACKAGE_NAME}) to ${lockPath}`);
+            console.log(`  [dry-run] would write session defaults to ${file}`);
         return;
     }
-    await fs.mkdir(pluginsDir, { recursive: true });
-    await fs.writeFile(lockPath, JSON.stringify(config, null, 2) + '\n', 'utf8');
-    console.log(`  [write] Plugin settings in ${lockPath}`);
+    await fs.mkdir(path.dirname(file), { recursive: true });
+    await fs.writeFile(file, `${JSON.stringify(values, null, 2)}\n`, 'utf8');
+    console.log(`  [write] Session defaults in ${file}`);
 }
 function formatProfile(profile) {
     return `combo=${profile.comboDefault} (caveman=${profile.cavemanDefault} · rtk=${profile.rtkDefault ? 'on' : 'off'} · ponytail=${profile.ponytailDefault}) · currency=${profile.currency}`;

package/cli/reset.js

@@ -1,11 +1,6 @@
-// cli/reset.ts — clear tersio-owned statistics: the usage ledger plus a reset
-// watermark that filters session-derived and RTK-metered rows out of every
-// derived view. Session transcripts (~/.omp/agent/sessions) and the RTK
-// database are host/tool-owned and are never touched; the watermark only
-// changes what tersio shows.
-import { cancel as clackCancel, confirm as clackConfirm } from '@clack/prompts';
+// Clears tersio-owned stats only; transcripts and RTK data stay.
 import { dryRun, yes } from './common.js';
-import { ask, closeRL, tty } from './interactive.js';
+import { confirmDestructive, sayTagged } from './interactive.js';
 import { clearUsageLedger, importSessionTokens, ledgerPath, markReset, readUsage, sessionsDir } from '../extensions/shared/usage-ledger.js';
 import { clearUsageDb, usageDbPath } from '../extensions/shared/usage-store.js';
 import { readRtkGain, rtkDbPath } from '../extensions/shared/rtk-gain.js';
@@ -25,34 +20,12 @@ async function runReset() {
         console.log('Nothing to reset — no statistics recorded.');
         return true;
     }
-    if (!yes) {
-        if (tty()) {
-            closeRL();
-            const confirmedChoice = await clackConfirm({ message: 'Clear tersio statistics?', initialValue: false });
-            if (typeof confirmedChoice !== 'boolean') {
-                clackCancel('Aborted.');
-                closeRL();
-                return false;
-            }
-            if (!confirmedChoice) {
-                console.log('Aborted.');
-                closeRL();
-                return false;
-            }
-        }
-        else {
-            const answer = await ask('\nProceed? [y/N]: ');
-            if (!answer.toLowerCase().startsWith('y')) {
-                console.log('Aborted.');
-                closeRL();
-                return false;
-            }
-        }
-    }
+    if (!yes && !(await confirmDestructive('Clear tersio statistics?')))
+        return false;
     const cleared = clearUsageLedger();
     const dbCleared = clearUsageDb();
     const ts = markReset();
-    console.log(`[ok] reset — removed ${cleared} usage rows${dbCleared ? ' + usage.db' : ''}; statistics view starts at ${new Date(ts).toISOString()}`);
+    sayTagged(`[ok] reset — removed ${cleared} usage rows${dbCleared ? ' + usage.db' : ''}; statistics view starts at ${new Date(ts).toISOString()}`);
     return true;
 }
 export { runReset };

package/cli/rtk-wiring.js

@@ -1,12 +1,4 @@
-// cli/rtk-wiring.ts — wire the installed rtk binary into OMP.
-// `rtk init -g --agent omp` writes rtk's tool_call extension to
-// ~/.omp/agent/extensions/rtk.ts, and we register that path in config.yml
-// (OMP only loads listed extensions — rtk init does not register it).
-// Once loaded, OMP rewrites bash commands to rtk before execution, so every
-// rewritten call lands in rtk's history.db and shows metered savings.
-// Fail-open: a failed wire only downgrades to manual `rtk` prefixing.
-// Deliberately free of cli/common.ts imports (argv side effects) so tests
-// can load it directly.
+// OMP loads only listed extensions, so register rtk's path; fail-open.
 import { promises as fs } from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
@@ -34,8 +26,7 @@ function execFileP(cmd, args, timeout) {
         });
     });
 }
-// Idempotent: rtk rewrites its extension file on every init run, so
-// reinstalling tersio refreshes the wiring for free.
+// Idempotent: rtk rewrites its file on every init run.
 export async function wireRtkOmp(rtkBin, options = {}) {
     if (!options.dryRun)
         debugWire(options, 'Wiring rtk → OMP (bash tool_call rewrite)…');
@@ -47,14 +38,13 @@ export async function wireRtkOmp(rtkBin, options = {}) {
     await ensureRtkInConfig(options);
     return true;
 }
-// The rtk.ts path rtk init writes (mirrors OMP_AGENT_DIR in cli/common.ts
-// without importing it — see header note on argv side effects).
+// The rtk.ts path rtk init writes (OMP_AGENT_DIR inlined; see header note).
 function rtkExtensionPath() {
     const home = process.env.HOME || process.env.USERPROFILE || os.homedir();
     return path.join(home, '.omp', 'agent', 'extensions', 'rtk.ts');
 }
-// OMP loads only listed extensions: append rtk.ts after the existing entries
-// (or create the key) so a fresh wire takes effect on next OMP start.
+// Append rtk.ts after the existing entries (or create the key) so the wire
+// takes effect on the next OMP start.
 export async function ensureRtkInConfig(options) {
     const home = process.env.HOME || process.env.USERPROFILE || os.homedir();
     const configPath = path.join(home, '.omp', 'agent', 'config.yml');
@@ -98,8 +88,8 @@ async function runRtkInit(rtkBin, options) {
         return true;
     }
     catch (first) {
-        // A freshly written binary can lose its first exec to macOS Gatekeeper
-        // verification; give it one settle-and-retry before reporting failure.
+        // A fresh binary can lose its first exec to macOS Gatekeeper, so settle and
+        // retry once before reporting failure.
         await new Promise((resolve) => setTimeout(resolve, 2000));
         try {
             await execFileP(rtkBin, ['init', '-g', '--agent', 'omp'], 30000);

package/cli/settings.js

@@ -1,8 +1,4 @@
-// cli/settings.ts — view/edit session-start defaults (combo/caveman/rtk/ponytail)
-// plus the display-currency default for usage/dashboard reports.
-// Non-interactive: `tersio settings --combo-default balanced` (plus per-mode
-// override flags and --currency). Interactive: clack selects seeded from the
-// stored profile.
+// cli/settings.ts — view/edit session-start defaults and the display currency.
 import path from 'node:path';
 import { CAVEMAN_DEFAULTS, COMBO_DEFAULTS, COMBO_PRESET_MODES, OMP_PLUGINS_DIR, PACKAGE_NAME, PONYTAIL_DEFAULTS, cavemanDefaultFlag, comboDefaultFlag, currency, currencyGiven, diagScheduleFlag, dryRun, ponytailDefaultFlag, profileFlagsGiven, rtkDefaultFlag, settingArg, } from './common.js';
 import { CURRENCY_CODES } from './currency.js';
@@ -44,6 +40,7 @@ async function askProfile(current) {
         rtkDefault: preset.rtk,
         ponytailDefault: preset.ponytail,
         currency: current.currency,
+        backupSchedule: current.backupSchedule,
     };
     const caveman = await askInteractiveChoice('Caveman default', [...CAVEMAN_DEFAULTS].map((v) => ({
         value: v, label: v,
@@ -162,9 +159,7 @@ async function runSingleSetting(name, current, nextDiag) {
 }
 function printSettingsTable(current) {
     console.log('\n=== Tersio Settings ===');
-    // Currency lives here no longer: the dashboard owns displaying and
-    // persisting it (its picker POSTs to /currency); settings can still set
-    // the stored default via --currency or the prompt below.
+    // The dashboard owns displaying currency; settings only sets the default.
     const rows = [
         ['combo', current.comboDefault, [...COMBO_DEFAULTS].join(' | ')],
         ['caveman', current.cavemanDefault, [...CAVEMAN_DEFAULTS].join(' | ')],