@nexrall/code-core 1.4.76 → 1.4.77

package/dist/util/cellWidth.js

@@ -0,0 +1,161 @@
+"use strict";
+// Terminal-cell width helpers, shared by the diff/review renderers in core.
+//
+// This is the CLI theme.ts's measurement pair, extracted (2026-10-04) because
+// the review queue moved to core: the VS Code panel renders the same columns,
+// and core cannot depend on the CLI's theme module (which also carries ANSI
+// painting the panel has no use for). The rules are copied, not reinvented:
+//
+//   • width is measured in terminal CELLS, not String#length — CJK and emoji
+//     occupy two cells, combining marks and ZWJ add none;
+//   • ANSI escape sequences are zero-width and must be copied through whole
+//     when truncating (cutting inside one leaves a lone ESC that swallows the
+//     rest of the line in a real terminal);
+//   • truncation cuts on grapheme boundaries and reserves one cell for '…'.
+//
+// Deliberately dependency-free: the CLI's version delegates to `string-width`
+// (Ink already depends on it), but core has no such dependency and must not
+// grow one just for column arithmetic on file paths.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.graphemes = graphemes;
+exports.visibleLen = visibleLen;
+exports.truncateCells = truncateCells;
+const graphemeSegmenter = typeof Intl.Segmenter === 'function'
+    ? new Intl.Segmenter(undefined, { granularity: 'grapheme' })
+    : null;
+/** Split into user-perceived characters so accents/emoji/CJK are never cut in half. */
+function graphemes(s) {
+    return graphemeSegmenter ? Array.from(graphemeSegmenter.segment(s), (x) => x.segment) : Array.from(s);
+}
+/** Width of one code point in cells: 0 (combining/zero-width), 2 (wide), else 1. */
+function codePointWidth(cp) {
+    // Zero-width: combining marks, ZWJ/ZWNJ, variation selectors, BOM, soft hyphen.
+    if ((cp >= 0x0300 && cp <= 0x036f) ||
+        cp === 0x200b ||
+        cp === 0x200c ||
+        cp === 0x200d ||
+        cp === 0xfeff ||
+        cp === 0x00ad ||
+        (cp >= 0xfe00 && cp <= 0xfe0f) ||
+        (cp >= 0xe0100 && cp <= 0xe01ef))
+        return 0;
+    // Wide: CJK/kana/Hangul/fullwidth, plus emoji. The emoji set is the
+    // Emoji_Presentation ranges (calibrated against `string-width`, which the
+    // CLI uses — everything here it also counts as 2). Deliberately NOT all of
+    // 0x2600–0x27BF: ❯ (276F) and ✶ (2736) are width 1 there, and over-counting
+    // them would truncate box rows early.
+    if ((cp >= 0x1100 && cp <= 0x115f) ||
+        (cp >= 0x2e80 && cp <= 0x303e) ||
+        (cp >= 0x3041 && cp <= 0x33ff) ||
+        (cp >= 0x3400 && cp <= 0x4dbf) ||
+        (cp >= 0x4e00 && cp <= 0x9fff) ||
+        (cp >= 0xa000 && cp <= 0xa4cf) ||
+        (cp >= 0xac00 && cp <= 0xd7a3) ||
+        (cp >= 0xf900 && cp <= 0xfaff) ||
+        (cp >= 0xfe30 && cp <= 0xfe4f) ||
+        (cp >= 0xff00 && cp <= 0xff60) ||
+        (cp >= 0xffe0 && cp <= 0xffe6) ||
+        (cp >= 0x1f300 && cp <= 0x1faff) ||
+        (cp >= 0x20000 && cp <= 0x3fffd) ||
+        // Emoji_Presentation singletons and ranges scattered through symbols.
+        cp === 0x231a ||
+        cp === 0x231b ||
+        (cp >= 0x23e9 && cp <= 0x23ec) ||
+        cp === 0x23f0 ||
+        cp === 0x23f3 ||
+        (cp >= 0x25fd && cp <= 0x25fe) ||
+        (cp >= 0x2614 && cp <= 0x2615) ||
+        (cp >= 0x2648 && cp <= 0x2653) ||
+        cp === 0x267f ||
+        cp === 0x2693 ||
+        cp === 0x26a0 ||
+        cp === 0x26a1 ||
+        (cp >= 0x26aa && cp <= 0x26ab) ||
+        (cp >= 0x26bd && cp <= 0x26be) ||
+        (cp >= 0x26c4 && cp <= 0x26c5) ||
+        cp === 0x26ce ||
+        cp === 0x26d4 ||
+        cp === 0x26ea ||
+        (cp >= 0x26f2 && cp <= 0x26f3) ||
+        cp === 0x26f5 ||
+        cp === 0x26fa ||
+        cp === 0x26fd ||
+        cp === 0x2705 ||
+        (cp >= 0x270a && cp <= 0x270b) ||
+        cp === 0x2728 ||
+        cp === 0x274c ||
+        cp === 0x274e ||
+        (cp >= 0x2753 && cp <= 0x2755) ||
+        cp === 0x2757 ||
+        (cp >= 0x2795 && cp <= 0x2797) ||
+        cp === 0x27b0 ||
+        cp === 0x27bf ||
+        (cp >= 0x2b1b && cp <= 0x2b1c) ||
+        cp === 0x2b50 ||
+        cp === 0x2b55)
+        return 2;
+    return 1;
+}
+/**
+ * Width of `s` in terminal cells, ignoring ANSI styling. A grapheme measures as
+ * the sum of its code points' widths, except that any 2-wide code point in the
+ * cluster (an emoji base) makes the whole cluster 2 — a ZWJ family sequence is
+ * many code points but one two-cell glyph.
+ */
+function visibleLen(s) {
+    let total = 0;
+    // ANSI runs are zero cells — measured by walking the escape-aware runs, so
+    // `\x1b[2mfoo\x1b[22m` counts as 3 cells, not as the length of the bytes.
+    for (const run of runs(String(s))) {
+        if (run.escape)
+            continue;
+        for (const g of graphemes(run.raw)) {
+            let w = 0;
+            for (const ch of g)
+                w += codePointWidth(ch.codePointAt(0) ?? 0);
+            total += w > 0 ? Math.min(w, 2) : 0;
+        }
+    }
+    return total;
+}
+// eslint-disable-next-line no-control-regex -- ANSI parser: the ESC/BEL bytes are the grammar
+const ANSI_RUN_RE = /\x1b\[[0-9;?]*[ -/]*[@-~]|\x1b\][^\x07\x1b]*(?:\x07|\x1b\\)|\x1b[@-Z\\-_]|\x1b/g;
+function runs(s) {
+    const out = [];
+    let last = 0;
+    for (const m of s.matchAll(ANSI_RUN_RE)) {
+        const at = m.index ?? 0;
+        if (at > last)
+            out.push({ raw: s.slice(last, at), escape: false });
+        out.push({ raw: m[0], escape: true });
+        last = at + m[0].length;
+    }
+    if (last < s.length)
+        out.push({ raw: s.slice(last), escape: false });
+    return out;
+}
+/** Cut `s` to at most `max` terminal cells, ending in `…` when something was dropped. */
+function truncateCells(s, max) {
+    if (max <= 0)
+        return '';
+    if (visibleLen(s) <= max)
+        return s;
+    let out = '';
+    let used = 0;
+    const room = max - 1; // one cell is reserved for the ellipsis
+    for (const run of runs(s)) {
+        if (run.escape) {
+            out += run.raw;
+            continue;
+        }
+        for (const g of graphemes(run.raw)) {
+            const w = visibleLen(g);
+            if (used + w > room)
+                return out + '…';
+            out += g;
+            used += w;
+        }
+    }
+    return out + '…';
+}
+//# sourceMappingURL=cellWidth.js.map

