qlogicagent 2.13.5 → 2.13.6

package/dist/runtime/infra/skill-injector.js

@@ -1,155 +0,0 @@
-/**
- * Skill Injector — shares qlogicagent skills with external ACP agents.
- *
- * Two injection methods:
- *
- * 1. **Native skill directory sync**: For agents that support a `skillsDirs`
- *    convention (e.g. `.claude/skills/`), create symlinks or copies of
- *    qlogicagent's optional skills into the agent's native directory.
- *
- * 2. **First-message prompt injection**: For agents without native skill
- *    directory support, prepend skill instructions text to the first prompt.
- *    Subject to a token budget to prevent context bloat.
- */
-import { existsSync, mkdirSync, readFileSync, writeFileSync, symlinkSync } from "node:fs";
-import { basename, dirname, join } from "node:path";
-import { resolveActiveSkills } from "./skill-resolver.js";
-import { SKILL_INJECTION_MAX_CHARS, SKILL_INJECTION_MAX_COUNT, } from "../config/tunable-defaults.js";
-export { SKILL_INJECTION_MAX_CHARS, SKILL_INJECTION_MAX_COUNT };
-const SYSTEM_GENERATED_SKILL_PREFIXES = ["auto-skill-", "test-skill-"];
-export function isSystemGeneratedSkillName(name) {
-    return SYSTEM_GENERATED_SKILL_PREFIXES.some(prefix => name.startsWith(prefix));
-}
-// ── Skill Injection ─────────────────────────────────────────
-export class SkillInjector {
-    /**
-     * Synchronize skills to an agent's native skill directory.
-     * Creates symlinks where possible; falls back to file copy.
-     *
-     * @param targetDir - Agent's native skill directory (e.g. `<cwd>/.claude/skills/`)
-     * @param cwd - Project working directory (for project-level skills)
-     */
-    syncSkillsToDir(targetDir, cwd) {
-        const skillSources = this.collectSkillPaths(cwd);
-        if (skillSources.length === 0)
-            return;
-        // Ensure target directory exists
-        mkdirSync(targetDir, { recursive: true });
-        for (const srcPath of skillSources) {
-            // srcPath = <dir>/<skillName>/SKILL.md → extract skillName from parent
-            const name = basename(dirname(srcPath));
-            const dest = join(targetDir, `qlogicagent-${name}.md`);
-            // Skip if already exists
-            if (existsSync(dest))
-                continue;
-            try {
-                symlinkSync(srcPath, dest);
-            }
-            catch {
-                // Symlink may fail on Windows without admin — fall back to copy
-                try {
-                    const content = readFileSync(srcPath, "utf-8");
-                    writeFileSync(dest, content, "utf-8");
-                }
-                catch {
-                    // Best-effort; skip this skill
-                }
-            }
-        }
-    }
-    /**
-     * Build a skill description block to prepend to the first message
-     * for agents that don't support native skill directories.
-     *
-     * Respects SKILL_INJECTION_MAX_CHARS and SKILL_INJECTION_MAX_COUNT
-     * to prevent token bloat.
-     *
-     * @param cwd - Project working directory (for project-level skills)
-     * @returns Markdown text with skill instructions, or empty string if no skills.
-     */
-    buildPromptWithSkills(cwd) {
-        const skillSources = this.collectSkillPaths(cwd);
-        if (skillSources.length === 0)
-            return "";
-        const blocks = [
-            "## Available Skills (from qlogicagent)\n",
-            "The following skills are available to you as additional capabilities:\n",
-        ];
-        let totalChars = blocks.join("\n").length;
-        let injectedCount = 0;
-        for (const srcPath of skillSources) {
-            if (injectedCount >= SKILL_INJECTION_MAX_COUNT)
-                break;
-            try {
-                let content = readFileSync(srcPath, "utf-8").trim();
-                if (!content)
-                    continue;
-                // srcPath = <dir>/<skillName>/SKILL.md → extract skillName from parent
-                const name = basename(dirname(srcPath));
-                const header = `### ${name}\n\n`;
-                // Truncate skill content if it would exceed budget
-                const remaining = SKILL_INJECTION_MAX_CHARS - totalChars - header.length - 2;
-                if (remaining <= 100)
-                    break; // Not enough room for meaningful content
-                if (content.length > remaining) {
-                    content = content.slice(0, remaining) + "\n...(truncated)";
-                }
-                const block = `${header}${content}\n`;
-                blocks.push(block);
-                totalChars += block.length;
-                injectedCount++;
-            }
-            catch {
-                // Skip unreadable files
-            }
-        }
-        if (injectedCount > 0 && skillSources.length > injectedCount) {
-            blocks.push(`\n_...and ${skillSources.length - injectedCount} more skill(s) available via \`skill list\`._\n`);
-        }
-        return injectedCount > 0 ? blocks.join("\n") : "";
-    }
-    /**
-     * Determine the injection method for an agent.
-     *
-     * @param capabilities - Agent's discovered capabilities
-     * @returns "native" if agent has skillsDirs, "prompt" otherwise
-     */
-    getInjectionMethod(capabilities) {
-        if (capabilities?.skillsDirs?.length) {
-            return "native";
-        }
-        return "prompt";
-    }
-    /**
-     * Apply skills to an agent based on its capabilities.
-     *
-     * @param capabilities - Agent's discovered capabilities
-     * @param cwd - Project working directory
-     * @returns Skill prompt text (for "prompt" method) or empty string (for "native" method)
-     */
-    applySkills(capabilities, cwd) {
-        const method = this.getInjectionMethod(capabilities);
-        if (method === "native" && capabilities?.skillsDirs?.length) {
-            for (const dir of capabilities.skillsDirs) {
-                const targetDir = join(cwd ?? process.cwd(), dir);
-                this.syncSkillsToDir(targetDir, cwd);
-            }
-            return "";
-        }
-        // Prompt injection fallback
-        return this.buildPromptWithSkills(cwd);
-    }
-    // ── Internal Helpers ──────────────────────────────────────
-    /**
-     * Collect all skill file paths from project-level and user-level dirs.
-     * Skills are stored as `<dir>/<skillName>/SKILL.md`.
-     * Priority: project > global (project listed first for budget-constrained injection).
-     */
-    collectSkillPaths(cwd) {
-        // Single global store + per-project manifest: the resolver yields exactly
-        // the skills effective in this project, already deduped by name.
-        return resolveActiveSkills(cwd)
-            .filter((s) => !isSystemGeneratedSkillName(s.name))
-            .map((s) => s.filePath);
-    }
-}

