qlogicagent 2.13.5 → 2.13.7

package/dist/cli/handlers/config-handler.tools-list.test.js

@@ -1,93 +0,0 @@
-import * as fs from "node:fs";
-import * as os from "node:os";
-import * as path from "node:path";
-import { afterEach, describe, expect, it } from "vitest";
-import { createToolCatalogFixture } from "../test-support/tool-catalog-fixture.js";
-import { getAllBaseTools, setMediaClientConfig } from "../tool-bootstrap.js";
-import { handleToolsList } from "./config-handler.js";
-const tmpRoots = [];
-function createWorkdir() {
-    const root = fs.mkdtempSync(path.join(os.tmpdir(), "qlogicagent-tools-list-"));
-    tmpRoots.push(root);
-    return root;
-}
-function createMediaClient() {
-    return {
-        getTransport(providerId) {
-            return providerId === "volcengine" ? {} : undefined;
-        },
-        resolveModelById(providerId, modelId, mediaType) {
-            return {
-                providerId,
-                mediaType,
-                providerDef: { id: providerId },
-                modelInfo: {
-                    id: modelId,
-                    name: modelId,
-                    mediaType,
-                },
-            };
-        },
-    };
-}
-describe("handleToolsList", () => {
-    afterEach(() => {
-        setMediaClientConfig(undefined);
-        for (const root of tmpRoots.splice(0)) {
-            fs.rmSync(root, { recursive: true, force: true });
-        }
-    });
-    it("syncs media config before returning the manifest", () => {
-        const toolCatalog = createToolCatalogFixture();
-        getAllBaseTools({ workdir: createWorkdir(), toolCatalog });
-        let response;
-        const host = {
-            taskStore: undefined,
-            backgroundTasks: undefined,
-            toolCatalog,
-            syncToolListMediaConfig() {
-                setMediaClientConfig(createMediaClient(), { volcengine: "test-key" }, undefined, { image: { provider: "volcengine", model: "doubao-seedream-4-5" } });
-            },
-            sendResponse(_id, result) {
-                response = result;
-            },
-        };
-        const msg = {
-            jsonrpc: "2.0",
-            id: 1,
-            method: "tools.list",
-            params: { includeDeferred: true },
-        };
-        handleToolsList.call(host, msg);
-        const tools = response.tools.map(tool => tool.id);
-        expect(tools).toContain("image_generate");
-        const imageTool = toolCatalog.getToolManifest(true).find(tool => tool.function.name === "image_generate");
-        expect(imageTool?.meta?.isDangerous).toBe(false);
-    });
-    it("merges the declarative session-suite manifest, marking those tools sessionScoped", () => {
-        const toolCatalog = createToolCatalogFixture();
-        getAllBaseTools({ workdir: createWorkdir(), toolCatalog });
-        let response;
-        const host = {
-            taskStore: undefined,
-            backgroundTasks: undefined,
-            toolCatalog,
-            sendResponse(_id, result) {
-                response = result;
-            },
-        };
-        const msg = {
-            jsonrpc: "2.0",
-            id: 1,
-            method: "tools.list",
-            params: { includeDeferred: true },
-        };
-        handleToolsList.call(host, msg);
-        // agent/team etc. are registered per-session, not in the static catalog —
-        // the manifest merge surfaces them with sessionScoped=true so the UI shows
-        // the full tool surface even before a session runs.
-        const tools = response.tools;
-        expect(tools.some((tool) => tool.id === "agent" && tool.sessionScoped === true)).toBe(true);
-        expect(tools.some((tool) => tool.id === "team" && tool.sessionScoped === true)).toBe(true);
-    });
-});

package/dist/cli/handlers/control-handler.d.ts

