workspacecord 1.0.2

package/dist/chunk-TSBM3BNT.js

@@ -0,0 +1,1224 @@
+#!/usr/bin/env node
+import {
+  config
+} from "./chunk-2LBNM64L.js";
+import {
+  Store,
+  bindProjectCategory,
+  getProjectByCategoryId,
+  getProjectByName,
+  loadRegistry,
+  setProjectControlChannel,
+  setProjectHistoryChannel,
+  updateProject
+} from "./chunk-NIXZJTOZ.js";
+import {
+  isAbortError,
+  resolvePath,
+  sanitizeName
+} from "./chunk-WE4X3JB3.js";
+
+// src/thread-manager.ts
+import { existsSync as existsSync2 } from "fs";
+import { sep } from "path";
+
+// src/providers/claude-provider.ts
+import { query } from "@anthropic-ai/claude-agent-sdk";
+var TASK_TOOLS = /* @__PURE__ */ new Set(["TaskCreate", "TaskUpdate", "TaskList", "TaskGet"]);
+var IMAGE_EXTENSIONS = /* @__PURE__ */ new Set([".png", ".jpg", ".jpeg", ".gif", ".webp", ".svg", ".bmp"]);
+function extractImagePath(toolName, toolInput) {
+  try {
+    const data = JSON.parse(toolInput);
+    if (toolName === "Write" || toolName === "Read") {
+      const filePath = data.file_path;
+      if (filePath && IMAGE_EXTENSIONS.has(filePath.slice(filePath.lastIndexOf(".")).toLowerCase())) {
+        return filePath;
+      }
+    }
+  } catch {
+  }
+  return null;
+}
+function buildClaudeSystemPrompt(parts) {
+  if (parts.length > 0) {
+    return { type: "preset", preset: "claude_code", append: parts.join("\n\n") };
+  }
+  return { type: "preset", preset: "claude_code" };
+}
+var ClaudeProvider = class {
+  name = "claude";
+  supports(feature) {
+    return [
+      "resume_from_terminal",
+      "plugins",
+      "ask_user_question",
+      "mode_switching",
+      "continue"
+    ].includes(feature);
+  }
+  async *sendPrompt(prompt, options) {
+    const systemPrompt = buildClaudeSystemPrompt(options.systemPromptParts);
+    const isBypass = options.claudePermissionMode === "bypass";
+    function buildQueryPrompt() {
+      if (typeof prompt === "string") return prompt;
+      const claudeBlocks = prompt.filter((b) => b.type !== "local_image");
+      const userMessage = {
+        type: "user",
+        message: { role: "user", content: claudeBlocks },
+        parent_tool_use_id: null,
+        session_id: ""
+      };
+      return (async function* () {
+        yield userMessage;
+      })();
+    }
+    let retried = false;
+    let resumeId = options.providerSessionId;
+    while (true) {
+      let failed = false;
+      const stream = query({
+        prompt: buildQueryPrompt(),
+        options: {
+          cwd: options.directory,
+          resume: resumeId,
+          abortController: options.abortController,
+          permissionMode: isBypass ? "bypassPermissions" : "default",
+          ...isBypass ? { allowDangerouslySkipPermissions: true } : {},
+          model: options.model,
+          systemPrompt,
+          canUseTool: options.canUseTool,
+          includePartialMessages: true,
+          settingSources: ["user", "project", "local"]
+        }
+      });
+      yield* this.translateStream(stream, resumeId, retried, (f, r) => {
+        failed = f;
+        retried = r;
+      });
+      if (failed && !retried) {
+        retried = true;
+        resumeId = void 0;
+        yield { type: "session_init", providerSessionId: "" };
+        continue;
+      }
+      break;
+    }
+  }
+  async *continueSession(options) {
+    const systemPrompt = buildClaudeSystemPrompt(options.systemPromptParts);
+    const isBypass = options.claudePermissionMode === "bypass";
+    let retried = false;
+    let resumeId = options.providerSessionId;
+    while (true) {
+      let failed = false;
+      const stream = query({
+        prompt: "",
+        options: {
+          cwd: options.directory,
+          ...resumeId ? { continue: true, resume: resumeId } : {},
+          abortController: options.abortController,
+          permissionMode: isBypass ? "bypassPermissions" : "default",
+          ...isBypass ? { allowDangerouslySkipPermissions: true } : {},
+          model: options.model,
+          systemPrompt,
+          canUseTool: options.canUseTool,
+          includePartialMessages: true,
+          settingSources: ["user", "project", "local"]
+        }
+      });
+      yield* this.translateStream(stream, resumeId, retried, (f, r) => {
+        failed = f;
+        retried = r;
+      });
+      if (failed && !retried) {
+        retried = true;
+        resumeId = void 0;
+        yield { type: "session_init", providerSessionId: "" };
+        continue;
+      }
+      break;
+    }
+  }
+  async *translateStream(stream, resumeId, alreadyRetried, setRetry) {
+    let currentToolName = null;
+    let currentToolInput = "";
+    for await (const message of stream) {
+      if (message.type === "system" && "subtype" in message && message.subtype === "init") {
+        const initMessage = message;
+        yield { type: "session_init", providerSessionId: initMessage.session_id || "" };
+      }
+      if (message.type === "stream_event") {
+        const event = message.event;
+        if (event?.type === "content_block_start") {
+          if (event.content_block?.type === "tool_use") {
+            currentToolName = event.content_block.name || "tool";
+            currentToolInput = "";
+          }
+        }
+        if (event?.type === "content_block_delta") {
+          if (event.delta?.type === "text_delta" && event.delta.text) {
+            yield { type: "text_delta", text: event.delta.text };
+          }
+          if (event.delta?.type === "input_json_delta" && event.delta.partial_json) {
+            currentToolInput += event.delta.partial_json;
+          }
+        }
+        if (event?.type === "content_block_stop") {
+          if (currentToolName) {
+            if (currentToolName === "AskUserQuestion") {
+              yield { type: "ask_user", questionsJson: currentToolInput };
+            } else if (TASK_TOOLS.has(currentToolName)) {
+              yield { type: "task", action: currentToolName, dataJson: currentToolInput };
+            } else {
+              yield { type: "tool_start", toolName: currentToolName, toolInput: currentToolInput };
+            }
+            const imagePath = extractImagePath(currentToolName, currentToolInput);
+            if (imagePath) {
+              yield { type: "image_file", filePath: imagePath };
+            }
+            currentToolName = null;
+            currentToolInput = "";
+          }
+        }
+      }
+      if (message.type === "user") {
+        const content = message.message?.content;
+        let resultText = "";
+        const toolName = "";
+        if (Array.isArray(content)) {
+          for (const block of content) {
+            if (block.type === "tool_result" && block.content) {
+              if (typeof block.content === "string") {
+                resultText += block.content;
+              } else if (Array.isArray(block.content)) {
+                for (const sub of block.content) {
+                  if (sub.type === "text") resultText += sub.text;
+                }
+              }
+            }
+          }
+        }
+        if (resultText) {
+          yield { type: "tool_result", toolName, result: resultText };
+        }
+      }
+      if (message.type === "system") {
+        const systemMessage = message;
+        const sub = systemMessage.subtype;
+        if (sub === "task_started") {
+          yield {
+            type: "task_started",
+            taskId: systemMessage.task_id || "",
+            description: systemMessage.description || ""
+          };
+        } else if (sub === "task_progress") {
+          yield {
+            type: "task_progress",
+            taskId: systemMessage.task_id || "",
+            description: systemMessage.description || "",
+            lastToolName: systemMessage.last_tool_name,
+            summary: systemMessage.summary
+          };
+        } else if (sub === "task_notification") {
+          yield {
+            type: "task_done",
+            taskId: systemMessage.task_id || "",
+            status: systemMessage.status || "completed",
+            summary: systemMessage.summary || ""
+          };
+        }
+      }
+      if (message.type === "result") {
+        const r = message;
+        if (r.subtype !== "success" && !alreadyRetried && resumeId) {
+          setRetry(true, false);
+          break;
+        }
+        yield {
+          type: "result",
+          success: r.subtype === "success",
+          costUsd: r.total_cost_usd ?? 0,
+          durationMs: r.duration_ms ?? 0,
+          numTurns: r.num_turns ?? 0,
+          errors: r.errors ?? []
+        };
+      }
+    }
+  }
+};
+
+// src/providers/index.ts
+var providers = /* @__PURE__ */ new Map();
+providers.set("claude", new ClaudeProvider());
+var codexLoadAttempted = false;
+async function loadCodexProvider() {
+  try {
+    const { CodexProvider } = await import("./codex-provider-7CI5W34X.js");
+    providers.set("codex", new CodexProvider());
+    codexLoadAttempted = true;
+  } catch (err) {
+    codexLoadAttempted = true;
+    throw new Error(
+      `Codex provider is unavailable. Install @openai/codex-sdk manually. Root cause: ${err.message}`
+    );
+  }
+}
+async function ensureProvider(name) {
+  if (providers.has(name)) return providers.get(name);
+  if (name === "codex" && !codexLoadAttempted) {
+    await loadCodexProvider();
+    return providers.get("codex");
+  }
+  if (name === "codex") {
+    throw new Error(
+      "Codex provider is unavailable. Install @openai/codex-sdk and restart workspacecord."
+    );
+  }
+  throw new Error(`Unknown provider: ${name}`);
+}
+
+// src/agents.ts
+var agents = [
+  {
+    name: "code-reviewer",
+    emoji: "\u{1F50D}",
+    description: "Code quality, bugs, best practices",
+    systemPrompt: `You are a senior code reviewer. Focus on:
+- Code quality and readability
+- Potential bugs and edge cases
+- Security vulnerabilities
+- Performance concerns
+- Best practices and design patterns
+Be specific, cite line numbers, and suggest concrete improvements.`
+  },
+  {
+    name: "architect",
+    emoji: "\u{1F3D7}\uFE0F",
+    description: "System design, patterns, scalability",
+    systemPrompt: `You are a software architect. Focus on:
+- System design and architecture patterns
+- Scalability and maintainability
+- Component boundaries and interfaces
+- Data flow and state management
+- Trade-offs between different approaches
+Think in terms of systems, not just code.`
+  },
+  {
+    name: "debugger",
+    emoji: "\u{1F41B}",
+    description: "Root cause analysis, debugging strategies",
+    systemPrompt: `You are a debugging specialist. Focus on:
+- Root cause analysis over symptoms
+- Systematic debugging strategies
+- Reproducing issues reliably
+- Tracing data flow to find where things break
+- Suggesting targeted fixes with minimal side effects
+Think methodically and follow the evidence.`
+  },
+  {
+    name: "security",
+    emoji: "\u{1F512}",
+    description: "Vulnerabilities, OWASP, secure coding",
+    systemPrompt: `You are a security analyst. Focus on:
+- OWASP Top 10 vulnerabilities
+- Input validation and sanitization
+- Authentication and authorization flaws
+- Injection attacks (SQL, XSS, command)
+- Secure defaults and least privilege
+Flag issues with severity ratings and remediation steps.`
+  },
+  {
+    name: "performance",
+    emoji: "\u{1F680}",
+    description: "Optimization, profiling, bottlenecks",
+    systemPrompt: `You are a performance engineer. Focus on:
+- Identifying bottlenecks and hot paths
+- Algorithm and data structure choices
+- Memory allocation and GC pressure
+- I/O optimization and caching strategies
+- Benchmarking and profiling recommendations
+Quantify impact where possible.`
+  },
+  {
+    name: "devops",
+    emoji: "\u2699\uFE0F",
+    description: "CI/CD, Docker, infrastructure",
+    systemPrompt: `You are a DevOps engineer. Focus on:
+- CI/CD pipeline design and optimization
+- Container and orchestration best practices
+- Infrastructure as code
+- Monitoring, logging, and observability
+- Deployment strategies and rollback plans
+Prioritize reliability and automation.`
+  },
+  {
+    name: "general",
+    emoji: "\u{1F9E0}",
+    description: "Default \u2014 no specialized focus",
+    systemPrompt: ""
+  }
+];
+function getAgent(name) {
+  return agents.find((a) => a.name === name);
+}
+
+// src/project-manager.ts
+import { readFile, writeFile } from "fs/promises";
+import { existsSync } from "fs";
+import { join } from "path";
+async function loadProjects() {
+  await loadRegistry();
+}
+function getProject(categoryId) {
+  const project = getProjectByCategoryId(categoryId);
+  if (!project) return void 0;
+  return {
+    categoryId: project.discordCategoryId ?? categoryId,
+    historyChannelId: project.historyChannelId,
+    controlChannelId: project.controlChannelId,
+    name: project.name,
+    directory: project.path,
+    personality: project.personality,
+    skills: Object.entries(project.skills).map(([name, prompt]) => ({ name, prompt })),
+    mcpServers: project.mcpServers,
+    createdAt: project.createdAt
+  };
+}
+async function bindMountedProjectToCategory(projectName, categoryId, categoryName) {
+  const project = getProjectByName(projectName);
+  if (!project) throw new Error(`Mounted project not found: ${projectName}`);
+  if (project.discordCategoryId && project.discordCategoryId !== categoryId) {
+    throw new Error(`Project "${projectName}" is already bound to another Discord category`);
+  }
+  await bindProjectCategory(projectName, categoryId, categoryName);
+  return getProject(categoryId);
+}
+function setHistoryChannelId(categoryId, channelId) {
+  const project = getProjectByCategoryId(categoryId);
+  if (!project) return;
+  void setProjectHistoryChannel(project.name, channelId);
+}
+function setControlChannelId(categoryId, channelId) {
+  const project = getProjectByCategoryId(categoryId);
+  if (!project) return;
+  void setProjectControlChannel(project.name, channelId);
+}
+function setPersonality(categoryId, personality) {
+  const project = getProjectByCategoryId(categoryId);
+  if (!project) return;
+  project.personality = personality;
+  void updateProject(project);
+}
+function getPersonality(categoryId) {
+  return getProjectByCategoryId(categoryId)?.personality;
+}
+function clearPersonality(categoryId) {
+  const project = getProjectByCategoryId(categoryId);
+  if (!project) return;
+  delete project.personality;
+  void updateProject(project);
+}
+function addSkill(categoryId, name, prompt) {
+  const project = getProjectByCategoryId(categoryId);
+  if (!project) return;
+  project.skills[name] = prompt;
+  void updateProject(project);
+}
+function removeSkill(categoryId, name) {
+  const project = getProjectByCategoryId(categoryId);
+  if (!project || !project.skills[name]) return false;
+  delete project.skills[name];
+  void updateProject(project);
+  return true;
+}
+function getSkills(categoryId) {
+  const project = getProjectByCategoryId(categoryId);
+  if (!project) return [];
+  return Object.entries(project.skills).map(([name, prompt]) => ({ name, prompt }));
+}
+function executeSkill(categoryId, name, input) {
+  const project = getProjectByCategoryId(categoryId);
+  if (!project) return null;
+  const template = project.skills[name];
+  if (!template) return null;
+  return input ? template.replace(/\{input\}/g, input) : template.replace(/\{input\}/g, "");
+}
+async function addMcpServer(categoryId, serverName, command, args) {
+  const project = getProjectByCategoryId(categoryId);
+  if (!project) return;
+  const existing = project.mcpServers.findIndex((server2) => server2.name === serverName);
+  const server = {
+    name: serverName,
+    command,
+    ...args?.length ? { args } : {}
+  };
+  if (existing >= 0) {
+    project.mcpServers[existing] = server;
+  } else {
+    project.mcpServers.push(server);
+  }
+  await updateProject(project);
+  await writeMcpJson(project.path, project.mcpServers);
+}
+async function removeMcpServer(categoryId, serverName) {
+  const project = getProjectByCategoryId(categoryId);
+  if (!project) return false;
+  const index = project.mcpServers.findIndex((server) => server.name === serverName);
+  if (index < 0) return false;
+  project.mcpServers.splice(index, 1);
+  await updateProject(project);
+  await writeMcpJson(project.path, project.mcpServers);
+  return true;
+}
+function getMcpServers(categoryId) {
+  return getProjectByCategoryId(categoryId)?.mcpServers || [];
+}
+async function writeMcpJson(projectDir, servers) {
+  const mcpPath = join(projectDir, ".mcp.json");
+  let mcpConfig = {};
+  try {
+    if (existsSync(mcpPath)) {
+      const existing = await readFile(mcpPath, "utf-8");
+      mcpConfig = JSON.parse(existing);
+    }
+  } catch {
+  }
+  const mcpServers = {};
+  for (const server of servers) {
+    mcpServers[server.name] = {
+      command: server.command,
+      ...server.args?.length ? { args: server.args } : {}
+    };
+  }
+  mcpConfig.mcpServers = mcpServers;
+  await writeFile(mcpPath, JSON.stringify(mcpConfig, null, 2), "utf-8");
+}
+
+// src/thread-manager.ts
+var MODE_PROMPTS = {
+  auto: "",
+  plan: "You MUST use EnterPlanMode at the start of every task. Present your plan for user approval before making any code changes. Do not write or edit files until the user approves the plan.",
+  normal: "Before performing destructive or significant operations (deleting files, running dangerous commands, making large refactors, writing to many files), use AskUserQuestion to confirm with the user first. Ask for explicit approval before proceeding with changes.",
+  monitor: "This session is running in monitored autonomy mode. Treat the active user request as the task objective and keep working until it is fully satisfied. Do not stop at a partial implementation or ask the user for follow-up direction unless you are truly blocked by missing permissions, credentials, or required external information that you cannot obtain yourself. When you believe the task is complete, explain concisely what was finished and why it satisfies the request."
+};
+var MONITOR_SYSTEM_PROMPT = `You are a monitor agent supervising another coding agent.
+
+Your job is to judge progress against the user's original request and decide whether the worker should continue.
+
+Return JSON only in this schema:
+{
+  "status": "complete" | "continue" | "blocked",
+  "confidence": "high" | "medium" | "low",
+  "rationale": "Short explanation tied to the original request",
+  "steering": "Concrete next instructions for the worker. Empty string only when status is complete.",
+  "completionSummary": "Short summary of what is complete. Empty string unless status is complete."
+}
+
+Rules:
+- Favor continuing unless the task clearly satisfies the original request.
+- Judge against robustness, completeness, and the user's stated quality bar, not just whether some code changed.
+- If the worker stopped early, ask for the next concrete step instead of accepting the output.
+- Use "blocked" only for true blockers the worker cannot resolve autonomously.
+- Never ask the human for optional next steps.
+- Output valid JSON and nothing else.`;
+var sessionStore = new Store("sessions.json");
+var sessions = /* @__PURE__ */ new Map();
+var idToChannelId = /* @__PURE__ */ new Map();
+var sessionsByCategory = /* @__PURE__ */ new Map();
+var sessionControllers = /* @__PURE__ */ new Map();
+var sessionAbortReasons = /* @__PURE__ */ new Map();
+var saveQueue = Promise.resolve();
+var saveTimer = null;
+function createDefaultWorkflowState() {
+  return {
+    status: "idle",
+    iteration: 0,
+    updatedAt: Date.now()
+  };
+}
+async function loadSessions() {
+  const data = await sessionStore.read();
+  if (!data) return;
+  let cleaned = false;
+  for (const s of data) {
+    if (!s.categoryId) {
+      cleaned = true;
+      console.warn(`Skipping invalid persisted session "${s.id}" (missing categoryId).`);
+      continue;
+    }
+    if (!s.channelId) {
+      cleaned = true;
+      console.warn(`Skipping invalid persisted session "${s.id}" (missing channelId).`);
+      continue;
+    }
+    if (sessions.has(s.channelId)) {
+      cleaned = true;
+      console.warn(
+        `Skipping duplicate persisted session "${s.id}" (channelId ${s.channelId} already loaded).`
+      );
+      continue;
+    }
+    const provider = s.provider ?? "claude";
+    sessions.set(s.channelId, {
+      ...s,
+      provider,
+      verbose: s.verbose ?? false,
+      mode: s.mode ?? "auto",
+      subagentDepth: s.subagentDepth ?? 0,
+      type: s.type ?? "persistent",
+      workflowState: s.workflowState ?? createDefaultWorkflowState(),
+      currentTurn: s.currentTurn ?? 0,
+      humanResolved: s.humanResolved ?? false,
+      currentInteractionMessageId: s.currentInteractionMessageId,
+      statusCardMessageId: s.statusCardMessageId,
+      discoverySource: s.discoverySource ?? "discord",
+      lastObservedState: s.lastObservedState,
+      lastObservedEventKey: s.lastObservedEventKey,
+      lastObservedAt: s.lastObservedAt,
+      lastObservedCwd: s.lastObservedCwd,
+      remoteHumanControl: s.remoteHumanControl,
+      activeHumanGateId: s.activeHumanGateId,
+      isGenerating: false
+    });
+    idToChannelId.set(s.id, s.channelId);
+    if (!sessionsByCategory.has(s.categoryId)) {
+      sessionsByCategory.set(s.categoryId, /* @__PURE__ */ new Set());
+    }
+    sessionsByCategory.get(s.categoryId).add(s.channelId);
+  }
+  if (cleaned) {
+    await saveSessions();
+  }
+  console.log(`[session-manager] Restored ${sessions.size} session(s)`);
+}
+async function persistSessionsNow() {
+  const data = [];
+  for (const [, s] of sessions) {
+    data.push({
+      id: s.id,
+      channelId: s.channelId,
+      categoryId: s.categoryId,
+      projectName: s.projectName,
+      agentLabel: s.agentLabel,
+      provider: s.provider,
+      providerSessionId: s.providerSessionId,
+      model: s.model,
+      type: s.type,
+      parentChannelId: s.parentChannelId,
+      subagentDepth: s.subagentDepth,
+      directory: s.directory,
+      mode: s.mode,
+      agentPersona: s.agentPersona,
+      verbose: s.verbose || false,
+      claudePermissionMode: s.claudePermissionMode,
+      monitorGoal: s.monitorGoal,
+      monitorProviderSessionId: s.monitorProviderSessionId,
+      workflowState: s.workflowState,
+      createdAt: s.createdAt,
+      lastActivity: s.lastActivity,
+      messageCount: s.messageCount,
+      totalCost: s.totalCost,
+      currentTurn: s.currentTurn,
+      humanResolved: s.humanResolved,
+      currentInteractionMessageId: s.currentInteractionMessageId,
+      statusCardMessageId: s.statusCardMessageId,
+      discoverySource: s.discoverySource,
+      lastObservedState: s.lastObservedState,
+      lastObservedEventKey: s.lastObservedEventKey,
+      lastObservedAt: s.lastObservedAt,
+      lastObservedCwd: s.lastObservedCwd,
+      remoteHumanControl: s.remoteHumanControl,
+      activeHumanGateId: s.activeHumanGateId
+    });
+  }
+  await sessionStore.write(data);
+}
+function saveSessions() {
+  saveQueue = saveQueue.catch(() => {
+  }).then(async () => {
+    try {
+      await persistSessionsNow();
+    } catch (err) {
+      console.error(`[session-manager] Failed to persist sessions: ${err.message}`);
+    }
+  });
+  return saveQueue;
+}
+function debouncedSave() {
+  if (saveTimer) clearTimeout(saveTimer);
+  saveTimer = setTimeout(() => {
+    saveTimer = null;
+    saveSessions();
+  }, 1e3);
+}
+function saveSessionsImmediate() {
+  if (saveTimer) {
+    clearTimeout(saveTimer);
+    saveTimer = null;
+  }
+  return saveSessions();
+}
+async function createSession(params) {
+  const {
+    channelId,
+    categoryId,
+    projectName,
+    agentLabel,
+    provider,
+    providerSessionId,
+    model,
+    type,
+    parentChannelId,
+    subagentDepth = 0,
+    mode = config.defaultMode,
+    claudePermissionMode,
+    discoverySource = "discord",
+    remoteHumanControl
+  } = params;
+  const resolvedDir = resolvePath(params.directory);
+  if (!existsSync2(resolvedDir)) {
+    throw new Error(`Directory does not exist: ${resolvedDir}`);
+  }
+  await ensureProvider(provider);
+  if (sessions.has(channelId)) {
+    throw new Error(`Session for channelId "${channelId}" already exists`);
+  }
+  let id = sanitizeName(agentLabel);
+  let suffix = 1;
+  while (idToChannelId.has(id)) {
+    suffix++;
+    id = sanitizeName(`${agentLabel}-${suffix}`);
+  }
+  const session = {
+    id,
+    channelId,
+    categoryId,
+    projectName,
+    agentLabel,
+    provider,
+    providerSessionId,
+    model,
+    type,
+    parentChannelId,
+    subagentDepth,
+    directory: resolvedDir,
+    mode,
+    agentPersona: void 0,
+    verbose: false,
+    claudePermissionMode,
+    monitorGoal: void 0,
+    monitorProviderSessionId: void 0,
+    workflowState: createDefaultWorkflowState(),
+    isGenerating: false,
+    createdAt: Date.now(),
+    lastActivity: Date.now(),
+    messageCount: 0,
+    totalCost: 0,
+    currentTurn: 0,
+    humanResolved: false,
+    currentInteractionMessageId: void 0,
+    statusCardMessageId: void 0,
+    discoverySource,
+    remoteHumanControl
+  };
+  sessions.set(channelId, session);
+  idToChannelId.set(id, channelId);
+  if (!sessionsByCategory.has(categoryId)) {
+    sessionsByCategory.set(categoryId, /* @__PURE__ */ new Set());
+  }
+  sessionsByCategory.get(categoryId).add(channelId);
+  await saveSessionsImmediate();
+  return session;
+}
+function getSession(id) {
+  const channelId = idToChannelId.get(id);
+  return channelId ? sessions.get(channelId) : void 0;
+}
+function getSessionByChannel(channelId) {
+  return sessions.get(channelId);
+}
+var getSessionByThread = getSessionByChannel;
+function getSessionByCodexId(codexSessionId) {
+  for (const session of sessions.values()) {
+    if (session.provider === "codex" && session.providerSessionId === codexSessionId) {
+      return session;
+    }
+  }
+  return void 0;
+}
+function getSessionByProviderSession(provider, providerSessionId) {
+  if (!providerSessionId) return void 0;
+  for (const session of sessions.values()) {
+    if (session.provider !== provider) continue;
+    if (session.providerSessionId === providerSessionId) return session;
+  }
+  return void 0;
+}
+function getSessionsByCategory(categoryId) {
+  const channelIds = sessionsByCategory.get(categoryId);
+  if (!channelIds) return [];
+  const result = [];
+  for (const channelId of channelIds) {
+    const session = sessions.get(channelId);
+    if (session) result.push(session);
+  }
+  return result;
+}
+function getAllSessions() {
+  return Array.from(sessions.values());
+}
+function getSessionByProviderSessionId(provider, providerSessionId) {
+  for (const session of sessions.values()) {
+    if (session.provider !== provider) continue;
+    if (!session.providerSessionId) continue;
+    if (session.providerSessionId === providerSessionId) return session;
+  }
+  return void 0;
+}
+function findCodexSessionForMonitor(providerSessionId, cwd) {
+  if (providerSessionId) {
+    const byProviderId = getSessionByProviderSessionId("codex", providerSessionId);
+    if (byProviderId) return byProviderId;
+  }
+  if (!cwd) return void 0;
+  const normalizedCwd = resolvePath(cwd);
+  let matched;
+  let matchedLen = -1;
+  for (const session of sessions.values()) {
+    if (session.provider !== "codex") continue;
+    const sessionDir = resolvePath(session.directory);
+    if (normalizedCwd !== sessionDir && !normalizedCwd.startsWith(`${sessionDir}/`)) continue;
+    if (sessionDir.length > matchedLen) {
+      matched = session;
+      matchedLen = sessionDir.length;
+    }
+  }
+  return matched;
+}
+function stripCodexMonitorPrefix(sessionId) {
+  return sessionId.startsWith("codex:") ? sessionId.slice("codex:".length) : sessionId;
+}
+function findCodexSessionByProviderSessionId(providerSessionId) {
+  const normalized = stripCodexMonitorPrefix(providerSessionId);
+  for (const session of sessions.values()) {
+    if (session.provider !== "codex") continue;
+    if (!session.providerSessionId) continue;
+    if (session.providerSessionId === normalized || session.providerSessionId === providerSessionId) {
+      return session;
+    }
+  }
+  return void 0;
+}
+function findCodexSessionByCwd(cwd) {
+  const normalizedCwd = resolvePath(cwd);
+  let best;
+  let bestLen = -1;
+  for (const session of sessions.values()) {
+    if (session.provider !== "codex") continue;
+    const dir = resolvePath(session.directory);
+    const isMatch = normalizedCwd === dir || normalizedCwd.startsWith(`${dir}${sep}`);
+    if (!isMatch) continue;
+    if (dir.length > bestLen) {
+      best = session;
+      bestLen = dir.length;
+    }
+  }
+  return best;
+}
+function resolveCodexSessionFromMonitor(monitorSessionId, cwd) {
+  const byProviderSessionId = findCodexSessionByProviderSessionId(monitorSessionId);
+  if (byProviderSessionId) return byProviderSessionId;
+  if (cwd) return findCodexSessionByCwd(cwd);
+  return void 0;
+}
+function updateSession(sessionId, patch) {
+  const session = getSession(sessionId);
+  if (!session) return;
+  Object.assign(session, patch);
+  debouncedSave();
+}
+function setStatusCardBinding(sessionId, binding) {
+  const session = getSession(sessionId);
+  if (!session) return;
+  session.statusCardMessageId = binding.messageId;
+  debouncedSave();
+}
+function setCurrentInteractionMessage(sessionId, messageId) {
+  const session = getSession(sessionId);
+  if (!session) return;
+  session.currentInteractionMessageId = messageId;
+  debouncedSave();
+}
+async function endSession(id) {
+  const session = getSession(id);
+  if (!session) throw new Error(`Session "${id}" not found`);
+  const controller = sessionControllers.get(session.id);
+  if (controller && session.isGenerating) {
+    controller.abort();
+  }
+  sessionControllers.delete(session.id);
+  sessionAbortReasons.delete(session.id);
+  idToChannelId.delete(session.id);
+  sessions.delete(session.channelId);
+  const categorySet = sessionsByCategory.get(session.categoryId);
+  if (categorySet) {
+    categorySet.delete(session.channelId);
+    if (categorySet.size === 0) {
+      sessionsByCategory.delete(session.categoryId);
+    }
+  }
+  await saveSessionsImmediate();
+}
+function setMode(sessionId, mode) {
+  const session = getSession(sessionId);
+  if (session) {
+    session.mode = mode;
+    if (mode === "monitor") {
+      session.monitorProviderSessionId = void 0;
+    }
+    session.workflowState = createDefaultWorkflowState();
+    debouncedSave();
+  }
+}
+function setVerbose(sessionId, verbose) {
+  const session = getSession(sessionId);
+  if (session) {
+    session.verbose = verbose;
+    debouncedSave();
+  }
+}
+function setModel(sessionId, model) {
+  const session = getSession(sessionId);
+  if (session) {
+    session.model = model;
+    debouncedSave();
+  }
+}
+function setAgentPersona(sessionId, persona) {
+  const session = getSession(sessionId);
+  if (session) {
+    session.agentPersona = persona;
+    debouncedSave();
+  }
+}
+function setMonitorGoal(sessionId, goal) {
+  const session = getSession(sessionId);
+  if (session) {
+    session.monitorGoal = goal;
+    if (!goal) {
+      session.monitorProviderSessionId = void 0;
+    }
+    session.workflowState = createDefaultWorkflowState();
+    debouncedSave();
+  }
+}
+function updateWorkflowState(sessionId, patch) {
+  const session = getSession(sessionId);
+  if (!session) return;
+  const next = typeof patch === "function" ? patch(session.workflowState) : { ...session.workflowState, ...patch };
+  session.workflowState = {
+    ...next,
+    updatedAt: Date.now()
+  };
+  debouncedSave();
+}
+function resetWorkflowState(sessionId) {
+  const session = getSession(sessionId);
+  if (!session) return;
+  session.workflowState = createDefaultWorkflowState();
+  debouncedSave();
+}
+function buildSystemPromptParts(session) {
+  const parts = [];
+  const personality = getPersonality(session.categoryId);
+  if (personality) parts.push(personality);
+  if (session.agentPersona) {
+    const agent = getAgent(session.agentPersona);
+    if (agent?.systemPrompt) parts.push(agent.systemPrompt);
+  }
+  const modePrompt = MODE_PROMPTS[session.mode];
+  if (modePrompt) parts.push(modePrompt);
+  return parts;
+}
+function buildMonitorSystemPromptParts(session) {
+  const parts = [];
+  const personality = getPersonality(session.categoryId);
+  if (personality) parts.push(personality);
+  parts.push(MONITOR_SYSTEM_PROMPT);
+  return parts;
+}
+function buildProviderOptions(session, controller, isMonitor = false, runtimeOverrides = {}) {
+  const isAutoMode = session.mode === "auto";
+  return {
+    directory: session.directory,
+    providerSessionId: isMonitor ? session.monitorProviderSessionId : session.providerSessionId,
+    model: session.model,
+    sandboxMode: config.codexSandboxMode,
+    approvalPolicy: isAutoMode ? "never" : config.codexApprovalPolicy,
+    networkAccessEnabled: config.codexNetworkAccessEnabled,
+    webSearchMode: config.codexWebSearchMode,
+    modelReasoningEffort: config.codexReasoningEffort || void 0,
+    claudePermissionMode: isAutoMode ? "bypass" : session.claudePermissionMode ?? config.claudePermissionMode,
+    systemPromptParts: isMonitor ? buildMonitorSystemPromptParts(session) : buildSystemPromptParts(session),
+    abortController: controller,
+    canUseTool: runtimeOverrides.canUseTool
+  };
+}
+async function* sendPrompt(sessionId, prompt, runtimeOverrides = {}) {
+  const session = getSession(sessionId);
+  if (!session) throw new Error(`Session "${sessionId}" not found`);
+  if (session.isGenerating) throw new Error("Session is already generating");
+  const controller = new AbortController();
+  sessionControllers.set(session.id, controller);
+  session.isGenerating = true;
+  session.lastActivity = Date.now();
+  const provider = await ensureProvider(session.provider);
+  try {
+    const stream = provider.sendPrompt(prompt, buildProviderOptions(session, controller, false, runtimeOverrides));
+    for await (const event of stream) {
+      if (event.type === "session_init") {
+        session.providerSessionId = event.providerSessionId || void 0;
+        debouncedSave();
+      }
+      if (event.type === "result") {
+        session.totalCost += event.costUsd;
+      }
+      yield event;
+    }
+    session.messageCount++;
+  } catch (err) {
+    if (isAbortError(err)) {
+    } else {
+      throw err;
+    }
+  } finally {
+    session.isGenerating = false;
+    session.lastActivity = Date.now();
+    sessionControllers.delete(session.id);
+    await saveSessionsImmediate();
+  }
+}
+async function* continueSession(sessionId) {
+  yield* continueSessionWithOverrides(sessionId);
+}
+async function* continueSessionWithOverrides(sessionId, runtimeOverrides = {}) {
+  const session = getSession(sessionId);
+  if (!session) throw new Error(`Session "${sessionId}" not found`);
+  if (session.isGenerating) throw new Error("Session is already generating");
+  const controller = new AbortController();
+  sessionControllers.set(session.id, controller);
+  session.isGenerating = true;
+  session.lastActivity = Date.now();
+  const provider = await ensureProvider(session.provider);
+  try {
+    const stream = provider.continueSession(
+      buildProviderOptions(session, controller, false, runtimeOverrides)
+    );
+    for await (const event of stream) {
+      if (event.type === "session_init") {
+        session.providerSessionId = event.providerSessionId || void 0;
+        debouncedSave();
+      }
+      if (event.type === "result") {
+        session.totalCost += event.costUsd;
+      }
+      yield event;
+    }
+    session.messageCount++;
+  } catch (err) {
+    if (isAbortError(err)) {
+    } else {
+      throw err;
+    }
+  } finally {
+    session.isGenerating = false;
+    session.lastActivity = Date.now();
+    sessionControllers.delete(session.id);
+    await saveSessionsImmediate();
+  }
+}
+async function* sendMonitorPrompt(sessionId, prompt) {
+  const session = getSession(sessionId);
+  if (!session) throw new Error(`Session "${sessionId}" not found`);
+  const provider = await ensureProvider(session.provider);
+  session.lastActivity = Date.now();
+  const controller = new AbortController();
+  const stream = provider.sendPrompt(prompt, buildProviderOptions(session, controller, true));
+  for await (const event of stream) {
+    if (event.type === "session_init") {
+      session.monitorProviderSessionId = event.providerSessionId || void 0;
+      debouncedSave();
+    }
+    if (event.type === "result") {
+      session.totalCost += event.costUsd;
+    }
+    yield event;
+  }
+  session.lastActivity = Date.now();
+  debouncedSave();
+}
+function abortSession(sessionId) {
+  return abortSessionWithReason(sessionId, "user");
+}
+function abortSessionWithReason(sessionId, reason) {
+  const session = getSession(sessionId);
+  if (!session) return false;
+  const controller = sessionControllers.get(session.id);
+  sessionAbortReasons.set(session.id, reason);
+  if (controller) {
+    controller.abort();
+  }
+  if (session.isGenerating) {
+    session.isGenerating = false;
+    sessionControllers.delete(session.id);
+    debouncedSave();
+    return true;
+  }
+  return !!controller;
+}
+function consumeAbortReason(sessionId) {
+  const session = getSession(sessionId);
+  if (!session) return void 0;
+  const reason = sessionAbortReasons.get(session.id);
+  sessionAbortReasons.delete(session.id);
+  return reason;
+}
+function updateLocalObservation(sessionId, patch) {
+  const observationPatch = {
+    discoverySource: patch.discoverySource,
+    lastObservedAt: Date.now(),
+    lastObservedCwd: resolvePath(patch.cwd)
+  };
+  if (patch.remoteHumanControl !== void 0) {
+    observationPatch.remoteHumanControl = patch.remoteHumanControl;
+  }
+  updateSession(sessionId, observationPatch);
+}
+async function registerLocalSession(params, guild) {
+  const { provider, providerSessionId, cwd, discoverySource, labelHint, remoteHumanControl } = params;
+  const existing = getSessionByProviderSessionId(provider, providerSessionId);
+  if (existing) {
+    updateLocalObservation(existing.id, {
+      discoverySource,
+      cwd,
+      remoteHumanControl
+    });
+    return { session: existing, isNewlyCreated: false };
+  }
+  const { getProjectByPath, getAllRegisteredProjects: getAllRegisteredProjects2 } = await import("./project-registry-DQT5ORUU.js");
+  const { resolvePath: resolvePath2 } = await import("./utils-72GMT2X5.js");
+  const normalizedCwd = resolvePath2(cwd);
+  let project = getProjectByPath(normalizedCwd);
+  if (!project) {
+    const allProjects = getAllRegisteredProjects2();
+    let bestMatch;
+    let bestMatchPathLength = -1;
+    for (const p of allProjects) {
+      const projectPath = resolvePath2(p.path);
+      if (normalizedCwd.startsWith(projectPath + sep) && projectPath.length > bestMatchPathLength) {
+        bestMatch = p;
+        bestMatchPathLength = projectPath.length;
+      }
+    }
+    project = bestMatch;
+  }
+  if (!project || !project.discordCategoryId) {
+    console.warn(
+      `[registerLocalSession] Cannot register ${provider} session ${providerSessionId}: cwd "${cwd}" does not belong to any mounted project`
+    );
+    return null;
+  }
+  const { ChannelType } = await import("discord.js");
+  const category = guild.channels.cache.get(project.discordCategoryId);
+  if (!category || category.type !== ChannelType.GuildCategory) {
+    console.warn(
+      `[registerLocalSession] Cannot register ${provider} session ${providerSessionId}: category ${project.discordCategoryId} not found`
+    );
+    return null;
+  }
+  const base = labelHint ? labelHint.toLowerCase().replace(/[^a-z0-9-]/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "").slice(0, 60) : providerSessionId.slice(0, 12);
+  const channelName = `${provider}-${base}`.slice(0, 100);
+  let channel = category.children.cache.find(
+    (ch) => ch.type === ChannelType.GuildText && typeof ch.topic === "string" && ch.topic.includes(`Provider Session: ${providerSessionId}`)
+  );
+  if (!channel) {
+    channel = await guild.channels.create({
+      name: channelName,
+      type: ChannelType.GuildText,
+      parent: category.id,
+      topic: `${provider} session (local) | Provider Session: ${providerSessionId}`
+    });
+  }
+  const session = await createSession({
+    channelId: channel.id,
+    categoryId: project.discordCategoryId,
+    projectName: project.name,
+    agentLabel: labelHint || providerSessionId.slice(0, 12),
+    provider,
+    providerSessionId,
+    directory: normalizedCwd,
+    type: "persistent",
+    discoverySource,
+    remoteHumanControl: remoteHumanControl ?? false
+  });
+  updateLocalObservation(session.id, {
+    discoverySource,
+    cwd: normalizedCwd,
+    remoteHumanControl: remoteHumanControl ?? false
+  });
+  console.log(
+    `[registerLocalSession] Registered ${provider} session ${providerSessionId} (source: ${discoverySource}, channel: ${channel.id})`
+  );
+  return { session, isNewlyCreated: true };
+}
+
+export {
+  loadProjects,
+  getProject,
+  bindMountedProjectToCategory,
+  setHistoryChannelId,
+  setControlChannelId,
+  setPersonality,
+  clearPersonality,
+  addSkill,
+  removeSkill,
+  getSkills,
+  executeSkill,
+  addMcpServer,
+  removeMcpServer,
+  getMcpServers,
+  loadSessions,
+  createSession,
+  getSession,
+  getSessionByChannel,
+  getSessionByThread,
+  getSessionByCodexId,
+  getSessionByProviderSession,
+  getSessionsByCategory,
+  getAllSessions,
+  getSessionByProviderSessionId,
+  findCodexSessionForMonitor,
+  findCodexSessionByProviderSessionId,
+  findCodexSessionByCwd,
+  resolveCodexSessionFromMonitor,
+  updateSession,
+  setStatusCardBinding,
+  setCurrentInteractionMessage,
+  endSession,
+  setMode,
+  setVerbose,
+  setModel,
+  setAgentPersona,
+  setMonitorGoal,
+  updateWorkflowState,
+  resetWorkflowState,
+  sendPrompt,
+  continueSession,
+  continueSessionWithOverrides,
+  sendMonitorPrompt,
+  abortSession,
+  abortSessionWithReason,
+  consumeAbortReason,
+  updateLocalObservation,
+  registerLocalSession
+};