qlogicagent 2.13.3 → 2.13.5

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

@@ -0,0 +1,93 @@
+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

@@ -0,0 +1,23 @@
+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

@@ -0,0 +1,88 @@
+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

@@ -0,0 +1,31 @@
+/**
+ * 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

@@ -0,0 +1,235 @@
+/**
+ * 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

@@ -0,0 +1,22 @@
+/**
+ * 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

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

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

@@ -0,0 +1,127 @@
+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",
+                }),
+            ],
+        });
+    });
+});