package/dist/util/duration.d.ts

@@ -0,0 +1,8 @@
+export declare function formatDuration(ms: number): string;
+/** '940' · '12.4k' · '482k' · '1.2M' — tokens are read at a glance, never to three decimals. */
+export declare function formatTokens(n: number): string;
+/** Sub-cent costs keep four decimals; everything else reads as cents. */
+export declare function formatCost(usd: number): string;
+/** '3s' · '4m 05s' · '1h 02m' — the compact elapsed form for badges and notes. */
+export declare function formatElapsed(ms: number): string;
+//# sourceMappingURL=duration.d.ts.map

package/dist/util/duration.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"duration.d.ts","sourceRoot":"","sources":["../../src/util/duration.ts"],"names":[],"mappings":"AAIA,wBAAgB,cAAc,CAAC,EAAE,EAAE,MAAM,GAAG,MAAM,CAWjD;AAED,gGAAgG;AAChG,wBAAgB,YAAY,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,CAI9C;AAED,yEAAyE;AACzE,wBAAgB,UAAU,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAG9C;AAED,kFAAkF;AAClF,wBAAgB,aAAa,CAAC,EAAE,EAAE,MAAM,GAAG,MAAM,CAMhD"}

package/dist/util/duration.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatDuration = formatDuration;
+exports.formatTokens = formatTokens;
+exports.formatCost = formatCost;
+exports.formatElapsed = formatElapsed;
+// Duration formatting shared by panels that show elapsed/elapsed-since numbers
+// (the failure timeline's "5m ago", turn summaries). Moved here from the CLI's
+// ui/turnSummary.ts (2026-10-04) when the verification modules ported to core;
+// the CLI re-exports it so there is exactly one spelling of "1.2s" anywhere.
+function formatDuration(ms) {
+    const clamped = Math.max(0, ms);
+    if (clamped < 1000)
+        return `${Math.round(clamped)}ms`;
+    const s = clamped / 1000;
+    if (s < 60)
+        return `${s < 10 ? s.toFixed(1) : Math.round(s)}s`;
+    const m = Math.floor(s / 60);
+    const rest = Math.round(s - m * 60);
+    if (m < 60)
+        return rest ? `${m}m ${rest}s` : `${m}m`;
+    const h = Math.floor(m / 60);
+    const rem = m - h * 60;
+    return rem ? `${h}h ${rem}m` : `${h}h`;
+}
+/** '940' · '12.4k' · '482k' · '1.2M' — tokens are read at a glance, never to three decimals. */
+function formatTokens(n) {
+    if (n < 1000)
+        return String(n);
+    if (n < 1000000)
+        return `${(n / 1000).toFixed(n < 100000 ? 1 : 0)}k`;
+    return `${(n / 1000000).toFixed(1)}M`;
+}
+/** Sub-cent costs keep four decimals; everything else reads as cents. */
+function formatCost(usd) {
+    if (usd > 0 && usd < 0.01)
+        return `$${usd.toFixed(4)}`;
+    return `$${usd.toFixed(2)}`;
+}
+/** '3s' · '4m 05s' · '1h 02m' — the compact elapsed form for badges and notes. */
+function formatElapsed(ms) {
+    const s = Math.max(0, Math.floor(ms / 1000));
+    if (s < 60)
+        return `${s}s`;
+    const m = Math.floor(s / 60);
+    if (m < 60)
+        return `${m}m ${String(s % 60).padStart(2, '0')}s`;
+    return `${Math.floor(m / 60)}h ${String(m % 60).padStart(2, '0')}m`;
+}
+//# sourceMappingURL=duration.js.map

