qlogicagent 2.13.3 → 2.13.5

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

@@ -0,0 +1,421 @@
+/**
+ * Project CRUD handlers extracted from StdioServer.
+ * Handles: project.create, project.list, project.delete, project.rename,
+ *          project.archive, project.unarchive, project.archiveByGroup
+ */
+import * as fs from "node:fs";
+import * as path from "node:path";
+import * as projectStore from "../../runtime/infra/project-store.js";
+import { getUserAgentHome } from "../../runtime/infra/agent-paths.js";
+import { AGENT_RPC_ERROR_CODES } from "../../protocol/wire/index.js";
+import { createProject, isProjectPlanStatus } from "../project-command-service.js";
+export async function handleProjectCreate(msg) {
+    const params = msg.params;
+    if (!params?.name) {
+        if (msg.id !== undefined) {
+            this.sendResponse(msg.id, undefined, {
+                code: AGENT_RPC_ERROR_CODES.INVALID_PARAMS,
+                message: "Missing required param: name",
+            });
+        }
+        return;
+    }
+    let result;
+    try {
+        result = await createProject(this, { name: params.name, workspaceDir: params.workspaceDir, type: params.type, groupId: params.groupId });
+    }
+    catch (err) {
+        if (msg.id !== undefined) {
+            this.sendResponse(msg.id, undefined, {
+                code: AGENT_RPC_ERROR_CODES.INTERNAL_ERROR,
+                message: err instanceof Error ? err.message : `Cannot create workspace directory: ${params.workspaceDir ?? params.name}`,
+            });
+        }
+        return;
+    }
+    const { project, nameDuplicate, autoSwitched, deduplicated } = result;
+    if (deduplicated) {
+        if (msg.id !== undefined) {
+            this.sendResponse(msg.id, { ok: true, project, deduplicated: true });
+        }
+        return;
+    }
+    this.sendNotification("project.created", {
+        id: project.id,
+        name: project.name,
+        workspaceDir: project.workspaceDir,
+        type: project.type,
+    });
+    if (autoSwitched) {
+        this.sendNotification("project.switched", {
+            id: project.id,
+            name: project.name,
+            workspaceDir: project.workspaceDir,
+        });
+    }
+    if (msg.id !== undefined) {
+        const response = { ok: true, project };
+        if (nameDuplicate) {
+            response.warning = `A project named "${nameDuplicate.name}" already exists at ${nameDuplicate.workspaceDir}. Consider renaming one of them to avoid ambiguity.`;
+        }
+        this.sendResponse(msg.id, response);
+    }
+}
+export function handleProjectList(msg) {
+    const projects = projectStore.listProjects();
+    if (msg.id !== undefined) {
+        this.sendResponse(msg.id, { projects });
+    }
+}
+/**
+ * Remove a project's workspace directory — but NEVER one that another project still references.
+ * Solo/Product plan projects deliberately reuse their host project's workspaceDir (the run executes
+ * in the user's real workspace, isolated per-agent via git worktrees), so rmSync'ing a shared dir
+ * would wipe the host project and every sibling plan. Centralizing this keeps project.delete and
+ * project.purgeAll from drifting apart. `requireManaged` additionally restricts deletion to dirs
+ * under ~/.qlogicagent/workspaces/ (project.delete's safety rule); purgeAll leaves it off.
+ */
+function removeProjectDirIfSafe(normalizedDir, opts = {}) {
+    if (opts.requireManaged) {
+        const managedRoot = path.resolve(path.join(getUserAgentHome(), "workspaces")) + path.sep;
+        if (!normalizedDir.startsWith(managedRoot)) {
+            return {
+                deleted: false,
+                skipped: "external",
+                error: "Project directory is outside the managed workspace root and was not deleted automatically.",
+            };
+        }
+    }
+    if (projectStore.isWorkspaceDirShared(normalizedDir)) {
+        return { deleted: false, skipped: "shared" };
+    }
+    try {
+        opts.releaseDir?.(normalizedDir);
+    }
+    catch { /* ignore */ }
+    // Retry for Windows file-locking (EBUSY/EPERM/ENOTEMPTY); the sync sleep is bounded and short.
+    for (let attempt = 0; attempt < 3; attempt++) {
+        try {
+            if (fs.existsSync(normalizedDir))
+                fs.rmSync(normalizedDir, { recursive: true, force: true });
+            return { deleted: true };
+        }
+        catch (err) {
+            if (attempt < 2 && (err.code === "EBUSY" || err.code === "EPERM" || err.code === "ENOTEMPTY")) {
+                const start = Date.now();
+                while (Date.now() - start < 300) { /* busy-wait */ }
+            }
+            else {
+                return { deleted: false, error: err.message ?? String(err) };
+            }
+        }
+    }
+    return { deleted: false };
+}
+export function handleProjectDelete(msg) {
+    const params = msg.params;
+    if (!params?.projectId) {
+        if (msg.id !== undefined) {
+            this.sendResponse(msg.id, undefined, {
+                code: AGENT_RPC_ERROR_CODES.INVALID_PARAMS,
+                message: "Missing required param: projectId",
+            });
+        }
+        return;
+    }
+    // Retrieve project info BEFORE deletion (need workspaceDir for cleanup)
+    const projectInfo = projectStore.getProjectById(params.projectId);
+    const result = projectStore.deleteProject(params.projectId);
+    if (!result.deleted) {
+        if (msg.id !== undefined) {
+            this.sendResponse(msg.id, undefined, {
+                code: AGENT_RPC_ERROR_CODES.INTERNAL_ERROR,
+                message: "Cannot delete project (not found or is default project)",
+            });
+        }
+        return;
+    }
+    // Filesystem cleanup: remove the project's workspace dir (managed + not shared by another project).
+    let dirDeleted = false;
+    let dirDeleteError;
+    if (projectInfo?.workspaceDir) {
+        const r = removeProjectDirIfSafe(path.resolve(projectInfo.workspaceDir), {
+            requireManaged: true,
+            releaseDir: (dir) => this.mediaPersistence?.releaseProjectDir?.(dir),
+        });
+        dirDeleted = r.deleted;
+        dirDeleteError = r.error;
+    }
+    this.sendNotification("project.deleted", { id: params.projectId });
+    if (result.switchedTo) {
+        this.setActiveWorkdir(result.switchedTo.workspaceDir);
+        this.sendNotification("project.switched", {
+            id: result.switchedTo.id,
+            name: result.switchedTo.name,
+            workspaceDir: result.switchedTo.workspaceDir,
+        });
+    }
+    if (msg.id !== undefined) {
+        this.sendResponse(msg.id, { ok: true, switchedTo: result.switchedTo, dirDeleted, dirDeleteError });
+    }
+}
+export function handleProjectPurgeAll(msg) {
+    const allProjects = projectStore.listProjects();
+    const managedRoot = path.join(getUserAgentHome(), "workspaces");
+    const resolvedManagedRoot = path.resolve(managedRoot) + path.sep;
+    let deletedCount = 0;
+    let dirErrors = [];
+    for (const project of allProjects) {
+        if (project.type === "default")
+            continue;
+        // Hard delete from store
+        projectStore.deleteProject(project.id);
+        deletedCount++;
+        // Filesystem cleanup: delete the project's own workspace dir (any location, but not if shared).
+        if (project.workspaceDir) {
+            const r = removeProjectDirIfSafe(path.resolve(project.workspaceDir), {
+                releaseDir: (dir) => this.mediaPersistence?.releaseProjectDir?.(dir),
+            });
+            if (r.error)
+                dirErrors.push(`${project.name}: ${r.error}`);
+        }
+        this.sendNotification("project.deleted", { id: project.id });
+    }
+    // Scan managed workspaces directory for orphaned directories (not in store)
+    if (fs.existsSync(managedRoot)) {
+        const defaultProject = projectStore.listProjects().find(p => p.type === "default");
+        const keepDirs = new Set();
+        if (defaultProject?.workspaceDir)
+            keepDirs.add(path.resolve(defaultProject.workspaceDir));
+        const scanDirs = (dir) => {
+            try {
+                const entries = fs.readdirSync(dir, { withFileTypes: true });
+                for (const entry of entries) {
+                    if (!entry.isDirectory())
+                        continue;
+                    const fullPath = path.join(dir, entry.name);
+                    if (keepDirs.has(path.resolve(fullPath)))
+                        continue;
+                    // Sub-directory under managed root (for example "groups/"): scan recursively.
+                    if (entry.name === "groups") {
+                        scanDirs(fullPath);
+                        // Remove empty groups dir after cleanup
+                        try {
+                            const remaining = fs.readdirSync(fullPath);
+                            if (remaining.length === 0)
+                                fs.rmdirSync(fullPath);
+                        }
+                        catch { /* ignore */ }
+                        continue;
+                    }
+                    // Orphaned project directory: delete it.
+                    try {
+                        fs.rmSync(fullPath, { recursive: true, force: true });
+                    }
+                    catch (err) {
+                        dirErrors.push(`orphan:${entry.name}: ${err.message ?? err}`);
+                    }
+                }
+            }
+            catch { /* ignore unreadable dir */ }
+        };
+        scanDirs(managedRoot);
+    }
+    // Switch to default project
+    const defaultProject = projectStore.listProjects().find(p => p.type === "default");
+    if (defaultProject) {
+        this.setActiveWorkdir(defaultProject.workspaceDir);
+        this.sendNotification("project.switched", {
+            id: defaultProject.id,
+            name: defaultProject.name,
+            workspaceDir: defaultProject.workspaceDir,
+        });
+    }
+    if (msg.id !== undefined) {
+        this.sendResponse(msg.id, { ok: true, deletedCount, dirErrors: dirErrors.length ? dirErrors : undefined });
+    }
+}
+export function handleProjectRename(msg) {
+    const params = msg.params;
+    if (!params?.projectId || !params?.newName) {
+        if (msg.id !== undefined) {
+            this.sendResponse(msg.id, undefined, {
+                code: AGENT_RPC_ERROR_CODES.INVALID_PARAMS,
+                message: "Missing required params: projectId, newName",
+            });
+        }
+        return;
+    }
+    const project = projectStore.renameProject(params.projectId, params.newName);
+    if (!project) {
+        if (msg.id !== undefined) {
+            this.sendResponse(msg.id, undefined, {
+                code: AGENT_RPC_ERROR_CODES.INTERNAL_ERROR,
+                message: "Cannot rename project (not found, is default, or name already taken)",
+            });
+        }
+        return;
+    }
+    // Filesystem rename: if workspaceDir is under managed workspaces, rename the directory
+    const managedRoot = path.join(getUserAgentHome(), "workspaces");
+    const normalizedOldDir = path.resolve(project.workspaceDir);
+    if (normalizedOldDir.startsWith(path.resolve(managedRoot) + path.sep)) {
+        const newDir = path.join(managedRoot, params.newName);
+        // Only rename if the old dir exists and the new path doesn't conflict
+        if (fs.existsSync(normalizedOldDir) && !fs.existsSync(newDir)) {
+            try {
+                fs.renameSync(normalizedOldDir, newDir);
+                // Update workspaceDir in the store
+                projectStore.updateProjectWorkspaceDir(params.projectId, newDir);
+                project.workspaceDir = newDir;
+                // If this is the active project, update the runtime reference
+                if (this.getActiveProjectRoot() === normalizedOldDir) {
+                    this.setActiveWorkdir(newDir);
+                }
+            }
+            catch {
+                // Best-effort rename: project metadata is already updated if the directory remains at the old path.
+            }
+        }
+    }
+    this.sendNotification("project.renamed", {
+        id: project.id,
+        name: project.name,
+        workspaceDir: project.workspaceDir,
+    });
+    if (msg.id !== undefined) {
+        this.sendResponse(msg.id, { ok: true, project });
+    }
+}
+export function handleProjectArchive(msg) {
+    const params = msg.params;
+    if (!params?.projectId) {
+        if (msg.id !== undefined) {
+            this.sendResponse(msg.id, undefined, {
+                code: AGENT_RPC_ERROR_CODES.INVALID_PARAMS,
+                message: "Missing required param: projectId",
+            });
+        }
+        return;
+    }
+    const result = projectStore.archiveProject(params.projectId);
+    if (!result.archived) {
+        if (msg.id !== undefined) {
+            this.sendResponse(msg.id, undefined, {
+                code: AGENT_RPC_ERROR_CODES.INTERNAL_ERROR,
+                message: "Cannot archive project (not found or is default project)",
+            });
+        }
+        return;
+    }
+    this.sendNotification("project.archived", { id: params.projectId });
+    if (result.switchedTo) {
+        this.setActiveWorkdir(result.switchedTo.workspaceDir);
+        this.sendNotification("project.switched", {
+            id: result.switchedTo.id,
+            name: result.switchedTo.name,
+            workspaceDir: result.switchedTo.workspaceDir,
+        });
+    }
+    if (msg.id !== undefined) {
+        this.sendResponse(msg.id, { ok: true, switchedTo: result.switchedTo });
+    }
+}
+export function handleProjectUnarchive(msg) {
+    const params = msg.params;
+    if (!params?.projectId) {
+        if (msg.id !== undefined) {
+            this.sendResponse(msg.id, undefined, {
+                code: AGENT_RPC_ERROR_CODES.INVALID_PARAMS,
+                message: "Missing required param: projectId",
+            });
+        }
+        return;
+    }
+    const project = projectStore.unarchiveProject(params.projectId);
+    if (!project) {
+        if (msg.id !== undefined) {
+            this.sendResponse(msg.id, undefined, {
+                code: AGENT_RPC_ERROR_CODES.INTERNAL_ERROR,
+                message: "Cannot unarchive project (not found or not archived)",
+            });
+        }
+        return;
+    }
+    this.sendNotification("project.unarchived", {
+        id: project.id,
+        name: project.name,
+        workspaceDir: project.workspaceDir,
+    });
+    if (msg.id !== undefined) {
+        this.sendResponse(msg.id, { ok: true, project });
+    }
+}
+export function handleProjectArchiveByGroup(msg) {
+    const params = msg.params;
+    if (!params?.groupId) {
+        if (msg.id !== undefined) {
+            this.sendResponse(msg.id, undefined, {
+                code: AGENT_RPC_ERROR_CODES.INVALID_PARAMS,
+                message: "Missing required param: groupId",
+            });
+        }
+        return;
+    }
+    const result = projectStore.archiveByGroupId(params.groupId);
+    if (!result.archived) {
+        if (msg.id !== undefined) {
+            this.sendResponse(msg.id, { ok: false, error: "No active project with this groupId" });
+        }
+        return;
+    }
+    this.sendNotification("project.deleted", { id: result.projectId });
+    if (result.switchedTo) {
+        this.setActiveWorkdir(result.switchedTo.workspaceDir);
+        this.sendNotification("project.switched", {
+            id: result.switchedTo.id,
+            name: result.switchedTo.name,
+            workspaceDir: result.switchedTo.workspaceDir,
+        });
+    }
+    if (msg.id !== undefined) {
+        this.sendResponse(msg.id, { ok: true, projectId: result.projectId });
+    }
+}
+export function handleProjectUpdate(msg) {
+    const params = msg.params;
+    if (!params?.projectId) {
+        if (msg.id !== undefined) {
+            this.sendResponse(msg.id, undefined, {
+                code: AGENT_RPC_ERROR_CODES.INVALID_PARAMS,
+                message: "projectId is required",
+            });
+        }
+        return;
+    }
+    const patch = {};
+    if ("planStatus" in params) {
+        if (params.planStatus !== undefined && !isProjectPlanStatus(params.planStatus)) {
+            if (msg.id !== undefined) {
+                this.sendResponse(msg.id, undefined, {
+                    code: AGENT_RPC_ERROR_CODES.INVALID_PARAMS,
+                    message: `Invalid planStatus: ${params.planStatus}`,
+                });
+            }
+            return;
+        }
+        patch.planStatus = params.planStatus;
+    }
+    if ("planAgents" in params)
+        patch.planAgents = params.planAgents;
+    if ("planWinnerId" in params)
+        patch.planWinnerId = params.planWinnerId;
+    if ("leaderSessionId" in params)
+        patch.leaderSessionId = params.leaderSessionId;
+    if ("primaryWorkflowId" in params)
+        patch.primaryWorkflowId = params.primaryWorkflowId;
+    const ok = projectStore.updateProject(params.projectId, patch);
+    if (msg.id !== undefined) {
+        this.sendResponse(msg.id, { ok });
+    }
+}