package/dist/runtime/infra/skill-injector.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/runtime/infra/skill-injector.test.js

@@ -1,9 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { isSystemGeneratedSkillName } from "./skill-injector.js";
-describe("skill injector", () => {
-    it("does not treat generated orchestration skills as user skills", () => {
-        expect(isSystemGeneratedSkillName("auto-skill-exec-memory-read")).toBe(true);
-        expect(isSystemGeneratedSkillName("test-skill-1778828263490")).toBe(true);
-        expect(isSystemGeneratedSkillName("express-health-check")).toBe(false);
-    });
-});

package/dist/runtime/infra/skill-resolver.d.ts

@@ -1,51 +0,0 @@
-/**
- * Skill resolver — single source of truth for "which skills are effective in a
- * given project" under the global-single-store + per-project-manifest model.
- *
- * Storage: ONE global store at getUserSkillsDir(). A skill is project-scoped if
- * it appears in the owner-level project-scoped registry (skills-scoped.json);
- * otherwise it is global. Project-scoped skills are active only where the
- * project manifest (skills-enabled.json) lists them.
- *
- *   effective(project) = { store skills NOT marked project-scoped }
- *                      ∪ { project-scoped skills whose name ∈ project manifest }
- *
- * All resolution / listing / injection surfaces MUST go through this module so
- * precedence and name-collision semantics live in exactly one place. Kept in
- * runtime/infra (no skills-layer imports) so both runtime and cli callers may
- * use it without crossing the runtime → skills boundary.
- */
-export interface ResolvedSkill {
-    name: string;
-    /** Absolute path to <store>/<name>/SKILL.md */
-    filePath: string;
-    /** Absolute path to <store>/<name> */
-    baseDir: string;
-    enabledScope: "global" | "project";
-    /** Active in the resolution context: global, or project-enabled via manifest. */
-    active: boolean;
-    systemGenerated: boolean;
-    description?: string;
-    version?: string;
-}
-export declare function isSystemGeneratedSkillName(name: string): boolean;
-/**
- * Resolve all skills in the global store, annotated with enablement scope and
- * whether they're active in the given project context.
- *
- * Returns ALL store skills (active and inactive) so listing surfaces can show
- * enable/disable state; callers that only want active skills filter `.active`
- * (or use resolveActiveSkills).
- */
-export declare function resolveSkills(projectRoot?: string): ResolvedSkill[];
-/** Only the skills active in the given project (for prompt injection / resolution). */
-export declare function resolveActiveSkills(projectRoot?: string): ResolvedSkill[];
-/**
- * Resolve a single skill by name to its store paths, or null if not present.
- * Resolution honors only the global store (single source of truth) and ignores
- * enablement — any stored skill is invocable by explicit name.
- */
-export declare function resolveSkillPath(name: string): {
-    baseDir: string;
-    filePath: string;
-} | null;