package/dist/util/loopJobs.d.ts

@@ -0,0 +1,67 @@
+export declare const MIN_INTERVAL_MS = 60000;
+export declare const MAX_AGE_MS: number;
+export declare const MAX_LOOPS = 20;
+export declare const MAX_PROMPT_CHARS = 4000;
+export type LoopArgs = {
+    kind: 'list';
+} | {
+    kind: 'stop';
+    target: string;
+} | {
+    kind: 'add';
+    intervalMs: number;
+    prompt: string;
+    clamped: boolean;
+} | {
+    kind: 'error';
+    message: string;
+};
+export declare function parseInterval(tok: string): number | null;
+export declare function parseLoopArgs(arg: string): LoopArgs;
+export interface LoopJob {
+    id: string;
+    prompt: string;
+    intervalMs: number;
+    createdAt: number;
+    nextAt: number;
+    runs: number;
+    /** Fire once, then remove itself (a wake-up rather than a recurring loop). */
+    once?: boolean;
+    /** Who created it — shown in /loop list so a model-made job is never invisible. */
+    by?: 'user' | 'model';
+}
+/** Deterministic jitter in [0, min(10% of interval, 5 min)) from the job id and run number. */
+export declare function jitterMs(id: string, run: number, intervalMs: number): number;
+export type AddResult = {
+    ok: true;
+    job: LoopJob;
+} | {
+    ok: false;
+    message: string;
+};
+export declare class LoopScheduler {
+    private readonly now;
+    private jobs;
+    private seq;
+    constructor(now?: () => number);
+    list(): LoopJob[];
+    get size(): number;
+    add(prompt: string, intervalMs: number, opts?: {
+        once?: boolean;
+        by?: 'user' | 'model';
+    }): AddResult;
+    /** Remove one job by id, or all with "all". Returns how many were removed. */
+    stop(target: string): number;
+    /**
+     * Called on a timer. Drops expired jobs and returns the jobs due NOW — but none while the
+     * session is busy (they stay due and fire on the first idle tick). A job owed several runs
+     * fires once; its next time is measured from now, so a long busy spell cannot cause a burst.
+     */
+    tick(busy: boolean, max?: number): {
+        due: LoopJob[];
+        expired: LoopJob[];
+    };
+}
+export declare function formatInterval(ms: number): string;
+export declare function formatLoopList(jobs: LoopJob[], now: number): string[];
+//# sourceMappingURL=loopJobs.d.ts.map