package/dist/cli/handlers/session-handler.channel.test.d.ts

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

package/dist/cli/handlers/session-handler.channel.test.js

@@ -0,0 +1,157 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { afterEach, describe, expect, it, vi } from "vitest";
+import { getOrCreateDefaultProject, createProject } from "../../runtime/infra/project-store.js";
+import { getSessionMetadata, updateSessionMetadata } from "../../runtime/session/session-persistence.js";
+import { handleSessionResolve } from "./session-handler.js";
+const tmpDirs = [];
+function makeTempDir() {
+    const dir = fs.mkdtempSync(path.join(os.tmpdir(), "qlogicagent-session-handler-"));
+    tmpDirs.push(dir);
+    return dir;
+}
+function createHost() {
+    const responses = [];
+    return {
+        responses,
+        sessionHistory: { saveResumedSession: () => { } },
+        log: () => { },
+        setActiveWorkdir: () => { },
+        getActiveProjectRoot: () => "",
+        enableIdleDream: () => { },
+        sendNotification: () => { },
+        sendResponse: (id, result, error) => responses.push({ id, result, error }),
+        sendError: (id, code, message, data) => responses.push({ id, error: { code, message, data } }),
+    };
+}
+afterEach(() => {
+    vi.unstubAllEnvs();
+    for (const dir of tmpDirs.splice(0)) {
+        fs.rmSync(dir, { recursive: true, force: true });
+    }
+});
+describe("channel session resolution", () => {
+    it("creates new personal IM sessions in the default project instead of the active desktop project", async () => {
+        const home = makeTempDir();
+        vi.stubEnv("QLOGICAGENT_HOME", home);
+        vi.stubEnv("QLOGIC_LLMROUTER_USER_ID", "owner/channel-test");
+        const defaultWorkspace = path.join(home, "default-workspace");
+        const activeWorkspace = path.join(home, "test-workspace");
+        fs.mkdirSync(defaultWorkspace, { recursive: true });
+        fs.mkdirSync(activeWorkspace, { recursive: true });
+        const defaultProject = getOrCreateDefaultProject(defaultWorkspace);
+        const activeProject = createProject({ name: "test", workspaceDir: activeWorkspace });
+        expect(activeProject.id).not.toBe(defaultProject.id);
+        const host = createHost();
+        await handleSessionResolve.call(host, {
+            jsonrpc: "2.0",
+            id: "resolve-1",
+            method: "session.resolve",
+            params: {
+                platform: "wecom",
+                chatId: "wecom-chat-1",
+                chatType: "dm",
+                userId: "wecom-user-1",
+            },
+        });
+        const response = host.responses[0]?.result;
+        expect(response.projectId).toBe(defaultProject.id);
+        expect(response.ownerPlatform).toBe("wecom");
+        expect(response.ownerId).toBe("wecom-user-1");
+        expect(getSessionMetadata(response.sessionId, defaultWorkspace)?.projectId).toBe(defaultProject.id);
+        expect(getSessionMetadata(response.sessionId, activeWorkspace)).toBeNull();
+    });
+    it("does not reuse a personal IM session that was incorrectly created outside the default project", async () => {
+        const home = makeTempDir();
+        vi.stubEnv("QLOGICAGENT_HOME", home);
+        vi.stubEnv("QLOGIC_LLMROUTER_USER_ID", "owner/channel-repair-test");
+        const defaultWorkspace = path.join(home, "default-workspace");
+        const activeWorkspace = path.join(home, "test-workspace");
+        fs.mkdirSync(defaultWorkspace, { recursive: true });
+        fs.mkdirSync(activeWorkspace, { recursive: true });
+        const defaultProject = getOrCreateDefaultProject(defaultWorkspace);
+        const activeProject = createProject({ name: "test", workspaceDir: activeWorkspace });
+        await updateSessionMetadata("wrong-project-session", {
+            sessionId: "wrong-project-session",
+            type: "personal",
+            ownerPlatform: "wecom",
+            ownerId: "wecom-user-1",
+            projectId: activeProject.id,
+        }, activeWorkspace);
+        const host = createHost();
+        await handleSessionResolve.call(host, {
+            jsonrpc: "2.0",
+            id: "resolve-1",
+            method: "session.resolve",
+            params: {
+                platform: "wecom",
+                chatId: "wecom-chat-1",
+                chatType: "dm",
+                userId: "wecom-user-1",
+            },
+        });
+        const response = host.responses[0]?.result;
+        expect(response.sessionId).not.toBe("wrong-project-session");
+        expect(response.projectId).toBe(defaultProject.id);
+    });
+    it("does not reuse an archived personal IM session", async () => {
+        const home = makeTempDir();
+        vi.stubEnv("QLOGICAGENT_HOME", home);
+        vi.stubEnv("QLOGIC_LLMROUTER_USER_ID", "owner/channel-archive-test");
+        const defaultWorkspace = path.join(home, "default-workspace");
+        fs.mkdirSync(defaultWorkspace, { recursive: true });
+        const defaultProject = getOrCreateDefaultProject(defaultWorkspace);
+        await updateSessionMetadata("archived-im-session", {
+            sessionId: "archived-im-session",
+            type: "personal",
+            ownerPlatform: "weixin",
+            ownerId: "wechat-user-1",
+            projectId: defaultProject.id,
+            archivedAt: "2026-06-08T00:00:00.000Z",
+        }, defaultWorkspace);
+        const host = createHost();
+        await handleSessionResolve.call(host, {
+            jsonrpc: "2.0",
+            id: "resolve-archived",
+            method: "session.resolve",
+            params: {
+                platform: "weixin",
+                chatId: "wechat-chat-1",
+                chatType: "dm",
+                userId: "wechat-user-1",
+            },
+        });
+        const response = host.responses[0]?.result;
+        expect(response.sessionId).not.toBe("archived-im-session");
+        expect(response.projectId).toBe(defaultProject.id);
+        expect(response.ownerPlatform).toBe("weixin");
+        expect(response.ownerId).toBe("wechat-user-1");
+        expect(getSessionMetadata(response.sessionId, defaultWorkspace)?.archivedAt).toBeUndefined();
+    });
+    it("persists and returns the initial title for newly resolved IM sessions", async () => {
+        const home = makeTempDir();
+        vi.stubEnv("QLOGICAGENT_HOME", home);
+        vi.stubEnv("QLOGIC_LLMROUTER_USER_ID", "owner/channel-title-test");
+        const defaultWorkspace = path.join(home, "default-workspace");
+        fs.mkdirSync(defaultWorkspace, { recursive: true });
+        const defaultProject = getOrCreateDefaultProject(defaultWorkspace);
+        const host = createHost();
+        await handleSessionResolve.call(host, {
+            jsonrpc: "2.0",
+            id: "resolve-title",
+            method: "session.resolve",
+            params: {
+                platform: "weixin",
+                chatId: "wechat-chat-1",
+                chatType: "dm",
+                userId: "wechat-user-1",
+                title: "我再来做一个对话测试",
+            },
+        });
+        const response = host.responses[0]?.result;
+        expect(response.projectId).toBe(defaultProject.id);
+        expect(response.title).toBe("我再来做一个对话测试");
+        expect(getSessionMetadata(response.sessionId, defaultWorkspace)?.title).toBe("我再来做一个对话测试");
+    });
+});

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

