@pellux/goodvibes-sdk 0.38.0 → 1.1.0

package/dist/platform/orchestration/worktree-isolation.js

@@ -0,0 +1,248 @@
+/** SDK-owned platform module. This implementation is maintained in goodvibes-sdk. */
+/**
+ * WorktreeIsolationManager — the engine-side driver for `worktree` isolation
+ * mode (see WorkstreamIsolation, types.ts, and IsolatedWorktree, worktree.ts).
+ *
+ * Owns three things the engine calls into at well-defined lifecycle points:
+ *
+ *   ensureWorktree()      — at an item's FIRST claim (engine.ts runItemPhase),
+ *                           create its dedicated worktree if it doesn't have
+ *                           one yet. Idempotent across an item's phases (a
+ *                           worktree persists for the item's whole run).
+ *   enqueueIntegration()  — when a passed item's pipeline terminates, queue its
+ *                           branch onto the SINGLE sequential integration lane
+ *                           (completion order, not claim order). A conflict
+ *                           keeps the worktree + branch and lets the lane
+ *                           continue with the next item — never auto-resolved,
+ *                           never silently dropped.
+ *   cleanupTerminated()   — when an item fails or is killed, remove its
+ *                           worktree ONLY if the tree is clean; a dirty tree
+ *                           is KEPT (data safety) and counted against the
+ *                           kept-worktree cap (oldest-first eviction).
+ *   reconcileOrphans()    — at import (a resumed/crashed workstream), find any
+ *                           on-disk `ws/<wsShort>/*` worktree not already
+ *                           recorded on one of the imported items and either
+ *                           ADOPT it (the item still has unresolved work) or
+ *                           REPORT it (leave in place for the operator — NEVER
+ *                           deleted on sight).
+ *
+ * Location + naming: worktrees live under
+ * `<projectRoot>/.goodvibes/.worktrees/ws/<wsShort>/<itemShort>` on branch
+ * `ws/<wsShort>/<itemShort>` — deterministic from (workstreamId, itemId), so
+ * `ensureWorktree` and `reconcileOrphans` agree on where a given item's
+ * worktree lives without any extra bookkeeping.
+ *
+ * SYNCHRONOUS orphan scan (deliberate — mirrors dirty-guard.ts's
+ * snapshotDirtyTree precedent): `reconcileOrphans` must resolve BEFORE the
+ * engine's first tick() can claim any item, or a claim could race the async
+ * git listing and create a second worktree at the same deterministic path an
+ * orphan already occupies (`git worktree add` on an existing path throws).
+ * importWorkstream (engine.ts) is itself a synchronous function, so
+ * reconciliation is done with Bun.spawnSync, paid once per import, exactly
+ * like the launch-dirty snapshot.
+ */
+import { createHash } from 'node:crypto';
+import { join } from 'node:path';
+import { GitService } from '../git/service.js';
+import { IsolatedWorktree } from '../agents/worktree.js';
+import { logger } from '../utils/logger.js';
+import { summarizeError } from '../utils/error-display.js';
+/** Derives a short, filesystem/branch-safe fragment from an id: the suffix after the last '-' when it's plain alphanumerics, else a stable short hash of the whole id (caller-supplied WorkItemSpec.id can be arbitrary text). */
+function shortId(id) {
+    const dash = id.lastIndexOf('-');
+    const candidate = dash >= 0 ? id.slice(dash + 1) : id;
+    if (candidate.length > 0 && /^[A-Za-z0-9]+$/.test(candidate))
+        return candidate;
+    return createHash('sha1').update(id).digest('hex').slice(0, 8);
+}
+export function itemWorktreeBranch(workstreamId, itemId) {
+    return `ws/${shortId(workstreamId)}/${shortId(itemId)}`;
+}
+function itemWorktreeDir(projectRoot, workstreamId, itemId) {
+    return join(projectRoot, '.goodvibes', '.worktrees', 'ws', shortId(workstreamId), shortId(itemId));
+}
+export function createWorktreeIsolationManager(deps) {
+    const now = deps.now ?? (() => Date.now());
+    const keptCap = deps.keptWorktreeCap ?? 20;
+    const rootGit = new GitService(deps.projectRoot);
+    const instances = new Map(); // itemId -> instance
+    const kept = [];
+    let baseBranchCache = null;
+    let integrationLane = Promise.resolve();
+    /** Resolved once (Bun.spawnSync, mirroring dirty-guard.ts) since every IsolatedWorktree for this manager's lifetime merges into the SAME root-tree branch. */
+    function resolveBaseBranch() {
+        if (baseBranchCache)
+            return baseBranchCache;
+        try {
+            const result = Bun.spawnSync(['git', '-C', deps.projectRoot, 'rev-parse', '--abbrev-ref', 'HEAD']);
+            const branch = result.exitCode === 0 ? new TextDecoder().decode(result.stdout).trim() : '';
+            baseBranchCache = branch.length > 0 && branch !== 'HEAD' ? branch : 'main';
+        }
+        catch (error) {
+            logger.warn('worktree-isolation: could not resolve base branch, defaulting to "main"', { error: summarizeError(error) });
+            baseBranchCache = 'main';
+        }
+        return baseBranchCache;
+    }
+    function getOrCreateInstance(workstream, item, path, branch) {
+        let instance = instances.get(item.id);
+        if (!instance) {
+            instance = new IsolatedWorktree(deps.projectRoot, path, branch, resolveBaseBranch());
+            instances.set(item.id, instance);
+        }
+        return instance;
+    }
+    async function ensureWorktree(workstream, item) {
+        const path = item.worktreePath ?? itemWorktreeDir(deps.projectRoot, workstream.id, item.id);
+        const branch = item.worktreeBranch ?? itemWorktreeBranch(workstream.id, item.id);
+        const instance = getOrCreateInstance(workstream, item, path, branch);
+        if (!item.worktreePath) {
+            await instance.create();
+            item.worktreePath = instance.path;
+            item.worktreeBranch = instance.branch;
+            deps.emit({ type: 'item-worktree-created', workstreamId: workstream.id, itemId: item.id, path: instance.path, branch: instance.branch });
+        }
+        return { path: instance.path, commit: (message, paths) => instance.commit(message, paths) };
+    }
+    function keepWorktree(workstream, item, instance, reason) {
+        item.worktreeKept = true;
+        deps.emit({ type: 'item-worktree-kept', workstreamId: workstream.id, itemId: item.id, path: instance.path, reason });
+        kept.push({ workstream, item, instance, keptAt: now() });
+        enforceKeptCap();
+    }
+    function enforceKeptCap() {
+        while (kept.length > keptCap) {
+            const oldest = kept.shift();
+            if (!oldest)
+                break;
+            void removeWorktree(oldest.workstream, oldest.item, oldest.instance, true).catch((error) => {
+                logger.error('worktree-isolation: eviction of oldest kept worktree did not complete', {
+                    itemId: oldest.item.id, error: summarizeError(error),
+                });
+            });
+        }
+    }
+    async function removeWorktree(workstream, item, instance, evicted) {
+        const path = instance.path;
+        try {
+            await instance.remove();
+        }
+        catch (error) {
+            logger.warn('worktree-isolation: worktree removal did not complete', { itemId: item.id, path, error: summarizeError(error) });
+        }
+        instances.delete(item.id);
+        item.worktreePath = undefined;
+        item.worktreeKept = false;
+        deps.emit(evicted
+            ? { type: 'item-worktree-evicted', workstreamId: workstream.id, itemId: item.id, path }
+            : { type: 'item-worktree-removed', workstreamId: workstream.id, itemId: item.id, path });
+    }
+    async function integrateOne(workstream, item) {
+        const path = item.worktreePath ?? itemWorktreeDir(deps.projectRoot, workstream.id, item.id);
+        const branch = item.worktreeBranch ?? itemWorktreeBranch(workstream.id, item.id);
+        const instance = getOrCreateInstance(workstream, item, path, branch);
+        item.mergeState = 'pending';
+        try {
+            const outcome = await instance.integrate();
+            if (outcome.status === 'merged') {
+                item.mergeState = 'merged';
+                item.mergeHash = outcome.hash;
+                deps.emit({ type: 'item-merged', workstreamId: workstream.id, itemId: item.id, branch: instance.branch, hash: outcome.hash });
+                await removeWorktree(workstream, item, instance, false);
+                return;
+            }
+            if (outcome.status === 'conflict') {
+                item.mergeState = 'conflict';
+                item.blockedReason = `merge-conflict: ${outcome.files.join(', ') || 'unknown files'}`;
+                deps.emit({
+                    type: 'item-merge-conflict', workstreamId: workstream.id, itemId: item.id,
+                    branch: instance.branch, path: instance.path, files: outcome.files,
+                });
+                keepWorktree(workstream, item, instance, `merge-conflict: ${outcome.files.join(', ') || 'unknown files'}`);
+                return;
+            }
+            // 'empty' — the item branch carries no commits beyond base: an honest
+            // no-op, not a failure. Nothing to merge, so trivially "merged" (no
+            // hash — there is no merge commit to report) and the worktree is
+            // reclaimed like any other successfully-integrated item.
+            item.mergeState = 'merged';
+            await removeWorktree(workstream, item, instance, false);
+        }
+        catch (error) {
+            logger.error('worktree-isolation: integration attempt threw', { itemId: item.id, error: summarizeError(error) });
+            item.mergeState = 'conflict';
+            item.blockedReason = `merge-conflict: integration did not complete (${summarizeError(error)})`;
+            keepWorktree(workstream, item, instance, `integration attempt threw: ${summarizeError(error)}`);
+        }
+    }
+    function enqueueIntegration(workstream, item) {
+        const run = integrationLane.then(() => integrateOne(workstream, item));
+        // Chain off a NEVER-REJECTING tail so one item's (already internally
+        // caught) failure can't skip the lane forward for the next enqueue —
+        // integrateOne never actually throws past its own try/catch, but this is
+        // cheap insurance against a future change forgetting that invariant.
+        integrationLane = run.catch((error) => {
+            logger.error('worktree-isolation: integration lane step did not complete', { itemId: item.id, error: summarizeError(error) });
+        });
+        return run;
+    }
+    async function cleanupTerminated(workstream, item) {
+        const instance = instances.get(item.id);
+        if (!instance)
+            return; // never got a worktree (failed before claim, or shared mode)
+        try {
+            const clean = await instance.isClean();
+            if (clean) {
+                await removeWorktree(workstream, item, instance, false);
+            }
+            else {
+                keepWorktree(workstream, item, instance, 'dirty tree after item failed/killed');
+            }
+        }
+        catch (error) {
+            logger.error('worktree-isolation: cleanup-on-terminate check did not complete, keeping worktree for safety', {
+                itemId: item.id, error: summarizeError(error),
+            });
+            keepWorktree(workstream, item, instance, `cleanup check did not complete: ${summarizeError(error)}`);
+        }
+    }
+    function reconcileOrphans(workstream) {
+        let raw;
+        try {
+            const result = Bun.spawnSync(['git', '-C', deps.projectRoot, 'worktree', 'list', '--porcelain']);
+            if (result.exitCode !== 0)
+                return;
+            raw = new TextDecoder().decode(result.stdout);
+        }
+        catch (error) {
+            logger.warn('worktree-isolation: orphan scan (worktree list) did not complete', { error: summarizeError(error) });
+            return;
+        }
+        const prefix = `ws/${shortId(workstream.id)}/`;
+        const knownPaths = new Set(workstream.items.map((i) => i.worktreePath).filter((p) => typeof p === 'string' && p.length > 0));
+        for (const block of raw.trim().split('\n\n').filter(Boolean)) {
+            const lines = block.split('\n');
+            const path = lines.find((l) => l.startsWith('worktree '))?.slice('worktree '.length) ?? '';
+            const branchLine = lines.find((l) => l.startsWith('branch '));
+            const branch = branchLine ? branchLine.slice('branch '.length).replace(/^refs\/heads\//, '') : '';
+            if (!path || !branch.startsWith(prefix))
+                continue;
+            if (knownPaths.has(path))
+                continue; // already tracked by an item's recorded worktreePath — not an orphan
+            const itemShort = branch.slice(prefix.length);
+            const item = workstream.items.find((i) => shortId(i.id) === itemShort);
+            const unresolved = !!item && ((item.state !== 'passed' && item.state !== 'failed')
+                || item.mergeState === 'pending');
+            if (item && unresolved) {
+                item.worktreePath = path;
+                item.worktreeBranch = branch;
+                instances.set(item.id, new IsolatedWorktree(deps.projectRoot, path, branch, resolveBaseBranch()));
+                deps.emit({ type: 'orphan-worktree-reconciled', workstreamId: workstream.id, path, branch, disposition: 'adopted' });
+            }
+            else {
+                deps.emit({ type: 'orphan-worktree-reconciled', workstreamId: workstream.id, path, branch, disposition: 'reported' });
+            }
+        }
+    }
+    return { ensureWorktree, enqueueIntegration, cleanupTerminated, reconcileOrphans };
+}

package/dist/platform/presentation/glyphs.d.ts

@@ -0,0 +1,91 @@
+/**
+ * glyphs.ts — the canonical glyph registry for status/frame/navigation/meter
+ * rendering, hoisted from `goodvibes-tui` src/renderer/ui-primitives.ts (GLYPHS)
+ * and src/renderer/status-glyphs.ts (STATE_GLYPHS).
+ *
+ * This is one of the four genuinely-duplicated presentation tables named by the
+ * renderer/input parity audit (see CHANGELOG 1.0.0; both the TUI and the agent shipped a near-twin
+ * copy). The TUI is the reference: it is the more-complete, more-recently-fixed
+ * copy, and per the presentation-contract decision record its `status` group is
+ * the one both renderers converge on.
+ *
+ * Reconciliation (the one real content choice this hoist makes): the TUI and
+ * agent status groups disagreed —
+ *   - TUI:   idle = '◌' (U+25CC), info = '○' (U+25CB), warn = '⚠' present
+ *   - agent: idle = '○' (U+25CB), info = '•' (U+2022), no `warn` key
+ * GLYPHS.status below is the TUI's values verbatim. Consumers that previously
+ * carried the agent's values will see idle/info visibly change when they adopt
+ * this module — an intentional convergence, not a regression (see the decision
+ * record's divergence ruling).
+ */
+/** The full glyph registry — frame/surface/navigation/status/meter groups. */
+export declare const GLYPHS: {
+    readonly frame: {
+        readonly topLeft: "┌";
+        readonly topRight: "┐";
+        readonly bottomLeft: "└";
+        readonly bottomRight: "┘";
+        readonly horizontal: "─";
+        readonly vertical: "│";
+        readonly teeLeft: "├";
+        readonly teeRight: "┤";
+        readonly teeTop: "┬";
+        readonly teeBottom: "┴";
+        readonly cross: "┼";
+    };
+    readonly surface: {
+        readonly top: "▄";
+        readonly bottom: "▀";
+        readonly cursor: "█";
+        readonly altCursor: "▌";
+    };
+    readonly navigation: {
+        readonly selected: "▸";
+        readonly collapsed: "▸";
+        readonly expanded: "▾";
+        readonly up: "↑";
+        readonly down: "↓";
+        readonly moreAbove: "▲";
+        readonly moreBelow: "▼";
+        readonly next: "→";
+        readonly back: "←";
+        readonly pipeSeparator: "│";
+    };
+    readonly status: {
+        readonly success: "✓";
+        readonly failure: "✕";
+        readonly pending: "•";
+        readonly active: "●";
+        readonly idle: "◌";
+        readonly info: "○";
+        readonly warn: "⚠";
+        readonly blocked: "⊘";
+        readonly skipped: "◇";
+        readonly review: "◈";
+        readonly retry: "↻";
+        readonly handoff: "⇢";
+        readonly reference: "↗";
+        readonly partial: "◐";
+        readonly dualPane: "◆";
+        readonly star: "★";
+    };
+    readonly meter: {
+        readonly filled: "█";
+        readonly medium: "▓";
+        readonly light: "▒";
+        readonly empty: "░";
+        readonly spark: readonly ["▁", "▂", "▃", "▄", "▅", "▆", "▇", "█"];
+    };
+};
+/** The four semantic status states STATE_GLYPHS maps onto. */
+export type StatusState = 'good' | 'warn' | 'bad' | 'info';
+/**
+ * STATE_GLYPHS — the 4-state semantic alias map, aliased to GLYPHS.status (the
+ * TUI's mechanism). The agent's twin (status-glyphs.ts) hardcoded its own
+ * literals ('✓'/'⚠'/'✕'/'○') instead of aliasing a shared registry; hoisting
+ * the TUI's alias pattern here means there is exactly one place these four
+ * glyphs are spelled out, and STATUS_GLYPHS/GLYPHS.status can never drift
+ * apart again.
+ */
+export declare const STATE_GLYPHS: Record<StatusState, string>;
+//# sourceMappingURL=glyphs.d.ts.map

package/dist/platform/presentation/glyphs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"glyphs.d.ts","sourceRoot":"","sources":["../../../src/platform/presentation/glyphs.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAEH,8EAA8E;AAC9E,eAAO,MAAM,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAyDT,CAAC;AAEX,8DAA8D;AAC9D,MAAM,MAAM,WAAW,GAAG,MAAM,GAAG,MAAM,GAAG,KAAK,GAAG,MAAM,CAAC;AAE3D;;;;;;;GAOG;AACH,eAAO,MAAM,YAAY,EAAE,MAAM,CAAC,WAAW,EAAE,MAAM,CAKpD,CAAC"}

package/dist/platform/presentation/glyphs.js

@@ -0,0 +1,93 @@
+/**
+ * glyphs.ts — the canonical glyph registry for status/frame/navigation/meter
+ * rendering, hoisted from `goodvibes-tui` src/renderer/ui-primitives.ts (GLYPHS)
+ * and src/renderer/status-glyphs.ts (STATE_GLYPHS).
+ *
+ * This is one of the four genuinely-duplicated presentation tables named by the
+ * renderer/input parity audit (see CHANGELOG 1.0.0; both the TUI and the agent shipped a near-twin
+ * copy). The TUI is the reference: it is the more-complete, more-recently-fixed
+ * copy, and per the presentation-contract decision record its `status` group is
+ * the one both renderers converge on.
+ *
+ * Reconciliation (the one real content choice this hoist makes): the TUI and
+ * agent status groups disagreed —
+ *   - TUI:   idle = '◌' (U+25CC), info = '○' (U+25CB), warn = '⚠' present
+ *   - agent: idle = '○' (U+25CB), info = '•' (U+2022), no `warn` key
+ * GLYPHS.status below is the TUI's values verbatim. Consumers that previously
+ * carried the agent's values will see idle/info visibly change when they adopt
+ * this module — an intentional convergence, not a regression (see the decision
+ * record's divergence ruling).
+ */
+/** The full glyph registry — frame/surface/navigation/status/meter groups. */
+export const GLYPHS = {
+    frame: {
+        topLeft: '┌',
+        topRight: '┐',
+        bottomLeft: '└',
+        bottomRight: '┘',
+        horizontal: '─',
+        vertical: '│',
+        teeLeft: '├',
+        teeRight: '┤',
+        teeTop: '┬',
+        teeBottom: '┴',
+        cross: '┼',
+    },
+    surface: {
+        top: '▄',
+        bottom: '▀',
+        cursor: '█',
+        altCursor: '▌',
+    },
+    navigation: {
+        selected: '▸',
+        collapsed: '▸',
+        expanded: '▾',
+        up: '↑',
+        down: '↓',
+        moreAbove: '▲',
+        moreBelow: '▼',
+        next: '→',
+        back: '←',
+        pipeSeparator: '│',
+    },
+    status: {
+        success: '✓',
+        failure: '✕',
+        pending: '•',
+        active: '●',
+        idle: '◌',
+        info: '○',
+        warn: '⚠',
+        blocked: '⊘',
+        skipped: '◇',
+        review: '◈',
+        retry: '↻',
+        handoff: '⇢',
+        reference: '↗',
+        partial: '◐',
+        dualPane: '◆',
+        star: '★',
+    },
+    meter: {
+        filled: '█',
+        medium: '▓',
+        light: '▒',
+        empty: '░',
+        spark: ['▁', '▂', '▃', '▄', '▅', '▆', '▇', '█'],
+    },
+};
+/**
+ * STATE_GLYPHS — the 4-state semantic alias map, aliased to GLYPHS.status (the
+ * TUI's mechanism). The agent's twin (status-glyphs.ts) hardcoded its own
+ * literals ('✓'/'⚠'/'✕'/'○') instead of aliasing a shared registry; hoisting
+ * the TUI's alias pattern here means there is exactly one place these four
+ * glyphs are spelled out, and STATUS_GLYPHS/GLYPHS.status can never drift
+ * apart again.
+ */
+export const STATE_GLYPHS = {
+    good: GLYPHS.status.success, // ✓
+    warn: GLYPHS.status.warn, // ⚠
+    bad: GLYPHS.status.failure, // ✕
+    info: GLYPHS.status.info, // ○
+};

package/dist/platform/presentation/index.d.ts

@@ -0,0 +1,28 @@
+/**
+ * @pellux/goodvibes-sdk/platform/presentation
+ *
+ * The presentation contract — the four genuinely-duplicated presentation
+ * tables named by the renderer/input parity audit (see CHANGELOG 1.0.0; goodvibes-tui vs
+ * goodvibes-agent), hoisted into one pure, dependency-free module per Mike's
+ * SDK-boundary rule (machinery needed by 2+ surfaces => SDK):
+ *
+ *  - GLYPHS / STATE_GLYPHS  — the glyph registry + semantic status-glyph alias.
+ *  - TONE_TOKENS / resolveTones / DIFF_TONES / SPINNER_FRAMES — the chrome
+ *    tone-token table and its dark/light mode resolution.
+ *  - THINKING_PHRASES       — the rotating thinking-phrase pool.
+ *  - WaitingState / waitingPhrase — the honest waiting-state wording contract.
+ *
+ * The TUI is the reference for every value here; dark stays byte-identical to
+ * today's TUI. See docs/decisions/2026-07-05-presentation-contract-sdk-extraction.md
+ * for the full decision record, including the GLYPHS status-group reconciliation
+ * ruling and the consumption plan (the agent picks this up via R4; the TUI swap is
+ * deferred to a future coherence pass).
+ *
+ * PURE — no fs, no terminal I/O, no process globals. Painting stays
+ * renderer-owned; this module owns only tokens and pure wording functions.
+ */
+export { GLYPHS, STATE_GLYPHS, type StatusState } from './glyphs.js';
+export { TONE_TOKENS, resolveTones, DIFF_TONES, SPINNER_FRAMES, type ThemeMode, type ToneTokens, } from './tones.js';
+export { THINKING_PHRASES } from './thinking-phrases.js';
+export { waitingPhrase, type WaitingState, type WaitingPhraseContext, } from './waiting-wording.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/platform/presentation/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/platform/presentation/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAEH,OAAO,EAAE,MAAM,EAAE,YAAY,EAAE,KAAK,WAAW,EAAE,MAAM,aAAa,CAAC;AAErE,OAAO,EACL,WAAW,EACX,YAAY,EACZ,UAAU,EACV,cAAc,EACd,KAAK,SAAS,EACd,KAAK,UAAU,GAChB,MAAM,YAAY,CAAC;AAEpB,OAAO,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AAEzD,OAAO,EACL,aAAa,EACb,KAAK,YAAY,EACjB,KAAK,oBAAoB,GAC1B,MAAM,sBAAsB,CAAC"}

package/dist/platform/presentation/index.js

@@ -0,0 +1,27 @@
+/**
+ * @pellux/goodvibes-sdk/platform/presentation
+ *
+ * The presentation contract — the four genuinely-duplicated presentation
+ * tables named by the renderer/input parity audit (see CHANGELOG 1.0.0; goodvibes-tui vs
+ * goodvibes-agent), hoisted into one pure, dependency-free module per Mike's
+ * SDK-boundary rule (machinery needed by 2+ surfaces => SDK):
+ *
+ *  - GLYPHS / STATE_GLYPHS  — the glyph registry + semantic status-glyph alias.
+ *  - TONE_TOKENS / resolveTones / DIFF_TONES / SPINNER_FRAMES — the chrome
+ *    tone-token table and its dark/light mode resolution.
+ *  - THINKING_PHRASES       — the rotating thinking-phrase pool.
+ *  - WaitingState / waitingPhrase — the honest waiting-state wording contract.
+ *
+ * The TUI is the reference for every value here; dark stays byte-identical to
+ * today's TUI. See docs/decisions/2026-07-05-presentation-contract-sdk-extraction.md
+ * for the full decision record, including the GLYPHS status-group reconciliation
+ * ruling and the consumption plan (the agent picks this up via R4; the TUI swap is
+ * deferred to a future coherence pass).
+ *
+ * PURE — no fs, no terminal I/O, no process globals. Painting stays
+ * renderer-owned; this module owns only tokens and pure wording functions.
+ */
+export { GLYPHS, STATE_GLYPHS } from './glyphs.js';
+export { TONE_TOKENS, resolveTones, DIFF_TONES, SPINNER_FRAMES, } from './tones.js';
+export { THINKING_PHRASES } from './thinking-phrases.js';
+export { waitingPhrase, } from './waiting-wording.js';

package/dist/platform/presentation/thinking-phrases.d.ts

@@ -0,0 +1,12 @@
+/**
+ * thinking-phrases.ts — the rotating "thinking" phrase pool, hoisted from
+ * `goodvibes-tui` src/renderer/ui-factory.ts (THINKING_PHRASES). Verbatim
+ * identical to the agent's copy today (per the renderer/input parity audit) — a pure
+ * move, no reconciliation needed.
+ *
+ * Vaporwave / good-vibes themed; shown by waitingPhrase()'s 'thinking' case
+ * while a turn is genuinely producing tokens at a normal cadence (see
+ * waiting-wording.ts).
+ */
+export declare const THINKING_PHRASES: readonly ["Thinking...", "Vibing...", "Manifesting...", "Channeling energy...", "Tuning frequencies...", "Riding the wave...", "Aligning chakras...", "Entering flow state...", "Consulting the void...", "Absorbing aesthetics...", "Synthesizing vibes...", "Transcending...", "Dreaming in neon...", "Parsing the cosmos...", "Loading good vibes...", "Meditating...", "Catching a vibe...", "Harmonizing...", "Feeling it...", "In the zone..."];
+//# sourceMappingURL=thinking-phrases.d.ts.map

package/dist/platform/presentation/thinking-phrases.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"thinking-phrases.d.ts","sourceRoot":"","sources":["../../../src/platform/presentation/thinking-phrases.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AACH,eAAO,MAAM,gBAAgB,ubAqBnB,CAAC"}

package/dist/platform/presentation/thinking-phrases.js

@@ -0,0 +1,32 @@
+/**
+ * thinking-phrases.ts — the rotating "thinking" phrase pool, hoisted from
+ * `goodvibes-tui` src/renderer/ui-factory.ts (THINKING_PHRASES). Verbatim
+ * identical to the agent's copy today (per the renderer/input parity audit) — a pure
+ * move, no reconciliation needed.
+ *
+ * Vaporwave / good-vibes themed; shown by waitingPhrase()'s 'thinking' case
+ * while a turn is genuinely producing tokens at a normal cadence (see
+ * waiting-wording.ts).
+ */
+export const THINKING_PHRASES = [
+    'Thinking...',
+    'Vibing...',
+    'Manifesting...',
+    'Channeling energy...',
+    'Tuning frequencies...',
+    'Riding the wave...',
+    'Aligning chakras...',
+    'Entering flow state...',
+    'Consulting the void...',
+    'Absorbing aesthetics...',
+    'Synthesizing vibes...',
+    'Transcending...',
+    'Dreaming in neon...',
+    'Parsing the cosmos...',
+    'Loading good vibes...',
+    'Meditating...',
+    'Catching a vibe...',
+    'Harmonizing...',
+    'Feeling it...',
+    'In the zone...',
+];