package/dist/runtime/infra/skill-resolver.js

@@ -1,109 +0,0 @@
-/**
- * Skill resolver — single source of truth for "which skills are effective in a
- * given project" under the global-single-store + per-project-manifest model.
- *
- * Storage: ONE global store at getUserSkillsDir(). A skill is project-scoped if
- * it appears in the owner-level project-scoped registry (skills-scoped.json);
- * otherwise it is global. Project-scoped skills are active only where the
- * project manifest (skills-enabled.json) lists them.
- *
- *   effective(project) = { store skills NOT marked project-scoped }
- *                      ∪ { project-scoped skills whose name ∈ project manifest }
- *
- * All resolution / listing / injection surfaces MUST go through this module so
- * precedence and name-collision semantics live in exactly one place. Kept in
- * runtime/infra (no skills-layer imports) so both runtime and cli callers may
- * use it without crossing the runtime → skills boundary.
- */
-import { existsSync, readdirSync, readFileSync, statSync } from "node:fs";
-import { join } from "node:path";
-import { getUserSkillsDir } from "./agent-paths.js";
-import { readEnabledSkills, readGloballyDisabledSkills, readProjectScopedSkills } from "./project-skill-manifest.js";
-const SYSTEM_GENERATED_PREFIXES = ["auto-skill-", "test-skill-"];
-export function isSystemGeneratedSkillName(name) {
-    return SYSTEM_GENERATED_PREFIXES.some((p) => name.startsWith(p));
-}
-function extractMeta(content) {
-    const versionMatch = content.match(/^---\n[\s\S]*?^version:\s*(\S+)/m);
-    const descMatch = content.match(/^---\n[\s\S]*?^description:\s*(.+)/m);
-    return { version: versionMatch?.[1], description: descMatch?.[1]?.trim() };
-}
-/**
- * Resolve all skills in the global store, annotated with enablement scope and
- * whether they're active in the given project context.
- *
- * Returns ALL store skills (active and inactive) so listing surfaces can show
- * enable/disable state; callers that only want active skills filter `.active`
- * (or use resolveActiveSkills).
- */
-export function resolveSkills(projectRoot) {
-    const storeDir = getUserSkillsDir();
-    if (!existsSync(storeDir))
-        return [];
-    const scoped = readProjectScopedSkills();
-    const enabled = projectRoot ? readEnabledSkills(projectRoot) : new Set();
-    // Global mute list (the plugin card's off switch): a global skill in this set
-    // is inactive everywhere; resolveActiveSkills/injection honor it via `active`.
-    const disabled = readGloballyDisabledSkills();
-    let entries;
-    try {
-        entries = readdirSync(storeDir, { withFileTypes: true });
-    }
-    catch {
-        return [];
-    }
-    const out = [];
-    for (const entry of entries) {
-        if (!entry.isDirectory())
-            continue;
-        if (entry.name.startsWith("."))
-            continue; // skip .archive and similar
-        const baseDir = join(storeDir, entry.name);
-        const filePath = join(baseDir, "SKILL.md");
-        let content;
-        try {
-            if (!statSync(filePath).isFile())
-                continue;
-            content = readFileSync(filePath, "utf8");
-        }
-        catch {
-            continue; // no readable SKILL.md — not resolvable
-        }
-        const isScoped = scoped.has(entry.name);
-        const enabledScope = isScoped ? "project" : "global";
-        const active = isScoped ? enabled.has(entry.name) : !disabled.has(entry.name);
-        const meta = extractMeta(content);
-        out.push({
-            name: entry.name,
-            filePath,
-            baseDir,
-            enabledScope,
-            active,
-            systemGenerated: isSystemGeneratedSkillName(entry.name),
-            description: meta.description,
-            version: meta.version,
-        });
-    }
-    return out;
-}
-/** Only the skills active in the given project (for prompt injection / resolution). */
-export function resolveActiveSkills(projectRoot) {
-    return resolveSkills(projectRoot).filter((s) => s.active);
-}
-/**
- * Resolve a single skill by name to its store paths, or null if not present.
- * Resolution honors only the global store (single source of truth) and ignores
- * enablement — any stored skill is invocable by explicit name.
- */
-export function resolveSkillPath(name) {
-    const baseDir = join(getUserSkillsDir(), name);
-    const filePath = join(baseDir, "SKILL.md");
-    try {
-        if (statSync(filePath).isFile())
-            return { baseDir, filePath };
-    }
-    catch {
-        /* not found */
-    }
-    return null;
-}