package/dist/util/loopJobs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"loopJobs.d.ts","sourceRoot":"","sources":["../../src/util/loopJobs.ts"],"names":[],"mappings":"AAqBA,eAAO,MAAM,eAAe,QAAS,CAAC;AACtC,eAAO,MAAM,UAAU,QAAoB,CAAC;AAC5C,eAAO,MAAM,SAAS,KAAK,CAAC;AAC5B,eAAO,MAAM,gBAAgB,OAAO,CAAC;AAGrC,MAAM,MAAM,QAAQ,GAChB;IAAE,IAAI,EAAE,MAAM,CAAA;CAAE,GAChB;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,GAChC;IAAE,IAAI,EAAE,KAAK,CAAC;IAAC,UAAU,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,OAAO,CAAA;CAAE,GACrE;IAAE,IAAI,EAAE,OAAO,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,CAAC;AAEvC,wBAAgB,aAAa,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAKxD;AAED,wBAAgB,aAAa,CAAC,GAAG,EAAE,MAAM,GAAG,QAAQ,CA6BnD;AAED,MAAM,WAAW,OAAO;IACtB,EAAE,EAAE,MAAM,CAAC;IACX,MAAM,EAAE,MAAM,CAAC;IACf,UAAU,EAAE,MAAM,CAAC;IACnB,SAAS,EAAE,MAAM,CAAC;IAClB,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,MAAM,CAAC;IACb,8EAA8E;IAC9E,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,mFAAmF;IACnF,EAAE,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC;CACvB;AAED,+FAA+F;AAC/F,wBAAgB,QAAQ,CAAC,EAAE,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,MAAM,CAQ5E;AAED,MAAM,MAAM,SAAS,GAAG;IAAE,EAAE,EAAE,IAAI,CAAC;IAAC,GAAG,EAAE,OAAO,CAAA;CAAE,GAAG;IAAE,EAAE,EAAE,KAAK,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,CAAC;AAEpF,qBAAa,aAAa;IAGZ,OAAO,CAAC,QAAQ,CAAC,GAAG;IAFhC,OAAO,CAAC,IAAI,CAAiB;IAC7B,OAAO,CAAC,GAAG,CAAK;gBACa,GAAG,GAAE,MAAM,MAAiB;IAEzD,IAAI,IAAI,OAAO,EAAE;IAGjB,IAAI,IAAI,IAAI,MAAM,CAEjB;IAED,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,EAAE,IAAI,GAAE;QAAE,IAAI,CAAC,EAAE,OAAO,CAAC;QAAC,EAAE,CAAC,EAAE,MAAM,GAAG,OAAO,CAAA;KAAO,GAAG,SAAS;IAoBxG,8EAA8E;IAC9E,IAAI,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM;IAM5B;;;;OAIG;IACH,IAAI,CAAC,IAAI,EAAE,OAAO,EAAE,GAAG,SAAW,GAAG;QAAE,GAAG,EAAE,OAAO,EAAE,CAAC;QAAC,OAAO,EAAE,OAAO,EAAE,CAAA;KAAE;CAiB5E;AAED,wBAAgB,cAAc,CAAC,EAAE,EAAE,MAAM,GAAG,MAAM,CAKjD;AAED,wBAAgB,cAAc,CAAC,IAAI,EAAE,OAAO,EAAE,EAAE,GAAG,EAAE,MAAM,GAAG,MAAM,EAAE,CAQrE"}

