workspacecord 1.1.0 → 1.1.2

package/README.md

@@ -35,7 +35,11 @@ Discord Server
 - Discord-side project binding with `/project setup`
 - Main session channels and subagent threads
 - Session archiving into `#history`
+- Project-level personality, reusable skills, and MCP registry management
 - Support for both Claude and Codex providers
+- `monitor` mode with continued steering until task completion
+- Remote human approval / gate handling from Discord for managed sessions
+- Managed local `Codex` launch plus automatic local session discovery/sync
 - Global config storage without requiring a project-local `.env`
 - Optional daemon install and background management
 
@@ -153,6 +157,42 @@ workspacecord codex [options]   # Launch managed Codex session with remote appro
 - `/subagent list` — list subagents for the current session
 - `/shell run` / `/shell processes` / `/shell kill`
 
+
+## Capability Matrix
+
+| Capability | Status | Entry Points |
+|---|---|---|
+| Global configuration | Stable | `workspacecord config *` |
+| Explicit local project mounting | Stable | `workspacecord project *` |
+| Discord category binding | Stable | `/project setup`, `/project info` |
+| Project-level personality | Available | `/project personality`, `/project personality-clear` |
+| Project-level reusable skills | Available | `/project skill-add`, `/project skill-list`, `/project skill-run` |
+| Project-level MCP registry | Available | `/project mcp-add`, `/project mcp-list`, `/project mcp-remove` |
+| Main agent sessions | Stable | `/agent spawn`, `/agent list`, `/agent archive`, `/agent cleanup` |
+| Subagent threads | Stable | `/subagent run`, `/subagent list` |
+| Session execution modes | Stable | `/agent mode`, `/agent goal`, `/agent verbose` |
+| Remote human approval / gates | Available | interaction cards, `monitor` mode, Claude permission handling |
+| Managed local Codex launch | Available | `workspacecord codex` |
+| Local session discovery / sync | Available | hook / codex-log / sync recovery paths |
+| Shell execution from Discord | Available | `/shell run`, `/shell processes`, `/shell kill` |
+| History archive | Stable | `#history`, `/agent archive` |
+| Daemon installation / background run | Available | `workspacecord daemon *` |
+
+## Runtime Architecture
+
+Current main runtime path:
+
+```text
+bot.ts
+  -> BotEventRouter
+    -> command handlers / button handler / message handler
+      -> thread-manager façade
+        -> session-registry / session runtime / state machine / panel adapter
+          -> Discord delivery + status cards + summaries
+```
+
+This repository intentionally keeps Discord as the control plane, while local project state, provider sessions, approvals, and output rendering stay on the machine that runs `workspacecord`.
+
 ## Development
 
 Run the standard verification flow:

package/README.zh-CN.md

@@ -35,7 +35,11 @@ Discord Server
 - 使用 `/project setup` 在 Discord 中绑定项目
 - 主会话频道与子代理线程模型
 - 会话自动归档到 `#history`
+- 项目级人格、可复用技能和 MCP 服务注册管理
 - 同时支持 Claude 与 Codex 提供方
+- `monitor` 模式可持续推进直到任务完成
+- 托管会话支持 Discord 远程人工审批 / 门控处理
+- 支持本地托管 `Codex` 启动与自动会话发现 / 同步
 - 使用全局配置存储，不依赖项目内 `.env`
 - 支持守护进程安装与后台管理
 
@@ -153,6 +157,42 @@ workspacecord codex [options]   # 启动托管的 Codex 会话（支持远程审
 - `/subagent list`：查看当前会话的子代理
 - `/shell run` / `/shell processes` / `/shell kill`
 
