@nexrall/code-core 1.4.76 → 1.4.78

package/dist/ui/notify.js

@@ -0,0 +1,235 @@
+"use strict";
+// Lives in core (moved from the CLI's ui/notify.ts, 2026-10-04) so the VS Code
+// panel reads the SAME `notifications` setting and composes the same notes with
+// its editor-native delivery; the CLI module is a re-export shim.
+// §25 Task notifications — "tell me when it needs me", as a terminal can.
+//
+// A terminal CLI cannot raise a Toast: it prints. What it CAN do is hand the message to
+// the emulator through an escape sequence, and every capability list here is grounded in
+// what the emulators actually document rather than in a guess:
+//
+//   OSC 9 ; <text> BEL   iTerm2 (the originator), WezTerm, kitty, Ghostty, Windows
+//                        Terminal, and the VS Code extension that adds it to the built-in
+//                        terminal. OSC 777 ; notify ; ; <text> is the urxvt/Ghostty sibling;
+//                        OSC 9 is the one every one of those five also accepts.
+//   BEL                  the fallback that has worked since VT100: no text, just attention.
+//
+// Two honesty rules the code below enforces rather than documents:
+//   1. NOTHING is written when stdout is not a TTY. A CI log or a `| jq` consumer must not
+//      receive control bytes because a background job happened to finish.
+//   2. A sequence is only emitted for a terminal that is KNOWN to read it. `auto` on
+//      Apple_Terminal or the VS Code terminal degrades to the bell instead of printing
+//      "9;done" into the middle of the screen — the failure mode that makes people turn
+//      notifications off forever.
+//
+// Configurable via the `notifications` setting and `/notify` (§25 "Notification should be
+// configurable"). Pure string/decision logic lives here so it is all unit-testable; the one
+// side effect (a stdout write) is injected.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Notifier = exports.SLOW_TURN_MS = exports.MAX_NOTE = exports.NOTIFY_USAGE = exports.NOTIFY_SETTING = exports.NOTIFY_MODES = void 0;
+exports.parseNotifyMode = parseNotifyMode;
+exports.readNotifySetting = readNotifySetting;
+exports.detectOscSupport = detectOscSupport;
+exports.sanitizeNote = sanitizeNote;
+exports.oscNotification = oscNotification;
+exports.passthrough = passthrough;
+exports.notificationBytes = notificationBytes;
+exports.bgShellNote = bgShellNote;
+exports.bgAgentNote = bgAgentNote;
+exports.needsYouNote = needsYouNote;
+exports.turnDoneNote = turnDoneNote;
+const duration_1 = require("../util/duration");
+exports.NOTIFY_MODES = ['auto', 'bell', 'osc', 'off'];
+exports.NOTIFY_SETTING = 'notifications';
+exports.NOTIFY_USAGE = '/notify [auto|bell|osc|off] [--project]';
+/** Longest notification body kept. Emulators truncate anyway; ours should be predictable. */
+exports.MAX_NOTE = 120;
+/**
+ * A turn only *notifies* when it ran long enough that the user plausibly walked away.
+ * Below this, the completion block is already on screen in front of them.
+ */
+exports.SLOW_TURN_MS = 30000;
+// ─── Parsing / settings ────────────────────────────────────────────────────────
+/**
+ * A mode string from the settings file or `/notify`. `null` for anything that is not a
+ * mode — the caller decides whether that is "unset, keep the default" (settings) or
+ * "invalid, tell the user" (`/notify`), which are different answers to the same input.
+ */
+function parseNotifyMode(raw) {
+    if (typeof raw !== 'string')
+        return null;
+    const v = raw.trim().toLowerCase();
+    return exports.NOTIFY_MODES.includes(v) ? v : null;
+}
+/**
+ * The `notifications` setting, defaulting to `auto`: on, using the best technique this
+ * terminal supports. A hand-written `false`/`"off"` means off, matching `/livediff`'s
+ * convention (a settings value a person typed must not be silently overruled).
+ */
+function readNotifySetting(raw) {
+    const v = (raw ?? {})[exports.NOTIFY_SETTING];
+    if (v === undefined)
+        return 'auto';
+    if (v === false)
+        return 'off';
+    return parseNotifyMode(v) ?? 'auto';
+}
+// ─── Capability ────────────────────────────────────────────────────────────────
+/**
+ * Does this terminal show OSC 9 notifications? Only the ones that document it get a yes;
+ * an unknown TERM_PROGRAM (VS Code's `vscode`, Apple's `Apple_Terminal`, a bare xterm)
+ * gets a `false` and therefore the bell.
+ */
+function detectOscSupport(env) {
+    const prog = (env.TERM_PROGRAM ?? '').toLowerCase();
+    if (prog === 'iterm.app' || prog === 'wezterm' || prog === 'ghostty' || prog === 'hyper')
+        return true;
+    if (prog === 'vscode' || prog === 'apple_terminal')
+        return false;
+    if (env.KITTY_WINDOW_ID !== undefined && env.KITTY_WINDOW_ID !== '')
+        return true;
+    if ((env.TERM ?? '').includes('kitty'))
+        return true;
+    if (env.WT_SESSION !== undefined && env.WT_SESSION !== '')
+        return true; // Windows Terminal
+    return false;
+}
+// ─── Building the bytes ────────────────────────────────────────────────────────
+/**
+ * A notification body safe to embed in an OSC sequence: no escape sequences, no control
+ * characters (a stray BEL would terminate the sequence early and print the rest as text),
+ * one line, bounded. Returns '' when nothing printable is left, which callers treat as
+ * "send nothing".
+ *
+ * The ANSI strip is not cosmetic. The permission prompts hand us strings that are already
+ * coloured (`paint.boldRed('Type "yes" …')`), and replacing the ESC byte alone leaves the
+ * parameters behind as visible text — measured on a real prompt:
+ * `waiting for you — [1m [31mType "yes" to run this destructive command:`.
+ */
+function sanitizeNote(text, max = exports.MAX_NOTE) {
+    const flat = text
+        // Whole ANSI sequences first: CSI (colours/cursor), OSC (titles/hyperlinks), and the
+        // two-character escapes (ESC 7/8 are the save/restore cursor pair readline emits).
+        // The ESC must go with its parameters, not on its own.
+        // eslint-disable-next-line no-control-regex
+        .replace(/\u001b\[[0-9;?]*[ -/]*[@-~]|\u001b\][^\u0007\u001b]*(?:\u0007|\u001b\\)|\u001b[@-Z\\-_78]/g, '')
+        // eslint-disable-next-line no-control-regex
+        .replace(/[\u0000-\u001f\u007f-\u009f]/g, ' ')
+        .replace(/\s+/g, ' ')
+        .trim();
+    if (!flat)
+        return '';
+    if (flat.length <= max)
+        return flat;
+    return flat.slice(0, max - 1).trimEnd() + '…';
+}
+/** The raw OSC 9 sequence. BEL-terminated: the form iTerm2 documents and every other
+ *  implementation of it inherits. */
+function oscNotification(text) {
+    return `\x1b]9;${text}\x07`;
+}
+/**
+ * tmux and screen do not forward an OSC sequence they do not recognise, so it has to be
+ * handed to the OUTER terminal wrapped in a DCS passthrough — with every ESC inside the
+ * payload doubled, which is what tmux's own parser un-escapes. Without a multiplexer the
+ * sequence passes through unchanged.
+ *
+ * If the user has not enabled `allow-passthrough` (tmux ≥ 3.3) the wrapper is discarded
+ * silently rather than printed — the reason to wrap even when unsure.
+ */
+function passthrough(seq, env) {
+    if (env.TMUX)
+        return '\x1bPtmux;' + seq.split('\x1b').join('\x1b\x1b') + '\x1b\\';
+    if (env.STY || (env.TERM ?? '').startsWith('screen'))
+        return '\x1bP' + seq + '\x1b\\';
+    return seq;
+}
+/**
+ * The bytes for one notification, or null for "say nothing".
+ *
+ * `bell` and `osc` are explicit requests and are honoured; `auto` picks OSC only where it
+ * is known to be read, and the bell otherwise.
+ */
+function notificationBytes(mode, env, text) {
+    if (mode === 'off')
+        return null;
+    const note = sanitizeNote(text);
+    if (mode === 'bell')
+        return '\x07';
+    if (mode === 'osc')
+        return note ? passthrough(oscNotification(note), env) : null;
+    // auto
+    if (detectOscSupport(env))
+        return note ? passthrough(oscNotification(note), env) : null;
+    return '\x07';
+}
+class Notifier {
+    constructor(opts = {}) {
+        this.mode = opts.mode ?? 'auto';
+        this.env = opts.env ?? {};
+        this.isTTY = opts.isTTY ?? false;
+        this.write =
+            opts.write ??
+                ((b) => {
+                    process.stdout.write(b);
+                });
+    }
+    setMode(mode) {
+        this.mode = mode;
+    }
+    getMode() {
+        return this.mode;
+    }
+    /** What a notification would do right now — the honest answer `/notify` prints. */
+    effective() {
+        if (this.mode === 'off' || !this.isTTY)
+            return { technique: 'off', unconfirmed: false };
+        if (this.mode === 'bell')
+            return { technique: 'bell', unconfirmed: false };
+        const recognised = detectOscSupport(this.env);
+        if (this.mode === 'osc')
+            return { technique: 'osc', unconfirmed: !recognised };
+        return { technique: recognised ? 'osc' : 'bell', unconfirmed: false };
+    }
+    /** Send one. False when nothing was written — not a TTY, mode off, or an empty note. */
+    notify(text) {
+        if (!this.isTTY || this.mode === 'off')
+            return false;
+        const bytes = notificationBytes(this.mode, this.env, text);
+        if (!bytes)
+            return false;
+        this.write(bytes);
+        return true;
+    }
+}
+exports.Notifier = Notifier;
+// ─── Event texts ───────────────────────────────────────────────────────────────
+/** One line naming what finished, for a `!command` that was moved to the background. */
+function bgShellNote(cmd, id, code, signal) {
+    const how = code === 0 ? 'exit 0' : `exit ${code ?? signal ?? '?'}`;
+    const short = cmd.length > 60 ? cmd.slice(0, 59) + '…' : cmd;
+    return sanitizeNote(`background #${id} finished (${how}): ${short}`);
+}
+/** A background sub-agent came back. */
+function bgAgentNote(descriptions) {
+    const one = descriptions.length === 1;
+    return sanitizeNote(`background agent${one ? '' : 's'} ${descriptions.map((d) => `"${d}"`).join(', ')} finished`);
+}
+/** The agent is blocked on a human: a permission box, a destructive confirm, a question. */
+function needsYouNote(what) {
+    return sanitizeNote(`waiting for you — ${what}`);
+}
+/**
+ * A turn finished. Null unless it ran long enough to have lost the user AND they did not
+ * touch the keyboard since it started — a notification for work they were watching is
+ * just noise, and "long enough" is measured, not guessed.
+ */
+function turnDoneNote(durationMs, userActive, sessionId) {
+    if (userActive || durationMs < exports.SLOW_TURN_MS)
+        return null;
+    // §94: this note is read on a phone or another window — exactly when "which session,
+    // and how do I get back to it" is the missing half. Carry the resume handle with it.
+    const where = sessionId ? ` · nex --resume ${sessionId.slice(0, 8)}` : '';
+    return sanitizeNote(`turn finished after ${(0, duration_1.formatElapsed)(durationMs)}${where}`);
+}
+//# sourceMappingURL=notify.js.map