package/dist/util/loopJobs.js

@@ -0,0 +1,169 @@
+"use strict";
+// Lives in core (moved from the CLI's ui/loop.ts, 2026-10-04) so the VS Code
+// panel honours the same loop rules (min interval, expiry, cap, no bursts); the
+// CLI module is a re-export shim.
+// /loop — re-run a prompt on a schedule while the session is open.
+//
+//   /loop 5m check the deploy          every 5 minutes
+//   /loop check the deploy every 2h    trailing "every <n><unit>" also accepted
+//   /loop list | /loop stop [id|all]
+//
+// Pure: parsing, interval rules and a clock-injected scheduler. chat.ts owns the timer
+// that calls tick() and the turn runner, so "when may a job fire" is testable offline.
+//
+// Hard rules (a recurring prompt is a recurring SPEND):
+//   - interval >= 1 minute
+//   - a job expires 7 days after creation
+//   - at most MAX_LOOPS jobs per session
+//   - a job never fires while a turn is running, and never stacks: at most one run is
+//     owed per job, however long the session was busy.
+//   - fire times carry deterministic jitter (up to 10% of the interval, capped at 5 min) so
+//     many sessions on one schedule do not hit the backend on the same second.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LoopScheduler = exports.MAX_PROMPT_CHARS = exports.MAX_LOOPS = exports.MAX_AGE_MS = exports.MIN_INTERVAL_MS = void 0;
+exports.parseInterval = parseInterval;
+exports.parseLoopArgs = parseLoopArgs;
+exports.jitterMs = jitterMs;
+exports.formatInterval = formatInterval;
+exports.formatLoopList = formatLoopList;
+exports.MIN_INTERVAL_MS = 60000;
+exports.MAX_AGE_MS = 7 * 24 * 3600000;
+exports.MAX_LOOPS = 20;
+exports.MAX_PROMPT_CHARS = 4000;
+const UNIT_MS = { s: 1000, m: 60000, h: 3600000, d: 86400000 };
+function parseInterval(tok) {
+    const m = /^(\d+(?:\.\d+)?)\s*([smhd])$/i.exec(tok.trim());
+    if (!m)
+        return null;
+    const ms = Math.round(parseFloat(m[1]) * UNIT_MS[m[2].toLowerCase()]);
+    return Number.isFinite(ms) && ms > 0 ? ms : null;
+}
+function parseLoopArgs(arg) {
+    const text = String(arg ?? '').trim();
+    if (!text || /^(list|ls)$/i.test(text))
+        return { kind: 'list' };
+    const stop = /^(?:stop|rm|remove|cancel|clear)(?:\s+(\S+))?$/i.exec(text);
+    if (stop)
+        return { kind: 'stop', target: stop[1] ?? 'all' };
+    let intervalMs = null;
+    let prompt = text;
+    const lead = /^(\S+)\s+([\s\S]+)$/.exec(text);
+    if (lead && parseInterval(lead[1]) !== null) {
+        intervalMs = parseInterval(lead[1]);
+        prompt = lead[2];
+    }
+    else {
+        const trail = /^([\s\S]+?)\s+every\s+(\d+(?:\.\d+)?\s*[smhd])$/i.exec(text);
+        if (trail && parseInterval(trail[2]) !== null) {
+            intervalMs = parseInterval(trail[2]);
+            prompt = trail[1];
+        }
+    }
+    if (intervalMs === null) {
+        return { kind: 'error', message: 'Give an interval: /loop 5m <prompt>  (units s, m, h, d; minimum 1m)' };
+    }
+    prompt = prompt.trim();
+    if (!prompt)
+        return { kind: 'error', message: 'Nothing to run — add a prompt after the interval.' };
+    if (prompt.length > exports.MAX_PROMPT_CHARS) {
+        return { kind: 'error', message: `The prompt is ${prompt.length} characters; keep it under ${exports.MAX_PROMPT_CHARS}.` };
+    }
+    const clamped = intervalMs < exports.MIN_INTERVAL_MS;
+    return { kind: 'add', intervalMs: Math.max(intervalMs, exports.MIN_INTERVAL_MS), prompt, clamped };
+}
+/** Deterministic jitter in [0, min(10% of interval, 5 min)) from the job id and run number. */
+function jitterMs(id, run, intervalMs) {
+    let h = 2166136261;
+    for (const ch of `${id}:${run}`) {
+        h ^= ch.charCodeAt(0);
+        h = Math.imul(h, 16777619) >>> 0;
+    }
+    const cap = Math.min(intervalMs * 0.1, 5 * 60000);
+    return Math.floor((h / 0xffffffff) * cap);
+}
+class LoopScheduler {
+    constructor(now = Date.now) {
+        this.now = now;
+        this.jobs = [];
+        this.seq = 0;
+    }
+    list() {
+        return this.jobs.map((j) => ({ ...j }));
+    }
+    get size() {
+        return this.jobs.length;
+    }
+    add(prompt, intervalMs, opts = {}) {
+        if (this.jobs.length >= exports.MAX_LOOPS)
+            return { ok: false, message: `At most ${exports.MAX_LOOPS} loops per session — /loop stop one first.` };
+        const id = String(++this.seq);
+        const t = this.now();
+        const interval = Math.max(intervalMs, exports.MIN_INTERVAL_MS);
+        const job = {
+            id,
+            prompt,
+            intervalMs: interval,
+            createdAt: t,
+            nextAt: t + interval + jitterMs(id, 0, interval),
+            runs: 0,
+            ...(opts.once ? { once: true } : {}),
+            by: opts.by ?? 'user',
+        };
+        this.jobs.push(job);
+        return { ok: true, job: { ...job } };
+    }
+    /** Remove one job by id, or all with "all". Returns how many were removed. */
+    stop(target) {
+        const before = this.jobs.length;
+        this.jobs = /^all$/i.test(target) ? [] : this.jobs.filter((j) => j.id !== target);
+        return before - this.jobs.length;
+    }
+    /**
+     * Called on a timer. Drops expired jobs and returns the jobs due NOW — but none while the
+     * session is busy (they stay due and fire on the first idle tick). A job owed several runs
+     * fires once; its next time is measured from now, so a long busy spell cannot cause a burst.
+     */
+    tick(busy, max = Infinity) {
+        const t = this.now();
+        const expired = this.jobs.filter((j) => t - j.createdAt >= exports.MAX_AGE_MS);
+        if (expired.length)
+            this.jobs = this.jobs.filter((j) => !expired.includes(j));
+        if (busy)
+            return { due: [], expired };
+        const due = [];
+        for (const j of this.jobs) {
+            if (due.length >= max)
+                break; // the rest stay due and go out on a later tick
+            if (t < j.nextAt)
+                continue;
+            j.runs += 1;
+            j.nextAt = t + j.intervalMs + jitterMs(j.id, j.runs, j.intervalMs);
+            due.push({ ...j });
+        }
+        // A one-shot is spent the moment it is handed out.
+        if (due.some((d) => d.once))
+            this.jobs = this.jobs.filter((j) => !(j.once && due.some((d) => d.id === j.id)));
+        return { due, expired };
+    }
+}
+exports.LoopScheduler = LoopScheduler;
+function formatInterval(ms) {
+    if (ms % 86400000 === 0)
+        return `${ms / 86400000}d`;
+    if (ms % 3600000 === 0)
+        return `${ms / 3600000}h`;
+    if (ms % 60000 === 0)
+        return `${ms / 60000}m`;
+    return `${Math.round(ms / 1000)}s`;
+}
+function formatLoopList(jobs, now) {
+    if (!jobs.length)
+        return ['No loops. Start one with: /loop 5m <prompt>'];
+    return jobs.map((j) => {
+        const inMin = Math.max(0, Math.round((j.nextAt - now) / 60000));
+        const p = j.prompt.length > 60 ? j.prompt.slice(0, 59) + '…' : j.prompt;
+        const when = j.once ? `once in ~${inMin}m` : `every ${formatInterval(j.intervalMs)}  next in ~${inMin}m`;
+        return `#${j.id}  ${when}  runs ${j.runs}${j.by === 'model' ? '  (by model)' : ''}  ${p}`;
+    });
+}
+//# sourceMappingURL=loopJobs.js.map