package/dist/runtime/infra/skill-resolver.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/runtime/infra/skill-resolver.test.js

@@ -1,72 +0,0 @@
-import * as fs from "node:fs";
-import * as os from "node:os";
-import * as path from "node:path";
-import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
-import { getUserSkillsDir } from "./agent-paths.js";
-import { resolveSkills, resolveActiveSkills, resolveSkillPath } from "./skill-resolver.js";
-import { enableSkill, markProjectScoped } from "./project-skill-manifest.js";
-function tmp(prefix) {
-    return fs.mkdtempSync(path.join(os.tmpdir(), prefix));
-}
-function writeSkill(store, name, body = `---\ndescription: ${name} desc\nversion: 1.0.0\n---\n# ${name}\n`) {
-    const dir = path.join(store, name);
-    fs.mkdirSync(dir, { recursive: true });
-    fs.writeFileSync(path.join(dir, "SKILL.md"), body, "utf8");
-}
-describe("skill-resolver", () => {
-    let project;
-    beforeEach(() => {
-        vi.stubEnv("QLOGICAGENT_HOME", tmp("qlogic-resolver-home-"));
-        project = tmp("qlogic-resolver-proj-");
-    });
-    afterEach(() => vi.unstubAllEnvs());
-    it("treats unmarked store skills as global (active everywhere)", () => {
-        const store = getUserSkillsDir();
-        writeSkill(store, "global-skill");
-        const resolved = resolveSkills(project);
-        expect(resolved).toHaveLength(1);
-        expect(resolved[0]).toMatchObject({ name: "global-skill", enabledScope: "global", active: true });
-        expect(resolveActiveSkills(project).map(s => s.name)).toEqual(["global-skill"]);
-    });
-    it("project-scoped skills are inactive unless the project manifest enables them", () => {
-        const store = getUserSkillsDir();
-        writeSkill(store, "learned-skill");
-        markProjectScoped("learned-skill");
-        expect(resolveSkills(project)[0]).toMatchObject({ enabledScope: "project", active: false });
-        expect(resolveActiveSkills(project)).toHaveLength(0);
-        enableSkill(project, "learned-skill");
-        expect(resolveSkills(project)[0]).toMatchObject({ enabledScope: "project", active: true });
-        expect(resolveActiveSkills(project).map(s => s.name)).toEqual(["learned-skill"]);
-    });
-    it("scoping is per-project: enabled in A stays inactive in B", () => {
-        const store = getUserSkillsDir();
-        writeSkill(store, "alpha");
-        markProjectScoped("alpha");
-        const projectB = tmp("qlogic-resolver-projB-");
-        enableSkill(project, "alpha");
-        expect(resolveActiveSkills(project).map(s => s.name)).toEqual(["alpha"]);
-        expect(resolveActiveSkills(projectB)).toHaveLength(0);
-    });
-    it("emits one entry per store name (no duplicate listing) and parses meta", () => {
-        const store = getUserSkillsDir();
-        writeSkill(store, "dup");
-        const resolved = resolveSkills(project);
-        expect(resolved.filter(s => s.name === "dup")).toHaveLength(1);
-        expect(resolved[0]).toMatchObject({ description: "dup desc", version: "1.0.0" });
-    });
-    it("resolveSkillPath finds any stored skill by name regardless of scope", () => {
-        const store = getUserSkillsDir();
-        writeSkill(store, "scoped");
-        markProjectScoped("scoped"); // inactive in project, but still resolvable by name
-        expect(resolveSkillPath("scoped")?.filePath).toBe(path.join(store, "scoped", "SKILL.md"));
-        expect(resolveSkillPath("nope")).toBeNull();
-    });
-    it("skips .archive and dirs without SKILL.md", () => {
-        const store = getUserSkillsDir();
-        fs.mkdirSync(path.join(store, ".archive", "old"), { recursive: true });
-        fs.writeFileSync(path.join(store, ".archive", "old", "SKILL.md"), "x", "utf8");
-        fs.mkdirSync(path.join(store, "empty"), { recursive: true }); // no SKILL.md
-        writeSkill(store, "real");
-        expect(resolveSkills(project).map(s => s.name)).toEqual(["real"]);
-    });
-});