package/dist/ui/promptSuggest.d.ts

@@ -0,0 +1,56 @@
+import { SUGGESTIONS_SETTING } from './configCmd';
+export { SUGGESTIONS_SETTING };
+/** The suggestion must fit an input box line; longer output is cut at a word. */
+export declare const SUGGESTION_MAX_CHARS = 200;
+/** Claude Code's number: "appear less often after 20 in a row go unused". */
+export declare const SUGGESTION_DAMP_AFTER = 20;
+/** While damped, one offer in this many opportunities (first one still shows). */
+export declare const SUGGESTION_DAMPED_EVERY = 4;
+/**
+ * On/off resolution: env (`NEXRALL_PROMPT_SUGGESTIONS`) beats the setting, the
+ * setting (`promptSuggestions`) beats the default, and the default is ON —
+ * matching CC, where the toggle only exists for sessions whose feature flags
+ * resolved. `0`/`false`/`off` turn it off in both places.
+ */
+export declare function resolvePromptSuggestions(f: {
+    env?: Record<string, string | undefined>;
+    setting?: unknown;
+}): boolean;
+/**
+ * The background request. Deliberately tiny: one short instruction plus the
+ * tail of the conversation, clipped — the suggestion is a guess at the next
+ * LINE, not a summary, and the call must stay cheap.
+ */
+export declare function buildSuggestionPrompt(lastUser: string, lastAssistant: string): string;
+/**
+ * Turn a raw model reply into something safe to place in the input box, or
+ * null when there is nothing usable. Rules, pinned by the tests:
+ *   · first non-empty line only (a multi-line reply is not a prompt line);
+ *   · a leading `> `/list marker and wrapping quotes/backticks are stripped;
+ *   · meta/evaluative text ("Sure!", "Here's a suggestion:") is rejected —
+ *     CC drops the same class;
+ *   · must carry at least one letter or digit (punctuation-only is noise);
+ *   · over-long output is cut at the last space with NO ellipsis — whatever
+ *     is placed in the box gets sent verbatim, so decoration would be typed.
+ */
+export declare function sanitizeSuggestion(raw: string | null | undefined): string | null;
+/**
+ * The ignore damping counter (CC: "after 20 in a row go unused" suggestions
+ * appear less often; using one brings them back). A suggestion counts as
+ * ignored when it was showing and the user typed something else; used when
+ * accepted. While damped only every `SUGGESTION_DAMPED_EVERY`th opportunity is
+ * offered — except the first, so the notice has something to accompany.
+ */
+export declare class SuggestionDamping {
+    private ignored;
+    private whileDamped;
+    private noticePending;
+    /** Consecutive ignored suggestions (0 = full frequency). */
+    get ignoredCount(): number;
+    noteIgnored(): void;
+    noteUsed(): void;
+    shouldOffer(): boolean;
+    /** True exactly once after damping begins (until a use re-arms it). */
+    takeNotice(): boolean;
+}
+//# sourceMappingURL=promptSuggest.d.ts.map