+
+## 能力矩阵
+
+| 能力 | 状态 | 入口 |
+|---|---|---|
+| 全局配置 | 稳定 | `workspacecord config *` |
+| 显式本地项目挂载 | 稳定 | `workspacecord project *` |
+| Discord 分类绑定 | 稳定 | `/project setup`, `/project info` |
+| 项目级人格 | 可用 | `/project personality`, `/project personality-clear` |
+| 项目级可复用技能 | 可用 | `/project skill-add`, `/project skill-list`, `/project skill-run` |
+| 项目级 MCP 注册表 | 可用 | `/project mcp-add`, `/project mcp-list`, `/project mcp-remove` |
+| 主代理会话 | 稳定 | `/agent spawn`, `/agent list`, `/agent archive`, `/agent cleanup` |
+| 子代理线程 | 稳定 | `/subagent run`, `/subagent list` |
+| 会话执行模式 | 稳定 | `/agent mode`, `/agent goal`, `/agent verbose` |
+| 远程人工审批 / 门控 | 可用 | 交互卡、`monitor` 模式、Claude 权限处理 |
+| 本地托管 Codex 启动 | 可用 | `workspacecord codex` |
+| 本地会话发现 / 同步 | 可用 | hook / codex-log / sync 恢复路径 |
+| 从 Discord 执行 shell | 可用 | `/shell run`, `/shell processes`, `/shell kill` |
+| 历史归档 | 稳定 | `#history`, `/agent archive` |
+| 守护进程安装 / 后台运行 | 可用 | `workspacecord daemon *` |
+
+## 运行时架构
+
+当前主运行路径：
+
+```text
+bot.ts
+  -> BotEventRouter
+    -> command handlers / button handler / message handler
+      -> thread-manager façade
+        -> session-registry / session runtime / state machine / panel adapter
+          -> Discord delivery + status cards + summaries
+```
+
+这意味着 Discord 只是控制平面；真正的项目状态、provider 会话、审批、输出渲染都发生在运行 `workspacecord` 的本机上。
+
 ## 开发与验证
 
 建议先运行基础验证：

package/dist/{archive-manager-KMNAWQIN.js → archive-manager-XM3UPOY2.js}

@@ -5,13 +5,11 @@ import {
   getArchivedSessions,
   isArchivedProviderSession,
   loadArchived
-} from "./chunk-PUKMHDXS.js";
-import "./chunk-IFSOU4XI.js";
-import "./chunk-D6J3X35H.js";
-import "./chunk-7KESUGJP.js";
-import "./chunk-CBNENUW6.js";
-import "./chunk-52OOARML.js";
-import "./chunk-K3NQKI34.js";
+} from "./chunk-GMYN4SYT.js";
+import "./chunk-54DP53ZK.js";
+import "./chunk-RK6EIZOL.js";
+import "./chunk-UEX7U2KW.js";
+import "./chunk-MO4EEYFW.js";
 export {
   archiveSession,
   checkAutoArchive,

package/dist/{attachment-cli-QEF7IZBI.js → attachment-cli-IGQBB6YJ.js}

@@ -1,9 +1,9 @@
 #!/usr/bin/env node
 import {
   fetchRegisteredAttachments
-} from "./chunk-Q2AJ4UEK.js";
-import "./chunk-CBNENUW6.js";
-import "./chunk-K3NQKI34.js";
+} from "./chunk-L2ZJXV6H.js";
+import "./chunk-UEX7U2KW.js";
+import "./chunk-MO4EEYFW.js";
 
 // src/attachment-cli.ts
 function printHelp() {

package/dist/{chunk-7KESUGJP.js → chunk-54DP53ZK.js}

@@ -1,9 +1,9 @@
 #!/usr/bin/env node
 import {
   Store
-} from "./chunk-CBNENUW6.js";
+} from "./chunk-UEX7U2KW.js";
 
-// src/project-registry.ts
+// ../engine/src/project-registry.ts
 import { randomUUID } from "crypto";
 import { resolve } from "path";
 var store = new Store("projects.json");

package/dist/chunk-COXPTYH5.js