@@ -0,0 +1,58 @@
+/**
+ * Session & Thread handlers - uses SessionLocator for all path resolution.
+ *
+ * Handles: thread.create, thread.list, session.create, session.resolve,
+ *          session.list, session.get, session.getMessages, session.update,
+ *          session.delete, session.deleteAll, session.archive, session.resume,
+ *          session.getInfo, session.switchProject, session.getState
+ *
+ * Key invariant: every session operation resolves storage path via projectId,
+ * never via the global `currentProjectRoot`. Sessions are immutably bound
+ * to a project at creation time.
+ */
+import { SessionState } from "../../runtime/session/session-state.js";
+import { createMemoryPrefetchState } from "../../runtime/hooks/memory-hooks.js";
+import { type AgentRpcError, type AgentRpcErrorCode, type AgentRpcRequest } from "../../protocol/wire/index.js";
+import type { SessionHistoryCoordinator } from "../session-history-coordinator.js";
+import type { TaskDomain } from "../../runtime/prompt/task-domain.js";
+export interface SessionHandlerHost {
+    currentSessionId?: string;
+    currentModel?: string;
+    sessionState?: SessionState | null;
+    sessionTaskDomain?: TaskDomain;
+    memoryPrefetchState?: ReturnType<typeof createMemoryPrefetchState>;
+    sessionHistory: Pick<SessionHistoryCoordinator, "saveResumedSession">;
+    log(message: string): void;
+    setActiveWorkdir(workdir: string): void;
+    getActiveProjectRoot(): string;
+    enableIdleDream(): void;
+    sendNotification(method: string, params: Record<string, unknown>): void;
+    sendResponse(id: string | number, result?: unknown, error?: AgentRpcError): void;
+    sendError(id: string | number, code: AgentRpcErrorCode | number, message: string, data?: unknown): void;
+}
+export declare function handleThreadCreate(this: SessionHandlerHost, msg: AgentRpcRequest): void;
+export declare function handleThreadList(this: SessionHandlerHost, msg: AgentRpcRequest): Promise<void>;
+export declare function handleSessionCreate(this: SessionHandlerHost, msg: AgentRpcRequest): Promise<void>;
+export declare function handleSessionResolve(this: SessionHandlerHost, msg: AgentRpcRequest): Promise<void>;
+export declare function handleSessionList(this: SessionHandlerHost, msg: AgentRpcRequest): Promise<void>;
+export declare function handleSessionGet(this: SessionHandlerHost, msg: AgentRpcRequest): Promise<void>;
+export declare function handleSessionGetMessages(this: SessionHandlerHost, msg: AgentRpcRequest): Promise<void>;
+export declare function handleSessionUpdate(this: SessionHandlerHost, msg: AgentRpcRequest): Promise<void>;
+export declare function handleSessionDelete(this: SessionHandlerHost, msg: AgentRpcRequest): Promise<void>;
+export declare function handleSessionDeleteAll(this: SessionHandlerHost, msg: AgentRpcRequest): Promise<void>;
+export declare function handleSessionArchive(this: SessionHandlerHost, msg: AgentRpcRequest): Promise<void>;
+export declare function handleSessionResume(this: SessionHandlerHost, msg: AgentRpcRequest): Promise<void>;
+export declare function handleSessionGetInfo(this: SessionHandlerHost, msg: AgentRpcRequest): void;
+export declare function handleSessionSwitchProject(this: SessionHandlerHost, msg: AgentRpcRequest): void;
+export declare function handleSessionGetState(this: SessionHandlerHost, msg: AgentRpcRequest): void;
+/**
+ * `session.focus` - Desktop UI reports which session is currently focused.
+ * Agent switches active project/cwd to the session's owning project.
+ */
+export declare function handleSessionFocus(this: SessionHandlerHost, msg: AgentRpcRequest): Promise<void>;
+/**
+ * `session.moveToProject` - Move a session from one project to another.
+ * Physically copies session files, updates metadata.projectId, then removes the source.
+ * Emits session:updated notification.
+ */
+export declare function handleSessionMoveToProject(this: SessionHandlerHost, msg: AgentRpcRequest): Promise<void>;