package/dist/ui/promptSuggest.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"promptSuggest.d.ts","sourceRoot":"","sources":["../../src/ui/promptSuggest.ts"],"names":[],"mappings":"AAgBA,OAAO,EAAE,mBAAmB,EAAE,MAAM,aAAa,CAAC;AAClD,OAAO,EAAE,mBAAmB,EAAE,CAAC;AAE/B,iFAAiF;AACjF,eAAO,MAAM,oBAAoB,MAAM,CAAC;AACxC,6EAA6E;AAC7E,eAAO,MAAM,qBAAqB,KAAK,CAAC;AACxC,kFAAkF;AAClF,eAAO,MAAM,uBAAuB,IAAI,CAAC;AAMzC;;;;;GAKG;AACH,wBAAgB,wBAAwB,CAAC,CAAC,EAAE;IAAE,GAAG,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC,CAAC;IAAC,OAAO,CAAC,EAAE,OAAO,CAAA;CAAE,GAAG,OAAO,CAQpH;AAOD;;;;GAIG;AACH,wBAAgB,qBAAqB,CAAC,QAAQ,EAAE,MAAM,EAAE,aAAa,EAAE,MAAM,GAAG,MAAM,CAQrF;AAiBD;;;;;;;;;;GAUG;AACH,wBAAgB,kBAAkB,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,GAAG,MAAM,GAAG,IAAI,CAoBhF;AAED;;;;;;GAMG;AACH,qBAAa,iBAAiB;IAC5B,OAAO,CAAC,OAAO,CAAK;IACpB,OAAO,CAAC,WAAW,CAAK;IACxB,OAAO,CAAC,aAAa,CAAS;IAE9B,4DAA4D;IAC5D,IAAI,YAAY,IAAI,MAAM,CAEzB;IAED,WAAW,IAAI,IAAI;IAOnB,QAAQ,IAAI,IAAI;IAKhB,WAAW,IAAI,OAAO;IAOtB,uEAAuE;IACvE,UAAU,IAAI,OAAO;CAKtB"}