@@ -0,0 +1,165 @@
+#!/usr/bin/env node
+import {
+  createSession,
+  getSessionByProviderSession,
+  updateSession
+} from "./chunk-RK6EIZOL.js";
+import {
+  resolvePath
+} from "./chunk-UEX7U2KW.js";
+
+// ../bot/src/session-local-registration.ts
+import { sep } from "path";
+function buildClaudeSubagentProviderSessionId(parentProviderSessionId, agentId) {
+  return `subagent:${parentProviderSessionId}:${agentId}`;
+}
+function updateLocalObservation(sessionId, patch) {
+  updateSession(sessionId, {
+    discoverySource: patch.discoverySource,
+    lastObservedAt: Date.now(),
+    lastObservedCwd: resolvePath(patch.cwd),
+    ...patch.remoteHumanControl !== void 0 ? { remoteHumanControl: patch.remoteHumanControl } : {}
+  });
+}
+async function registerLocalSession(params, guild) {
+  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-XM3UPOY2.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 });
+    return { session: existing, isNewlyCreated: false };
+  }
+  const { getProjectByPath, getAllRegisteredProjects } = await import("./project-registry-OEVPECMS.js");
+  const { ChannelType, ThreadAutoArchiveDuration } = await import("discord.js");
+  const normalizedCwd = resolvePath(cwd);
+  let project = getProjectByPath(normalizedCwd);
+  if (!project) {
+    const allProjects = getAllRegisteredProjects();
+    let bestMatch;
+    let bestMatchPathLength = -1;
+    for (const p of allProjects) {
+      const projectPath = resolvePath(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 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;
+  }
+  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: ${effectiveProviderSessionId}`)
+  );
+  if (!channel) {
+    channel = await guild.channels.create({
+      name: channelName,
+      type: ChannelType.GuildText,
+      parent: category.id,
+      topic: `${provider} session (local) | Provider Session: ${effectiveProviderSessionId}`
+    });
+  }
+  const session = await createSession({
+    channelId: channel.id,
+    categoryId: project.discordCategoryId,
+    projectName: project.name,
+    agentLabel: effectiveAgentLabel,
+    provider,
+    providerSessionId: effectiveProviderSessionId,
+    directory: normalizedCwd,
+    type: "persistent",
+    discoverySource,
+    remoteHumanControl: remoteHumanControl ?? false
+  });
+  updateLocalObservation(session.id, {
+    discoverySource,
+    cwd: normalizedCwd,
+    remoteHumanControl: remoteHumanControl ?? false
+  });
+  console.log(
+    `[registerLocalSession] Registered ${provider} session ${effectiveProviderSessionId} (source: ${discoverySource}, channel: ${channel.id})`
+  );
+  return { session, isNewlyCreated: true };
+}
+
+export {
+  buildClaudeSubagentProviderSessionId,
+  updateLocalObservation,
+  registerLocalSession
+};

package/dist/{chunk-PUKMHDXS.js → chunk-GMYN4SYT.js}

@@ -1,19 +1,170 @@
 #!/usr/bin/env node
+import {
+  bindProjectCategory,
+  getProjectByCategoryId,
+  getProjectByName,
+  loadRegistry,
+  setProjectControlChannel,
+  setProjectHistoryChannel,
+  updateProject
+} from "./chunk-54DP53ZK.js";
 import {
   endSession,
-  getAllSessions,
-  getProject,
-  setHistoryChannelId
-} from "./chunk-IFSOU4XI.js";
+  getAllSessions
+} from "./chunk-RK6EIZOL.js";
 import {
+  Store,
   config
-} from "./chunk-D6J3X35H.js";
-import {
-  Store
-} from "./chunk-CBNENUW6.js";
+} from "./chunk-UEX7U2KW.js";
 
-// src/archive-manager.ts
+// ../bot/src/archive-manager.ts
 import { ChannelType, EmbedBuilder } from "discord.js";
+
+// ../engine/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;
+  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;
+  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;
+  updateProject(project).catch(
+    (err) => console.error(`Failed to update personality for project "${project.name}": ${err.message}`)
+  );
+}
+function getPersonality(categoryId) {
+  return getProjectByCategoryId(categoryId)?.personality;
+}
+function clearPersonality(categoryId) {
+  const project = getProjectByCategoryId(categoryId);
+  if (!project) return;
+  delete project.personality;
+  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;
+  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];
+  updateProject(project).catch(
+    (err) => console.error(`Failed to remove skill "${name}" for project "${project.name}": ${err.message}`)
+  );
+  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");
+}
+
+// ../bot/src/archive-manager.ts
 var archiveStore = new Store("archived.json");
 var archived = [];
 async function loadArchived() {
@@ -188,6 +339,21 @@ function formatDuration(ms) {
 }
 
 export {
+  loadProjects,
+  getProject,
+  bindMountedProjectToCategory,
+  setHistoryChannelId,
+  setControlChannelId,
+  setPersonality,
+  getPersonality,
+  clearPersonality,
+  addSkill,
+  removeSkill,
+  getSkills,
+  executeSkill,
+  addMcpServer,
+  removeMcpServer,
+  getMcpServers,
   loadArchived,
   getArchivedSessions,
   isArchivedProviderSession,