package/dist/runtime/infra/task-runtime.d.ts

@@ -1,71 +0,0 @@
-/**
- * Task Runtime — CC framework.ts parity.
- *
- * Manages task lifecycle: creation, state updates, completion, cleanup.
- * All task types (local_bash, local_agent, dream, etc.) use this framework.
- *
- * CC equivalent: src/utils/task/framework.ts + src/Task.ts
- *
- * Architecture note: CC uses React-style setAppState(prev => next). We use
- * a simple Map-based store since we're in a subprocess (no React).
- */
-import type { TaskState, TaskType, TaskLifecycle } from "../tasks/task-types.js";
-import type { HookRegistry } from "../../contracts/hooks.js";
-/** Grace period for terminal tasks before eviction (ms) */
-export declare const PANEL_GRACE_MS = 30000;
-export declare function generateTaskId(type: TaskType): string;
-/**
- * In-memory task store — replaces CC's AppState.tasks.
- *
- * Thread-safe for single-process use. All mutations go through
- * updateTaskState / registerTask for consistency.
- */
-export declare class TaskStore {
-    private tasks;
-    private listeners;
-    private hooks;
-    private sessionId;
-    /** Attach a hook registry to fire task.created / task.completed hooks. */
-    setHooks(hooks: HookRegistry, sessionId: string): void;
-    /**
-     * Register a listener for task state changes.
-     * @returns Unregister function
-     */
-    onTaskChange(listener: (taskId: string, task: TaskState | null) => void): () => void;
-    private notify;
-    /**
-     * Register a new task.
-     */
-    registerTask(task: TaskState): void;
-    /**
-     * Update a task's state via an updater function.
-     * CC equivalent: updateTaskState()
-     */
-    updateTask<T extends TaskState>(taskId: string, updater: (task: T) => T): void;
-    /**
-     * Get a task by ID.
-     */
-    getTask(taskId: string): TaskState | undefined;
-    /**
-     * Get all running tasks.
-     */
-    getRunningTasks(): TaskState[];
-    /**
-     * Get all tasks.
-     */
-    getAllTasks(): TaskState[];
-    /**
-     * Evict a terminal task from the store.
-     */
-    evictTask(taskId: string): void;
-    /**
-     * Evict all terminal tasks that have passed their grace period.
-     */
-    evictStaleTasks(graceMs?: number): void;
-}
-export declare function isTerminalLifecycle(lifecycle: TaskLifecycle): boolean;
-/**
- * Build a task notification message in CC's XML format.
- * This is injected into the conversation as context for the model.
- */
-export declare function buildTaskNotification(task: TaskState, summary: string): string;

package/dist/runtime/infra/task-runtime.js