@@ -1,23 +0,0 @@
-import { type AgentRpcError, type AgentRpcRequest } from "../../protocol/wire/index.js";
-import type { NotificationMethodMap } from "../../protocol/notifications.js";
-import type { ToolCatalog } from "../../runtime/ports/index.js";
-export interface ControlHandlerHost {
-    running: boolean;
-    startedAt: number;
-    packageVersion: string;
-    toolCatalog: ToolCatalog;
-    activeTurn: AbortController | null;
-    rpcContract: {
-        metrics(): unknown;
-        cancel(requestId: string, reason?: string): boolean;
-    };
-    log(message: string): void;
-    sendResponse(id: string | number, result?: unknown, error?: AgentRpcError): void;
-    sendNotification<M extends keyof NotificationMethodMap>(method: M, params: NotificationMethodMap[M]): void;
-    ensureDefaultProject(): void;
-}
-export declare function handleInitialize(this: ControlHandlerHost, msg: AgentRpcRequest): void;
-export declare function handlePing(this: ControlHandlerHost, msg: AgentRpcRequest): void;
-export declare function handleHealth(this: ControlHandlerHost, msg: AgentRpcRequest): void;
-export declare function handleMetrics(this: ControlHandlerHost, msg: AgentRpcRequest): void;
-export declare function handleCancel(this: ControlHandlerHost, msg: AgentRpcRequest): void;

package/dist/cli/handlers/control-handler.js

@@ -1,88 +0,0 @@
-import { ALL_RPC_METHODS } from "../../protocol/methods.js";
-import { AGENT_RPC_ERROR_CODES, AGENT_RPC_PROTOCOL_VERSION, } from "../../protocol/wire/index.js";
-export function handleInitialize(msg) {
-    const raw = msg.params;
-    const hostVersion = raw?.protocolVersion ?? "unknown";
-    const hostName = raw?.host?.name
-        ?? raw?.hostName
-        ?? "unknown";
-    const hostVer = raw?.host?.version
-        ?? raw?.hostVersion
-        ?? "?";
-    const majorHost = hostVersion.split(".")[0];
-    const majorSelf = AGENT_RPC_PROTOCOL_VERSION.split(".")[0];
-    if (majorHost !== majorSelf) {
-        this.log(`[initialize] protocol mismatch: host=${hostVersion} agent=${AGENT_RPC_PROTOCOL_VERSION}`);
-        if (msg.id !== undefined) {
-            this.sendResponse(msg.id, undefined, {
-                code: AGENT_RPC_ERROR_CODES.PROTOCOL_MISMATCH,
-                message: `Protocol version mismatch: host=${hostVersion}, agent=${AGENT_RPC_PROTOCOL_VERSION}`,
-            });
-        }
-        return;
-    }
-    this.log(`[initialize] host=${hostName} v${hostVer}`);
-    if (msg.id !== undefined) {
-        this.sendResponse(msg.id, {
-            protocolVersion: AGENT_RPC_PROTOCOL_VERSION,
-            agent: { name: "qlogicagent", version: "0.1.0" },
-            capabilities: {
-                tools: this.toolCatalog.getToolManifest().map(t => t.function.name),
-                streaming: true,
-                threads: true,
-                notifications: [
-                    "turn.start", "turn.delta", "turn.end", "turn.error",
-                    "turn.recovery", "turn.tool_call", "turn.tool_result",
-                    "turn.tool_blocked", "turn.reasoning_delta",
-                    "turn.plan_update", "turn.suggestions",
-                    "turn.subagent_started", "turn.subagent_delta",
-                    "turn.subagent_ended", "turn.media_result",
-                    "turn.todos_updated", "task.updated",
-                    "turn.exec_progress", "turn.artifact",
-                    "tool.approval.request", "turn.skill_instruction",
-                    "turn.ask_user",
-                    "memory.updated", "session.info",
-                    "permission.rule_updated", "team.updated",
-                    "turn.usage_update", "pong",
-                ],
-                methods: [...ALL_RPC_METHODS],
-            },
-        });
-    }
-    this.ensureDefaultProject();
-}
-export function handlePing(msg) {
-    if (msg.id !== undefined) {
-        this.sendResponse(msg.id, { status: "ok" });
-    }
-    this.sendNotification("pong", {});
-}
-export function handleHealth(msg) {
-    if (msg.id === undefined)
-        return;
-    this.sendResponse(msg.id, {
-        ok: true,
-        status: this.running ? "healthy" : "stopping",
-        uptimeMs: Date.now() - this.startedAt,
-        protocolVersion: AGENT_RPC_PROTOCOL_VERSION,
-        version: this.packageVersion,
-    });
-}
-export function handleMetrics(msg) {
-    if (msg.id === undefined)
-        return;
-    this.sendResponse(msg.id, { rpc: this.rpcContract.metrics() });
-}
-export function handleCancel(msg) {
-    const params = msg.params;
-    const requestId = params?.requestId;
-    const cancelled = typeof requestId === "string"
-        ? this.rpcContract.cancel(requestId, params?.reason ?? "host-cancelled")
-        : false;
-    if (cancelled && this.activeTurn) {
-        this.activeTurn.abort();
-    }
-    if (msg.id !== undefined) {
-        this.sendResponse(msg.id, { ok: true, cancelled });
-    }
-}

