@apolloyh/apollo-agent 0.1.0

package/dist/skills/skills.js

@@ -0,0 +1,195 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { safeRealResolve, truncate } from "../utils.js";
+export class SkillManager {
+    config;
+    catalogCache;
+    contentCache = new Map();
+    constructor(config) {
+        this.config = config;
+    }
+    skillDirs() {
+        const bundled = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "../../src/skills");
+        return Array.from(new Set([
+            ...this.config.skills.directories.map((dir) => path.resolve(this.config.workspaceRoot, dir)),
+            bundled,
+        ]));
+    }
+    async search(query) {
+        const results = [];
+        const terms = tokenizeQuery(query);
+        for (const skill of await this.catalog()) {
+            const haystack = `${skill.directoryName}\n${skill.body}`.toLowerCase();
+            const score = scoreSkillMatch(haystack, terms, query);
+            if (!query || score > 0) {
+                results.push({
+                    name: skill.directoryName,
+                    path: skill.path,
+                    score,
+                    summary: truncate(skill.body.replace(/\s+/g, " "), 400),
+                });
+            }
+        }
+        return results
+            .sort((a, b) => b.score - a.score || a.name.localeCompare(b.name))
+            .map(({ score: _score, ...result }) => result);
+    }
+    async metadata() {
+        const results = (await this.catalog()).map((skill) => {
+            const frontmatter = parseFrontmatter(skill.body);
+            return {
+                description: frontmatter.description || "",
+                name: frontmatter.name || skill.directoryName,
+                path: skill.path,
+            };
+        });
+        return results.sort((a, b) => a.name.localeCompare(b.name));
+    }
+    async read(skillPath) {
+        const fullPath = path.resolve(this.config.workspaceRoot, skillPath);
+        if (!this.skillDirs().some((dir) => fullPath === dir || fullPath.startsWith(`${dir}${path.sep}`))) {
+            throw new Error(`Skill path is outside configured skill directories: ${skillPath}`);
+        }
+        const relativePath = path.relative(this.config.workspaceRoot, fullPath);
+        const cached = this.contentCache.get(relativePath);
+        if (cached !== undefined)
+            return truncate(cached, 20000);
+        const body = await fs.readFile(fullPath, "utf8");
+        this.contentCache.set(relativePath, body);
+        return truncate(body, 20000);
+    }
+    async installLocal(sourcePath, requestedName) {
+        // Confine the source to the workspace (rejects ../ and symlink escapes) so the
+        // install can't copy arbitrary files (e.g. /etc/passwd) into a skill dir that skill_read exposes.
+        const source = await safeRealResolve(this.config.workspaceRoot, sourcePath);
+        const stat = await fs.stat(source);
+        const skillFile = stat.isDirectory() ? path.join(source, "SKILL.md") : source;
+        if (path.basename(skillFile) !== "SKILL.md") {
+            throw new Error("Skill source must be a SKILL.md file or a directory containing SKILL.md.");
+        }
+        await fs.readFile(skillFile, "utf8");
+        const name = sanitizeSkillName(requestedName ?? path.basename(path.dirname(skillFile)));
+        const installRoot = this.skillDirs()[0];
+        if (!installRoot)
+            throw new Error("No skill directories configured.");
+        const targetDir = path.join(installRoot, name);
+        const targetFile = path.join(targetDir, "SKILL.md");
+        await fs.mkdir(installRoot, { recursive: true });
+        try {
+            await fs.mkdir(targetDir);
+        }
+        catch (error) {
+            if (error.code === "EEXIST")
+                throw new Error(`Skill already installed: ${name}`);
+            throw error;
+        }
+        try {
+            if (stat.isDirectory())
+                await fs.cp(source, targetDir, { recursive: true, dereference: true });
+            else
+                await fs.copyFile(skillFile, targetFile);
+        }
+        catch (error) {
+            await fs.rm(targetDir, { recursive: true, force: true });
+            throw error;
+        }
+        this.catalogCache = undefined;
+        this.contentCache.clear();
+        return {
+            name,
+            path: path.relative(this.config.workspaceRoot, targetFile),
+        };
+    }
+    catalog() {
+        if (!this.catalogCache)
+            this.catalogCache = this.loadCatalog();
+        return this.catalogCache;
+    }
+    async loadCatalog() {
+        const catalog = [];
+        for (const dir of this.skillDirs()) {
+            let entries = [];
+            try {
+                entries = await fs.readdir(dir);
+            }
+            catch {
+                continue;
+            }
+            for (const directoryName of entries) {
+                const skillPath = path.join(dir, directoryName, "SKILL.md");
+                try {
+                    const body = await fs.readFile(skillPath, "utf8");
+                    const relativePath = path.relative(this.config.workspaceRoot, skillPath);
+                    this.contentCache.set(relativePath, body);
+                    catalog.push({ body, directoryName, path: relativePath });
+                }
+                catch {
+                    // Ignore malformed skill folders.
+                }
+            }
+        }
+        return catalog;
+    }
+}
+function sanitizeSkillName(name) {
+    const normalized = name.trim().toLowerCase().replace(/[^a-z0-9_-]+/g, "-").replace(/^-+|-+$/g, "");
+    if (!normalized)
+        throw new Error("Skill name is empty.");
+    return normalized;
+}
+function parseFrontmatter(body) {
+    const match = body.match(/^---\n([\s\S]*?)\n---/);
+    if (!match?.[1])
+        return {};
+    const metadata = {};
+    for (const line of match[1].split("\n")) {
+        const separator = line.indexOf(":");
+        if (separator === -1)
+            continue;
+        const key = line.slice(0, separator).trim();
+        const value = stripYamlString(line.slice(separator + 1).trim());
+        if (key === "name" || key === "description") {
+            metadata[key] = value;
+        }
+    }
+    return metadata;
+}
+function stripYamlString(value) {
+    if ((value.startsWith('"') && value.endsWith('"')) ||
+        (value.startsWith("'") && value.endsWith("'"))) {
+        return value.slice(1, -1);
+    }
+    return value;
+}
+function tokenizeQuery(query) {
+    const normalized = query.toLowerCase().trim();
+    if (!normalized)
+        return [];
+    const terms = new Set();
+    terms.add(normalized);
+    for (const match of normalized.matchAll(/[a-z0-9][a-z0-9_-]{1,}/g)) {
+        terms.add(match[0]);
+    }
+    for (const match of normalized.matchAll(/[\u3400-\u9fff]{2,}/g)) {
+        const text = match[0];
+        terms.add(text);
+        for (let size = 2; size <= Math.min(4, text.length); size += 1) {
+            for (let index = 0; index <= text.length - size; index += 1) {
+                terms.add(text.slice(index, index + size));
+            }
+        }
+    }
+    return [...terms].filter((term) => term.length >= 2);
+}
+function scoreSkillMatch(haystack, terms, query) {
+    if (!query)
+        return 1;
+    let score = 0;
+    for (const term of terms) {
+        if (!haystack.includes(term))
+            continue;
+        score += term.length >= 6 ? 4 : term.length >= 3 ? 2 : 1;
+    }
+    return score;
+}