@@ -1,181 +0,0 @@
-/**
- * Task Runtime — CC framework.ts parity.
- *
- * Manages task lifecycle: creation, state updates, completion, cleanup.
- * All task types (local_bash, local_agent, dream, etc.) use this framework.
- *
- * CC equivalent: src/utils/task/framework.ts + src/Task.ts
- *
- * Architecture note: CC uses React-style setAppState(prev => next). We use
- * a simple Map-based store since we're in a subprocess (no React).
- */
-import { randomUUID } from "node:crypto";
-// ── Constants (CC parity) ───────────────────────────────────
-/** Grace period for terminal tasks before eviction (ms) */
-export const PANEL_GRACE_MS = 30_000;
-// ── Task ID Generation (CC parity) ──────────────────────────
-/**
- * Generate a task ID with type prefix.
- *
- * CC format: prefix + 8 base36 chars (36^8 ≈ 2.8T combinations)
- *   a = local_agent
- *   b = local_bash
- *   d = dream
- *   t = team_member
- *   r = remote_agent
- *   w = local_workflow
- *   m = monitor_mcp
- */
-const TASK_PREFIX = {
-    local_agent: "a",
-    local_bash: "b",
-    dream: "d",
-    team_member: "t",
-    remote_agent: "r",
-    local_workflow: "w",
-    monitor_mcp: "m",
-};
-export function generateTaskId(type) {
-    const prefix = TASK_PREFIX[type] ?? "x";
-    // 8 chars of base36 from random UUID
-    const random = randomUUID().replace(/-/g, "").slice(0, 8);
-    const base36 = parseInt(random, 16).toString(36).slice(0, 8).padStart(8, "0");
-    return `${prefix}${base36}`;
-}
-// ── Task Store ──────────────────────────────────────────────
-/**
- * In-memory task store — replaces CC's AppState.tasks.
- *
- * Thread-safe for single-process use. All mutations go through
- * updateTaskState / registerTask for consistency.
- */
-export class TaskStore {
-    tasks = new Map();
-    listeners = new Set();
-    hooks = null;
-    sessionId = "";
-    /** Attach a hook registry to fire task.created / task.completed hooks. */
-    setHooks(hooks, sessionId) {
-        this.hooks = hooks;
-        this.sessionId = sessionId;
-    }
-    /**
-     * Register a listener for task state changes.
-     * @returns Unregister function
-     */
-    onTaskChange(listener) {
-        this.listeners.add(listener);
-        return () => this.listeners.delete(listener);
-    }
-    notify(taskId, task) {
-        for (const listener of this.listeners) {
-            try {
-                listener(taskId, task);
-            }
-            catch { /* non-blocking */ }
-        }
-    }
-    /**
-     * Register a new task.
-     */
-    registerTask(task) {
-        this.tasks.set(task.taskId, task);
-        this.notify(task.taskId, task);
-        this.hooks?.invoke("task.created", {
-            sessionId: this.sessionId,
-            taskId: task.taskId,
-            taskType: task.type,
-            label: task.label,
-        }).catch(() => { });
-    }
-    /**
-     * Update a task's state via an updater function.
-     * CC equivalent: updateTaskState()
-     */
-    updateTask(taskId, updater) {
-        const existing = this.tasks.get(taskId);
-        if (!existing)
-            return;
-        const updated = updater(existing);
-        if (updated === existing)
-            return; // No change
-        this.tasks.set(taskId, updated);
-        this.notify(taskId, updated);
-        // Fire task.completed when transitioning to a terminal lifecycle
-        if (!isTerminalLifecycle(existing.lifecycle) && isTerminalLifecycle(updated.lifecycle)) {
-            this.hooks?.invoke("task.completed", {
-                sessionId: this.sessionId,
-                taskId: updated.taskId,
-                taskType: updated.type,
-                label: updated.label,
-            }).catch(() => { });
-        }
-    }
-    /**
-     * Get a task by ID.
-     */
-    getTask(taskId) {
-        return this.tasks.get(taskId);
-    }
-    /**
-     * Get all running tasks.
-     */
-    getRunningTasks() {
-        return [...this.tasks.values()].filter(t => t.lifecycle === "running");
-    }
-    /**
-     * Get all tasks.
-     */
-    getAllTasks() {
-        return [...this.tasks.values()];
-    }
-    /**
-     * Evict a terminal task from the store.
-     */
-    evictTask(taskId) {
-        const task = this.tasks.get(taskId);
-        if (!task)
-            return;
-        if (!isTerminalLifecycle(task.lifecycle))
-            return;
-        this.tasks.delete(taskId);
-        this.notify(taskId, null);
-    }
-    /**
-     * Evict all terminal tasks that have passed their grace period.
-     */
-    evictStaleTasks(graceMs = PANEL_GRACE_MS) {
-        const now = Date.now();
-        for (const [taskId, task] of this.tasks) {
-            if (isTerminalLifecycle(task.lifecycle) && task.endedAt) {
-                if (now - task.endedAt > graceMs) {
-                    this.tasks.delete(taskId);
-                    this.notify(taskId, null);
-                }
-            }
-        }
-    }
-}
-// ── Lifecycle Helpers ───────────────────────────────────────
-export function isTerminalLifecycle(lifecycle) {
-    return lifecycle === "completed" || lifecycle === "failed" || lifecycle === "cancelled" || lifecycle === "timeout";
-}
-// ── Task Notification (CC XML format parity) ────────────────
-/**
- * Build a task notification message in CC's XML format.
- * This is injected into the conversation as context for the model.
- */
-export function buildTaskNotification(task, summary) {
-    const statusText = task.lifecycle === "completed" ? "completed successfully"
-        : task.lifecycle === "failed" ? "failed"
-            : task.lifecycle === "cancelled" ? "was stopped"
-                : task.lifecycle === "running" ? "is running"
-                    : "is pending";
-    return `<task_notification>
-<task_id>${task.taskId}</task_id>
-<task_type>${task.type}</task_type>
-<status>${task.lifecycle}</status>
-<summary>Task "${task.label}" ${statusText}</summary>
-${summary ? `<result>${summary}</result>` : ""}
-</task_notification>`;
-}