workspacecord 1.0.2 → 1.1.0

package/dist/{chunk-TSBM3BNT.js → chunk-IFSOU4XI.js}

@@ -1,9 +1,8 @@
 #!/usr/bin/env node
 import {
   config
-} from "./chunk-2LBNM64L.js";
+} from "./chunk-D6J3X35H.js";
 import {
-  Store,
   bindProjectCategory,
   getProjectByCategoryId,
   getProjectByName,
@@ -11,16 +10,14 @@ import {
   setProjectControlChannel,
   setProjectHistoryChannel,
   updateProject
-} from "./chunk-NIXZJTOZ.js";
+} from "./chunk-7KESUGJP.js";
 import {
-  isAbortError,
-  resolvePath,
-  sanitizeName
-} from "./chunk-WE4X3JB3.js";
+  Store
+} from "./chunk-CBNENUW6.js";
 
 // src/thread-manager.ts
-import { existsSync as existsSync2 } from "fs";
-import { sep } from "path";
+import "fs";
+import { sep as sep2 } from "path";
 
 // src/providers/claude-provider.ts
 import { query } from "@anthropic-ai/claude-agent-sdk";
@@ -253,7 +250,7 @@ providers.set("claude", new ClaudeProvider());
 var codexLoadAttempted = false;
 async function loadCodexProvider() {
   try {
-    const { CodexProvider } = await import("./codex-provider-7CI5W34X.js");
+    const { CodexProvider } = await import("./codex-provider-P7TDYK6B.js");
     providers.set("codex", new CodexProvider());
     codexLoadAttempted = true;
   } catch (err) {
@@ -396,18 +393,24 @@ async function bindMountedProjectToCategory(projectName, categoryId, categoryNam
 function setHistoryChannelId(categoryId, channelId) {
   const project = getProjectByCategoryId(categoryId);
   if (!project) return;
-  void setProjectHistoryChannel(project.name, channelId);
+  setProjectHistoryChannel(project.name, channelId).catch(
+    (err) => console.error(`Failed to set history channel for project "${project.name}": ${err.message}`)
+  );
 }
 function setControlChannelId(categoryId, channelId) {
   const project = getProjectByCategoryId(categoryId);
   if (!project) return;
-  void setProjectControlChannel(project.name, channelId);
+  setProjectControlChannel(project.name, channelId).catch(
+    (err) => console.error(`Failed to set control channel for project "${project.name}": ${err.message}`)
+  );
 }
 function setPersonality(categoryId, personality) {
   const project = getProjectByCategoryId(categoryId);
   if (!project) return;
   project.personality = personality;
-  void updateProject(project);
+  updateProject(project).catch(
+    (err) => console.error(`Failed to update personality for project "${project.name}": ${err.message}`)
+  );
 }
 function getPersonality(categoryId) {
   return getProjectByCategoryId(categoryId)?.personality;
@@ -416,19 +419,25 @@ function clearPersonality(categoryId) {
   const project = getProjectByCategoryId(categoryId);
   if (!project) return;
   delete project.personality;
-  void updateProject(project);
+  updateProject(project).catch(
+    (err) => console.error(`Failed to clear personality for project "${project.name}": ${err.message}`)
+  );
 }
 function addSkill(categoryId, name, prompt) {
   const project = getProjectByCategoryId(categoryId);
   if (!project) return;
   project.skills[name] = prompt;
-  void updateProject(project);
+  updateProject(project).catch(
+    (err) => console.error(`Failed to add skill "${name}" for project "${project.name}": ${err.message}`)
+  );
 }
 function removeSkill(categoryId, name) {
   const project = getProjectByCategoryId(categoryId);
   if (!project || !project.skills[name]) return false;
   delete project.skills[name];
-  void updateProject(project);
+  updateProject(project).catch(
+    (err) => console.error(`Failed to remove skill "${name}" for project "${project.name}": ${err.message}`)
+  );
   return true;
 }
 function getSkills(categoryId) {
@@ -494,33 +503,75 @@ async function writeMcpJson(projectDir, servers) {
   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.
+// src/utils.ts
+import { resolve, isAbsolute } from "path";
+import { homedir } from "os";
+function sanitizeName(name) {
+  return name.toLowerCase().replace(/[^a-z0-9-]/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "").slice(0, 50) || "session";
+}
+function resolvePath(p) {
+  if (p.startsWith("~/") || p === "~") {
+    return p.replace("~", homedir());
+  }
+  return isAbsolute(p) ? p : resolve(process.cwd(), p);
+}
+function formatDuration(ms) {
+  const s = Math.floor(ms / 1e3);
+  if (s < 60) return `${s}s`;
+  const m = Math.floor(s / 60);
+  if (m < 60) return `${m}m ${s % 60}s`;
+  const h = Math.floor(m / 60);
+  return `${h}h ${m % 60}m`;
+}
+function formatRelative(ts) {
+  const diff = Date.now() - ts;
+  if (diff < 6e4) return "just now";
+  if (diff < 36e5) return `${Math.floor(diff / 6e4)}m ago`;
+  if (diff < 864e5) return `${Math.floor(diff / 36e5)}h ago`;
+  return `${Math.floor(diff / 864e5)}d ago`;
+}
+function truncate(s, max) {
+  if (s.length <= max) return s;
+  return s.slice(0, max - 1) + "\u2026";
+}
+function isUserAllowed(userId, allowedUsers, allowAll) {
+  if (allowAll) return true;
+  if (allowedUsers.length === 0) return false;
+  return allowedUsers.includes(userId);
+}
+var ABORT_PATTERNS = ["abort", "cancel", "interrupt", "killed", "signal"];
+function isAbortError(err) {
+  if (err instanceof Error && err.name === "AbortError") return true;
+  const msg = (err.message || "").toLowerCase();
+  return ABORT_PATTERNS.some((p) => msg.includes(p));
+}
+function formatUptime(startTime) {
+  const ms = Date.now() - startTime;
+  const seconds = Math.floor(ms / 1e3);
+  const minutes = Math.floor(seconds / 60);
+  const hours = Math.floor(minutes / 60);
+  const days = Math.floor(hours / 24);
+  if (days > 0) return `${days}d ${hours % 24}h`;
+  if (hours > 0) return `${hours}h ${minutes % 60}m`;
+  if (minutes > 0) return `${minutes}m`;
+  return `${seconds}s`;
+}
 
-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."
+// src/discord/session-message-context.ts
+function buildDiscordSessionMessageContext() {
+  return [
+    "\u5F53\u524D\u4F1A\u8BDD\u4E2D\u7684\u6D88\u606F\u6765\u81EA Discord\u3002",
+    "\u6D88\u606F\u5305\u4E2D\u7684 [attachments] \u5757\u4F1A\u66B4\u9732 session_id\u3001message_id \u4E0E attachment_id\uFF0C\u8DB3\u4EE5\u6784\u6210 `workspacecord attachment fetch --session <session-id> --message <message-id> --attachment <attachment-id>` \u6216 `workspacecord attachment fetch --session <session-id> --message <message-id> --all`\u3002",
+    "\u9644\u4EF6\u9ED8\u8BA4\u4E0D\u81EA\u52A8\u4E0B\u8F7D\uFF0C\u4F60\u9996\u5148\u53EA\u4F1A\u770B\u5230\u9644\u4EF6\u6458\u8981\u3002",
+    "\u5982\u679C\u4F60\u9700\u8981\u67E5\u770B\u9644\u4EF6\u5185\u5BB9\uFF0C\u8BF7\u901A\u8FC7\u4E0A\u8FF0\u672C\u5730\u547D\u4EE4\u83B7\u53D6\u3002",
+    "\u6B63\u5E38\u56DE\u590D\u65F6\u4E0D\u9700\u8981\u53CD\u590D\u5F15\u7528\u6700\u65B0\u4E00\u6761 Discord \u6D88\u606F\u3002",
+    "\u957F\u4EFB\u52A1\u5B8C\u6210\u540E\uFF0C\u5FC5\u987B\u53D1\u9001\u65B0\u7684\u53EF\u89C1\u6D88\u606F\uFF0C\u4E0D\u8981\u53EA\u4F9D\u8D56\u7F16\u8F91\u65E7\u7684\u8FDB\u5EA6\u6D88\u606F\u3002"
+  ].join(" ");
 }
 
-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.`;
+// src/session-registry.ts
+import { existsSync as existsSync2 } from "fs";
+import { sep } from "path";
 var sessionStore = new Store("sessions.json");
 var sessions = /* @__PURE__ */ new Map();
 var idToChannelId = /* @__PURE__ */ new Map();
@@ -566,11 +617,17 @@ async function loadSessions() {
       mode: s.mode ?? "auto",
       subagentDepth: s.subagentDepth ?? 0,
       type: s.type ?? "persistent",
+      codexSandboxMode: s.codexSandboxMode,
+      codexApprovalPolicy: s.codexApprovalPolicy,
+      codexBypass: s.codexBypass,
+      codexNetworkAccessEnabled: s.codexNetworkAccessEnabled,
+      codexWebSearchMode: s.codexWebSearchMode,
       workflowState: s.workflowState ?? createDefaultWorkflowState(),
       currentTurn: s.currentTurn ?? 0,
       humanResolved: s.humanResolved ?? false,
       currentInteractionMessageId: s.currentInteractionMessageId,
       statusCardMessageId: s.statusCardMessageId,
+      lastInboundMessageId: s.lastInboundMessageId,
       discoverySource: s.discoverySource ?? "discord",
       lastObservedState: s.lastObservedState,
       lastObservedEventKey: s.lastObservedEventKey,
@@ -611,6 +668,11 @@ async function persistSessionsNow() {
       agentPersona: s.agentPersona,
       verbose: s.verbose || false,
       claudePermissionMode: s.claudePermissionMode,
+      codexSandboxMode: s.codexSandboxMode,
+      codexApprovalPolicy: s.codexApprovalPolicy,
+      codexBypass: s.codexBypass,
+      codexNetworkAccessEnabled: s.codexNetworkAccessEnabled,
+      codexWebSearchMode: s.codexWebSearchMode,
       monitorGoal: s.monitorGoal,
       monitorProviderSessionId: s.monitorProviderSessionId,
       workflowState: s.workflowState,
@@ -622,6 +684,7 @@ async function persistSessionsNow() {
       humanResolved: s.humanResolved,
       currentInteractionMessageId: s.currentInteractionMessageId,
       statusCardMessageId: s.statusCardMessageId,
+      lastInboundMessageId: s.lastInboundMessageId,
       discoverySource: s.discoverySource,
       lastObservedState: s.lastObservedState,
       lastObservedEventKey: s.lastObservedEventKey,
@@ -672,6 +735,11 @@ async function createSession(params) {
     subagentDepth = 0,
     mode = config.defaultMode,
     claudePermissionMode,
+    codexSandboxMode,
+    codexApprovalPolicy,
+    codexBypass,
+    codexNetworkAccessEnabled,
+    codexWebSearchMode,
     discoverySource = "discord",
     remoteHumanControl
   } = params;
@@ -679,7 +747,6 @@ async function createSession(params) {
   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`);
   }
@@ -706,6 +773,11 @@ async function createSession(params) {
     agentPersona: void 0,
     verbose: false,
     claudePermissionMode,
+    codexSandboxMode,
+    codexApprovalPolicy,
+    codexBypass,
+    codexNetworkAccessEnabled,
+    codexWebSearchMode,
     monitorGoal: void 0,
     monitorProviderSessionId: void 0,
     workflowState: createDefaultWorkflowState(),
@@ -718,6 +790,7 @@ async function createSession(params) {
     humanResolved: false,
     currentInteractionMessageId: void 0,
     statusCardMessageId: void 0,
+    lastInboundMessageId: void 0,
     discoverySource,
     remoteHumanControl
   };
@@ -767,17 +840,9 @@ function getSessionsByCategory(categoryId) {
 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);
+    const byProviderId = getSessionByProviderSession("codex", providerSessionId);
     if (byProviderId) return byProviderId;
   }
   if (!cwd) return void 0;
@@ -837,6 +902,58 @@ function updateSession(sessionId, patch) {
   Object.assign(session, patch);
   debouncedSave();
 }
+async function updateSessionPermissions(sessionId, patch) {
+  const session = getSession(sessionId);
+  if (!session) {
+    throw new Error(`Session "${sessionId}" not found`);
+  }
+  Object.assign(session, patch);
+  session.lastActivity = Date.now();
+  await saveSessionsImmediate();
+}
+function resolveEffectiveClaudePermissionMode(session) {
+  return session.mode === "auto" ? "bypass" : session.claudePermissionMode ?? config.claudePermissionMode;
+}
+function resolveEffectiveCodexOptions(session) {
+  const bypass = session.codexBypass === true;
+  if (bypass) {
+    return {
+      sandboxMode: "danger-full-access",
+      approvalPolicy: "never",
+      networkAccessEnabled: true,
+      webSearchMode: "live",
+      bypass: true
+    };
+  }
+  return {
+    sandboxMode: session.codexSandboxMode ?? config.codexSandboxMode,
+    approvalPolicy: session.mode === "auto" ? "never" : session.codexApprovalPolicy ?? config.codexApprovalPolicy,
+    networkAccessEnabled: session.codexNetworkAccessEnabled ?? config.codexNetworkAccessEnabled,
+    webSearchMode: session.codexWebSearchMode ?? config.codexWebSearchMode,
+    bypass: false
+  };
+}
+function getSessionPermissionSummary(session) {
+  if (session.provider === "claude") {
+    return resolveEffectiveClaudePermissionMode(session);
+  }
+  const codex = resolveEffectiveCodexOptions(session);
+  if (codex.bypass) return "bypass";
+  return `${codex.sandboxMode} | ${codex.approvalPolicy} | net:${codex.networkAccessEnabled ? "on" : "off"} | search:${codex.webSearchMode}`;
+}
+function getSessionPermissionDetails(session) {
+  if (session.provider === "claude") {
+    return `Claude: ${resolveEffectiveClaudePermissionMode(session)}`;
+  }
+  const codex = resolveEffectiveCodexOptions(session);
+  return [
+    `sandbox=${codex.sandboxMode}`,
+    `approval=${codex.approvalPolicy}`,
+    `bypass=${codex.bypass ? "on" : "off"}`,
+    `network=${codex.networkAccessEnabled ? "on" : "off"}`,
+    `search=${codex.webSearchMode}`
+  ].join(" | ");
+}
 function setStatusCardBinding(sessionId, binding) {
   const session = getSession(sessionId);
   if (!session) return;
@@ -928,6 +1045,81 @@ function resetWorkflowState(sessionId) {
   session.workflowState = createDefaultWorkflowState();
   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 setSessionController(sessionId, controller) {
+  sessionControllers.set(sessionId, controller);
+}
+function clearSessionController(sessionId) {
+  sessionControllers.delete(sessionId);
+}
+function markSessionGenerating(sessionId, generating) {
+  const session = getSession(sessionId);
+  if (!session) return;
+  session.isGenerating = generating;
+  session.lastActivity = Date.now();
+  if (!generating) {
+    void saveSessionsImmediate();
+  }
+}
+function saveSessionImmediate() {
+  return saveSessionsImmediate();
+}
+function debouncedSaveSession() {
+  debouncedSave();
+}
+
+// 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.`;
 function buildSystemPromptParts(session) {
   const parts = [];
   const personality = getPersonality(session.categoryId);
@@ -938,6 +1130,7 @@ function buildSystemPromptParts(session) {
   }
   const modePrompt = MODE_PROMPTS[session.mode];
   if (modePrompt) parts.push(modePrompt);
+  parts.push(buildDiscordSessionMessageContext());
   return parts;
 }
 function buildMonitorSystemPromptParts(session) {
@@ -945,20 +1138,21 @@ function buildMonitorSystemPromptParts(session) {
   const personality = getPersonality(session.categoryId);
   if (personality) parts.push(personality);
   parts.push(MONITOR_SYSTEM_PROMPT);
+  parts.push(buildDiscordSessionMessageContext());
   return parts;
 }
 function buildProviderOptions(session, controller, isMonitor = false, runtimeOverrides = {}) {
-  const isAutoMode = session.mode === "auto";
+  const effectiveCodex = resolveEffectiveCodexOptions(session);
   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,
+    sandboxMode: effectiveCodex.sandboxMode,
+    approvalPolicy: effectiveCodex.approvalPolicy,
+    networkAccessEnabled: effectiveCodex.networkAccessEnabled,
+    webSearchMode: effectiveCodex.webSearchMode,
     modelReasoningEffort: config.codexReasoningEffort || void 0,
-    claudePermissionMode: isAutoMode ? "bypass" : session.claudePermissionMode ?? config.claudePermissionMode,
+    claudePermissionMode: resolveEffectiveClaudePermissionMode(session),
     systemPromptParts: isMonitor ? buildMonitorSystemPromptParts(session) : buildSystemPromptParts(session),
     abortController: controller,
     canUseTool: runtimeOverrides.canUseTool
@@ -969,33 +1163,39 @@ async function* sendPrompt(sessionId, prompt, runtimeOverrides = {}) {
   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();
+  setSessionController(session.id, controller);
+  markSessionGenerating(session.id, true);
   const provider = await ensureProvider(session.provider);
   try {
-    const stream = provider.sendPrompt(prompt, buildProviderOptions(session, controller, false, runtimeOverrides));
+    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();
+        const s2 = getSession(sessionId);
+        if (s2) {
+          s2.providerSessionId = event.providerSessionId || void 0;
+          debouncedSaveSession();
+        }
       }
       if (event.type === "result") {
-        session.totalCost += event.costUsd;
+        const s2 = getSession(sessionId);
+        if (s2) s2.totalCost += event.costUsd;
       }
       yield event;
     }
-    session.messageCount++;
+    const s = getSession(sessionId);
+    if (s) s.messageCount++;
   } catch (err) {
     if (isAbortError(err)) {
     } else {
       throw err;
     }
   } finally {
-    session.isGenerating = false;
-    session.lastActivity = Date.now();
-    sessionControllers.delete(session.id);
-    await saveSessionsImmediate();
+    markSessionGenerating(sessionId, false);
+    clearSessionController(sessionId);
+    await saveSessionImmediate();
   }
 }
 async function* continueSession(sessionId) {
@@ -1006,9 +1206,8 @@ async function* continueSessionWithOverrides(sessionId, runtimeOverrides = {}) {
   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();
+  setSessionController(session.id, controller);
+  markSessionGenerating(session.id, true);
   const provider = await ensureProvider(session.provider);
   try {
     const stream = provider.continueSession(
@@ -1016,106 +1215,103 @@ async function* continueSessionWithOverrides(sessionId, runtimeOverrides = {}) {
     );
     for await (const event of stream) {
       if (event.type === "session_init") {
-        session.providerSessionId = event.providerSessionId || void 0;
-        debouncedSave();
+        const s2 = getSession(sessionId);
+        if (s2) {
+          s2.providerSessionId = event.providerSessionId || void 0;
+          debouncedSaveSession();
+        }
       }
       if (event.type === "result") {
-        session.totalCost += event.costUsd;
+        const s2 = getSession(sessionId);
+        if (s2) s2.totalCost += event.costUsd;
       }
       yield event;
     }
-    session.messageCount++;
+    const s = getSession(sessionId);
+    if (s) s.messageCount++;
   } catch (err) {
     if (isAbortError(err)) {
     } else {
       throw err;
     }
   } finally {
-    session.isGenerating = false;
-    session.lastActivity = Date.now();
-    sessionControllers.delete(session.id);
-    await saveSessionsImmediate();
+    markSessionGenerating(sessionId, false);
+    clearSessionController(sessionId);
+    await saveSessionImmediate();
   }
 }
 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 s = getSession(sessionId);
+  if (s) s.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();
+      const cur2 = getSession(sessionId);
+      if (cur2) {
+        cur2.monitorProviderSessionId = event.providerSessionId || void 0;
+        debouncedSaveSession();
+      }
     }
     if (event.type === "result") {
-      session.totalCost += event.costUsd;
+      const cur2 = getSession(sessionId);
+      if (cur2) cur2.totalCost += event.costUsd;
     }
     yield event;
   }
-  session.lastActivity = Date.now();
-  debouncedSave();
+  const cur = getSession(sessionId);
+  if (cur) cur.lastActivity = Date.now();
+  debouncedSaveSession();
 }
-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 buildClaudeSubagentProviderSessionId(parentProviderSessionId, agentId) {
+  return `subagent:${parentProviderSessionId}:${agentId}`;
 }
 function updateLocalObservation(sessionId, patch) {
-  const observationPatch = {
+  updateSession(sessionId, {
     discoverySource: patch.discoverySource,
     lastObservedAt: Date.now(),
-    lastObservedCwd: resolvePath(patch.cwd)
-  };
-  if (patch.remoteHumanControl !== void 0) {
-    observationPatch.remoteHumanControl = patch.remoteHumanControl;
-  }
-  updateSession(sessionId, observationPatch);
+    lastObservedCwd: resolvePath(patch.cwd),
+    ...patch.remoteHumanControl !== void 0 ? { remoteHumanControl: patch.remoteHumanControl } : {}
+  });
 }
 async function registerLocalSession(params, guild) {
-  const { provider, providerSessionId, cwd, discoverySource, labelHint, remoteHumanControl } = params;
-  const existing = getSessionByProviderSessionId(provider, providerSessionId);
+  const {
+    provider,
+    providerSessionId,
+    cwd,
+    discoverySource,
+    labelHint,
+    remoteHumanControl,
+    subagent
+  } = params;
+  const effectiveProviderSessionId = provider === "claude" && subagent?.parentProviderSessionId && subagent.agentId ? buildClaudeSubagentProviderSessionId(subagent.parentProviderSessionId, subagent.agentId) : providerSessionId;
+  const effectiveAgentLabel = subagent?.agentType || labelHint || effectiveProviderSessionId.slice(0, 12);
+  const { isArchivedProviderSession } = await import("./archive-manager-KMNAWQIN.js");
+  if (isArchivedProviderSession(provider, effectiveProviderSessionId)) {
+    console.log(
+      `[registerLocalSession] Skip archived ${provider} session ${effectiveProviderSessionId} (source: ${discoverySource})`
+    );
+    return null;
+  }
+  const existing = getSessionByProviderSession(provider, effectiveProviderSessionId);
   if (existing) {
-    updateLocalObservation(existing.id, {
-      discoverySource,
-      cwd,
-      remoteHumanControl
-    });
+    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);
+  const { getProjectByPath, getAllRegisteredProjects: getAllRegisteredProjects2 } = await import("./project-registry-LL75XEUV.js");
+  const { ChannelType, ThreadAutoArchiveDuration } = await import("discord.js");
+  const normalizedCwd = resolvePath(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) {
+      const projectPath = resolvePath(p.path);
+      if (normalizedCwd.startsWith(projectPath + sep2) && projectPath.length > bestMatchPathLength) {
         bestMatch = p;
         bestMatchPathLength = projectPath.length;
       }
@@ -1128,7 +1324,6 @@ async function registerLocalSession(params, guild) {
     );
     return null;
   }
-  const { ChannelType } = await import("discord.js");
   const category = guild.channels.cache.get(project.discordCategoryId);
   if (!category || category.type !== ChannelType.GuildCategory) {
     console.warn(
@@ -1136,26 +1331,73 @@ async function registerLocalSession(params, guild) {
     );
     return null;
   }
-  const base = labelHint ? labelHint.toLowerCase().replace(/[^a-z0-9-]/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "").slice(0, 60) : providerSessionId.slice(0, 12);
+  if (subagent?.parentProviderSessionId) {
+    const parentSession = getSessionByProviderSession(provider, subagent.parentProviderSessionId);
+    if (!parentSession) {
+      console.warn(
+        `[registerLocalSession] Delaying subagent ${provider} session ${providerSessionId}: parent provider session ${subagent.parentProviderSessionId} not registered yet`
+      );
+      return null;
+    }
+    const parentChannel = guild.channels.cache.get(parentSession.channelId);
+    const threadHostChannel = parentChannel?.type === ChannelType.GuildText ? parentChannel : parentChannel?.isThread?.() || parentChannel?.type === ChannelType.PublicThread ? parentChannel.parent : void 0;
+    if (threadHostChannel?.type !== ChannelType.GuildText) {
+      console.warn(
+        `[registerLocalSession] Delaying subagent ${provider} session ${providerSessionId}: parent channel ${parentSession.channelId} is unavailable`
+      );
+      return null;
+    }
+    const normalizedThreadName = `[sub:${provider}] ${effectiveAgentLabel}`.slice(0, 100);
+    const thread = await threadHostChannel.threads.create({
+      name: normalizedThreadName,
+      type: ChannelType.PublicThread,
+      autoArchiveDuration: ThreadAutoArchiveDuration.OneHour,
+      reason: `Auto-registered subagent session ${effectiveProviderSessionId}`
+    });
+    const session2 = await createSession({
+      channelId: thread.id,
+      categoryId: parentSession.categoryId,
+      projectName: parentSession.projectName,
+      agentLabel: effectiveAgentLabel,
+      provider,
+      providerSessionId: effectiveProviderSessionId,
+      directory: normalizedCwd,
+      type: "subagent",
+      parentChannelId: parentSession.type === "subagent" ? parentSession.parentChannelId ?? threadHostChannel.id : parentSession.channelId,
+      subagentDepth: Math.max(1, subagent.depth ?? parentSession.subagentDepth + 1),
+      discoverySource,
+      remoteHumanControl: remoteHumanControl ?? false
+    });
+    updateLocalObservation(session2.id, {
+      discoverySource,
+      cwd: normalizedCwd,
+      remoteHumanControl: remoteHumanControl ?? false
+    });
+    console.log(
+      `[registerLocalSession] Registered subagent ${provider} session ${effectiveProviderSessionId} (source: ${discoverySource}, parent: ${parentSession.channelId}, thread: ${thread.id})`
+    );
+    return { session: session2, isNewlyCreated: true };
+  }
+  const base = labelHint ? labelHint.toLowerCase().replace(/[^a-z0-9-]/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "").slice(0, 60) : effectiveProviderSessionId.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}`)
+    (ch) => ch.type === ChannelType.GuildText && typeof ch.topic === "string" && ch.topic.includes(`Provider Session: ${effectiveProviderSessionId}`)
   );
   if (!channel) {
     channel = await guild.channels.create({
       name: channelName,
       type: ChannelType.GuildText,
       parent: category.id,
-      topic: `${provider} session (local) | Provider Session: ${providerSessionId}`
+      topic: `${provider} session (local) | Provider Session: ${effectiveProviderSessionId}`
     });
   }
   const session = await createSession({
     channelId: channel.id,
     categoryId: project.discordCategoryId,
     projectName: project.name,
-    agentLabel: labelHint || providerSessionId.slice(0, 12),
+    agentLabel: effectiveAgentLabel,
     provider,
-    providerSessionId,
+    providerSessionId: effectiveProviderSessionId,
     directory: normalizedCwd,
     type: "persistent",
     discoverySource,
@@ -1167,7 +1409,7 @@ async function registerLocalSession(params, guild) {
     remoteHumanControl: remoteHumanControl ?? false
   });
   console.log(
-    `[registerLocalSession] Registered ${provider} session ${providerSessionId} (source: ${discoverySource}, channel: ${channel.id})`
+    `[registerLocalSession] Registered ${provider} session ${effectiveProviderSessionId} (source: ${discoverySource}, channel: ${channel.id})`
   );
   return { session, isNewlyCreated: true };
 }
@@ -1187,6 +1429,12 @@ export {
   addMcpServer,
   removeMcpServer,
   getMcpServers,
+  formatDuration,
+  formatRelative,
+  truncate,
+  isUserAllowed,
+  isAbortError,
+  formatUptime,
   loadSessions,
   createSession,
   getSession,
@@ -1196,12 +1444,16 @@ export {
   getSessionByProviderSession,
   getSessionsByCategory,
   getAllSessions,
-  getSessionByProviderSessionId,
   findCodexSessionForMonitor,
   findCodexSessionByProviderSessionId,
   findCodexSessionByCwd,
   resolveCodexSessionFromMonitor,
   updateSession,
+  updateSessionPermissions,
+  resolveEffectiveClaudePermissionMode,
+  resolveEffectiveCodexOptions,
+  getSessionPermissionSummary,
+  getSessionPermissionDetails,
   setStatusCardBinding,
   setCurrentInteractionMessage,
   endSession,
@@ -1212,13 +1464,14 @@ export {
   setMonitorGoal,
   updateWorkflowState,
   resetWorkflowState,
+  abortSession,
+  abortSessionWithReason,
+  consumeAbortReason,
   sendPrompt,
   continueSession,
   continueSessionWithOverrides,
   sendMonitorPrompt,
-  abortSession,
-  abortSessionWithReason,
-  consumeAbortReason,
+  buildClaudeSubagentProviderSessionId,
   updateLocalObservation,
   registerLocalSession
 };