package/dist/status-ui.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Claude Code–style waiting indicator + outcome dots.
+ *
+ * Running: morphing sparkle · ✢ ✳ ✶ ✻ ✽ + shimmer label
+ * Success: green ●  (CC uses ● / ⏺ for completed status)
+ * Failure: red ●
+ *
+ * Refs: SpinnerGlyph (stalled→error red), figures BLACK_CIRCLE, BriefIdleStatus ●
+ */
+/** Filled circle — CC completed / idle status glyph. */
+export declare const STATUS_DOT = "\u25CF";
+export declare function spinnerGlyph(frame: number): string;
+export declare function glimmerIndex(frame: number, messageWidth: number): number;
+export declare function shimmerLabel(label: string, frame: number, useColor: boolean): string;
+export declare function formatSpinnerGlyph(frame: number, useColor: boolean): string;
+export declare const STATUS_TICK_MS = 160;
+export declare function formatWaitLine(options: {
+    frame: number;
+    label: string;
+    elapsed: string;
+    useColor: boolean;
+}): string;
+/**
+ * Permanent outcome line after spinner stops (Claude Code style).
+ * success → green ● Thought for 3.7s
+ * error   → red ● Failed · 3.7s
+ */
+export declare function formatOutcomeLine(options: {
+    outcome: "success" | "error";
+    /** e.g. Thinking / Processing */
+    label: string;
+    elapsed: string;
+    useColor: boolean;
+}): string;
+export declare function blinkDiamond(frame: number, useColor: boolean): string;
+export declare function diamondOn(_frame: number): boolean;
+//# sourceMappingURL=status-ui.d.ts.map

