@waishnav/devspace 1.0.3 → 1.0.4

package/dist/apply-patch.js

@@ -1,8 +1,9 @@
 import { randomUUID } from "node:crypto";
 import { constants } from "node:fs";
-import { access, mkdir, readFile, realpath, rename, rm, stat, writeFile } from "node:fs/promises";
+import { access, lstat, mkdir, readFile, realpath, rename, rm, stat, writeFile } from "node:fs/promises";
 import { dirname, isAbsolute, relative, resolve } from "node:path";
 import { TextDecoder } from "node:util";
+import { createTwoFilesPatch, FILE_HEADERS_ONLY } from "diff";
 function patchError(message) {
     return new Error(`Invalid patch: ${message}`);
 }
@@ -249,23 +250,56 @@ export async function replaceFile(temporary, destination, destinationExists, pla
     }
     await rm(backup, { force: true });
 }
+export async function isSamePatchFile(source, destination, readIdentity = lstat) {
+    if (source === destination)
+        return true;
+    if (source.toLowerCase() !== destination.toLowerCase())
+        return false;
+    try {
+        const [sourceIdentity, destinationIdentity] = await Promise.all([
+            readIdentity(source),
+            readIdentity(destination),
+        ]);
+        return sourceIdentity.dev === destinationIdentity.dev && sourceIdentity.ino === destinationIdentity.ino;
+    }
+    catch (error) {
+        const code = error.code;
+        if (code === "ENOENT" || code === "ENOTDIR")
+            return false;
+        throw error;
+    }
+}
 export async function applyPatch(root, patch) {
     const actions = parsePatch(patch);
     const results = [];
     const patches = [];
+    const staged = new Map();
+    const readStagedOptional = async (absolute, displayPath) => {
+        if (staged.has(absolute))
+            return staged.get(absolute) ?? null;
+        const file = await readOptionalTextFile(absolute, displayPath);
+        staged.set(absolute, file);
+        return file;
+    };
+    const readStagedRequired = async (absolute, displayPath) => {
+        const file = await readStagedOptional(absolute, displayPath);
+        if (!file)
+            throw patchError(`file does not exist: ${displayPath}`);
+        return file;
+    };
     for (const action of actions) {
         if (action.kind === "add") {
             const absolute = await resolveConfinedPath(root, action.path);
-            const original = await readOptionalTextFile(absolute, action.path);
-            await writeTextFile(absolute, action.content, original?.mode);
+            const original = await readStagedOptional(absolute, action.path);
+            staged.set(absolute, { content: action.content, mode: original?.mode });
             patches.push(unifiedFilePatch(action.path, action.path, original?.content ?? null, action.content));
             results.push({ path: action.path, operation: "add" });
             continue;
         }
         const absolute = await resolveConfinedPath(root, action.path);
-        const file = await readRequiredTextFile(absolute, action.path);
+        const file = await readStagedRequired(absolute, action.path);
         if (action.kind === "delete") {
-            await rm(absolute);
+            staged.set(absolute, null);
             patches.push(unifiedFilePatch(action.path, action.path, file.content, null));
             results.push({ path: action.path, operation: "delete" });
             continue;
@@ -273,32 +307,35 @@ export async function applyPatch(root, patch) {
         const updated = applyHunks(action.path, file.content, action.hunks);
         if (action.moveTo) {
             const destination = await resolveConfinedPath(root, action.moveTo);
-            if (destination !== absolute)
-                await readOptionalTextFile(destination, action.moveTo);
-            await writeTextFile(destination, updated, file.mode);
-            if (destination !== absolute)
-                await rm(absolute);
+            const samePatchFile = await isSamePatchFile(absolute, destination);
+            if (!samePatchFile)
+                await readStagedOptional(destination, action.moveTo);
+            if (samePatchFile)
+                staged.delete(absolute);
+            staged.set(destination, { content: updated, mode: file.mode });
+            if (!samePatchFile)
+                staged.set(absolute, null);
             patches.push(unifiedFilePatch(action.path, action.moveTo, file.content, updated));
             results.push({ path: action.moveTo, previousPath: action.path, operation: "move" });
         }
         else {
-            await writeTextFile(absolute, updated, file.mode);
+            staged.set(absolute, { content: updated, mode: file.mode });
             patches.push(unifiedFilePatch(action.path, action.path, file.content, updated));
             results.push({ path: action.path, operation: "update" });
         }
     }
+    for (const [absolute, file] of staged) {
+        if (file)
+            await writeTextFile(absolute, file.content, file.mode);
+    }
+    for (const [absolute, file] of staged) {
+        if (!file)
+            await rm(absolute, { force: true });
+    }
     const unifiedPatch = patches.filter(Boolean).join("\n");
     const stats = countPatchStats(unifiedPatch);
     return { files: results, patch: unifiedPatch, ...stats };
 }
-async function readRequiredTextFile(absolute, displayPath) {
-    if (!(await fileExists(absolute)))
-        throw patchError(`file does not exist: ${displayPath}`);
-    const metadata = await stat(absolute);
-    if (!metadata.isFile())
-        throw patchError(`path is not a regular file: ${displayPath}`);
-    return { content: await readUtf8Text(absolute, displayPath), mode: metadata.mode };
-}
 async function readOptionalTextFile(absolute, displayPath) {
     if (!(await fileExists(absolute)))
         return null;
@@ -332,60 +369,26 @@ async function writeTextFile(destination, content, mode) {
         throw error;
     }
 }
-function fileLines(content) {
-    if (content.length === 0)
-        return [];
-    const normalized = content.replace(/\r\n/g, "\n");
-    const lines = normalized.split("\n");
-    if (normalized.endsWith("\n"))
-        lines.pop();
-    return lines;
-}
-function hunkRange(start, count) {
-    return count === 0 ? "0,0" : `${start},${count}`;
-}
 function unifiedFilePatch(oldPath, newPath, oldContent, newContent) {
-    const oldLines = fileLines(oldContent ?? "");
-    const newLines = fileLines(newContent ?? "");
-    let prefix = 0;
-    while (prefix < oldLines.length &&
-        prefix < newLines.length &&
-        oldLines[prefix] === newLines[prefix]) {
-        prefix += 1;
-    }
-    let suffix = 0;
-    while (suffix < oldLines.length - prefix &&
-        suffix < newLines.length - prefix &&
-        oldLines[oldLines.length - 1 - suffix] === newLines[newLines.length - 1 - suffix]) {
-        suffix += 1;
-    }
-    const contextBefore = Math.min(3, prefix);
-    const contextAfter = Math.min(3, suffix);
-    const oldChanged = oldLines.slice(prefix, oldLines.length - suffix);
-    const newChanged = newLines.slice(prefix, newLines.length - suffix);
-    const before = oldLines.slice(prefix - contextBefore, prefix);
-    const after = oldLines.slice(oldLines.length - suffix, oldLines.length - suffix + contextAfter);
-    const oldCount = contextBefore + oldChanged.length + contextAfter;
-    const newCount = contextBefore + newChanged.length + contextAfter;
-    const oldStart = oldContent === null ? 0 : prefix - contextBefore + 1;
-    const newStart = newContent === null ? 0 : prefix - contextBefore + 1;
-    const displayOld = oldContent === null ? "/dev/null" : `a/${oldPath}`;
-    const displayNew = newContent === null ? "/dev/null" : `b/${newPath}`;
+    const oldFileName = oldContent === null ? "/dev/null" : `a/${oldPath}`;
+    const newFileName = newContent === null ? "/dev/null" : `b/${newPath}`;
+    const body = createTwoFilesPatch(oldFileName, newFileName, oldContent ?? "", newContent ?? "", "", "", { context: 3, headerOptions: FILE_HEADERS_ONLY });
     return [
         `diff --git a/${oldPath} b/${newPath}`,
         oldContent === null ? "new file mode 100644" : undefined,
         newContent === null ? "deleted file mode 100644" : undefined,
-        `--- ${displayOld}`,
-        `+++ ${displayNew}`,
-        `@@ -${hunkRange(oldStart, oldCount)} +${hunkRange(newStart, newCount)} @@`,
-        ...before.map((line) => ` ${line}`),
-        ...oldChanged.map((line) => `-${line}`),
-        ...newChanged.map((line) => `+${line}`),
-        ...after.map((line) => ` ${line}`),
+        stripFinalNewline(body),
     ]
         .filter((line) => line !== undefined)
         .join("\n");
 }
+function stripFinalNewline(value) {
+    if (value.endsWith("\r\n"))
+        return value.slice(0, -2);
+    if (value.endsWith("\n"))
+        return value.slice(0, -1);
+    return value;
+}
 function countPatchStats(patch) {
     let additions = 0;
     let removals = 0;

package/dist/cli.js

@@ -1,12 +1,22 @@
 #!/usr/bin/env node
 import { createRequire } from "node:module";
 import { stdin as input, stdout as output } from "node:process";
-import { resolve } from "node:path";
+import { spawn } from "node:child_process";
+import { mkdtempSync, writeFileSync } from "node:fs";
+import { readFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
 import * as prompts from "@clack/prompts";
 import { getShellConfig } from "@earendil-works/pi-coding-agent";
 import { satisfies } from "semver";
 import { loadConfig } from "./config.js";
-import { generateOwnerToken, loadDevspaceFiles, writeDevspaceAuth, writeDevspaceConfig, } from "./user-config.js";
+import { runLocalAgentProvider } from "./local-agent-adapters.js";
+import { isLocalAgentProvider, loadLocalAgentProfiles, } from "./local-agent-profiles.js";
+import { assertLocalAgentProviderAvailable, formatLocalAgentProviderAvailabilitySummary, } from "./local-agent-availability.js";
+import { formatAvailableLocalAgentTargets, parseLocalAgentRunArgs, resolveLocalAgentTarget, } from "./local-agent-targets.js";
+import { createLocalAgentStore } from "./local-agent-store.js";
+import { ensureDevspaceDefaultSkills, generateOwnerToken, loadDevspaceFiles, resolveSubagentsFlag, writeDevspaceAuth, writeDevspaceConfig, } from "./user-config.js";
 import { expandHomePath } from "./roots.js";
 const require = createRequire(import.meta.url);
 const SUPPORTED_NODE_RANGE = ">=20.12 <27";
@@ -28,6 +38,9 @@ async function main(argv) {
         case "config":
             runConfigCommand(args);
             return;
+        case "agents":
+            await runAgentsCommand(args);
+            return;
         case "help":
             printHelp();
             return;
@@ -39,7 +52,7 @@ async function main(argv) {
 function normalizeCommand(command) {
     if (!command || command === "serve" || command === "start")
         return "serve";
-    if (command === "init" || command === "doctor" || command === "config")
+    if (command === "init" || command === "doctor" || command === "config" || command === "agents")
         return command;
     if (command === "help" || command === "--help" || command === "-h")
         return "help";
@@ -113,15 +126,18 @@ async function runInit({ force }) {
             port,
             allowedRoots,
             publicBaseUrl,
+            subagents: resolveSubagentsFlag(files.config),
         };
         const auth = {
             ownerToken: files.auth.ownerToken ?? generateOwnerToken(),
         };
         const configPath = writeDevspaceConfig(config);
         const authPath = writeDevspaceAuth(auth);
+        const seededSkillPaths = config.subagents ? ensureDevspaceDefaultSkills() : [];
         const lines = [
             `Config: ${configPath}`,
             `Auth: ${authPath}`,
+            ...seededSkillPaths.map((path) => `Default skill: ${path}`),
             `Local MCP URL: http://${config.host}:${config.port}/mcp`,
             ...(publicBaseUrl ? [`Public MCP URL: ${publicBaseUrl}/mcp`] : []),
         ];
@@ -154,7 +170,7 @@ async function serve() {
     }
     const { createServer } = await import("./server.js");
     const config = loadConfig();
-    const { app, close } = createServer(config);
+    const { app, close, localAgentProviders } = createServer(config);
     const httpServer = app.listen(config.port, config.host, () => {
         console.log(`devspace listening on http://${config.host}:${config.port}/mcp`);
         console.log(`public base url: ${config.publicBaseUrl}`);
@@ -165,6 +181,9 @@ async function serve() {
         }
         console.log("auth: Owner password approval required");
         console.log(`logging: ${config.logging.level} ${config.logging.format}`);
+        if (config.subagents) {
+            console.log(`subagent providers: ${formatLocalAgentProviderAvailabilitySummary(localAgentProviders)}`);
+        }
     });
     const shutdown = () => {
         httpServer.close(() => {
@@ -231,12 +250,232 @@ function printHelp() {
         "  devspace doctor          Show config, runtime, and native dependency status",
         "  devspace config get      Print persisted config",
         "  devspace config set publicBaseUrl <url|null>",
+        "  devspace agents ls       List subagent sessions",
+        "  devspace agents run <profile-or-provider-or-id> [--model <model>] <prompt>",
+        "  devspace agents show <id>",
         "  devspace -v, --version   Print the installed version",
         "",
         "For temporary tunnels:",
         "  DEVSPACE_PUBLIC_BASE_URL=https://example.trycloudflare.com devspace serve",
     ].join("\n"));
 }
+async function runAgentsCommand(args) {
+    const [subcommand, ...rest] = args;
+    switch (subcommand) {
+        case "ls":
+        case "list":
+            await runAgentsList();
+            return;
+        case "run":
+            await runAgentsRun(rest);
+            return;
+        case "show":
+            await runAgentsShow(rest);
+            return;
+        case "__worker":
+            await runAgentsWorker(rest);
+            return;
+        case undefined:
+        case "help":
+        case "--help":
+        case "-h":
+            printAgentsHelp();
+            return;
+        default:
+            throw new Error(`Unknown agents command: ${subcommand}`);
+    }
+}
+async function runAgentsList() {
+    const config = loadConfig();
+    const store = createLocalAgentStore(config);
+    const agents = store.list(resolveCurrentWorkspaceScope());
+    if (agents.length === 0) {
+        console.log("No subagent sessions found for this workspace.");
+        return;
+    }
+    for (const agent of agents) {
+        console.log(formatAgentLine(agent));
+    }
+}
+async function runAgentsRun(args) {
+    const parsed = parseLocalAgentRunArgs(args);
+    const config = loadConfig();
+    const workspaceRoot = resolveCurrentWorkspaceRoot();
+    const store = createLocalAgentStore(config);
+    const existing = store.get(parsed.target);
+    if (existing) {
+        if (!isLocalAgentProvider(existing.provider)) {
+            throw new Error(`Unknown subagent provider for existing session: ${existing.provider}`);
+        }
+        assertLocalAgentProviderAvailable(existing.provider);
+        const promptFile = writeAgentPromptFile(parsed.prompt);
+        store.update(existing.id, {
+            status: "starting",
+            model: parsed.model ?? existing.model,
+            thinking: parsed.thinking ?? existing.thinking,
+            latestResponse: undefined,
+            error: undefined,
+        });
+        spawnAgentWorker(existing.id, promptFile);
+        console.log(formatAgentLine({
+            ...existing,
+            status: "running",
+            model: parsed.model ?? existing.model,
+            thinking: parsed.thinking ?? existing.thinking,
+        }));
+        return;
+    }
+    const profiles = await loadLocalAgentProfiles(config, workspaceRoot);
+    const target = resolveLocalAgentTarget(parsed.target, profiles, parsed.model, parsed.thinking);
+    if (!target) {
+        throw new Error(`Unknown subagent profile, provider, or id: ${parsed.target}. Available ${formatAvailableLocalAgentTargets(profiles)}`);
+    }
+    assertLocalAgentProviderAvailable(target.provider);
+    const promptFile = writeAgentPromptFile(parsed.prompt);
+    const record = store.create({
+        workspaceId: process.env.DEVSPACE_WORKSPACE_ID,
+        workspaceRoot,
+        profileName: target.name,
+        provider: target.provider,
+        model: target.model,
+        thinking: target.thinking,
+    });
+    spawnAgentWorker(record.id, promptFile);
+    console.log(formatAgentLine({ ...record, status: "running" }));
+}
+async function runAgentsShow(args) {
+    const [id] = args;
+    if (!id)
+        throw new Error("Usage: devspace agents show <id>");
+    const config = loadConfig();
+    const store = createLocalAgentStore(config);
+    let record = store.get(id);
+    if (!record)
+        throw new Error(`Unknown subagent id: ${id}`);
+    const deadline = Date.now() + 15_000;
+    while ((record.status === "starting" || record.status === "running") && Date.now() < deadline) {
+        await sleep(500);
+        record = store.get(id) ?? record;
+    }
+    console.log(formatAgentLine(record));
+    if (record.latestResponse) {
+        console.log(record.latestResponse);
+        return;
+    }
+    if (record.error) {
+        console.log(record.error);
+        return;
+    }
+    if (record.status === "starting" || record.status === "running") {
+        console.log(`No final response yet. Call \`devspace agents show ${record.id}\` again later.`);
+    }
+}
+async function runAgentsWorker(args) {
+    const [id, promptFileFlag, promptFile] = args;
+    if (!id || promptFileFlag !== "--prompt-file" || !promptFile) {
+        throw new Error("Usage: devspace agents __worker <id> --prompt-file <path>");
+    }
+    const config = loadConfig();
+    const store = createLocalAgentStore(config);
+    const record = store.get(id);
+    if (!record)
+        throw new Error(`Unknown subagent id: ${id}`);
+    store.update(record.id, { status: "running", error: undefined });
+    try {
+        const profiles = await loadLocalAgentProfiles(config, record.workspaceRoot);
+        const profile = profiles.find((candidate) => candidate.name === record.profileName);
+        const prompt = await readFile(promptFile, "utf8");
+        const result = profile
+            ? await runLocalAgentProfile(profile, record, prompt)
+            : await runRawLocalAgentProvider(record, prompt);
+        store.update(record.id, {
+            providerSessionId: result.providerSessionId ?? undefined,
+            status: "idle",
+            latestResponse: result.finalResponse,
+            error: undefined,
+        });
+    }
+    catch (error) {
+        store.update(record.id, {
+            status: "error",
+            error: error instanceof Error ? error.message : String(error),
+        });
+    }
+}
+async function runLocalAgentProfile(profile, record, prompt) {
+    const body = profile.body.trim();
+    const fullPrompt = body ? `${body}\n\nTask:\n${prompt}` : prompt;
+    return runLocalAgentProvider(profile.provider, {
+        prompt: fullPrompt,
+        workspace: record.workspaceRoot,
+        providerSessionId: record.providerSessionId,
+        writeMode: "allowed",
+        model: record.model ?? profile.model,
+        thinking: record.thinking ?? profile.thinking,
+    });
+}
+async function runRawLocalAgentProvider(record, prompt) {
+    if (record.profileName !== record.provider || !isLocalAgentProvider(record.provider)) {
+        throw new Error(`Subagent profile not found: ${record.profileName}`);
+    }
+    return runLocalAgentProvider(record.provider, {
+        prompt,
+        workspace: record.workspaceRoot,
+        providerSessionId: record.providerSessionId,
+        writeMode: "allowed",
+        model: record.model,
+        thinking: record.thinking,
+    });
+}
+function spawnAgentWorker(agentId, promptFile) {
+    const child = spawn(process.execPath, [
+        ...process.execArgv,
+        fileURLToPath(import.meta.url),
+        "agents",
+        "__worker",
+        agentId,
+        "--prompt-file",
+        promptFile,
+    ], {
+        detached: true,
+        stdio: "ignore",
+        env: process.env,
+    });
+    child.unref();
+}
+function writeAgentPromptFile(prompt) {
+    const directory = mkdtempSync(join(tmpdir(), "devspace-agent-prompt-"));
+    const filePath = join(directory, "prompt.txt");
+    writeFileSync(filePath, prompt, { mode: 0o600 });
+    return filePath;
+}
+function resolveCurrentWorkspaceRoot() {
+    return resolve(process.env.DEVSPACE_WORKSPACE_ROOT || process.cwd());
+}
+function resolveCurrentWorkspaceScope() {
+    return {
+        workspaceId: process.env.DEVSPACE_WORKSPACE_ID,
+        workspaceRoot: resolveCurrentWorkspaceRoot(),
+    };
+}
+function formatAgentLine(agent) {
+    const model = agent.model ? ` ${agent.model}` : "";
+    const thinking = agent.thinking ? ` thinking=${agent.thinking}` : "";
+    return `${agent.id} ${agent.status} ${agent.profileName} ${agent.provider}${model}${thinking}`;
+}
+function sleep(ms) {
+    return new Promise((resolveSleep) => setTimeout(resolveSleep, ms));
+}
+function printAgentsHelp() {
+    console.log([
+        "DevSpace agents",
+        "",
+        "Usage:",
+        "  devspace agents ls",
+        "  devspace agents run <profile-or-provider-or-id> [--model <model>] [--thinking <level>] <prompt>",
+        "  devspace agents show <id>",
+    ].join("\n"));
+}
 function printVersion() {
     const packageJson = require("../package.json");
     if (typeof packageJson.version !== "string") {

package/dist/config.js

@@ -1,7 +1,7 @@
 import { homedir } from "node:os";
 import { join, resolve } from "node:path";
 import { expandHomePath } from "./roots.js";
-import { loadDevspaceFiles } from "./user-config.js";
+import { devspaceAgentsDir, devspaceSkillsDir, loadDevspaceFiles } from "./user-config.js";
 const DEFAULT_OAUTH_ACCESS_TOKEN_TTL_SECONDS = 60 * 60;
 const DEFAULT_OAUTH_REFRESH_TOKEN_TTL_SECONDS = 30 * 24 * 60 * 60;
 function parsePort(value) {
@@ -91,13 +91,6 @@ function parsePositiveInteger(value, fallback, name) {
     }
     return parsed;
 }
-function parseToolNaming(value) {
-    if (!value || value === "short")
-        return "short";
-    if (value === "legacy")
-        return "legacy";
-    throw new Error(`Invalid DEVSPACE_TOOL_NAMING: ${value}`);
-}
 function parseLoggingConfig(env) {
     return {
         level: parseLogLevel(env.DEVSPACE_LOG_LEVEL),
@@ -169,12 +162,16 @@ export function loadConfig(env = process.env) {
         allowedHosts: parseAllowedHosts(env.DEVSPACE_ALLOWED_HOSTS, derivedAllowedHosts),
         publicBaseUrl,
         toolMode: parseToolMode(env),
-        toolNaming: parseToolNaming(env.DEVSPACE_TOOL_NAMING),
         widgets: parseWidgetMode(env.DEVSPACE_WIDGETS),
         stateDir: resolve(expandHomePath(env.DEVSPACE_STATE_DIR ?? files.config.stateDir ?? defaultStateDir())),
         worktreeRoot: resolve(expandHomePath(env.DEVSPACE_WORKTREE_ROOT ?? files.config.worktreeRoot ?? defaultWorktreeRoot())),
         skillsEnabled: env.DEVSPACE_SKILLS === undefined ? true : parseBoolean(env.DEVSPACE_SKILLS),
         skillPaths: parsePathList(env.DEVSPACE_SKILL_PATHS),
+        devspaceSkillsDir: devspaceSkillsDir(env),
+        devspaceAgentsDir: devspaceAgentsDir(env),
+        subagents: env.DEVSPACE_SUBAGENTS === undefined
+            ? files.config.subagents === true
+            : parseBoolean(env.DEVSPACE_SUBAGENTS),
         agentDir: resolve(expandHomePath(env.DEVSPACE_AGENT_DIR ?? files.config.agentDir ?? defaultAgentDir())),
         logging: parseLoggingConfig(env),
     };

package/dist/db/migrations.js

@@ -9,6 +9,11 @@ const migrations = [
         name: "oauth-state",
         up: migrateOAuthState,
     },
+    {
+        version: 3,
+        name: "local-agent-sessions",
+        up: migrateLocalAgentSessions,
+    },
 ];
 export function migrateDatabase(sqlite) {
     const migrate = sqlite.transaction(() => {
@@ -115,6 +120,35 @@ function migrateOAuthState(sqlite) {
       on oauth_refresh_tokens(expires_at);
   `);
 }
+function migrateLocalAgentSessions(sqlite) {
+    sqlite.exec(`
+    create table if not exists local_agent_sessions (
+      id text primary key,
+      workspace_id text,
+      workspace_root text not null,
+      profile_name text not null,
+      provider text not null,
+      model text,
+      thinking text,
+      provider_session_id text,
+      status text not null,
+      latest_response text,
+      error text,
+      created_at text not null,
+      updated_at text not null
+    );
+
+    create index if not exists local_agent_sessions_workspace_id_idx
+      on local_agent_sessions(workspace_id, updated_at desc);
+
+    create index if not exists local_agent_sessions_workspace_root_idx
+      on local_agent_sessions(workspace_root, updated_at desc);
+
+    create index if not exists local_agent_sessions_provider_session_id_idx
+      on local_agent_sessions(provider_session_id);
+  `);
+    addColumnIfMissing(sqlite, "local_agent_sessions", "thinking", "text");
+}
 function addColumnIfMissing(sqlite, table, column, definition) {
     const columns = sqlite.prepare(`pragma table_info(${table})`).all();
     if (columns.some((existingColumn) => existingColumn.name === column))

package/dist/db/schema.js

@@ -50,3 +50,22 @@ export const oauthRefreshTokens = sqliteTable("oauth_refresh_tokens", {
     expiresAt: integer("expires_at").notNull(),
     resource: text("resource"),
 });
+export const localAgentSessions = sqliteTable("local_agent_sessions", {
+    id: text("id").primaryKey(),
+    workspaceId: text("workspace_id"),
+    workspaceRoot: text("workspace_root").notNull(),
+    profileName: text("profile_name").notNull(),
+    provider: text("provider").notNull(),
+    model: text("model"),
+    thinking: text("thinking"),
+    providerSessionId: text("provider_session_id"),
+    status: text("status").notNull(),
+    latestResponse: text("latest_response"),
+    error: text("error"),
+    createdAt: text("created_at").notNull(),
+    updatedAt: text("updated_at").notNull(),
+}, (table) => [
+    index("local_agent_sessions_workspace_id_idx").on(table.workspaceId, table.updatedAt),
+    index("local_agent_sessions_workspace_root_idx").on(table.workspaceRoot, table.updatedAt),
+    index("local_agent_sessions_provider_session_id_idx").on(table.providerSessionId),
+]);