@nexrall/code-core 1.4.76 → 1.4.78

package/dist/ui/taskGraph.js

@@ -0,0 +1,289 @@
+"use strict";
+// Lives in core (moved from the CLI's ui/taskGraph.ts, 2026-10-04) so the VS Code
+// panel draws the same shared-task DAG; the CLI module is a re-export shim.
+// The shared-task DAG (spec §41).
+//
+// WHY a graph and not a list: `list_shared_tasks` already prints the tasks, but a list
+// flattens away the only thing that makes a set of tasks a plan — which ones are waiting
+// on which. `blockedBy` is a real dependency edge written by whoever created the task, so
+// the graph is measured, not inferred. Reading it as layers answers the question a list
+// cannot: what can start RIGHT NOW, and what is stuck behind what.
+//
+// Drawn as a tree from the dependency roots (the spec's own shape), because a terminal
+// has one column to draw in. The limitation that comes with that choice is handled out
+// loud rather than hidden: a task reachable from two blockers is a diamond, and a tree has
+// no place to draw the second edge, so the task is drawn again under the other blocker and
+// marked `↖ also after #id` — naming the edge makes the repeat read as ONE task, not two.
+// Everything drawn under that repeat is a copy of rows above it, so those are marked too.
+//
+// A cycle is not a crash and not a silent loop — it is reported as a named group, since a
+// cycle means nobody can ever claim those tasks and the user needs to know that.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.STATUS_MARK = void 0;
+exports.roots = roots;
+exports.blockersOf = blockersOf;
+exports.missingBlockers = missingBlockers;
+exports.readyTasks = readyTasks;
+exports.findCycle = findCycle;
+exports.formatTaskGraph = formatTaskGraph;
+/** Local copy of the one-line clip (formerly ui/taskPanel.ts's) so core needs
+ *  no import from the CLI; identical behaviour. */
+function clip(text, max) {
+    const tt = String(text ?? '')
+        .replace(/\s+/g, ' ')
+        .trim();
+    if (max <= 1)
+        return tt.slice(0, Math.max(0, max));
+    return tt.length <= max ? tt : tt.slice(0, max - 1).trimEnd() + '\u2026';
+}
+const duration_1 = require("../util/duration");
+/** Rows built past the cap before giving up on an exact count (see `buildCap`). */
+const ROW_BUILD_SLACK = 50;
+exports.STATUS_MARK = {
+    pending: '○',
+    in_progress: '⠋',
+    completed: '✓',
+    blocked: '⊘',
+};
+/** Tasks that no one has to wait for: no blockers, or blockers we cannot see. */
+function roots(tasks) {
+    const known = new Set(tasks.map((t) => t.id));
+    return tasks.filter((t) => !(t.blockedBy ?? []).some((b) => known.has(b)));
+}
+function blockersOf(tasks, t) {
+    const known = new Set(tasks.map((x) => x.id));
+    return (t.blockedBy ?? []).filter((b) => known.has(b));
+}
+/** Blockers that are named but do not exist — a broken edge the user should see. */
+function missingBlockers(tasks, t) {
+    const known = new Set(tasks.map((x) => x.id));
+    return (t.blockedBy ?? []).filter((b) => !known.has(b));
+}
+/**
+ * Tasks that can be claimed this instant: nothing blocking, and nobody holding them.
+ *
+ * A task blocked by an in-progress or pending dependency is NOT ready even though it is
+ * itself `pending` — the whole point of the graph. Claimed-but-abandoned tasks are left
+ * out too: core's claim-liveness rules are the authority on whether a claim is dead, and
+ * second-guessing them here would print "ready" for something core would refuse.
+ */
+function readyTasks(tasks) {
+    const byId = new Map(tasks.map((t) => [t.id, t]));
+    return tasks.filter((t) => {
+        if (t.status !== 'pending' && t.status !== 'blocked')
+            return false;
+        const blockers = t.blockedBy ?? [];
+        return blockers.every((b) => byId.get(b)?.status === 'completed');
+    });
+}
+/** Task ids in a dependency cycle (mutual or longer). Empty when the graph is a DAG. */
+function findCycle(tasks) {
+    const byId = new Map(tasks.map((t) => [t.id, t]));
+    const state = new Map();
+    const stack = [];
+    const inCycle = new Set();
+    const visit = (id) => {
+        const st = state.get(id) ?? 0;
+        if (st === 2)
+            return;
+        if (st === 1) {
+            // Found a back edge: everything from this node's position on the stack is a cycle.
+            const at = stack.indexOf(id);
+            for (const x of stack.slice(at === -1 ? 0 : at))
+                inCycle.add(x);
+            return;
+        }
+        state.set(id, 1);
+        stack.push(id);
+        for (const b of byId.get(id)?.blockedBy ?? [])
+            if (byId.has(b))
+                visit(b);
+        stack.pop();
+        state.set(id, 2);
+    };
+    for (const t of tasks)
+        visit(t.id);
+    return [...inCycle];
+}
+/**
+ * Build the forest to print: each root with the tasks it directly unblocks, recursively.
+ * Children are ordered by creation-independent input order so two runs print the same
+ * picture (`updatedAt` moves as work progresses; sorting by it would reshuffle rows
+ * while the user is reading them).
+ *
+ * Structure only — which copy of a twice-reachable task is the repeat is decided by the
+ * caller, because that is the one place that knows what has already been printed.
+ */
+function forest(pool) {
+    const unblocks = new Map();
+    for (const t of pool) {
+        for (const b of blockersOf(pool, t)) {
+            const list = unblocks.get(b);
+            if (list)
+                list.push(t);
+            else
+                unblocks.set(b, [t]);
+        }
+    }
+    const out = [];
+    const walked = new Set();
+    for (const r of roots(pool)) {
+        if (walked.has(r.id))
+            continue;
+        const kids = new Map();
+        const walk = (id) => {
+            const list = unblocks.get(id) ?? [];
+            kids.set(id, list);
+            // Each child is expanded once. Walking it again rebuilds the same lists, and a
+            // handful of stacked diamonds would multiply that out towards 2^depth.
+            for (const child of list) {
+                if (walked.has(child.id))
+                    continue;
+                walked.add(child.id);
+                walk(child.id);
+            }
+        };
+        walked.add(r.id);
+        walk(r.id);
+        out.push({ root: r, kids });
+    }
+    return out;
+}
+function mark(t) {
+    return exports.STATUS_MARK[t.status] ?? '○';
+}
+/**
+ * Clip a FINISHED row to `cols` without the whitespace collapse `clip` performs: the leading
+ * indent IS the tree structure, and clip() flattens the stem of a grandchild to column zero —
+ * which drew a depth-2 task exactly like a depth-1 one. Contents are clipped individually
+ * before they get here, so all that is left is the final fit.
+ */
+function fit(line, cols) {
+    if (line.length <= cols)
+        return line;
+    return line.slice(0, Math.max(1, cols - 1)).trimEnd() + '…';
+}
+function taskLine(t, now, cols, extra = '') {
+    const bits = [];
+    bits.push(t.status === 'in_progress' && t.claimedAt
+        ? `${t.claimedBy ?? 'someone'} · ${(0, duration_1.formatElapsed)(now - t.claimedAt)}`
+        : t.status.replace('_', ' '));
+    if (extra)
+        bits.push(extra);
+    return fit(`${mark(t)} ${clip(t.content, Math.max(16, cols - 40))}  ·  ${bits.join(' · ')}`, cols);
+}
+/**
+ * The whole graph, as lines for the caller to print.
+ *
+ * Empty input is a normal state, not an error — most projects never create shared tasks.
+ * The caller pairs this with an explanation of how one gets created, which is why the
+ * empty case returns no lines at all rather than a placeholder.
+ */
+function formatTaskGraph(input) {
+    const cols = Math.max(24, input.cols ?? 100);
+    const maxRows = input.maxRows ?? 30;
+    const tasks = input.tasks;
+    if (!tasks.length)
+        return [];
+    const cycle = new Set(findCycle(tasks));
+    const healthy = tasks.filter((t) => !cycle.has(t.id));
+    const out = [];
+    const ready = readyTasks(tasks);
+    const counts = {
+        pending: tasks.filter((t) => t.status === 'pending').length,
+        running: tasks.filter((t) => t.status === 'in_progress').length,
+        done: tasks.filter((t) => t.status === 'completed').length,
+    };
+    const workers = new Set(tasks.filter((t) => t.status === 'in_progress' && t.claimedBy).map((t) => t.claimedBy));
+    out.push(fit(`Task graph — ${tasks.length} task${tasks.length === 1 ? '' : 's'}: ` +
+        `${counts.done} done · ${counts.running} in progress · ${counts.pending} pending` +
+        `${workers.size ? ` · ${workers.size} worker${workers.size === 1 ? '' : 's'}` : ''}`, cols));
+    if (ready.length) {
+        out.push(fit(`${ready.length} ready to claim now: ${ready
+            .slice(0, 3)
+            .map((t) => `#${t.id}`)
+            .join(', ')}${ready.length > 3 ? ` (+${ready.length - 3})` : ''}`, cols));
+    }
+    const rows = [];
+    // Rows are built only as far as the cap can use them. A task reachable two ways is drawn
+    // under BOTH, so a plan that fans out and re-joins at every step multiplies the rows:
+    // 16 stacked diamonds is 65k rows, which is both a hang and a stack overflow on spread.
+    // The slack keeps the exact count for boards of an ordinary size, where the reader is
+    // owed a number, and switches to "N+" once the multiplication takes over.
+    const buildCap = maxRows + ROW_BUILD_SLACK;
+    let capped = false;
+    // Ids already printed, so a repeated copy can say so. The set also covers the copies'
+    // DESCENDANTS: the whole subtree under a repeat is already on screen above, and a row
+    // that looks identical to one three lines up reads as a second, separate task.
+    const printed = new Set();
+    for (const { root, kids } of forest(healthy)) {
+        rows.push(taskLine(root, input.now, cols));
+        // A root of the drawn forest can still name blockers from the FULL list: ones inside a
+        // cycle (excluded from the forest) and ones that do not exist. Reporting a task printed
+        // three lines below as "no such task" would be a plain lie, so the two read differently.
+        const cyc = blockersOf(tasks, root).filter((b) => cycle.has(b));
+        if (cyc.length)
+            rows.push(fit(`  ⚠ depends on ${cyc.map((b) => `#${b}`).join(', ')} — inside a dependency cycle (listed below)`, cols));
+        const skipped = missingBlockers(tasks, root);
+        if (skipped.length)
+            rows.push(fit(`  ⚠ depends on ${skipped.map((b) => `#${b}`).join(', ')} — no such task`, cols));
+        const walk = (id, stem) => {
+            const list = kids.get(id) ?? [];
+            list.forEach((child, i) => {
+                if (rows.length >= buildCap) {
+                    capped = true;
+                    return;
+                }
+                const last = i === list.length - 1;
+                const lead = stem + (last ? '└─ ' : '├─ ');
+                const bits = [];
+                if (child.status === 'in_progress' && child.claimedAt)
+                    bits.push(`${child.claimedBy ?? 'someone'} · ${(0, duration_1.formatElapsed)(input.now - child.claimedAt)}`);
+                else
+                    bits.push(child.status.replace('_', ' '));
+                const seen = printed.has(child.id);
+                printed.add(child.id);
+                if (seen) {
+                    // The same task under a second blocker (a tree has no room for the second edge).
+                    // Name the other edge when there is one, so the repeat reads as ONE task rather
+                    // than as two tasks with the same content; a descendant of a repeat has no other
+                    // edge of its own, it is simply the copy above it.
+                    const others = blockersOf(healthy, child).filter((b) => b !== id);
+                    bits.push(others.length ? `↖ also after ${others.map((b) => `#${b}`).join(', ')}` : '↖ also drawn above');
+                }
+                const cycB = blockersOf(tasks, child).filter((b) => cycle.has(b));
+                if (cycB.length)
+                    bits.push(`⚠ needs ${cycB.map((b) => `#${b}`).join(', ')} (cycle)`);
+                const miss = missingBlockers(tasks, child);
+                if (miss.length)
+                    bits.push(`⚠ missing ${miss.map((b) => `#${b}`).join(', ')}`);
+                const text = clip(child.content, Math.max(16, cols - lead.length - 34));
+                rows.push(fit(`${lead}${mark(child)} ${text}  ·  ${bits.join(' · ')}`, cols));
+                walk(child.id, stem + (last ? '   ' : '│  '));
+            });
+        };
+        printed.add(root.id);
+        walk(root.id, '');
+    }
+    if (rows.length > maxRows) {
+        out.push(...rows.slice(0, maxRows));
+        // Both counts are true: the exact one when every row was built, and a lower bound when
+        // building stopped early — "1 more row" there would be a lie with a straight face.
+        const hidden = `${rows.length - maxRows}${capped ? '+' : ''}`;
+        out.push(fit(`  … ${hidden} more row(s) not drawn — this view caps at ${maxRows}; the counts above cover every task`, cols));
+    }
+    else {
+        out.push(...rows);
+    }
+    if (cycle.size) {
+        // A cycle is why a task can sit pending forever with every dependency "somewhere in
+        // the graph": naming the members is the only actionable way to say that.
+        out.push(fit(`⚠ ${cycle.size} task(s) form a dependency cycle — none of them can ever be claimed:`, cols));
+        for (const id of cycle) {
+            const t = tasks.find((x) => x.id === id);
+            out.push(fit(`  ⊘ #${id} ${clip(t?.content ?? '', Math.max(10, cols - 24))}`, cols));
+        }
+    }
+    return out;
+}
+//# sourceMappingURL=taskGraph.js.map