package/dist/cli/handlers/dream-handler.d.ts

@@ -1,31 +0,0 @@
-/**
- * Dream/memory consolidation handler — extracted from StdioServer.
- * Handles: memory.dream
- */
-import type { TurnConfig } from "../../agent/types.js";
-import type { AgentRpcError, AgentRpcRequest } from "../../protocol/wire/index.js";
-import { type DreamRunDeps } from "../../runtime/execution/dream-agent.js";
-import { type DecayCycleDeps } from "../../runtime/execution/memory-decay.js";
-import type { TaskStore } from "../../runtime/infra/task-runtime.js";
-import type { ToolCatalog } from "../../runtime/ports/index.js";
-type DreamMemoryProvider = NonNullable<DreamRunDeps["memoryProvider"]> & DecayCycleDeps["adapter"];
-export interface DreamHandlerHost {
-    activeTurn?: AbortController | null;
-    currentTransport: DreamRunDeps["transport"] | null;
-    currentApiKey: string;
-    currentModel: string;
-    currentHooks?: DreamRunDeps["hooks"] | null;
-    memoryProvider?: DreamMemoryProvider | null;
-    memoryUserId?: string;
-    toolCatalog: ToolCatalog;
-    taskStore: TaskStore;
-    verbose?: boolean;
-    log(message: string): void;
-    resolveMemoryRoot?(): string;
-    resolveTranscriptDir?(): string;
-    resolveAgent(config: TurnConfig): unknown | null;
-    sendNotification(method: string, params: Record<string, unknown>): void;
-    sendResponse(id: string | number, result?: unknown, error?: AgentRpcError): void;
-}
-export declare function handleDream(this: DreamHandlerHost, msg: AgentRpcRequest): Promise<void>;
-export {};

package/dist/cli/handlers/dream-handler.js