package/dist/util/settingsFile.d.ts

@@ -0,0 +1,14 @@
+export interface WriteResult {
+    ok: boolean;
+    path: string;
+    error?: string;
+}
+/** The settings file a scoped write targets. */
+export declare function settingsPath(workDir: string, scope?: 'user' | 'project'): string;
+/**
+ * Sets one key in one settings file, preserving everything else. Written via a
+ * temp file + rename so an interrupted write cannot leave a half-JSON file that
+ * would silently drop every permission rule in it.
+ */
+export declare function writeSetting(workDir: string, key: string, value: unknown, scope?: 'user' | 'project'): WriteResult;
+//# sourceMappingURL=settingsFile.d.ts.map

package/dist/util/settingsFile.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"settingsFile.d.ts","sourceRoot":"","sources":["../../src/util/settingsFile.ts"],"names":[],"mappings":"AAiBA,MAAM,WAAW,WAAW;IAC1B,EAAE,EAAE,OAAO,CAAC;IACZ,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED,gDAAgD;AAChD,wBAAgB,YAAY,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,GAAE,MAAM,GAAG,SAAkB,GAAG,MAAM,CAIxF;AAED;;;;GAIG;AACH,wBAAgB,YAAY,CAC1B,OAAO,EAAE,MAAM,EACf,GAAG,EAAE,MAAM,EACX,KAAK,EAAE,OAAO,EACd,KAAK,GAAE,MAAM,GAAG,SAAkB,GACjC,WAAW,CA6Bb"}