package/dist/status-ui.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"status-ui.d.ts","sourceRoot":"","sources":["../src/status-ui.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAmCH,wDAAwD;AACxD,eAAO,MAAM,UAAU,WAAM,CAAC;AAE9B,wBAAgB,YAAY,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAGlD;AAED,wBAAgB,YAAY,CAAC,KAAK,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,GAAG,MAAM,CAKxE;AAED,wBAAgB,YAAY,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,QAAQ,EAAE,OAAO,GAAG,MAAM,CAkBpF;AAED,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,MAAM,EAAE,QAAQ,EAAE,OAAO,GAAG,MAAM,CAO3E;AAED,eAAO,MAAM,cAAc,MAAM,CAAC;AAElC,wBAAgB,cAAc,CAAC,OAAO,EAAE;IACtC,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,MAAM,CAAC;IACd,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,EAAE,OAAO,CAAC;CACnB,GAAG,MAAM,CAKT;AAED;;;;GAIG;AACH,wBAAgB,iBAAiB,CAAC,OAAO,EAAE;IACzC,OAAO,EAAE,SAAS,GAAG,OAAO,CAAC;IAC7B,iCAAiC;IACjC,KAAK,EAAE,MAAM,CAAC;IACd,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,EAAE,OAAO,CAAC;CACnB,GAAG,MAAM,CAcT;AAeD,wBAAgB,YAAY,CAAC,KAAK,EAAE,MAAM,EAAE,QAAQ,EAAE,OAAO,GAAG,MAAM,CAErE;AACD,wBAAgB,SAAS,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAEjD"}

package/dist/status-ui.js