@@ -1,235 +0,0 @@
-/**
- * Dream/memory consolidation handler — extracted from StdioServer.
- * Handles: memory.dream
- */
-import { randomUUID } from "node:crypto";
-import * as path from "node:path";
-import { runDream } from "../../runtime/execution/dream-agent.js";
-import { runDecayCycle } from "../../runtime/execution/memory-decay.js";
-import { getUserAgentHome } from "../../runtime/infra/agent-paths.js";
-import { getModelRegistry } from "../../runtime/infra/model-registry.js";
-import { createCliForkedAgentRunner } from "../agent-runner-factory.js";
-export async function handleDream(msg) {
-    const params = (msg.params ?? {});
-    const turnId = params.turnId ?? randomUUID();
-    const sessionId = params.sessionId;
-    const config = params.config;
-    // Dream-specific context from Gateway
-    const agentHome = getUserAgentHome();
-    const memoryRoot = config?.memoryRoot || this.resolveMemoryRoot?.() || path.join(agentHome, "memory");
-    const transcriptDir = config?.transcriptDir || this.resolveTranscriptDir?.() || path.join(agentHome, "agent-logs");
-    const dreamSessionIds = config?.dreamSessionIds ?? [];
-    if (msg.id !== undefined) {
-        this.sendResponse(msg.id, { accepted: true, turnId });
-    }
-    const ac = new AbortController();
-    this.activeTurn = ac;
-    this.log(`dream ${turnId} starting (session: ${sessionId}, sessions reviewing: ${dreamSessionIds.length})`);
-    // Notify UI: dream starting
-    this.sendNotification("system.activity", {
-        category: "dream",
-        level: "info",
-        title: "梦境整理启动",
-        detail: `正在回顾 ${dreamSessionIds.length} 个会话的记忆...`,
-    });
-    // Ensure agent is resolved for LLM config
-    const turnConfig = {
-        provider: config?.provider,
-        model: config?.model,
-        apiKey: config?.apiKey,
-        baseUrl: config?.baseUrl,
-        maxRounds: config?.maxRounds,
-        temperature: config?.temperature,
-        contextWindowTokens: config?.contextWindowTokens,
-        maxOutputTokens: config?.maxOutputTokens,
-        modelMaxOutputTokens: config?.modelMaxOutputTokens,
-        reasoning: config?.reasoning,
-        promptCacheKey: config?.promptCacheKey,
-        promptCacheRetention: config?.promptCacheRetention,
-        serviceTier: config?.serviceTier,
-        openaiBuiltinTools: config?.openaiBuiltinTools,
-        maxToolCalls: config?.maxToolCalls,
-        parallelToolCalls: config?.parallelToolCalls,
-        textVerbosity: config?.textVerbosity,
-    };
-    // Inject streamRequired and contextWindowTokens from model metadata
-    {
-        const pId = turnConfig.provider ?? "";
-        const mId = turnConfig.model ?? "";
-        if (pId && mId) {
-            const modelInfo = getModelRegistry().getModelInfo(pId, mId);
-            if (modelInfo?.streamRequired) {
-                turnConfig.streamRequired = true;
-            }
-            if (!turnConfig.contextWindowTokens && modelInfo?.contextWindow) {
-                turnConfig.contextWindowTokens = modelInfo.contextWindow;
-            }
-        }
-    }
-    const agent = this.resolveAgent(turnConfig);
-    if (!agent || !this.currentTransport) {
-        this.sendNotification("turn.start", { turnId });
-        this.sendNotification("turn.error", {
-            turnId,
-            error: { message: "No LLM provider configured for dream.", code: "NO_PROVIDER" },
-        });
-        return;
-    }
-    this.sendNotification("turn.start", { turnId });
-    try {
-        // Use runDream with forked agent isolation (CC parity)
-        const dreamDeps = {
-            context: {
-                memoryRoot,
-                transcriptDir,
-                currentSessionId: sessionId,
-                listSessionsSince: async () => dreamSessionIds,
-                currentSessionTurnCount: config?.currentSessionTurnCount ?? 0,
-            },
-            triggerConfig: { force: config?.force !== false }, // Default force=true for on-demand; idle dream passes force=false
-            transport: this.currentTransport,
-            toolInvoker: {
-                invoke: async (_tid, name, args, signal) => {
-                    if (name.startsWith("$"))
-                        return { result: args };
-                    const localTool = this.toolCatalog.findTool(name);
-                    if (!localTool || typeof localTool.execute !== "function")
-                        return { result: "", error: `Unknown tool: ${name}` };
-                    const callId = `tc_${randomUUID().slice(0, 8)}`;
-                    try {
-                        const parsedArgs = JSON.parse(args);
-                        const result = await localTool.execute(callId, parsedArgs, signal);
-                        const resultText = result.content.map(c => c.text ?? "").join("\n");
-                        return { result: resultText, error: result.details?.error };
-                    }
-                    catch (err) {
-                        return { result: "", error: err instanceof Error ? err.message : String(err) };
-                    }
-                },
-            },
-            createAgentRunner: createCliForkedAgentRunner,
-            tools: this.toolCatalog.getToolManifest(),
-            taskStore: this.taskStore,
-            apiKey: this.currentApiKey,
-            model: turnConfig.model ?? this.currentModel,
-            log: {
-                info: (m) => this.log(m),
-                warn: (m) => this.log(`[warn] ${m}`),
-                error: (m) => this.log(`[error] ${m}`),
-                debug: (m) => { if (this.verbose)
-                    this.log(`[debug] ${m}`); },
-            },
-            hooks: this.currentHooks ?? undefined,
-            parentSignal: ac.signal,
-            // Hippocampus bridge: pass local memory provider to Dream if available
-            memoryProvider: this.memoryProvider ?? undefined,
-            memoryUserId: this.memoryUserId || undefined,
-        };
-        const result = await runDream(dreamDeps);
-        if (result.ok) {
-            // P7: Trigger importance decay after successful Dream consolidation
-            if (this.memoryProvider && this.memoryUserId) {
-                try {
-                    const decayResult = await runDecayCycle({
-                        adapter: this.memoryProvider,
-                        userId: this.memoryUserId,
-                        memoryRoot,
-                        log: { info: (m) => this.log(m), debug: (m) => { if (this.verbose)
-                                this.log(m); } },
-                    });
-                    if (decayResult.ran) {
-                        this.sendNotification("memory.decay.completed", {
-                            decayed: decayResult.decayed,
-                            archived: decayResult.archived,
-                            durationMs: decayResult.durationMs,
-                        });
-                        this.sendNotification("system.activity", {
-                            category: "decay",
-                            level: "info",
-                            title: "记忆衰减完成",
-                            detail: `衰减 ${decayResult.decayed} 条，归档 ${decayResult.archived} 条 (${decayResult.durationMs}ms)`,
-                        });
-                    }
-                }
-                catch (err) {
-                    this.log(`[decay] post-dream decay error: ${err instanceof Error ? err.message : String(err)}`);
-                }
-                // Drain the consolidation backlog: resolve accumulated conflicts and
-                // promote corroborated pending claims (otherwise proposals/conflicts
-                // pile up unbounded — the "proposals black hole").
-                try {
-                    const provider = this.memoryProvider;
-                    if (typeof provider.resolveConflicts === "function") {
-                        const r = await provider.resolveConflicts(this.memoryUserId);
-                        if (r.conflictsResolved > 0 || r.claimsPromoted > 0) {
-                            this.log(`[dream] resolved ${r.conflictsResolved} conflicts, promoted ${r.claimsPromoted} pending claims`);
-                            this.sendNotification("system.activity", {
-                                category: "consolidation",
-                                level: "info",
-                                title: "记忆冲突整理",
-                                detail: `解决 ${r.conflictsResolved} 处冲突，确认 ${r.claimsPromoted} 条待定记忆`,
-                            });
-                        }
-                    }
-                }
-                catch (err) {
-                    this.log(`[consolidation] post-dream conflict resolution error: ${err instanceof Error ? err.message : String(err)}`);
-                }
-            }
-            this.sendNotification("system.activity", {
-                category: "dream",
-                level: "success",
-                title: "梦境整理完成",
-                detail: `回顾 ${result.sessionsReviewed} 个会话，整理 ${result.filesTouched.length} 个记忆文件，耗时 ${result.durationMs}ms`,
-            });
-            this.sendNotification("memory.updated", {
-                source: "dream",
-                target: "consolidation",
-                files: result.filesTouched,
-            });
-            this.sendNotification("turn.end", {
-                turnId,
-                content: `Dream consolidation completed. ${result.sessionsReviewed} sessions reviewed, ${result.filesTouched.length} files touched. Duration: ${result.durationMs}ms.`,
-                usage: { inputTokens: 0, outputTokens: 0 },
-            });
-        }
-        else {
-            this.sendNotification("system.activity", {
-                category: "dream",
-                level: "error",
-                title: "梦境整理失败",
-                detail: result.error ?? "未知错误",
-            });
-            this.sendNotification("turn.error", {
-                turnId,
-                error: { message: result.error ?? "Dream consolidation failed", code: "DREAM_FAILED" },
-            });
-        }
-        this.log(`dream ${turnId} completed`);
-    }
-    catch (err) {
-        if (ac.signal.aborted) {
-            this.sendNotification("system.activity", {
-                category: "dream",
-                level: "warn",
-                title: "梦境整理被中断",
-            });
-            this.sendNotification("turn.error", { turnId, error: { message: "Dream aborted", code: "ABORTED" } });
-        }
-        else {
-            const message = err instanceof Error ? err.message : String(err);
-            this.sendNotification("system.activity", {
-                category: "dream",
-                level: "error",
-                title: "梦境整理异常",
-                detail: message,
-            });
-            this.sendNotification("turn.error", { turnId, error: { message, code: "INTERNAL_ERROR" } });
-        }
-    }
-    finally {
-        if (this.activeTurn === ac) {
-            this.activeTurn = null;
-        }
-    }
-}