package/dist/util/addDir.d.ts

@@ -0,0 +1,31 @@
+export type AddDirResult = {
+    kind: 'list';
+} | {
+    kind: 'error';
+    message: string;
+} | {
+    kind: 'noop';
+    dir: string;
+} | {
+    kind: 'added';
+    dir: string;
+    dirs: string[];
+};
+/**
+ * Tool lists arrive as `--allowedTools "Bash(git *)" Edit` (variadic), as one
+ * comma-separated string, or both. Commas INSIDE parentheses belong to the rule
+ * (`Bash(git log --format=a,b)`), so splitting is paren-aware.
+ */
+export declare function parseToolList(values: string[] | string | undefined): string[];
+export type Parsed<T> = {
+    ok: true;
+    value: T;
+} | {
+    ok: false;
+    error: string;
+};
+/** Resolve and VALIDATE --add-dir pieces: each must be an existing directory. */
+export declare function parseAddDirs(values: string[] | undefined, cwd: string): Parsed<string[]>;
+export declare function addDirNote(dirs: string[]): string;
+export declare function resolveAddDir(arg: string, cwd: string, current: string[], projectRoot: string): AddDirResult;
+//# sourceMappingURL=addDir.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"addDir.d.ts","sourceRoot":"","sources":["../../src/util/addDir.ts"],"names":[],"mappings":"AAaA,MAAM,MAAM,YAAY,GACpB;IAAE,IAAI,EAAE,MAAM,CAAA;CAAE,GAChB;IAAE,IAAI,EAAE,OAAO,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,GAClC;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,MAAM,CAAA;CAAE,GAC7B;IAAE,IAAI,EAAE,OAAO,CAAC;IAAC,GAAG,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,EAAE,CAAA;CAAE,CAAC;AAEnD;;;;GAIG;AACH,wBAAgB,aAAa,CAAC,MAAM,EAAE,MAAM,EAAE,GAAG,MAAM,GAAG,SAAS,GAAG,MAAM,EAAE,CAwB7E;AAED,MAAM,MAAM,MAAM,CAAC,CAAC,IAAI;IAAE,EAAE,EAAE,IAAI,CAAC;IAAC,KAAK,EAAE,CAAC,CAAA;CAAE,GAAG;IAAE,EAAE,EAAE,KAAK,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,CAAC;AAE9E,iFAAiF;AACjF,wBAAgB,YAAY,CAAC,MAAM,EAAE,MAAM,EAAE,GAAG,SAAS,EAAE,GAAG,EAAE,MAAM,GAAG,MAAM,CAAC,MAAM,EAAE,CAAC,CAgBxF;AAED,wBAAgB,UAAU,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,MAAM,CAGjD;AAED,wBAAgB,aAAa,CAAC,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,EAAE,WAAW,EAAE,MAAM,GAAG,YAAY,CAS5G"}