@@ -0,0 +1,130 @@
+/**
+ * Claude Code–style waiting indicator + outcome dots.
+ *
+ * Running: morphing sparkle · ✢ ✳ ✶ ✻ ✽ + shimmer label
+ * Success: green ●  (CC uses ● / ⏺ for completed status)
+ * Failure: red ●
+ *
+ * Refs: SpinnerGlyph (stalled→error red), figures BLACK_CIRCLE, BriefIdleStatus ●
+ */
+const SPINNER_CHARS = ["·", "✢", "✳", "✶", "✻", "✽"];
+const SPINNER_FRAMES = [
+    ...SPINNER_CHARS,
+    ...[...SPINNER_CHARS].reverse(),
+];
+const GLYPH_EVERY = 3;
+const SHIMMER_EVERY = 4;
+const BASE_RGB = { r: 148, g: 163, b: 184 };
+const SHIMMER_RGB = { r: 147, g: 197, b: 253 };
+const GLYPH_RGB = { r: 96, g: 165, b: 250 };
+const GREEN_RGB = { r: 34, g: 197, b: 94 }; // green-500
+const RED_RGB = { r: 239, g: 68, b: 68 }; // red-500
+function lerp(a, b, t) {
+    return Math.round(a + (b - a) * t);
+}
+function mixRgb(a, b, t) {
+    const u = Math.max(0, Math.min(1, t));
+    return { r: lerp(a.r, b.r, u), g: lerp(a.g, b.g, u), b: lerp(a.b, b.b, u) };
+}
+function rgbAnsi(c) {
+    return `\x1b[38;2;${c.r};${c.g};${c.b}m`;
+}
+const RESET = "\x1b[0m";
+const DIM = "\x1b[2m";
+/** Filled circle — CC completed / idle status glyph. */
+export const STATUS_DOT = "●";
+export function spinnerGlyph(frame) {
+    const i = Math.floor(frame / GLYPH_EVERY) % SPINNER_FRAMES.length;
+    return SPINNER_FRAMES[i] ?? "·";
+}
+export function glimmerIndex(frame, messageWidth) {
+    if (messageWidth <= 0)
+        return -100;
+    const cyclePosition = Math.floor(frame / SHIMMER_EVERY);
+    const cycleLength = messageWidth + 20;
+    return messageWidth + 10 - (cyclePosition % cycleLength);
+}
+export function shimmerLabel(label, frame, useColor) {
+    if (!useColor || label.length === 0)
+        return label;
+    const chars = [...label];
+    const g = glimmerIndex(frame, chars.length);
+    let out = "";
+    for (let i = 0; i < chars.length; i += 1) {
+        const dist = Math.abs(i - g);
+        let t = 0;
+        if (dist === 0)
+            t = 1;
+        else if (dist === 1)
+            t = 0.4;
+        else if (dist === 2)
+            t = 0.12;
+        if (t > 0) {
+            out += `${rgbAnsi(mixRgb(BASE_RGB, SHIMMER_RGB, t))}${chars[i]}${RESET}`;
+        }
+        else {
+            out += `${rgbAnsi(BASE_RGB)}${chars[i]}${RESET}`;
+        }
+    }
+    return out;
+}
+export function formatSpinnerGlyph(frame, useColor) {
+    const ch = spinnerGlyph(frame);
+    if (!useColor)
+        return ch;
+    const step = Math.floor(frame / GLYPH_EVERY) % SPINNER_FRAMES.length;
+    const peak = SPINNER_CHARS.length - 1;
+    const nearPeak = step === peak || step === SPINNER_FRAMES.length - peak - 1;
+    return `${rgbAnsi(nearPeak ? SHIMMER_RGB : GLYPH_RGB)}${ch}${RESET}`;
+}
+export const STATUS_TICK_MS = 160;
+export function formatWaitLine(options) {
+    const glyph = formatSpinnerGlyph(options.frame, options.useColor);
+    const label = shimmerLabel(options.label, options.frame, options.useColor);
+    const elapsed = options.useColor ? `${DIM}${options.elapsed}${RESET}` : options.elapsed;
+    return `${glyph} ${label} ${elapsed}`;
+}
+/**
+ * Permanent outcome line after spinner stops (Claude Code style).
+ * success → green ● Thought for 3.7s
+ * error   → red ● Failed · 3.7s
+ */
+export function formatOutcomeLine(options) {
+    const ok = options.outcome === "success";
+    const color = ok ? GREEN_RGB : RED_RGB;
+    const dot = options.useColor ? `${rgbAnsi(color)}${STATUS_DOT}${RESET}` : STATUS_DOT;
+    // Past-tense style like CC “Worked for …”
+    const text = ok
+        ? pastThoughtLabel(options.label, options.elapsed)
+        : `Failed · ${options.elapsed}`;
+    const body = options.useColor
+        ? ok
+            ? `${rgbAnsi(GREEN_RGB)}${text}${RESET}`
+            : `${rgbAnsi(RED_RGB)}${text}${RESET}`
+        : text;
+    return `${dot} ${body}`;
+}
+/** Thinking → Thought for 3.7s ; Processing → Processed · 3.7s */
+function pastThoughtLabel(label, elapsed) {
+    const base = label.replace(/\.\.\.$/, "").trim();
+    if (/^thinking$/i.test(base))
+        return `Thought for ${elapsed}`;
+    if (/^processing$/i.test(base))
+        return `Processed · ${elapsed}`;
+    if (/^working$/i.test(base))
+        return `Worked for ${elapsed}`;
+    if (/^considering$/i.test(base))
+        return `Considered · ${elapsed}`;
+    if (/^composing$/i.test(base))
+        return `Composed · ${elapsed}`;
+    // tool name mid-flight
+    if (/^[a-z_]+$/i.test(base) && !/ing$/i.test(base))
+        return `Used ${base} · ${elapsed}`;
+    return `${base} · ${elapsed}`;
+}
+export function blinkDiamond(frame, useColor) {
+    return formatSpinnerGlyph(frame, useColor);
+}
+export function diamondOn(_frame) {
+    return true;
+}