package/dist/cli/handlers/files-handler.d.ts

@@ -1,22 +0,0 @@
-/**
- * Files + Instructions handlers — extracted from StdioServer.
- * Handles: files.list, files.create, files.rename, files.delete, files.gitStatus,
- *          instructions.list, instructions.read, instructions.write, instructions.delete
- */
-import { type AgentRpcError, type AgentRpcRequest } from "../../protocol/wire/index.js";
-export interface FilesHandlerHost {
-    getActiveProjectRoot(): string;
-    sendResponse(id: string | number, result?: unknown, error?: AgentRpcError): void;
-}
-export declare function resolveProjectDir(projectId: string): string | null;
-export declare function handleFilesList(this: FilesHandlerHost, msg: AgentRpcRequest): Promise<void>;
-export declare function handleFilesCreate(this: FilesHandlerHost, msg: AgentRpcRequest): Promise<void>;
-export declare function handleFilesRead(this: FilesHandlerHost, msg: AgentRpcRequest): Promise<void>;
-export declare function handleFilesRename(this: FilesHandlerHost, msg: AgentRpcRequest): Promise<void>;
-export declare function handleFilesDelete(this: FilesHandlerHost, msg: AgentRpcRequest): Promise<void>;
-export declare function handleFilesGitStatus(this: FilesHandlerHost, msg: AgentRpcRequest): Promise<void>;
-export declare function handleInstructionsList(this: FilesHandlerHost, msg: AgentRpcRequest): void;
-export declare function handleInstructionsRead(this: FilesHandlerHost, msg: AgentRpcRequest): void;
-export declare function handleInstructionsWrite(this: FilesHandlerHost, msg: AgentRpcRequest): void;
-export declare function handleInstructionsDelete(this: FilesHandlerHost, msg: AgentRpcRequest): void;
-export declare function handlePlansList(this: FilesHandlerHost, msg: AgentRpcRequest): void;