package/dist/util/addDir.js

@@ -0,0 +1,124 @@
+"use strict";
+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.parseToolList = parseToolList;
+exports.parseAddDirs = parseAddDirs;
+exports.addDirNote = addDirNote;
+exports.resolveAddDir = resolveAddDir;
+// /add-dir <path> — widen the session to another directory mid-run (the interactive
+// twin of --add-dir). Moved from the CLI (ui/addDir.ts + the parseToolList /
+// parseAddDirs / addDirNote trio in headlessFlags.ts, 2026-10-04) so the VS Code
+// panel widens its brief with the same rules; the CLI modules re-export.
+const fs = __importStar(require("fs"));
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+/** `~` is expanded here: a REPL argument never saw a shell. */
+function expandHome(p) {
+    return p === '~' ? os.homedir() : p.startsWith('~/') ? os.homedir() + p.slice(1) : p;
+}
+/**
+ * Tool lists arrive as `--allowedTools "Bash(git *)" Edit` (variadic), as one
+ * comma-separated string, or both. Commas INSIDE parentheses belong to the rule
+ * (`Bash(git log --format=a,b)`), so splitting is paren-aware.
+ */
+function parseToolList(values) {
+    if (values === undefined)
+        return [];
+    const list = Array.isArray(values) ? values : [values];
+    const out = [];
+    for (const v of list) {
+        let depth = 0;
+        let cur = '';
+        const flush = () => {
+            const t = cur.trim();
+            if (t)
+                out.push(t);
+            cur = '';
+        };
+        for (const ch of String(v)) {
+            if (ch === '(')
+                depth++;
+            else if (ch === ')')
+                depth = Math.max(0, depth - 1);
+            if ((ch === ',' || /\s/.test(ch)) && depth === 0) {
+                flush();
+                continue;
+            }
+            cur += ch;
+        }
+        flush();
+    }
+    return out;
+}
+/** Resolve and VALIDATE --add-dir pieces: each must be an existing directory. */
+function parseAddDirs(values, cwd) {
+    const out = [];
+    for (const v of values ?? []) {
+        for (const piece of parseToolList(v)) {
+            const abs = path.resolve(cwd, piece);
+            let ok = false;
+            try {
+                ok = fs.statSync(abs).isDirectory();
+            }
+            catch {
+                /* fallthrough */
+            }
+            if (!ok)
+                return { ok: false, error: `--add-dir: "${piece}" is not an existing directory` };
+            if (!out.includes(abs))
+                out.push(abs);
+        }
+    }
+    return { ok: true, value: out };
+}
+function addDirNote(dirs) {
+    if (!dirs.length)
+        return '';
+    return `Additional working directories (you may read and edit files here with absolute paths, same as the main project):\n${dirs.map((d) => `- ${d}`).join('\n')}`;
+}
+function resolveAddDir(arg, cwd, current, projectRoot) {
+    const text = String(arg ?? '').trim();
+    if (!text)
+        return { kind: 'list' };
+    const unquoted = text.replace(/^(["'])([\s\S]*)\1$/, '$2');
+    const parsed = parseAddDirs([expandHome(unquoted)], cwd);
+    if (!parsed.ok)
+        return { kind: 'error', message: parsed.error.replace(/^--add-dir: /, '') };
+    const dir = parsed.value[0];
+    if (dir === projectRoot || current.includes(dir))
+        return { kind: 'noop', dir };
+    return { kind: 'added', dir, dirs: [...current, dir] };
+}
+//# sourceMappingURL=addDir.js.map

package/dist/util/batch.d.ts

@@ -0,0 +1,16 @@
+export declare const BATCH_MIN_UNITS = 2;
+export declare const BATCH_MAX_UNITS = 12;
+export type BatchArgs = {
+    kind: 'usage';
+} | {
+    kind: 'error';
+    message: string;
+} | {
+    kind: 'run';
+    instruction: string;
+};
+export declare function parseBatchArgs(arg: string): BatchArgs;
+/** Worktrees need a git repo. Walks up from `dir` looking for .git (file or dir). */
+export declare function isGitRepo(dir: string): boolean;
+export declare function buildBatchPrompt(instruction: string): string;
+//# sourceMappingURL=batch.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"batch.d.ts","sourceRoot":"","sources":["../../src/util/batch.ts"],"names":[],"mappings":"AAWA,eAAO,MAAM,eAAe,IAAI,CAAC;AACjC,eAAO,MAAM,eAAe,KAAK,CAAC;AAElC,MAAM,MAAM,SAAS,GAAG;IAAE,IAAI,EAAE,OAAO,CAAA;CAAE,GAAG;IAAE,IAAI,EAAE,OAAO,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,GAAG;IAAE,IAAI,EAAE,KAAK,CAAC;IAAC,WAAW,EAAE,MAAM,CAAA;CAAE,CAAC;AAEtH,wBAAgB,cAAc,CAAC,GAAG,EAAE,MAAM,GAAG,SAAS,CAMrD;AAED,qFAAqF;AACrF,wBAAgB,SAAS,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAQ9C;AAED,wBAAgB,gBAAgB,CAAC,WAAW,EAAE,MAAM,GAAG,MAAM,CAmB5D"}

package/dist/util/batch.js

@@ -0,0 +1,92 @@
+"use strict";
+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.BATCH_MAX_UNITS = exports.BATCH_MIN_UNITS = void 0;
+exports.parseBatchArgs = parseBatchArgs;
+exports.isGitRepo = isGitRepo;
+exports.buildBatchPrompt = buildBatchPrompt;
+// Lives in core (moved from the CLI's ui/batch.ts, 2026-10-04) so the VS Code
+// panel runs the same fan-out guards and prompt; the CLI module is a re-export shim.
+// /batch <instruction> — fan a large, mechanical change out across parallel sub-agents, each in
+// its OWN git worktree, so they cannot trample each other. Nothing is merged automatically: the
+// worktrees are handed back for the user to review.
+//
+// This is a prompt, not a new engine: the machinery (the `task` tool with isolation:"worktree",
+// background agents) already exists. Pure here: the argument check and the brief.
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+exports.BATCH_MIN_UNITS = 2;
+exports.BATCH_MAX_UNITS = 12;
+function parseBatchArgs(arg) {
+    const t = String(arg ?? '').trim();
+    if (!t)
+        return { kind: 'usage' };
+    if (t.length > 4000)
+        return { kind: 'error', message: `The instruction is ${t.length} characters; keep it under 4000.` };
+    return { kind: 'run', instruction: t };
+}
+/** Worktrees need a git repo. Walks up from `dir` looking for .git (file or dir). */
+function isGitRepo(dir) {
+    let cur = path.resolve(dir);
+    for (;;) {
+        if (fs.existsSync(path.join(cur, '.git')))
+            return true;
+        const up = path.dirname(cur);
+        if (up === cur)
+            return false;
+        cur = up;
+    }
+}
+function buildBatchPrompt(instruction) {
+    return [
+        `Carry out this change across the codebase as a PARALLEL BATCH:`,
+        ``,
+        `<instruction>`,
+        instruction,
+        `</instruction>`,
+        ``,
+        `Method:`,
+        `1. RESEARCH first (read-only): find every place the change applies. Do not edit anything yet.`,
+        `2. DECOMPOSE into ${exports.BATCH_MIN_UNITS}–${exports.BATCH_MAX_UNITS} independent units that touch DISJOINT files (group by directory or module). `,
+        `   If the work cannot be split into independent units, say so and do it directly instead of faking a split.`,
+        `3. Show the plan (unit → files) in a short list.`,
+        `4. Launch ONE sub-agent per unit with the \`task\` tool, \`isolation: "worktree"\`, all in the SAME message so they run in parallel. `,
+        `   Each unit's prompt must be fully self-contained: the instruction, its exact file list, the conventions to follow, and "run the tests/typecheck relevant to your files, then stop".`,
+        `5. When they finish, report per unit: what changed, whether its checks passed, and the worktree path/branch holding the result.`,
+        ``,
+        `Rules: never merge or push anything yourself; never let two units edit the same file; if a unit fails, report it plainly instead of retrying silently.`,
+    ].join('\n');
+}
+//# sourceMappingURL=batch.js.map

package/dist/util/cellWidth.d.ts

@@ -0,0 +1,12 @@
+/** Split into user-perceived characters so accents/emoji/CJK are never cut in half. */
+export declare function graphemes(s: string): string[];
+/**
+ * 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.
+ */
+export declare function visibleLen(s: string): number;
+/** Cut `s` to at most `max` terminal cells, ending in `…` when something was dropped. */
+export declare function truncateCells(s: string, max: number): string;
+//# sourceMappingURL=cellWidth.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"cellWidth.d.ts","sourceRoot":"","sources":["../../src/util/cellWidth.ts"],"names":[],"mappings":"AA2BA,uFAAuF;AACvF,wBAAgB,SAAS,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,CAE7C;AA4ED;;;;;GAKG;AACH,wBAAgB,UAAU,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,CAa5C;AAkBD,yFAAyF;AACzF,wBAAgB,aAAa,CAAC,CAAC,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,MAAM,CAmB5D"}