package/dist/thought-fold.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Terminal collapsible Thought blocks (like web ProcessTimeline).
+ * Default: one line “◆ Thought for 0.5s  ▸”
+ * Expand: /thought  or key `t`  → show detail lines under it.
+ */
+export type ThoughtBlock = {
+    id: string;
+    startedAt: number;
+    endedAt?: number;
+    /** Short lines shown when expanded */
+    lines: string[];
+    tools: string[];
+    expanded: boolean;
+    /** Printed to terminal already (collapsed header) */
+    printed: boolean;
+    /** true if turn failed */
+    failed?: boolean;
+};
+export type ThoughtFoldOptions = {
+    color: boolean;
+    out: (text: string) => void;
+};
+export declare class ThoughtFoldManager {
+    private blocks;
+    private current;
+    private options;
+    constructor(options: ThoughtFoldOptions);
+    setColor(color: boolean): void;
+    /** Start a new thought window for this user turn. */
+    beginTurn(): void;
+    note(line: string): void;
+    noteTool(tool: string): void;
+    /**
+     * Finalize current thought and print collapsed header (once).
+     * Call before streaming the final answer, or at end of turn.
+     */
+    finalizeAndPrint(defaultDetail?: string, failed?: boolean, printHeader?: boolean): ThoughtBlock | null;
+    /** Toggle expand/collapse of the last thought (or by id). */
+    toggle(id?: string): void;
+    expandLast(): void;
+    lastSummary(): string | null;
+    clear(): void;
+    private duration;
+    private printHeader;
+    private printExpanded;
+    private dim;
+}
+//# sourceMappingURL=thought-fold.d.ts.map

package/dist/thought-fold.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"thought-fold.d.ts","sourceRoot":"","sources":["../src/thought-fold.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,MAAM,MAAM,YAAY,GAAG;IACzB,EAAE,EAAE,MAAM,CAAC;IACX,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,sCAAsC;IACtC,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB,QAAQ,EAAE,OAAO,CAAC;IAClB,qDAAqD;IACrD,OAAO,EAAE,OAAO,CAAC;IACjB,0BAA0B;IAC1B,MAAM,CAAC,EAAE,OAAO,CAAC;CAClB,CAAC;AAEF,MAAM,MAAM,kBAAkB,GAAG;IAC/B,KAAK,EAAE,OAAO,CAAC;IACf,GAAG,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;CAC7B,CAAC;AAQF,qBAAa,kBAAkB;IAC7B,OAAO,CAAC,MAAM,CAAsB;IACpC,OAAO,CAAC,OAAO,CAA6B;IAC5C,OAAO,CAAC,OAAO,CAAqB;gBAExB,OAAO,EAAE,kBAAkB;IAIvC,QAAQ,CAAC,KAAK,EAAE,OAAO,GAAG,IAAI;IAI9B,qDAAqD;IACrD,SAAS,IAAI,IAAI;IAWjB,IAAI,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI;IASxB,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI;IAM5B;;;OAGG;IACH,gBAAgB,CAAC,aAAa,CAAC,EAAE,MAAM,EAAE,MAAM,UAAQ,EAAE,WAAW,UAAQ,GAAG,YAAY,GAAG,IAAI;IA0BlG,6DAA6D;IAC7D,MAAM,CAAC,EAAE,CAAC,EAAE,MAAM,GAAG,IAAI;IAgBzB,UAAU,IAAI,IAAI;IAclB,WAAW,IAAI,MAAM,GAAG,IAAI;IAO5B,KAAK,IAAI,IAAI;IAKb,OAAO,CAAC,QAAQ;IAKhB,OAAO,CAAC,WAAW;IAanB,OAAO,CAAC,aAAa;IAcrB,OAAO,CAAC,GAAG;CAIZ"}

package/dist/thought-fold.js

