agor-live 0.16.1 → 0.16.3

package/dist/cli/commands/board/add-session.js

@@ -161,8 +161,7 @@ var BoardAddSession = class _BoardAddSession extends BaseCommand {
     const { args } = await this.parse(_BoardAddSession);
     const client = await this.connectToDaemon();
     try {
-      const boardsResult = await client.service("boards").find({ query: { $limit: PAGINATION.DEFAULT_LIMIT } });
-      const boards = Array.isArray(boardsResult) ? boardsResult : boardsResult.data;
+      const boards = await client.service("boards").findAll({ query: { $limit: PAGINATION.DEFAULT_LIMIT } });
       const board = boards.find(
         (b) => b.board_id === args.boardId || b.board_id.startsWith(args.boardId) || b.slug === args.boardId
       );
@@ -170,8 +169,7 @@ var BoardAddSession = class _BoardAddSession extends BaseCommand {
         await this.cleanupClient(client);
         this.error(`Board not found: ${args.boardId}`);
       }
-      const sessionsResult = await client.service("sessions").find({ query: { $limit: PAGINATION.DEFAULT_LIMIT } });
-      const sessions = Array.isArray(sessionsResult) ? sessionsResult : sessionsResult.data;
+      const sessions = await client.service("sessions").findAll({ query: { $limit: PAGINATION.DEFAULT_LIMIT } });
       const session = sessions.find(
         (s) => s.session_id === args.sessionId || s.session_id.startsWith(args.sessionId)
       );
@@ -183,19 +181,17 @@ var BoardAddSession = class _BoardAddSession extends BaseCommand {
         await this.cleanupClient(client);
         this.error("Session has no worktree associated");
       }
-      const worktreesResult = await client.service("worktrees").find({ query: { $limit: PAGINATION.DEFAULT_LIMIT } });
-      const worktrees = Array.isArray(worktreesResult) ? worktreesResult : worktreesResult.data;
+      const worktrees = await client.service("worktrees").findAll({ query: { $limit: PAGINATION.DEFAULT_LIMIT } });
       const worktree = worktrees.find((w) => w.worktree_id === session.worktree_id);
       if (!worktree) {
         await this.cleanupClient(client);
         this.error("Worktree not found for session");
       }
-      const boardObjectsResult = await client.service("board-objects").find({
+      const boardObjects = await client.service("board-objects").findAll({
         query: {
           board_id: board.board_id
         }
       });
-      const boardObjects = Array.isArray(boardObjectsResult) ? boardObjectsResult : boardObjectsResult.data;
       const existingObject = boardObjects.find(
         (bo) => bo.worktree_id === worktree.worktree_id
       );

package/dist/cli/commands/board/list.js

@@ -156,15 +156,13 @@ var BoardList = class _BoardList extends BaseCommand {
     const { flags } = await this.parse(_BoardList);
     const client = await this.connectToDaemon();
     try {
-      const result = await client.service("boards").find({ query: { $limit: PAGINATION.DEFAULT_LIMIT } });
-      const allBoards = Array.isArray(result) ? result : result.data;
+      const allBoards = await client.service("boards").findAll({ query: { $limit: PAGINATION.DEFAULT_LIMIT } });
       if (allBoards.length === 0) {
         this.log(chalk2.yellow("No boards found."));
         await this.cleanupClient(client);
         return;
       }
-      const boardObjectsResult = await client.service("board-objects").find({ query: { $limit: PAGINATION.DEFAULT_LIMIT } });
-      const boardObjects = Array.isArray(boardObjectsResult) ? boardObjectsResult : boardObjectsResult.data;
+      const boardObjects = await client.service("board-objects").findAll({ query: { $limit: PAGINATION.DEFAULT_LIMIT } });
       const displayBoards = allBoards.slice(0, flags.limit);
       const table = new Table({
         head: [

package/dist/cli/commands/daemon/sync.d.ts

@@ -0,0 +1,19 @@
+import * as _oclif_core_interfaces from '@oclif/core/interfaces';
+import { Command } from '@oclif/core';
+
+declare class DaemonSync extends Command {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        'dry-run': _oclif_core_interfaces.BooleanFlag<boolean>;
+        config: _oclif_core_interfaces.OptionFlag<string | undefined, _oclif_core_interfaces.CustomOptions>;
+    };
+    run(): Promise<void>;
+    private loadConfigFromPath;
+    private logCounts;
+    private syncRepos;
+    private syncWorktrees;
+    private syncUsers;
+}
+
+export { DaemonSync as default };

package/dist/cli/commands/daemon/sync.js

@@ -0,0 +1,277 @@
+// src/commands/daemon/sync.ts
+import { existsSync, mkdirSync } from "fs";
+import { join } from "path";
+import {
+  buildSlugToRepoIdMap,
+  daemonResourcesConfigSchema,
+  determineRepoAction,
+  determineUserAction,
+  determineWorktreeAction,
+  getReposDir,
+  getWorktreePath,
+  loadConfig,
+  loadConfigFromFile,
+  resolvePassword,
+  validateResourceCrossReferences
+} from "@agor/core/config";
+import {
+  createDatabase,
+  getDatabaseUrl,
+  hash,
+  RepoRepository,
+  UsersRepository,
+  WorktreeRepository
+} from "@agor/core/db";
+import { autoAssignWorktreeUniqueId } from "@agor/core/environment/variable-resolver";
+import { cloneRepo, createWorktree, getWorktreesDir } from "@agor/core/git";
+import { Command, Flags } from "@oclif/core";
+import chalk from "chalk";
+var DaemonSync = class _DaemonSync extends Command {
+  static description = "Sync resources from config.yml into database and filesystem";
+  static examples = [
+    "<%= config.bin %> daemon sync",
+    "<%= config.bin %> daemon sync --dry-run",
+    "<%= config.bin %> daemon sync --config /path/to/config.yml"
+  ];
+  static flags = {
+    "dry-run": Flags.boolean({
+      description: "Validate and report what would change without making changes",
+      default: false
+    }),
+    config: Flags.string({
+      char: "c",
+      description: "Path to config file (default: ~/.agor/config.yaml)"
+    })
+  };
+  async run() {
+    const { flags } = await this.parse(_DaemonSync);
+    const dryRun = flags["dry-run"];
+    const config = flags.config ? await this.loadConfigFromPath(flags.config) : await loadConfig();
+    if (!config.resources) {
+      this.log(chalk.yellow("No resources section in config \u2014 nothing to sync."));
+      return;
+    }
+    const parseResult = daemonResourcesConfigSchema.safeParse(config.resources);
+    if (!parseResult.success) {
+      this.log(chalk.red("Config validation failed:"));
+      for (const issue of parseResult.error.issues) {
+        this.log(chalk.red(`  ${issue.path.join(".")}: ${issue.message}`));
+      }
+      this.exit(1);
+    }
+    const resources = parseResult.data;
+    const crossRefErrors = validateResourceCrossReferences(resources);
+    if (crossRefErrors.length > 0) {
+      this.log(chalk.red("Resource cross-reference errors:"));
+      for (const err of crossRefErrors) {
+        this.log(chalk.red(`  ${err.path}: ${err.message}`));
+      }
+      this.exit(1);
+    }
+    this.log(chalk.bold("Syncing resources from config..."));
+    if (dryRun) {
+      this.log(chalk.yellow("(dry-run mode \u2014 no changes will be made)"));
+    }
+    this.log("");
+    const dbUrl = getDatabaseUrl();
+    const db = createDatabase({ url: dbUrl });
+    const repoRepo = new RepoRepository(db);
+    const worktreeRepo = new WorktreeRepository(db);
+    const usersRepo = new UsersRepository(db);
+    const repoCounts = await this.syncRepos(resources.repos ?? [], repoRepo, dryRun);
+    const worktreeCounts = await this.syncWorktrees(
+      resources.worktrees ?? [],
+      resources.repos ?? [],
+      worktreeRepo,
+      dryRun
+    );
+    const userCounts = await this.syncUsers(resources.users ?? [], usersRepo, dryRun);
+    this.log("");
+    this.log(chalk.bold("Sync complete:"));
+    this.logCounts("Repos", repoCounts);
+    this.logCounts("Worktrees", worktreeCounts);
+    this.logCounts("Users", userCounts);
+  }
+  async loadConfigFromPath(configPath) {
+    try {
+      return await loadConfigFromFile(configPath);
+    } catch (error) {
+      this.log(chalk.red(`Failed to load config from ${configPath}:`));
+      this.log(chalk.red(`  ${error instanceof Error ? error.message : String(error)}`));
+      this.exit(1);
+    }
+  }
+  logCounts(label, counts) {
+    const parts = [];
+    if (counts.created > 0) parts.push(chalk.green(`${counts.created} created`));
+    if (counts.updated > 0) parts.push(chalk.yellow(`${counts.updated} updated`));
+    if (counts.unchanged > 0) parts.push(chalk.dim(`${counts.unchanged} unchanged`));
+    this.log(`  ${label}: ${parts.length > 0 ? parts.join(", ") : chalk.dim("none declared")}`);
+  }
+  // ---------------------------------------------------------------------------
+  // Repo sync
+  // ---------------------------------------------------------------------------
+  async syncRepos(repos, repoRepo, dryRun) {
+    const counts = { created: 0, updated: 0, unchanged: 0 };
+    for (const repoCfg of repos) {
+      const existing = await repoRepo.findBySlug(repoCfg.slug);
+      const repoPath = join(getReposDir(), repoCfg.slug);
+      const fsExists = existsSync(repoPath);
+      const action = determineRepoAction(repoCfg, existing);
+      if (action === "create") {
+        this.log(`  ${chalk.green("create")} repo ${chalk.cyan(repoCfg.slug)}`);
+        if (!dryRun) {
+          if (repoCfg.remote_url) {
+            mkdirSync(getReposDir(), { recursive: true });
+            await cloneRepo({ url: repoCfg.remote_url, targetDir: repoPath });
+          }
+          await repoRepo.create({
+            repo_id: repoCfg.repo_id,
+            slug: repoCfg.slug,
+            name: repoCfg.slug,
+            repo_type: repoCfg.repo_type ?? "remote",
+            remote_url: repoCfg.remote_url,
+            default_branch: repoCfg.default_branch ?? "main",
+            local_path: repoPath
+          });
+        }
+        counts.created++;
+      } else if (action === "update") {
+        this.log(`  ${chalk.yellow("update")} repo ${chalk.cyan(repoCfg.slug)}`);
+        if (!dryRun && existing) {
+          await repoRepo.update(existing.repo_id, {
+            remote_url: repoCfg.remote_url ?? existing.remote_url,
+            default_branch: repoCfg.default_branch ?? existing.default_branch
+          });
+        }
+        counts.updated++;
+      } else {
+        counts.unchanged++;
+      }
+      if (existing && !fsExists && repoCfg.remote_url && !dryRun) {
+        this.log(`  ${chalk.green("clone")} repo ${chalk.cyan(repoCfg.slug)} (filesystem missing)`);
+        mkdirSync(getReposDir(), { recursive: true });
+        await cloneRepo({ url: repoCfg.remote_url, targetDir: repoPath });
+      }
+    }
+    return counts;
+  }
+  // ---------------------------------------------------------------------------
+  // Worktree sync
+  // ---------------------------------------------------------------------------
+  async syncWorktrees(worktrees, repos, worktreeRepo, dryRun) {
+    const counts = { created: 0, updated: 0, unchanged: 0 };
+    const slugToId = buildSlugToRepoIdMap(repos);
+    for (const wtCfg of worktrees) {
+      const repoId = slugToId.get(wtCfg.repo);
+      if (!repoId) {
+        this.log(chalk.red(`  skip worktree "${wtCfg.name}" \u2014 repo "${wtCfg.repo}" not found`));
+        continue;
+      }
+      const existing = await worktreeRepo.findByRepoAndName(repoId, wtCfg.name);
+      const action = determineWorktreeAction(wtCfg, existing);
+      if (action === "create") {
+        this.log(
+          `  ${chalk.green("create")} worktree ${chalk.cyan(`${wtCfg.repo}/${wtCfg.name}`)}`
+        );
+        if (!dryRun) {
+          const repoPath = join(getReposDir(), wtCfg.repo);
+          const worktreePath = getWorktreePath(wtCfg.repo, wtCfg.name);
+          if (!existsSync(worktreePath)) {
+            mkdirSync(join(getWorktreesDir(), wtCfg.repo), { recursive: true });
+            await createWorktree(
+              repoPath,
+              worktreePath,
+              wtCfg.ref,
+              false,
+              false,
+              void 0,
+              void 0,
+              wtCfg.ref_type
+            );
+          }
+          const usedIds = await worktreeRepo.getAllUsedUniqueIds();
+          const nextId = autoAssignWorktreeUniqueId(usedIds);
+          await worktreeRepo.create({
+            worktree_id: wtCfg.worktree_id,
+            repo_id: repoId,
+            name: wtCfg.name,
+            ref: wtCfg.ref,
+            ref_type: wtCfg.ref_type ?? "branch",
+            path: worktreePath,
+            worktree_unique_id: nextId,
+            others_can: wtCfg.others_can ?? "session",
+            mcp_server_ids: wtCfg.mcp_server_ids,
+            new_branch: false,
+            last_used: (/* @__PURE__ */ new Date()).toISOString()
+          });
+        }
+        counts.created++;
+      } else if (action === "update") {
+        this.log(
+          `  ${chalk.yellow("update")} worktree ${chalk.cyan(`${wtCfg.repo}/${wtCfg.name}`)}`
+        );
+        if (!dryRun && existing) {
+          await worktreeRepo.update(existing.worktree_id, {
+            ref: wtCfg.ref,
+            ref_type: wtCfg.ref_type ?? existing.ref_type,
+            others_can: wtCfg.others_can ?? existing.others_can,
+            mcp_server_ids: wtCfg.mcp_server_ids ?? existing.mcp_server_ids
+          });
+        }
+        counts.updated++;
+      } else {
+        counts.unchanged++;
+      }
+    }
+    return counts;
+  }
+  // ---------------------------------------------------------------------------
+  // User sync
+  // ---------------------------------------------------------------------------
+  async syncUsers(users, usersRepo, dryRun) {
+    const counts = { created: 0, updated: 0, unchanged: 0 };
+    for (const userCfg of users) {
+      const existing = await usersRepo.findByEmail(userCfg.email);
+      const action = determineUserAction(userCfg, existing);
+      if (action === "create") {
+        this.log(`  ${chalk.green("create")} user ${chalk.cyan(userCfg.email)}`);
+        if (!dryRun) {
+          const resolved = resolvePassword(userCfg.password);
+          if (resolved.mustChange) {
+            this.log(
+              `    ${chalk.dim("generated temporary password for")} ${userCfg.email}: ${chalk.yellow(resolved.password)}`
+            );
+          }
+          const hashedPassword = await hash(resolved.password, 12);
+          await usersRepo.create({
+            user_id: userCfg.user_id,
+            email: userCfg.email,
+            name: userCfg.name,
+            role: userCfg.role ?? "member",
+            unix_username: userCfg.unix_username,
+            password: hashedPassword,
+            must_change_password: resolved.mustChange
+          });
+        }
+        counts.created++;
+      } else if (action === "update") {
+        this.log(`  ${chalk.yellow("update")} user ${chalk.cyan(userCfg.email)}`);
+        if (!dryRun && existing) {
+          await usersRepo.update(existing.user_id, {
+            name: userCfg.name ?? existing.name,
+            role: userCfg.role ?? existing.role,
+            unix_username: userCfg.unix_username ?? existing.unix_username
+          });
+        }
+        counts.updated++;
+      } else {
+        counts.unchanged++;
+      }
+    }
+    return counts;
+  }
+};
+export {
+  DaemonSync as default
+};

package/dist/cli/commands/mcp/list.js

@@ -172,8 +172,7 @@ var McpList = class _McpList extends BaseCommand {
       if (flags.scope) query.scope = flags.scope;
       if (flags.transport) query.transport = flags.transport;
       if (flags.enabled) query.enabled = true;
-      const result = await client.service("mcp-servers").find({ query });
-      const servers = Array.isArray(result) ? result : result.data;
+      const servers = await client.service("mcp-servers").findAll({ query });
       if (servers.length === 0) {
         this.log(chalk2.yellow("No MCP servers found."));
         await this.cleanupClient(client);

package/dist/cli/commands/mcp/remove.js

@@ -165,10 +165,9 @@ var McpRemove = class _McpRemove extends BaseCommand {
     try {
       let serverId = args.id;
       if (!args.id.match(/^[0-9a-f]{8}/i)) {
-        const result = await client.service("mcp-servers").find({
+        const servers = await client.service("mcp-servers").findAll({
           query: { $limit: 100 }
         });
-        const servers = Array.isArray(result) ? result : result.data;
         const server = servers.find((s) => s.name === args.id);
         if (!server) {
           await this.cleanupClient(client);

package/dist/cli/commands/mcp/show.js

@@ -160,10 +160,9 @@ var McpShow = class _McpShow extends BaseCommand {
       try {
         server = await client.service("mcp-servers").get(args.id);
       } catch {
-        const result = await client.service("mcp-servers").find({
+        const servers = await client.service("mcp-servers").findAll({
           query: { $limit: 1 }
         });
-        const servers = Array.isArray(result) ? result : result.data;
         server = servers.find((s) => s.name === args.id) || null;
       }
       if (!server) {

package/dist/cli/commands/repo/rm.js

@@ -173,8 +173,7 @@ var RepoRm = class _RepoRm extends BaseCommand {
       try {
         repo = await reposService.get(args.id);
       } catch {
-        const result = await reposService.find({ query: { slug: args.id } });
-        const repos = Array.isArray(result) ? result : result.data;
+        const repos = await reposService.findAll({ query: { slug: args.id } });
         if (repos.length > 0) {
           repo = repos[0];
         }

package/dist/cli/commands/session/load-claude.js

@@ -189,8 +189,7 @@ ${chalk2.blue("\u25CF")} Loading Claude Code session: ${chalk2.cyan(sessionId)}
       const projectName = path.basename(absoluteProjectDir);
       let repo = null;
       try {
-        const allRepos = await reposService.find({ query: { $limit: 1e3 } });
-        const reposList = Array.isArray(allRepos) ? allRepos : allRepos.data;
+        const reposList = await reposService.findAll({ query: { $limit: 1e3 } });
         repo = reposList.find((r) => r.local_path === absoluteProjectDir) || null;
       } catch {
       }

package/dist/cli/commands/user/delete.js

@@ -166,8 +166,7 @@ var UserDelete = class _UserDelete extends BaseCommand {
     const client = await this.connectToDaemon();
     try {
       const usersService = client.service("users");
-      const result = await usersService.find();
-      const users = Array.isArray(result) ? result : result.data;
+      const users = await usersService.findAll();
       const user = users.find(
         (u) => u.email === args.user || u.user_id === args.user || u.user_id.startsWith(args.user)
       );

package/dist/cli/commands/user/update.js

@@ -184,8 +184,7 @@ var UserUpdate = class _UserUpdate extends BaseCommand {
     const client = await this.connectToDaemon();
     try {
       const usersService = client.service("users");
-      const result = await usersService.find();
-      const users = Array.isArray(result) ? result : result.data;
+      const users = await usersService.findAll();
       const user = users.find(
         (u) => u.email === args.user || u.user_id === args.user || u.user_id.startsWith(args.user)
       );

package/dist/cli/commands/worktree/add.js

@@ -194,13 +194,12 @@ var WorktreeAdd = class _WorktreeAdd extends BaseCommand {
       const reposService = client.service("repos");
       const repo = await reposService.get(flags["repo-id"]);
       const worktreesService = client.service("worktrees");
-      const existingWorktrees = await worktreesService.find({
+      const worktreesList = await worktreesService.findAll({
         query: {
           repo_id: repo.repo_id,
           name: args.name
         }
       });
-      const worktreesList = Array.isArray(existingWorktrees) ? existingWorktrees : existingWorktrees.data;
       if (worktreesList.length > 0) {
         this.error(`Worktree '${args.name}' already exists at ${worktreesList[0].path}`);
       }

package/dist/cli/commands/worktree/archive.js

@@ -183,10 +183,9 @@ var WorktreeArchive = class _WorktreeArchive extends BaseCommand {
       this.log(`  ID:   ${chalk2.dim(formatShortId(worktree.worktree_id))}`);
       const sessionsService = client.service("sessions");
       try {
-        const sessionsResult = await sessionsService.find({
+        const allSessions = await sessionsService.findAll({
           query: { worktree_id: worktree.worktree_id, $limit: 1e4 }
         });
-        const allSessions = Array.isArray(sessionsResult) ? sessionsResult : sessionsResult.data;
         if (allSessions.length > 0) {
           this.log(
             `  Sessions: ${chalk2.dim(`${allSessions.length} session(s) will also be archived`)}`

package/dist/cli/commands/worktree/list.js

@@ -193,15 +193,13 @@ var WorktreeList = class _WorktreeList extends BaseCommand {
       const reposService = client.service("repos");
       let allWorktrees = [];
       if (flags["repo-id"]) {
-        const worktreesResult = await worktreesService.find({
+        allWorktrees = await worktreesService.findAll({
           query: { repo_id: flags["repo-id"], $limit: PAGINATION.DEFAULT_LIMIT }
         });
-        allWorktrees = Array.isArray(worktreesResult) ? worktreesResult : worktreesResult.data;
       } else {
-        const worktreesResult = await worktreesService.find({
+        allWorktrees = await worktreesService.findAll({
           query: { $limit: PAGINATION.DEFAULT_LIMIT }
         });
-        allWorktrees = Array.isArray(worktreesResult) ? worktreesResult : worktreesResult.data;
       }
       let filteredWorktrees = allWorktrees;
       if (flags.archived) {
@@ -239,10 +237,9 @@ var WorktreeList = class _WorktreeList extends BaseCommand {
       const sessionsService = client.service("sessions");
       const sessionCounts = /* @__PURE__ */ new Map();
       try {
-        const sessionsResult = await sessionsService.find({
+        const allSessions = await sessionsService.findAll({
           query: { $limit: PAGINATION.DEFAULT_LIMIT }
         });
-        const allSessions = Array.isArray(sessionsResult) ? sessionsResult : sessionsResult.data;
         for (const session of allSessions) {
           const count = sessionCounts.get(session.worktree_id) || 0;
           sessionCounts.set(session.worktree_id, count + 1);

package/dist/cli/commands/worktree/rm.js

@@ -173,10 +173,9 @@ var WorktreeRemove = class _WorktreeRemove extends BaseCommand {
       this.log(`  ID:   ${chalk2.dim(formatShortId(worktree.worktree_id))}`);
       const sessionsService = client.service("sessions");
       try {
-        const sessionsResult = await sessionsService.find({
+        const allSessions = await sessionsService.findAll({
           query: { worktree_id: worktree.worktree_id, $limit: 1e4 }
         });
-        const allSessions = Array.isArray(sessionsResult) ? sessionsResult : sessionsResult.data;
         if (allSessions.length > 0) {
           this.log(
             `  Sessions: ${chalk2.yellow(`${allSessions.length} session(s) reference this worktree`)}`

package/dist/cli/commands/worktree/show.js

@@ -214,10 +214,9 @@ var WorktreeShow = class _WorktreeShow extends BaseCommand {
       this.log(chalk2.bold("Sessions:"));
       const sessionsService = client.service("sessions");
       try {
-        const sessionsResult = await sessionsService.find({
+        const allSessions = await sessionsService.findAll({
           query: { worktree_id: worktree.worktree_id, $limit: 1e4 }
         });
-        const allSessions = Array.isArray(sessionsResult) ? sessionsResult : sessionsResult.data;
         if (allSessions.length > 0) {
           this.log(`  ${chalk2.cyan(allSessions.length.toString())} session(s)`);
           for (const session of allSessions.slice(0, 5)) {

package/dist/cli/commands/worktree/unarchive.js

@@ -179,7 +179,7 @@ var WorktreeUnarchive = class _WorktreeUnarchive extends BaseCommand {
       this.log(`  ID:   ${chalk2.dim(formatShortId(worktree.worktree_id))}`);
       const sessionsService = client.service("sessions");
       try {
-        const sessionsResult = await sessionsService.find({
+        const allSessions = await sessionsService.findAll({
           query: {
             worktree_id: worktree.worktree_id,
             archived: true,
@@ -187,7 +187,6 @@ var WorktreeUnarchive = class _WorktreeUnarchive extends BaseCommand {
             $limit: 1e4
           }
         });
-        const allSessions = Array.isArray(sessionsResult) ? sessionsResult : sessionsResult.data;
         if (allSessions.length > 0) {
           this.log(
             `  Sessions: ${chalk2.dim(`${allSessions.length} session(s) will also be unarchived`)}`

package/dist/core/{agentic-tool-COqFrlmU.d.ts → agentic-tool-1L19ixPC.d.ts}

@@ -1,4 +1,4 @@
-import { A as AgenticToolID } from './id-DSzvIi3c.js';
+import { A as AgenticToolID } from './id-Cv3ntaTJ.js';
 
 /**
  * Agentic coding tool names
@@ -106,5 +106,24 @@ type CodexNetworkAccess = boolean;
  * - bypassPermissions: Auto-approve everything (equivalent to approveAll helper)
  */
 type CopilotPermissionMode = 'default' | 'acceptEdits' | 'bypassPermissions';
+/**
+ * Static capability flags for agentic tools.
+ * Used by the UI to show/hide features based on what a tool supports.
+ * Mirrors the runtime ToolCapabilities in the executor but is available
+ * without instantiating a tool.
+ */
+interface AgenticToolCapabilities {
+    /** Can fork sessions (branch conversation at a decision point) */
+    supportsSessionFork: boolean;
+    /** Can spawn child sessions for subsessions */
+    supportsChildSpawn: boolean;
+    /** Can import historical sessions from tool's storage */
+    supportsSessionImport: boolean;
+}
+/**
+ * Static capability map for all agentic tools.
+ * Source of truth for what each tool supports — avoids scattered `if (tool === 'codex')` checks.
+ */
+declare const AGENTIC_TOOL_CAPABILITIES: Record<AgenticToolName, AgenticToolCapabilities>;
 
-export type { AgenticToolName as A, ClaudeCodePermissionMode as C, GeminiPermissionMode as G, OpenCodePermissionMode as O, CodexPermissionMode as a, AgenticTool as b, CodexSandboxMode as c, CodexApprovalPolicy as d, CodexNetworkAccess as e, CopilotPermissionMode as f };
+export { type AgenticToolName as A, type ClaudeCodePermissionMode as C, type GeminiPermissionMode as G, type OpenCodePermissionMode as O, type CodexPermissionMode as a, type AgenticTool as b, type CodexSandboxMode as c, type CodexApprovalPolicy as d, type CodexNetworkAccess as e, type CopilotPermissionMode as f, type AgenticToolCapabilities as g, AGENTIC_TOOL_CAPABILITIES as h };

package/dist/core/{agentic-tool-o8Io8dDl.d.cts → agentic-tool-3oiAj9Lg.d.cts}

@@ -1,4 +1,4 @@
-import { A as AgenticToolID } from './id-DSzvIi3c.cjs';
+import { A as AgenticToolID } from './id-Cv3ntaTJ.cjs';
 
 /**
  * Agentic coding tool names
@@ -106,5 +106,24 @@ type CodexNetworkAccess = boolean;
  * - bypassPermissions: Auto-approve everything (equivalent to approveAll helper)
  */
 type CopilotPermissionMode = 'default' | 'acceptEdits' | 'bypassPermissions';
+/**
+ * Static capability flags for agentic tools.
+ * Used by the UI to show/hide features based on what a tool supports.
+ * Mirrors the runtime ToolCapabilities in the executor but is available
+ * without instantiating a tool.
+ */
+interface AgenticToolCapabilities {
+    /** Can fork sessions (branch conversation at a decision point) */
+    supportsSessionFork: boolean;
+    /** Can spawn child sessions for subsessions */
+    supportsChildSpawn: boolean;
+    /** Can import historical sessions from tool's storage */
+    supportsSessionImport: boolean;
+}
+/**
+ * Static capability map for all agentic tools.
+ * Source of truth for what each tool supports — avoids scattered `if (tool === 'codex')` checks.
+ */
+declare const AGENTIC_TOOL_CAPABILITIES: Record<AgenticToolName, AgenticToolCapabilities>;
 
-export type { AgenticToolName as A, ClaudeCodePermissionMode as C, GeminiPermissionMode as G, OpenCodePermissionMode as O, CodexPermissionMode as a, AgenticTool as b, CodexSandboxMode as c, CodexApprovalPolicy as d, CodexNetworkAccess as e, CopilotPermissionMode as f };
+export { type AgenticToolName as A, type ClaudeCodePermissionMode as C, type GeminiPermissionMode as G, type OpenCodePermissionMode as O, type CodexPermissionMode as a, type AgenticTool as b, type CodexSandboxMode as c, type CodexApprovalPolicy as d, type CodexNetworkAccess as e, type CopilotPermissionMode as f, type AgenticToolCapabilities as g, AGENTIC_TOOL_CAPABILITIES as h };