package/dist/util/settingsFile.js

@@ -0,0 +1,99 @@
+"use strict";
+// Writes ONE key into ONE settings tier, preserving everything else.
+//
+// The settings hierarchy (see permissions/rules.ts) merges enterprise →
+// ~/.nexrall/settings.json → <project>/.nexrall/settings.json → settings.local.json.
+// Readers always see the merge; writers target a single tier, so a user-level
+// default cannot be silently overridden from inside one checkout — the same
+// rule the CLI's /theme, /livediff, /output-style and keybindings writers use.
+//
+// Lives in core (moved from the CLI's ui/themeSettings.ts, 2026-10-04) so the
+// VS Code panel writes the SAME tier with the SAME atomic-write guarantee; the
+// CLI module re-exports it.
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.settingsPath = settingsPath;
+exports.writeSetting = writeSetting;
+const fs = __importStar(require("fs"));
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+const hooks_1 = require("../agent/hooks");
+/** The settings file a scoped write targets. */
+function settingsPath(workDir, scope = 'user') {
+    return scope === 'project'
+        ? path.join(workDir, '.nexrall', 'settings.json')
+        : path.join(os.homedir(), '.nexrall', 'settings.json');
+}
+/**
+ * Sets one key in one settings file, preserving everything else. Written via a
+ * temp file + rename so an interrupted write cannot leave a half-JSON file that
+ * would silently drop every permission rule in it.
+ */
+function writeSetting(workDir, key, value, scope = 'user') {
+    const file = settingsPath(workDir, scope);
+    let existing = {};
+    if (fs.existsSync(file)) {
+        try {
+            const parsed = JSON.parse(fs.readFileSync(file, 'utf-8'));
+            if (parsed && typeof parsed === 'object' && !Array.isArray(parsed))
+                existing = parsed;
+            else
+                return { ok: false, path: file, error: 'the file is valid JSON but not an object' };
+        }
+        catch (e) {
+            return { ok: false, path: file, error: `could not parse it: ${e.message}` };
+        }
+    }
+    const next = { ...existing };
+    if (value === undefined)
+        delete next[key];
+    else
+        next[key] = value;
+    // A key reset (value === undefined) deletes rather than storing null, so a
+    // file that never had the setting does not gain a placeholder for it.
+    const body = JSON.stringify(next, null, 2) + '\n';
+    try {
+        fs.mkdirSync(path.dirname(file), { recursive: true });
+        const tmp = `${file}.${process.pid}.tmp`;
+        fs.writeFileSync(tmp, body, 'utf-8');
+        fs.renameSync(tmp, file);
+    }
+    catch (e) {
+        return { ok: false, path: file, error: e.message };
+    }
+    void (0, hooks_1.fireObserverHook)(workDir, 'ConfigChange', { key, scope, file }, key);
+    return { ok: true, path: file };
+}
+//# sourceMappingURL=settingsFile.js.map