@@ -0,0 +1,156 @@
+/**
+ * Terminal collapsible Thought blocks (like web ProcessTimeline).
+ * Default: one line “◆ Thought for 0.5s  ▸”
+ * Expand: /thought  or key `t`  → show detail lines under it.
+ */
+const DIM = "\x1b[90m";
+const RESET = "\x1b[0m";
+const AMBER = "\x1b[38;2;251;191;36m";
+const GREEN = "\x1b[32m";
+const RED = "\x1b[31m";
+export class ThoughtFoldManager {
+    blocks = [];
+    current = null;
+    options;
+    constructor(options) {
+        this.options = options;
+    }
+    setColor(color) {
+        this.options.color = color;
+    }
+    /** Start a new thought window for this user turn. */
+    beginTurn() {
+        this.current = {
+            id: `th-${Date.now()}`,
+            startedAt: Date.now(),
+            lines: [],
+            tools: [],
+            expanded: false,
+            printed: false,
+        };
+    }
+    note(line) {
+        if (!this.current)
+            return;
+        const t = line.trim();
+        if (!t)
+            return;
+        // de-dupe consecutive
+        if (this.current.lines[this.current.lines.length - 1] === t)
+            return;
+        this.current.lines.push(t);
+    }
+    noteTool(tool) {
+        if (!this.current)
+            return;
+        if (!this.current.tools.includes(tool))
+            this.current.tools.push(tool);
+        this.note(`used ${tool}`);
+    }
+    /**
+     * Finalize current thought and print collapsed header (once).
+     * Call before streaming the final answer, or at end of turn.
+     */
+    finalizeAndPrint(defaultDetail, failed = false, printHeader = false) {
+        if (!this.current)
+            return null;
+        if (this.current.printed)
+            return this.current;
+        this.current.endedAt = Date.now();
+        this.current.failed = failed;
+        if (this.current.lines.length === 0 && defaultDetail) {
+            this.current.lines.push(defaultDetail);
+        }
+        if (this.current.lines.length === 0) {
+            this.current.lines.push("Processed the request and prepared a reply.");
+        }
+        this.blocks.push(this.current);
+        // Only the most recent block is ever toggled/expanded; cap history so a long-lived
+        // interactive session doesn't grow this array (and its retained lines) without bound.
+        if (this.blocks.length > 50)
+            this.blocks.splice(0, this.blocks.length - 50);
+        if (printHeader) {
+            this.printHeader(this.current);
+            this.current.printed = true;
+        }
+        const done = this.current;
+        this.current = null;
+        return done;
+    }
+    /** Toggle expand/collapse of the last thought (or by id). */
+    toggle(id) {
+        const block = id
+            ? this.blocks.find((b) => b.id === id)
+            : this.blocks[this.blocks.length - 1];
+        if (!block) {
+            this.options.out(this.dim("(no thought to expand yet)\n"));
+            return;
+        }
+        block.expanded = !block.expanded;
+        if (block.expanded) {
+            this.printExpanded(block);
+        }
+        else {
+            this.options.out(this.dim("  (thought collapsed — /thought to expand again)\n"));
+        }
+    }
+    expandLast() {
+        const block = this.blocks[this.blocks.length - 1];
+        if (!block) {
+            this.options.out(this.dim("(no thought to expand yet)\n"));
+            return;
+        }
+        if (!block.expanded) {
+            block.expanded = true;
+            this.printExpanded(block);
+        }
+        else {
+            this.printExpanded(block); // re-print
+        }
+    }
+    lastSummary() {
+        const b = this.blocks[this.blocks.length - 1];
+        if (!b)
+            return null;
+        const sec = ((b.endedAt ?? Date.now()) - b.startedAt) / 1000;
+        return `Thought for ${sec.toFixed(1)}s · ${b.tools.length} tools · ${b.expanded ? "expanded" : "collapsed"}`;
+    }
+    clear() {
+        this.blocks = [];
+        this.current = null;
+    }
+    duration(block) {
+        const ms = (block.endedAt ?? Date.now()) - block.startedAt;
+        return `${(ms / 1000).toFixed(1)}s`;
+    }
+    printHeader(block) {
+        const arrow = block.expanded ? "▾" : "▸";
+        // CC style: green ● success, red ● failure (not amber while done)
+        const color = block.failed ? RED : GREEN;
+        const dot = this.options.color ? `${color}●${RESET}` : "●";
+        const label = block.failed
+            ? `Failed · ${this.duration(block)}`
+            : `Thought for ${this.duration(block)}`;
+        const labelPainted = this.options.color ? `${color}${label}${RESET}` : label;
+        const hint = this.dim(`  ${arrow}  /thought to expand`);
+        this.options.out(`\n${dot} ${labelPainted}${hint}\n`);
+    }
+    printExpanded(block) {
+        const color = block.failed ? RED : GREEN;
+        const dot = this.options.color ? `${color}●${RESET}` : "●";
+        const head = block.failed ? `Failed · ${this.duration(block)}` : `Thought for ${this.duration(block)}`;
+        this.options.out(`\n${dot} ${head}  ▾\n`);
+        if (block.tools.length) {
+            this.options.out(this.dim(`  tools: ${block.tools.join(", ")}\n`));
+        }
+        for (const line of block.lines) {
+            this.options.out(this.dim(`  │ ${line}\n`));
+        }
+        this.options.out(this.dim("  └ /thought to collapse\n\n"));
+    }
+    dim(text) {
+        if (!this.options.color)
+            return text;
+        return `${DIM}${text}${RESET}`;
+    }
+}

