@co0ontty/wand 4.21.0 → 4.22.0

package/dist/build-info.json

@@ -1,6 +1,6 @@
 {
-  "commit": "79972abbe91abdb5e1627ebb9eaba7b2e1ef8118",
-  "builtAt": "2026-07-22T05:37:40.056Z",
-  "version": "4.21.0",
+  "commit": "3e46be813515b326cd1be393157864d189bf48fe",
+  "builtAt": "2026-07-22T14:22:25.841Z",
+  "version": "4.22.0",
   "channel": "stable"
 }

package/dist/process-manager.d.ts

@@ -2,8 +2,8 @@ import { EventEmitter } from "node:events";
 import { WandStorage } from "./storage.js";
 import { ExecutionMode, ProcessEventHandler, SessionProvider, SessionSnapshot, SessionSource, WandConfig } from "./types.js";
 import { type PermissionResolution } from "./claude-pty-bridge.js";
-import { type ClaudeHistorySession, type CodexHistorySession } from "./provider-history-scanner.js";
-export type { ClaudeHistorySession, CodexHistorySession } from "./provider-history-scanner.js";
+import { type ClaudeHistorySession, type CodexHistorySession, type OpenCodeHistorySession, type QoderHistorySession } from "./provider-history-scanner.js";
+export type { ClaudeHistorySession, CodexHistorySession, OpenCodeHistorySession, QoderHistorySession, } from "./provider-history-scanner.js";
 /** Exported for focused policy tests. */
 export declare function isCommandAllowedByPrefixes(command: string, allowedPrefixes: readonly string[]): boolean;
 export type { ProcessEvent, ProcessEventHandler } from "./types.js";