package/dist/util/toolLabel.d.ts

@@ -0,0 +1,2 @@
+export declare function toolLabel(name: string, input: unknown): string;
+//# sourceMappingURL=toolLabel.d.ts.map

package/dist/util/toolLabel.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"toolLabel.d.ts","sourceRoot":"","sources":["../../src/util/toolLabel.ts"],"names":[],"mappings":"AAIA,wBAAgB,SAAS,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,GAAG,MAAM,CAQ9D"}

package/dist/util/toolLabel.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toolLabel = toolLabel;
+// One-line label for a tool call — `bash: npm test`, `read_file: src/app.ts`.
+// Moved from the CLI's ui/toolOutputStore.ts (2026-10-04) so the transcript
+// turns builder (core/search/conversationTurns.ts) can label tool lines; the
+// CLI module re-exports it.
+function toolLabel(name, input) {
+    const rec = (input && typeof input === 'object' ? input : {});
+    const pick = ['command', 'file_path', 'path', 'pattern', 'url', 'query', 'description']
+        .map((k) => rec[k])
+        .find((v) => typeof v === 'string' && v.length > 0);
+    const flat = (pick ?? '').replace(/\s+/g, ' ').trim();
+    const clipped = flat.length > 100 ? flat.slice(0, 99) + '\u2026' : flat;
+    return clipped ? `${name}: ${clipped}` : name;
+}
+//# sourceMappingURL=toolLabel.js.map