package/dist/ui/promptSuggest.js

@@ -0,0 +1,160 @@
+"use strict";
+// Lives in core (moved from the CLI's ui/promptSuggest.ts, 2026-10-05) so the VS
+// Code panel asks the same background suggestion question; the CLI module is a
+// re-export shim.
+// S19d — prompt suggestions (Claude Code parity): after a turn ends, a short
+// background request proposes the user's next prompt; the input box shows it as
+// ghost text; Tab (or →) places it, typing dismisses it.
+//
+// Pure half — parsing the raw model reply, building the request, the on/off
+// resolution and the ignore-damping counter. The caller owns the I/O (the
+// one-shot model call, the Ink ghost text) — see chat.ts and inkTerminal.tsx.
+//
+// Cost honesty: each shown suggestion is one small background request billed
+// like any turn. The context handed to the model is clipped hard (last prompt +
+// last reply), the reply must survive sanitizeSuggestion, and the feature can
+// be turned off three ways (env > setting > /suggestions).
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SuggestionDamping = exports.SUGGESTION_DAMPED_EVERY = exports.SUGGESTION_DAMP_AFTER = exports.SUGGESTION_MAX_CHARS = exports.SUGGESTIONS_SETTING = void 0;
+exports.resolvePromptSuggestions = resolvePromptSuggestions;
+exports.buildSuggestionPrompt = buildSuggestionPrompt;
+exports.sanitizeSuggestion = sanitizeSuggestion;
+const configCmd_1 = require("./configCmd");
+Object.defineProperty(exports, "SUGGESTIONS_SETTING", { enumerable: true, get: function () { return configCmd_1.SUGGESTIONS_SETTING; } });
+/** The suggestion must fit an input box line; longer output is cut at a word. */
+exports.SUGGESTION_MAX_CHARS = 200;
+/** Claude Code's number: "appear less often after 20 in a row go unused". */
+exports.SUGGESTION_DAMP_AFTER = 20;
+/** While damped, one offer in this many opportunities (first one still shows). */
+exports.SUGGESTION_DAMPED_EVERY = 4;
+/** How much of the conversation rides in the background request. */
+const CLIP_USER = 400;
+const CLIP_ASSISTANT = 600;
+/**
+ * On/off resolution: env (`NEXRALL_PROMPT_SUGGESTIONS`) beats the setting, the
+ * setting (`promptSuggestions`) beats the default, and the default is ON —
+ * matching CC, where the toggle only exists for sessions whose feature flags
+ * resolved. `0`/`false`/`off` turn it off in both places.
+ */
+function resolvePromptSuggestions(f) {
+    const raw = (f.env ?? {}).NEXRALL_PROMPT_SUGGESTIONS;
+    const v = typeof raw === 'string' ? raw.trim().toLowerCase() : '';
+    if (v === '0' || v === 'false' || v === 'off')
+        return false;
+    if (v === '1' || v === 'true')
+        return true;
+    const s = f.setting;
+    if (s === false || s === 'false' || s === '0' || s === 'off')
+        return false;
+    return true;
+}
+function clip(text, max) {
+    const t = text.replace(/\s+/g, ' ').trim();
+    return t.length > max ? t.slice(0, max - 1) + '…' : t;
+}
+/**
+ * The background request. Deliberately tiny: one short instruction plus the
+ * tail of the conversation, clipped — the suggestion is a guess at the next
+ * LINE, not a summary, and the call must stay cheap.
+ */
+function buildSuggestionPrompt(lastUser, lastAssistant) {
+    return ("You suggest the user's NEXT prompt in an AI coding terminal session.\n" +
+        'Reply with EXACTLY ONE short line (max 12 words): the literal text the user might type next.\n' +
+        'No quotes, no explanation, no preamble. Write it in the same language as the user.\n\n' +
+        `The user last said:\n${clip(lastUser, CLIP_USER)}\n\n` +
+        `The assistant replied:\n${clip(lastAssistant, CLIP_ASSISTANT)}`);
+}
+/** Prefixes that mean the model explained the suggestion instead of giving it. */
+const META_PREFIXES = [
+    /^(sure|okay|ok)[,.!:\s]/i,
+    /^here'?s\b/i,
+    /^i (suggest|recommend|would|could)\b/i,
+    /^you (could|can|might|should)\b/i,
+    /^the user\b/i,
+    /^(prompt|suggestion)\s*:/i,
+    /^let me\b/i,
+];
+function hasLetterOrDigit(s) {
+    return /[\p{L}\p{N}]/u.test(s);
+}
+/**
+ * Turn a raw model reply into something safe to place in the input box, or
+ * null when there is nothing usable. Rules, pinned by the tests:
+ *   · first non-empty line only (a multi-line reply is not a prompt line);
+ *   · a leading `> `/list marker and wrapping quotes/backticks are stripped;
+ *   · meta/evaluative text ("Sure!", "Here's a suggestion:") is rejected —
+ *     CC drops the same class;
+ *   · must carry at least one letter or digit (punctuation-only is noise);
+ *   · over-long output is cut at the last space with NO ellipsis — whatever
+ *     is placed in the box gets sent verbatim, so decoration would be typed.
+ */
+function sanitizeSuggestion(raw) {
+    if (typeof raw !== 'string')
+        return null;
+    const firstLine = raw.split('\n').find((l) => l.trim().length > 0);
+    if (!firstLine)
+        return null;
+    let s = firstLine.replace(/\s+/g, ' ').trim();
+    s = s.replace(/^>\s*/, '').trim();
+    // Strip one matching pair of wrappers the model likes to add.
+    for (const q of ['"', "'", '`']) {
+        if (s.length >= 2 && s.startsWith(q) && s.endsWith(q) && s.indexOf(q, 1) === s.length - 1) {
+            s = s.slice(1, -1).trim();
+        }
+    }
+    if (s.length < 2 || !hasLetterOrDigit(s))
+        return null;
+    if (META_PREFIXES.some((re) => re.test(s)))
+        return null;
+    if (s.length > exports.SUGGESTION_MAX_CHARS) {
+        const cut = s.slice(0, exports.SUGGESTION_MAX_CHARS);
+        const sp = cut.lastIndexOf(' ');
+        s = (sp > 0 ? cut.slice(0, sp) : cut).replace(/[\s,;:]+$/, '');
+    }
+    return s.length >= 2 && hasLetterOrDigit(s) ? s : null;
+}
+/**
+ * The ignore damping counter (CC: "after 20 in a row go unused" suggestions
+ * appear less often; using one brings them back). A suggestion counts as
+ * ignored when it was showing and the user typed something else; used when
+ * accepted. While damped only every `SUGGESTION_DAMPED_EVERY`th opportunity is
+ * offered — except the first, so the notice has something to accompany.
+ */
+class SuggestionDamping {
+    constructor() {
+        this.ignored = 0;
+        this.whileDamped = 0;
+        this.noticePending = false;
+    }
+    /** Consecutive ignored suggestions (0 = full frequency). */
+    get ignoredCount() {
+        return this.ignored;
+    }
+    noteIgnored() {
+        if (this.ignored < exports.SUGGESTION_DAMP_AFTER) {
+            this.ignored += 1;
+            if (this.ignored === exports.SUGGESTION_DAMP_AFTER)
+                this.noticePending = true;
+        }
+    }
+    noteUsed() {
+        this.ignored = 0;
+        this.whileDamped = 0;
+    }
+    shouldOffer() {
+        if (this.ignored < exports.SUGGESTION_DAMP_AFTER)
+            return true;
+        const k = this.whileDamped % exports.SUGGESTION_DAMPED_EVERY;
+        this.whileDamped += 1;
+        return k === 0;
+    }
+    /** True exactly once after damping begins (until a use re-arms it). */
+    takeNotice() {
+        if (!this.noticePending)
+            return false;
+        this.noticePending = false;
+        return true;
+    }
+}
+exports.SuggestionDamping = SuggestionDamping;
+//# sourceMappingURL=promptSuggest.js.map