package/dist/tools/builtin.d.ts

@@ -0,0 +1,27 @@
+import type { AgentConfig, SubagentConfig, TraceSink } from "../types.js";
+import { SkillManager } from "../skills/skills.js";
+import { McpManager } from "../mcp/manager.js";
+import { ToolRegistry } from "./registry.js";
+type AddressResolver = (hostname: string) => Promise<Array<{
+    address: string;
+    family: number;
+}>>;
+export type RunTaskFn = (agent: SubagentConfig, prompt: string, emit: TraceSink) => Promise<string>;
+type BuiltinOptions = {
+    config: AgentConfig;
+    skillManager: SkillManager;
+    mcpManager: McpManager;
+    /** Main agent only — launch Claude Code–style Task subagents */
+    runTask?: RunTaskFn;
+    /** When false, Task tool is not registered (subagents never nest) */
+    enableTask?: boolean;
+    /** Tool allowlist for subagents; ["*"] or omit = all registered tools */
+    allowedTools?: string[];
+};
+export declare function createBuiltinRegistry(options: BuiltinOptions): ToolRegistry;
+export declare function resolvePublicHttpAddress(url: URL, resolve?: AddressResolver): Promise<{
+    address: string;
+    family: 4 | 6;
+}>;
+export {};
+//# sourceMappingURL=builtin.d.ts.map

package/dist/tools/builtin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"builtin.d.ts","sourceRoot":"","sources":["../../src/tools/builtin.ts"],"names":[],"mappings":"AAUA,OAAO,KAAK,EAAE,WAAW,EAAc,cAAc,EAAwB,SAAS,EAAE,MAAM,aAAa,CAAC;AAE5G,OAAO,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AACnD,OAAO,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AAC/C,OAAO,EAAE,YAAY,EAAE,MAAM,eAAe,CAAC;AAY7C,KAAK,eAAe,GAAG,CAAC,QAAQ,EAAE,MAAM,KAAK,OAAO,CAAC,KAAK,CAAC;IAAE,OAAO,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CAAC,CAAC,CAAC;AAGjG,MAAM,MAAM,SAAS,GAAG,CACtB,KAAK,EAAE,cAAc,EACrB,MAAM,EAAE,MAAM,EACd,IAAI,EAAE,SAAS,KACZ,OAAO,CAAC,MAAM,CAAC,CAAC;AAErB,KAAK,cAAc,GAAG;IACpB,MAAM,EAAE,WAAW,CAAC;IACpB,YAAY,EAAE,YAAY,CAAC;IAC3B,UAAU,EAAE,UAAU,CAAC;IACvB,gEAAgE;IAChE,OAAO,CAAC,EAAE,SAAS,CAAC;IACpB,qEAAqE;IACrE,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,yEAAyE;IACzE,YAAY,CAAC,EAAE,MAAM,EAAE,CAAC;CACzB,CAAC;AAEF,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,cAAc,GAAG,YAAY,CA0hB3E;AAsKD,wBAAsB,wBAAwB,CAC5C,GAAG,EAAE,GAAG,EACR,OAAO,GAAE,eAA2E,GACnF,OAAO,CAAC;IAAE,OAAO,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,CAAC,GAAG,CAAC,CAAA;CAAE,CAAC,CAkB7C"}