package/dist/cli/handlers/files-handler.instructions.test.d.ts

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

package/dist/cli/handlers/files-handler.instructions.test.js

@@ -1,127 +0,0 @@
-import * as fs from "node:fs";
-import * as os from "node:os";
-import * as path from "node:path";
-import { afterEach, describe, expect, it } from "vitest";
-import { handleInstructionsDelete, handleInstructionsList, handleInstructionsRead, handleInstructionsWrite, handlePlansList } from "./files-handler.js";
-const tempDirs = [];
-function createHost(projectRoot) {
-    const responses = [];
-    return {
-        responses,
-        getActiveProjectRoot: () => projectRoot,
-        sendResponse(id, result, error) {
-            responses.push({ id, result, error });
-        },
-    };
-}
-function createProjectRoot() {
-    const dir = fs.mkdtempSync(path.join(os.tmpdir(), "qlogicagent-instructions-"));
-    tempDirs.push(dir);
-    return dir;
-}
-afterEach(() => {
-    for (const dir of tempDirs.splice(0)) {
-        fs.rmSync(dir, { recursive: true, force: true });
-    }
-});
-describe("instructions handler", () => {
-    it("does not list legacy instructions directory entries", () => {
-        const projectRoot = createProjectRoot();
-        const legacyDir = path.join(projectRoot, ".qlogicagent", "instructions");
-        fs.mkdirSync(legacyDir, { recursive: true });
-        fs.writeFileSync(path.join(legacyDir, "pcb-rules.md"), "# PCB Rules", "utf8");
-        const host = createHost(projectRoot);
-        handleInstructionsList.call(host, {
-            jsonrpc: "2.0",
-            id: 1,
-            method: "instructions.list",
-            params: {},
-        });
-        expect(host.responses[0].result).toMatchObject({
-            instructions: [],
-        });
-    });
-    it("rejects legacy instructions directory read paths", () => {
-        const projectRoot = createProjectRoot();
-        const legacyDir = path.join(projectRoot, ".qlogicagent", "instructions");
-        fs.mkdirSync(legacyDir, { recursive: true });
-        fs.writeFileSync(path.join(legacyDir, "pcb-rules.md"), "# PCB Rules\nUse thermal relief.", "utf8");
-        const host = createHost(projectRoot);
-        handleInstructionsRead.call(host, {
-            jsonrpc: "2.0",
-            id: 1,
-            method: "instructions.read",
-            params: { path: "instructions/pcb-rules.md" },
-        });
-        expect(host.responses[0].result).toBeUndefined();
-        expect(host.responses[0].error).toMatchObject({
-            message: expect.stringContaining("not found"),
-        });
-    });
-    it("round-trips top-level INSTRUCTIONS.md through write/read", () => {
-        const projectRoot = createProjectRoot();
-        const host = createHost(projectRoot);
-        handleInstructionsWrite.call(host, {
-            jsonrpc: "2.0",
-            id: 1,
-            method: "instructions.write",
-            params: {
-                path: "INSTRUCTIONS.md",
-                content: "# Project Instructions\nDo not break anything.",
-            },
-        });
-        handleInstructionsRead.call(host, {
-            jsonrpc: "2.0",
-            id: 2,
-            method: "instructions.read",
-            params: { path: "INSTRUCTIONS.md" },
-        });
-        expect(host.responses[0]).toMatchObject({ id: 1, result: { ok: true } });
-        expect(host.responses[1].error).toBeUndefined();
-        expect(host.responses[1].result).toMatchObject({
-            content: "# Project Instructions\nDo not break anything.",
-        });
-        expect(fs.readFileSync(path.join(projectRoot, ".qlogicagent", "INSTRUCTIONS.md"), "utf8"))
-            .toContain("Do not break anything.");
-    });
-    it("deletes top-level INSTRUCTIONS.md from the project agent directory", () => {
-        const projectRoot = createProjectRoot();
-        const agentDir = path.join(projectRoot, ".qlogicagent");
-        fs.mkdirSync(agentDir, { recursive: true });
-        fs.writeFileSync(path.join(agentDir, "INSTRUCTIONS.md"), "# Project Instructions\nDelete me.", "utf8");
-        const host = createHost(projectRoot);
-        handleInstructionsDelete.call(host, {
-            jsonrpc: "2.0",
-            id: 1,
-            method: "instructions.delete",
-            params: { path: "INSTRUCTIONS.md" },
-        });
-        expect(host.responses[0]).toMatchObject({ id: 1, result: { ok: true } });
-        expect(fs.existsSync(path.join(agentDir, "INSTRUCTIONS.md"))).toBe(false);
-    });
-});
-describe("plans handler", () => {
-    it("lists project plans with slug and frontmatter metadata", () => {
-        const projectRoot = createProjectRoot();
-        const plansDir = path.join(projectRoot, ".qlogicagent", "plans");
-        fs.mkdirSync(plansDir, { recursive: true });
-        fs.writeFileSync(path.join(plansDir, "schematic-review.md"), "---\ntitle: Schematic Review Plan\nstatus: active\n---\n\n## Steps\nReview power.", "utf8");
-        const host = createHost(projectRoot);
-        handlePlansList.call(host, {
-            jsonrpc: "2.0",
-            id: 1,
-            method: "plans.list",
-            params: {},
-        });
-        expect(host.responses[0].error).toBeUndefined();
-        expect(host.responses[0].result).toMatchObject({
-            plans: [
-                expect.objectContaining({
-                    slug: "schematic-review",
-                    title: "Schematic Review Plan",
-                    status: "active",
-                }),
-            ],
-        });
-    });
-});