package/dist/ui/taskGraph.d.ts

@@ -0,0 +1,44 @@
+/** Shape of the fields this module reads from core's SharedTask (kept structural). */
+export interface GraphTask {
+    id: string;
+    content: string;
+    status: 'pending' | 'in_progress' | 'completed' | 'blocked';
+    blockedBy?: string[];
+    claimedBy?: string;
+    claimedByPid?: number;
+    claimedAt?: number;
+    updatedAt?: number;
+}
+export interface GraphInput {
+    tasks: GraphTask[];
+    now: number;
+    cols?: number;
+    /** Max rows to print; the tail is summarised. A big board must not bury the prompt. */
+    maxRows?: number;
+}
+export declare const STATUS_MARK: Record<GraphTask['status'], string>;
+/** Tasks that no one has to wait for: no blockers, or blockers we cannot see. */
+export declare function roots(tasks: GraphTask[]): GraphTask[];
+export declare function blockersOf(tasks: GraphTask[], t: GraphTask): string[];
+/** Blockers that are named but do not exist — a broken edge the user should see. */
+export declare function missingBlockers(tasks: GraphTask[], t: GraphTask): string[];
+/**
+ * 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.
+ */
+export declare function readyTasks(tasks: GraphTask[]): GraphTask[];
+/** Task ids in a dependency cycle (mutual or longer). Empty when the graph is a DAG. */
+export declare function findCycle(tasks: GraphTask[]): string[];
+/**
+ * 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.
+ */
+export declare function formatTaskGraph(input: GraphInput): string[];
+//# sourceMappingURL=taskGraph.d.ts.map