@@ -64,6 +64,10 @@ export declare class ProcessManager extends EventEmitter {
     listCodexHistorySessions(): CodexHistorySession[];
     hasCodexSessionFile(threadId: string): boolean;
     deleteCodexHistoryFiles(threadIds: string[]): number;
+    listOpenCodeHistorySessions(): OpenCodeHistorySession[];
+    deleteOpenCodeHistorySessions(sessionIds: string[]): number;
+    listQoderHistorySessions(): QoderHistorySession[];
+    deleteQoderHistoryFiles(sessionIds: string[]): number;
     private captureCodexSessionId;
     private captureOpenCodeSessionId;
     private captureClaudeSessionId;

package/dist/process-manager.js

@@ -356,12 +356,9 @@ function selectCodexSessionForRecord(record, sessions) {
 function getLatestCodexSessionId(record, sessions) {
     return selectCodexSessionForRecord(record, sessions)?.claudeSessionId ?? null;
 }
-function getOpenCodeDatabasePath() {
-    const dataHome = process.env.XDG_DATA_HOME?.trim() || path.join(os.homedir(), ".local", "share");
-    return path.join(dataHome, "opencode", "opencode.db");
-}
 function listOpenCodeSessionCandidates() {
-    const dbPath = getOpenCodeDatabasePath();
+    const dataHome = process.env.XDG_DATA_HOME?.trim() || path.join(os.homedir(), ".local", "share");
+    const dbPath = path.join(dataHome, "opencode", "opencode.db");
     if (!existsSync(dbPath))
         return [];
     let db = null;
@@ -1213,6 +1210,18 @@ export class ProcessManager extends EventEmitter {
     deleteCodexHistoryFiles(threadIds) {
         return this.providerHistory.deleteCodexHistoryFiles(threadIds);
     }
+    listOpenCodeHistorySessions() {
+        return this.providerHistory.listOpenCodeHistorySessions();
+    }
+    deleteOpenCodeHistorySessions(sessionIds) {
+        return this.providerHistory.deleteOpenCodeHistorySessions(sessionIds);
+    }
+    listQoderHistorySessions() {
+        return this.providerHistory.listQoderHistorySessions();
+    }
+    deleteQoderHistoryFiles(sessionIds) {
+        return this.providerHistory.deleteQoderHistoryFiles(sessionIds);
+    }
     captureCodexSessionId(record, options) {
         if (record.provider !== "codex" || record.claudeSessionId) {
             return false;

package/dist/provider-history-scanner.d.ts

@@ -20,9 +20,34 @@ export interface CodexHistorySession {
     managedByWand: boolean;
     provider: "codex";
 }
+/** OpenCode persists session metadata and messages in its local SQLite database. */
+export interface OpenCodeHistorySession {
+    claudeSessionId: string;
+    cwd: string;
+    firstUserMessage: string;
+    timestamp: string;
+    mtimeMs: number;
+    hasConversation: boolean;
+    managedByWand: boolean;
+    provider: "opencode";
+}
+/** Qoder CLI keeps one JSONL transcript per project-local native session. */
+export interface QoderHistorySession {
+    claudeSessionId: string;
+    cwd: string;
+    firstUserMessage: string;
+    timestamp: string;
+    mtimeMs: number;
+    hasConversation: boolean;
+    managedByWand: boolean;
+    provider: "qoder";
+}
 export interface ProviderHistoryScannerOptions {
     claudeHome?: string;
     codexSessionsDir?: string;
+    openCodeDatabasePath?: string;
+    /** Qoder and Qoder CN use separate config roots; callers may override both for tests. */
+    qoderProjectsDirs?: string[];
 }
 /**
  * Incremental provider-history index. Directory entries are refreshed on each
@@ -32,23 +57,35 @@ export declare class ProviderHistoryScanner {
     private readonly claudeHome;
     private readonly claudeProjectsDir;
     private readonly codexSessionsDir;
+    private readonly openCodeDatabasePath;
+    private readonly qoderProjectsDirs;
     private readonly claudeIndex;
     private readonly codexIndex;
+    private readonly qoderIndex;
+    private openCodeFingerprint;
+    private openCodeSessions;
     private parsedFiles;
     constructor(options?: ProviderHistoryScannerOptions);
     getDiagnostics(): {
         parsedFiles: number;
         claudeEntries: number;
         codexEntries: number;
+        openCodeEntries: number;
+        qoderEntries: number;
     };
-    invalidate(provider?: "claude" | "codex"): void;
+    invalidate(provider?: "claude" | "codex" | "opencode" | "qoder"): void;
     listClaudeHistorySessions(): ClaudeHistorySession[];
     private listCodexRolloutFiles;
     listCodexHistorySessions(): CodexHistorySession[];
     hasCodexSessionFile(threadId: string): boolean;
+    listOpenCodeHistorySessions(): OpenCodeHistorySession[];
+    private listQoderTranscriptFiles;
+    listQoderHistorySessions(): QoderHistorySession[];
     deleteClaudeHistoryFiles(sessions: Array<{
         claudeSessionId: string;
         cwd: string;
     }>): number;
     deleteCodexHistoryFiles(threadIds: string[]): number;
+    deleteOpenCodeHistorySessions(sessionIds: string[]): number;
+    deleteQoderHistoryFiles(sessionIds: string[]): number;
 }

package/dist/provider-history-scanner.js

@@ -1,7 +1,9 @@
 import { closeSync, existsSync, openSync, readSync, readdirSync, rmSync, statSync, unlinkSync, } from "node:fs";
 import os from "node:os";
 import path from "node:path";
+import { DatabaseSync } from "node:sqlite";
 const UUID_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+const PROVIDER_SESSION_ID_PATTERN = /^[a-z0-9][a-z0-9._:-]{0,199}$/i;
 const WORKTREE_DIR_PATTERN = /--?\.?(?:wand-worktrees|claude-worktrees)-/;
 function readHead(filePath, maxBytes) {
     let fd = null;
@@ -102,6 +104,74 @@ function isCodexSystemInjectedText(text) {
     const trimmed = text.trimStart();
     return trimmed.startsWith("#") || trimmed.startsWith("<");
 }
+function qoderMessageText(content) {
+    if (typeof content === "string")
+        return content;
+    if (!Array.isArray(content))
+        return "";
+    return content
+        .filter((block) => Boolean(block && typeof block === "object"))
+        .filter((block) => block.type === "text" && typeof block.text === "string")
+        .map((block) => block.text)
+        .join("\n");
+}
+function isQoderGeneratedMessage(text) {
+    const trimmed = text.trimStart();
+    return trimmed.startsWith("<local-command-caveat>") || trimmed.startsWith("<command-message>");
+}
+function parseQoderSummary(id, head) {
+    let cwd = "";
+    let timestamp = "";
+    let firstUserMessage = "";
+    let aiTitle = "";
+    let hasUser = false;
+    let hasAssistant = false;
+    for (const line of head.text.split("\n")) {
+        if (!line.trim())
+            continue;
+        let parsed;
+        try {
+            parsed = JSON.parse(line);
+        }
+        catch {
+            continue;
+        }
+        if (!timestamp && typeof parsed.timestamp === "string")
+            timestamp = parsed.timestamp;
+        if (!cwd && typeof parsed.cwd === "string")
+            cwd = parsed.cwd;
+        if (!cwd && parsed.type === "workspace-directories" && Array.isArray(parsed.directories)) {
+            const directory = parsed.directories.find((value) => typeof value === "string" && value.trim().length > 0);
+            if (directory)
+                cwd = directory;
+        }
+        if (parsed.type === "ai-title" && typeof parsed.aiTitle === "string" && parsed.aiTitle.trim()) {
+            aiTitle = parsed.aiTitle.trim();
+        }
+        const role = parsed.message?.role;
+        if (parsed.type === "user" && role === "user") {
+            const text = qoderMessageText(parsed.message?.content).trim();
+            if (text && parsed.isMeta !== true && !isQoderGeneratedMessage(text)) {
+                hasUser = true;
+                if (!firstUserMessage)
+                    firstUserMessage = text.slice(0, 120);
+            }
+        }
+        else if (parsed.type === "assistant" && role === "assistant") {
+            hasAssistant = true;
+        }
+    }
+    return {
+        claudeSessionId: id,
+        cwd,
+        firstUserMessage: aiTitle || firstUserMessage,
+        timestamp: timestamp || new Date(head.mtimeMs).toISOString(),
+        mtimeMs: head.mtimeMs,
+        hasConversation: hasUser && hasAssistant,
+        managedByWand: false,
+        provider: "qoder",
+    };
+}
 /**
  * Codex versions used before quick commit enabled `--ephemeral` persisted these
  * internal one-shot prompts as ordinary sessions. Hide those legacy artifacts
@@ -192,22 +262,45 @@ export class ProviderHistoryScanner {
     claudeHome;
     claudeProjectsDir;
     codexSessionsDir;
+    openCodeDatabasePath;
+    qoderProjectsDirs;
     claudeIndex = new Map();
     codexIndex = new Map();
+    qoderIndex = new Map();
+    openCodeFingerprint = null;
+    openCodeSessions = [];
     parsedFiles = 0;
     constructor(options = {}) {
         this.claudeHome = options.claudeHome ?? path.join(os.homedir(), ".claude");
         this.claudeProjectsDir = path.join(this.claudeHome, "projects");
         this.codexSessionsDir = options.codexSessionsDir ?? path.join(os.homedir(), ".codex", "sessions");
+        const dataHome = process.env.XDG_DATA_HOME?.trim() || path.join(os.homedir(), ".local", "share");
+        this.openCodeDatabasePath = options.openCodeDatabasePath ?? path.join(dataHome, "opencode", "opencode.db");
+        this.qoderProjectsDirs = options.qoderProjectsDirs ?? [
+            path.join(os.homedir(), ".qoder", "projects"),
+            path.join(os.homedir(), ".qoder-cn", "projects"),
+        ];
     }
     getDiagnostics() {
-        return { parsedFiles: this.parsedFiles, claudeEntries: this.claudeIndex.size, codexEntries: this.codexIndex.size };
+        return {
+            parsedFiles: this.parsedFiles,
+            claudeEntries: this.claudeIndex.size,
+            codexEntries: this.codexIndex.size,
+            openCodeEntries: this.openCodeSessions.length,
+            qoderEntries: this.qoderIndex.size,
+        };
     }
     invalidate(provider) {
         if (!provider || provider === "claude")
             this.claudeIndex.clear();
         if (!provider || provider === "codex")
             this.codexIndex.clear();
+        if (!provider || provider === "opencode") {
+            this.openCodeFingerprint = null;
+            this.openCodeSessions = [];
+        }
+        if (!provider || provider === "qoder")
+            this.qoderIndex.clear();
     }
     listClaudeHistorySessions() {
         const observed = new Set();
@@ -319,6 +412,143 @@ export class ProviderHistoryScanner {
         return UUID_PATTERN.test(threadId)
             && this.listCodexHistorySessions().some((session) => session.claudeSessionId === threadId);
     }
+    listOpenCodeHistorySessions() {
+        const databasePaths = [this.openCodeDatabasePath, `${this.openCodeDatabasePath}-wal`];
+        const fingerprint = databasePaths.map((filePath) => {
+            try {
+                const stats = statSync(filePath);
+                return `${filePath}:${stats.mtimeMs}:${stats.size}`;
+            }
+            catch {
+                return `${filePath}:missing`;
+            }
+        }).join("|");
+        if (fingerprint === this.openCodeFingerprint) {
+            return this.openCodeSessions.map((session) => ({ ...session, managedByWand: false }));
+        }
+        this.openCodeFingerprint = fingerprint;
+        if (!existsSync(this.openCodeDatabasePath)) {
+            this.openCodeSessions = [];
+            return [];
+        }
+        let database = null;
+        try {
+            database = new DatabaseSync(this.openCodeDatabasePath, { readOnly: true });
+            const rows = database.prepare(`
+        SELECT
+          session.id AS id,
+          session.directory AS cwd,
+          session.title AS title,
+          session.time_created AS time_created,
+          session.time_updated AS time_updated,
+          SUM(CASE WHEN json_extract(message.data, '$.role') = 'user' THEN 1 ELSE 0 END) AS user_count,
+          SUM(CASE WHEN json_extract(message.data, '$.role') = 'assistant' THEN 1 ELSE 0 END) AS assistant_count
+        FROM session
+        LEFT JOIN message ON message.session_id = session.id
+        GROUP BY session.id
+        ORDER BY session.time_updated DESC
+        LIMIT 1000
+      `).all();
+            this.openCodeSessions = rows.flatMap((row) => {
+                if (typeof row.id !== "string" || !PROVIDER_SESSION_ID_PATTERN.test(row.id))
+                    return [];
+                if (typeof row.cwd !== "string" || !row.cwd.trim())
+                    return [];
+                const mtimeMs = Number(row.time_updated);
+                const createdMs = Number(row.time_created);
+                if (!Number.isFinite(mtimeMs) || !Number.isFinite(createdMs))
+                    return [];
+                return [{
+                        claudeSessionId: row.id,
+                        cwd: row.cwd,
+                        firstUserMessage: typeof row.title === "string" ? row.title.trim().slice(0, 120) : "",
+                        timestamp: new Date(createdMs).toISOString(),
+                        mtimeMs,
+                        hasConversation: Number(row.user_count) > 0 && Number(row.assistant_count) > 0,
+                        managedByWand: false,
+                        provider: "opencode",
+                    }];
+            });
+            return this.openCodeSessions.map((session) => ({ ...session }));
+        }
+        catch {
+            this.openCodeSessions = [];
+            return [];
+        }
+        finally {
+            try {
+                database?.close();
+            }
+            catch { /* best-effort read-only probe */ }
+        }
+    }
+    listQoderTranscriptFiles() {
+        const files = [];
+        for (const projectsDir of this.qoderProjectsDirs) {
+            let projects;
+            try {
+                projects = readdirSync(projectsDir, { withFileTypes: true });
+            }
+            catch {
+                continue;
+            }
+            for (const project of projects) {
+                if (!project.isDirectory())
+                    continue;
+                const projectDir = path.join(projectsDir, project.name);
+                let entries;
+                try {
+                    entries = readdirSync(projectDir, { withFileTypes: true });
+                }
+                catch {
+                    continue;
+                }
+                for (const entry of entries) {
+                    if (entry.isFile() && entry.name.endsWith(".jsonl"))
+                        files.push(path.join(projectDir, entry.name));
+                }
+            }
+        }
+        return files;
+    }
+    listQoderHistorySessions() {
+        const observed = new Set();
+        const bySessionId = new Map();
+        for (const filePath of this.listQoderTranscriptFiles()) {
+            const id = path.basename(filePath, ".jsonl");
+            if (!PROVIDER_SESSION_ID_PATTERN.test(id))
+                continue;
+            observed.add(filePath);
+            let stats;
+            try {
+                stats = statSync(filePath);
+            }
+            catch {
+                continue;
+            }
+            let cached = this.qoderIndex.get(filePath);
+            if (!cached || cached.mtimeMs !== stats.mtimeMs || cached.size !== stats.size) {
+                const head = readHead(filePath, 65536);
+                if (!head)
+                    continue;
+                cached = { mtimeMs: head.mtimeMs, size: head.size, summary: parseQoderSummary(id, head) };
+                this.qoderIndex.set(filePath, cached);
+                this.parsedFiles += 1;
+            }
+            const summary = cached.summary;
+            if (!summary || !summary.cwd)
+                continue;
+            const existing = bySessionId.get(summary.claudeSessionId);
+            if (!existing || summary.mtimeMs > existing.mtimeMs) {
+                bySessionId.set(summary.claudeSessionId, { ...summary, managedByWand: false });
+            }
+        }
+        for (const filePath of this.qoderIndex.keys()) {
+            if (!observed.has(filePath))
+                this.qoderIndex.delete(filePath);
+        }
+        return Array.from(bySessionId.values()).sort((left, right) => right.mtimeMs - left.mtimeMs);
+    }
     deleteClaudeHistoryFiles(sessions) {
         let deleted = 0;
         for (const { claudeSessionId, cwd } of sessions) {
@@ -369,4 +599,47 @@ export class ProviderHistoryScanner {
         }
         return deleted;
     }
+    deleteOpenCodeHistorySessions(sessionIds) {
+        const ids = sessionIds.filter((id) => PROVIDER_SESSION_ID_PATTERN.test(id));
+        if (ids.length === 0 || !existsSync(this.openCodeDatabasePath))
+            return 0;
+        let database = null;
+        try {
+            database = new DatabaseSync(this.openCodeDatabasePath);
+            database.exec("PRAGMA foreign_keys = ON");
+            const remove = database.prepare("DELETE FROM session WHERE id = ?");
+            let deleted = 0;
+            for (const id of ids)
+                deleted += Number(remove.run(id).changes ?? 0);
+            this.invalidate("opencode");
+            return deleted;
+        }
+        catch {
+            return 0;
+        }
+        finally {
+            try {
+                database?.close();
+            }
+            catch { /* best effort */ }
+        }
+    }
+    deleteQoderHistoryFiles(sessionIds) {
+        const ids = new Set(sessionIds.filter((id) => PROVIDER_SESSION_ID_PATTERN.test(id)));
+        if (ids.size === 0)
+            return 0;
+        let deleted = 0;
+        for (const filePath of this.listQoderTranscriptFiles()) {
+            const id = path.basename(filePath, ".jsonl");
+            if (!ids.has(id))
+                continue;
+            try {
+                unlinkSync(filePath);
+                deleted += 1;
+            }
+            catch { /* already absent */ }
+            this.qoderIndex.delete(filePath);
+        }
+        return deleted;
+    }
 }

package/dist/server-session-routes.d.ts

@@ -13,7 +13,7 @@ export declare function parseSessionCreationOrigin(body: {
     sessionSource: SessionSource;
     automationId?: string;
 };
-type SessionDeletionProcesses = Pick<ProcessManager, "get" | "delete" | "deleteClaudeHistoryFiles" | "deleteCodexHistoryFiles">;
+type SessionDeletionProcesses = Pick<ProcessManager, "get" | "delete" | "deleteClaudeHistoryFiles" | "deleteCodexHistoryFiles" | "deleteOpenCodeHistorySessions" | "deleteQoderHistoryFiles">;
 type SessionDeletionStructured = Pick<StructuredSessionManager, "get" | "delete">;
 /**
  * A Wand-managed session and its provider-native history represent the same
@@ -29,7 +29,7 @@ type ProviderHistorySession = {
     mtimeMs: number;
     hasConversation: boolean;
     managedByWand: boolean;
-    provider?: "claude" | "codex";
+    provider?: "claude" | "codex" | "opencode" | "qoder";
 };
 export type SessionListPageEntry = {
     type: "managed";
@@ -41,7 +41,7 @@ export type SessionListPageEntry = {
     key: string;
     sortTimestamp: number;
     history: ProviderHistorySession & {
-        provider: "claude" | "codex";
+        provider: "claude" | "codex" | "opencode" | "qoder";
     };
 };
 export interface SessionListPage {
@@ -50,14 +50,14 @@ export interface SessionListPage {
     total: number;
     revision: string;
 }
-export declare function buildSessionListPage(sessions: SessionSnapshot[], claudeHistory: ProviderHistorySession[], codexHistory: ProviderHistorySession[], hiddenHistoryIds: Set<string>, offset: number, limit: number): SessionListPage;
+export declare function buildSessionListPage(sessions: SessionSnapshot[], claudeHistory: ProviderHistorySession[], codexHistory: ProviderHistorySession[], hiddenHistoryIds: Set<string>, offset: number, limit: number, openCodeHistory?: ProviderHistorySession[], qoderHistory?: ProviderHistorySession[]): SessionListPage;
 /**
  * Provider history is scanned by ProcessManager, but structured sessions live
  * in StructuredSessionManager. Annotate against the combined session list so a
  * structured conversation is not also exposed as a recoverable native history
  * entry. Return copies for matches because ProcessManager caches scan results.
  */
-export declare function markManagedProviderHistory<T extends ProviderHistorySession>(history: T[], sessions: SessionSnapshot[], provider: "claude" | "codex"): T[];
+export declare function markManagedProviderHistory<T extends ProviderHistorySession>(history: T[], sessions: SessionSnapshot[], provider: "claude" | "codex" | "opencode" | "qoder"): T[];
 export declare function registerSessionRoutes(app: Express, processes: ProcessManager, structured: StructuredSessionManager, storage: WandStorage, defaultMode: ExecutionMode, config: WandConfig, sessions: SessionRegistry, onSessionCreated?: (cwd: string | undefined | null) => void): void;
 export declare function registerClaudeHistoryRoutes(app: Express, processes: ProcessManager, structured: StructuredSessionManager, storage: WandStorage, sessionRegistry: SessionRegistry): void;
 export {};

package/dist/server-session-routes.js

@@ -8,7 +8,7 @@ import { resolveSessionCwd } from "./session-cwd.js";
 import { resolveCommitAiContext } from "./session-ai-context.js";
 import { getGitStatusAsync, QuickCommitError, runQuickCommitWithFallback, runTagHead, runPush, generateCommitMessageOnly, } from "./git-quick-commit.js";
 import { getErrorMessage } from "./error-utils.js";
-import { buildProviderResumeCommand, isProviderSessionId } from "./resume-policy.js";
+import { buildProviderResumeCommand, isProviderSessionId, isSafeProviderSessionId } from "./resume-policy.js";
 import { parseBoundedInteger } from "./request-limits.js";
 import { asyncRoute } from "./express-async.js";
 import { enrichStructuredMessages, WAND_PROTOCOL_VERSION } from "./structured-client-protocol.js";
@@ -179,6 +179,12 @@ export function deleteSessionWithProviderHistory(processes, structured, storage,
     else if (provider === "codex") {
         processes.deleteCodexHistoryFiles([providerSessionId]);
     }
+    else if (provider === "opencode") {
+        processes.deleteOpenCodeHistorySessions([providerSessionId]);
+    }
+    else if (provider === "qoder") {
+        processes.deleteQoderHistoryFiles([providerSessionId]);
+    }
     else {
         return;
     }
@@ -190,7 +196,7 @@ function sessionSortTimestamp(snapshot) {
     const timestamp = Date.parse(snapshot.startedAt);
     return Number.isFinite(timestamp) ? timestamp : 0;
 }
-export function buildSessionListPage(sessions, claudeHistory, codexHistory, hiddenHistoryIds, offset, limit) {
+export function buildSessionListPage(sessions, claudeHistory, codexHistory, hiddenHistoryIds, offset, limit, openCodeHistory = [], qoderHistory = []) {
     const managed = sessions.map((session) => ({
         type: "managed",
         key: `session-${session.id}`,
@@ -200,8 +206,12 @@ export function buildSessionListPage(sessions, claudeHistory, codexHistory, hidd
     const recoverable = [
         ...markManagedProviderHistory(claudeHistory, sessions, "claude"),
         ...markManagedProviderHistory(codexHistory, sessions, "codex"),
+        ...markManagedProviderHistory(openCodeHistory, sessions, "opencode"),
+        ...markManagedProviderHistory(qoderHistory, sessions, "qoder"),
     ].flatMap((history) => {
-        const provider = history.provider === "codex" ? "codex" : "claude";
+        const provider = history.provider === "codex" || history.provider === "opencode" || history.provider === "qoder"
+            ? history.provider
+            : "claude";
         if (!history.hasConversation || history.managedByWand || hiddenHistoryIds.has(history.claudeSessionId)) {
             return [];
         }
@@ -238,7 +248,13 @@ export function markManagedProviderHistory(history, sessions, provider) {
     for (const session of sessions) {
         const sessionProvider = session.provider
             ?? session.structuredState?.provider
-            ?? (/^codex\b/i.test(session.command.trim()) ? "codex" : "claude");
+            ?? (/^codex\b/i.test(session.command.trim())
+                ? "codex"
+                : /^opencode\b/i.test(session.command.trim())
+                    ? "opencode"
+                    : /^qodercli\b/i.test(session.command.trim())
+                        ? "qoder"
+                        : "claude");
         const providerSessionId = session.claudeSessionId?.trim();
         if (sessionProvider === provider && providerSessionId) {
             managedIds.add(providerSessionId);
@@ -385,7 +401,7 @@ export function registerSessionRoutes(app, processes, structured, storage, defau
             const limit = parseBoundedInteger(req.query.limit, 40, 1, 200);
             const requestedRevision = typeof req.query.revision === "string" ? req.query.revision : "";
             const currentSessions = sessions.listSlim();
-            const page = buildSessionListPage(currentSessions, processes.listClaudeHistorySessions(), processes.listCodexHistorySessions(), getHiddenClaudeSessionIds(storage), offset, limit);
+            const page = buildSessionListPage(currentSessions, processes.listClaudeHistorySessions(), processes.listCodexHistorySessions(), getHiddenClaudeSessionIds(storage), offset, limit, processes.listOpenCodeHistorySessions(), processes.listQoderHistorySessions());
             if (offset > 0 && requestedRevision !== page.revision) {
                 res.status(409).json({ error: "会话列表已更新，请重新加载。", revision: page.revision });
                 return;
@@ -1136,6 +1152,80 @@ export function registerSessionRoutes(app, processes, structured, storage, defau
             res.status(400).json({ error: getErrorMessage(error, "无法按 Codex 会话 ID 恢复会话。") });
         }
     }));
+    /**
+     * OpenCode and Qoder own their native transcript storage. Restoring an
+     * external transcript creates a Wand structured shell carrying the native
+     * ID; each provider runner adds its own resume flag when the next input is
+     * sent, preserving the original context without importing the full history.
+     */
+    app.post("/api/opencode-sessions/:sessionId/resume", (req, res) => {
+        const sessionId = String(req.params.sessionId || "").trim();
+        const body = req.body;
+        try {
+            if (!isSafeProviderSessionId(sessionId)) {
+                res.status(400).json({ error: "OpenCode 会话 ID 格式无效。" });
+                return;
+            }
+            const history = processes.listOpenCodeHistorySessions().find((session) => session.claudeSessionId === sessionId);
+            if (!history) {
+                res.status(400).json({ error: "对应的 OpenCode 历史会话不存在，无法恢复。" });
+                return;
+            }
+            const cwd = body.cwd?.trim() || history.cwd;
+            if (!cwd) {
+                res.status(400).json({ error: "无法确定工作目录 (cwd)，无法恢复。" });
+                return;
+            }
+            const snapshot = structured.createSession({
+                cwd,
+                mode: parseExecutionMode(body.mode, defaultMode),
+                provider: "opencode",
+                runner: "opencode-cli-run",
+                worktreeEnabled: body.worktreeEnabled === true,
+                claudeSessionId: sessionId,
+                ...parseSessionCreationOrigin(body),
+            });
+            onSessionCreated?.(cwd);
+            res.status(201).json({ resumedClaudeSessionId: sessionId, ...sessionResponseDTO(snapshot) });
+        }
+        catch (error) {
+            res.status(400).json({ error: getErrorMessage(error, "无法按 OpenCode 会话 ID 恢复会话。") });
+        }
+    });
+    app.post("/api/qoder-sessions/:sessionId/resume", (req, res) => {
+        const sessionId = String(req.params.sessionId || "").trim();
+        const body = req.body;
+        try {
+            if (!isSafeProviderSessionId(sessionId)) {
+                res.status(400).json({ error: "Qoder 会话 ID 格式无效。" });
+                return;
+            }
+            const history = processes.listQoderHistorySessions().find((session) => session.claudeSessionId === sessionId);
+            if (!history) {
+                res.status(400).json({ error: "对应的 Qoder 历史会话不存在，无法恢复。" });
+                return;
+            }
+            const cwd = body.cwd?.trim() || history.cwd;
+            if (!cwd) {
+                res.status(400).json({ error: "无法确定工作目录 (cwd)，无法恢复。" });
+                return;
+            }
+            const snapshot = structured.createSession({
+                cwd,
+                mode: parseExecutionMode(body.mode, defaultMode),
+                provider: "qoder",
+                runner: "qoder-cli-print",
+                worktreeEnabled: body.worktreeEnabled === true,
+                claudeSessionId: sessionId,
+                ...parseSessionCreationOrigin(body),
+            });
+            onSessionCreated?.(cwd);
+            res.status(201).json({ resumedClaudeSessionId: sessionId, ...sessionResponseDTO(snapshot) });
+        }
+        catch (error) {
+            res.status(400).json({ error: getErrorMessage(error, "无法按 Qoder 会话 ID 恢复会话。") });
+        }
+    });
     app.post("/api/sessions/:id/resize", (req, res) => {
         const body = req.body;
         try {
@@ -1419,4 +1509,72 @@ export function registerClaudeHistoryRoutes(app, processes, structured, storage,
             res.status(500).json({ error: getErrorMessage(error, "无法批量删除历史会话。") });
         }
     });
+    const externalHistoryProviders = [
+        {
+            provider: "opencode",
+            label: "OpenCode",
+            list: () => processes.listOpenCodeHistorySessions(),
+            remove: (ids) => processes.deleteOpenCodeHistorySessions(ids),
+        },
+        {
+            provider: "qoder",
+            label: "Qoder",
+            list: () => processes.listQoderHistorySessions(),
+            remove: (ids) => processes.deleteQoderHistoryFiles(ids),
+        },
+    ];
+    for (const config of externalHistoryProviders) {
+        app.get(`/api/${config.provider}-history`, (_req, res) => {
+            try {
+                const history = markManagedProviderHistory(config.list(), sessionRegistry.listSlim(), config.provider);
+                const hidden = getHiddenClaudeSessionIds(storage);
+                res.json(hidden.size > 0 ? history.filter((session) => !hidden.has(session.claudeSessionId)) : history);
+            }
+            catch (error) {
+                res.status(500).json({ error: getErrorMessage(error, `无法扫描 ${config.label} 历史会话。`) });
+            }
+        });
+        app.delete(`/api/${config.provider}-history/:sessionId`, (req, res) => {
+            const sessionId = req.params.sessionId?.trim();
+            if (!sessionId) {
+                res.status(400).json({ error: "会话 ID 不能为空。" });
+                return;
+            }
+            try {
+                const exists = config.list().some((session) => session.claudeSessionId === sessionId);
+                if (exists) {
+                    config.remove([sessionId]);
+                    removeFromHiddenClaudeSessionIds(storage, [sessionId]);
+                }
+                else {
+                    addToHiddenClaudeSessionIds(storage, [sessionId]);
+                }
+                res.json({ ok: true });
+            }
+            catch (error) {
+                res.status(500).json({ error: getErrorMessage(error, `无法删除 ${config.label} 历史会话。`) });
+            }
+        });
+        app.post(`/api/${config.provider}-history/batch-delete`, (req, res) => {
+            const sessionIds = Array.isArray(req.body?.claudeSessionIds)
+                ? req.body.claudeSessionIds.filter((value) => typeof value === "string" && value.trim().length > 0)
+                : [];
+            if (sessionIds.length === 0) {
+                res.status(400).json({ error: "至少提供一个历史会话 ID。" });
+                return;
+            }
+            try {
+                const existing = new Set(config.list().map((session) => session.claudeSessionId));
+                const toDelete = sessionIds.filter((id) => existing.has(id));
+                const toHide = sessionIds.filter((id) => !existing.has(id));
+                const deleted = config.remove(toDelete);
+                removeFromHiddenClaudeSessionIds(storage, toDelete);
+                addToHiddenClaudeSessionIds(storage, toHide);
+                res.json({ ok: true, deleted: deleted + toHide.length });
+            }
+            catch (error) {
+                res.status(500).json({ error: getErrorMessage(error, `无法批量删除 ${config.label} 历史会话。`) });
+            }
+        });
+    }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@co0ontty/wand",
-  "version": "4.21.0",
+  "version": "4.22.0",
   "description": "A web console for Claude Code, Codex, OpenCode, and other local CLI tools.",
   "type": "module",
   "bin": {