package/dist/cli/handlers/session-handler.delete.test.d.ts

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

package/dist/cli/handlers/session-handler.delete.test.js

@@ -0,0 +1,38 @@
+import { describe, expect, it, vi } from "vitest";
+import { handleSessionDelete } from "./session-handler.js";
+import { AGENT_RPC_ERROR_CODES } from "../../protocol/wire/index.js";
+import { SessionHistoryCoordinator } from "../session-history-coordinator.js";
+function makeHost() {
+    const responses = [];
+    const host = {
+        sessionHistory: new SessionHistoryCoordinator(),
+        log: vi.fn(),
+        setActiveWorkdir: vi.fn(),
+        getActiveProjectRoot: vi.fn(() => "/unused"),
+        enableIdleDream: vi.fn(),
+        sendNotification: vi.fn(),
+        sendResponse: vi.fn((_id, result, error) => responses.push({ result, error })),
+        sendError: vi.fn(),
+    };
+    return { host, responses };
+}
+describe("handleSessionDelete", () => {
+    it("requires projectId so permanent deletion targets the owning project", async () => {
+        const { host, responses } = makeHost();
+        await handleSessionDelete.call(host, {
+            jsonrpc: "2.0",
+            id: 1,
+            method: "session.delete",
+            params: { sessionId: "session-a" },
+        });
+        expect(responses).toEqual([
+            {
+                result: undefined,
+                error: {
+                    code: AGENT_RPC_ERROR_CODES.INVALID_PARAMS,
+                    message: "Missing required param: projectId",
+                },
+            },
+        ]);
+    });
+});