package/dist/ui/taskGraph.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"taskGraph.d.ts","sourceRoot":"","sources":["../../src/ui/taskGraph.ts"],"names":[],"mappings":"AA+BA,sFAAsF;AACtF,MAAM,WAAW,SAAS;IACxB,EAAE,EAAE,MAAM,CAAC;IACX,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,SAAS,GAAG,aAAa,GAAG,WAAW,GAAG,SAAS,CAAC;IAC5D,SAAS,CAAC,EAAE,MAAM,EAAE,CAAC;IACrB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAED,MAAM,WAAW,UAAU;IACzB,KAAK,EAAE,SAAS,EAAE,CAAC;IACnB,GAAG,EAAE,MAAM,CAAC;IACZ,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,uFAAuF;IACvF,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAKD,eAAO,MAAM,WAAW,EAAE,MAAM,CAAC,SAAS,CAAC,QAAQ,CAAC,EAAE,MAAM,CAK3D,CAAC;AAEF,iFAAiF;AACjF,wBAAgB,KAAK,CAAC,KAAK,EAAE,SAAS,EAAE,GAAG,SAAS,EAAE,CAGrD;AAED,wBAAgB,UAAU,CAAC,KAAK,EAAE,SAAS,EAAE,EAAE,CAAC,EAAE,SAAS,GAAG,MAAM,EAAE,CAGrE;AAED,oFAAoF;AACpF,wBAAgB,eAAe,CAAC,KAAK,EAAE,SAAS,EAAE,EAAE,CAAC,EAAE,SAAS,GAAG,MAAM,EAAE,CAG1E;AAED;;;;;;;GAOG;AACH,wBAAgB,UAAU,CAAC,KAAK,EAAE,SAAS,EAAE,GAAG,SAAS,EAAE,CAO1D;AAED,wFAAwF;AACxF,wBAAgB,SAAS,CAAC,KAAK,EAAE,SAAS,EAAE,GAAG,MAAM,EAAE,CAwBtD;AAuED;;;;;;GAMG;AACH,wBAAgB,eAAe,CAAC,KAAK,EAAE,UAAU,GAAG,MAAM,EAAE,CA4H3D"}