work-ally 0.2.0-alpha.1

package/bridge/src/memory-digest.ts

@@ -0,0 +1,186 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import type { WorkAllyConfig } from './config.ts';
+import { todayStamp } from './utils.ts';
+
+const MAX_ARCHIVE_BYTES = Number(process.env.WORK_ALLY_MEMORY_DIGEST_MAX_ARCHIVE_BYTES || '120000');
+const DAILY_START = '<<<DAILY_MEMORY>>>';
+const DAILY_END = '<<<END_DAILY_MEMORY>>>';
+const LONG_START = '<<<LONG_TERM_MEMORY>>>';
+const LONG_END = '<<<END_LONG_TERM_MEMORY>>>';
+const SUMMARY_START = '<<<SUMMARY>>>';
+const SUMMARY_END = '<<<END_SUMMARY>>>';
+
+function readTextFile(filePath: string): string {
+  if (!fs.existsSync(filePath) || !fs.statSync(filePath).isFile()) {
+    return '';
+  }
+  return fs.readFileSync(filePath, 'utf8').trim();
+}
+
+function listFilesRecursive(root: string): string[] {
+  if (!fs.existsSync(root) || !fs.statSync(root).isDirectory()) {
+    return [];
+  }
+
+  const files: string[] = [];
+  const walk = (current: string) => {
+    for (const entry of fs.readdirSync(current, { withFileTypes: true })) {
+      const full = path.join(current, entry.name);
+      if (entry.isDirectory()) {
+        walk(full);
+        continue;
+      }
+      files.push(full);
+    }
+  };
+  walk(root);
+  return files.sort();
+}
+
+function archiveDayDir(archiveRoot: string, dateStamp: string): string {
+  const [year, month, day] = dateStamp.split('-');
+  return path.join(archiveRoot, year, month, day);
+}
+
+function collectArchiveSections(config: WorkAllyConfig, dateStamp: string, excludedRoutineIds: string[] = []): { text: string; truncated: boolean; fileCount: number } {
+  const dayDir = archiveDayDir(config.paths.archiveDir, dateStamp);
+  const excludedNames = new Set(excludedRoutineIds.map((id) => `routine--${id}.ndjson`));
+  const files = listFilesRecursive(dayDir).filter((file) => {
+    const base = path.basename(file);
+    if (!base.endsWith('.ndjson')) return false;
+    if (excludedNames.has(base)) return false;
+    // Thread sync files are keyed by thread id; legacy channel files contain "--".
+    return !base.includes('--');
+  });
+  if (files.length === 0) {
+    return {
+      text: '（当天没有归档原材料）',
+      truncated: false,
+      fileCount: 0,
+    };
+  }
+
+  let remaining = Math.max(4096, MAX_ARCHIVE_BYTES);
+  let truncated = false;
+  const parts: string[] = [];
+
+  for (const file of files) {
+    if (remaining <= 0) {
+      truncated = true;
+      break;
+    }
+
+    const relativePath = path.relative(config.workspaceRoot, file) || path.basename(file);
+    const content = fs.readFileSync(file, 'utf8');
+    const header = `## FILE: ${relativePath}\n`;
+    const bodyBudget = Math.max(0, remaining - Buffer.byteLength(header, 'utf8') - 2);
+    if (bodyBudget <= 0) {
+      truncated = true;
+      break;
+    }
+
+    let body = content;
+    const bodyBytes = Buffer.byteLength(body, 'utf8');
+    if (bodyBytes > bodyBudget) {
+      body = Buffer.from(body).subarray(0, bodyBudget).toString('utf8');
+      body += '\n\n[TRUNCATED]\n';
+      truncated = true;
+    }
+
+    const section = `${header}${body}`.trimEnd();
+    parts.push(section);
+    remaining -= Buffer.byteLength(section, 'utf8') + 2;
+  }
+
+  if (truncated) {
+    parts.push('## NOTE\n归档原材料过多，已按顺序截断；请基于当前已提供内容提炼记忆。');
+  }
+
+  return {
+    text: parts.join('\n\n'),
+    truncated,
+    fileCount: files.length,
+  };
+}
+
+function currentMemorySnapshot(config: WorkAllyConfig, dateStamp: string): string {
+  const dailyFile = path.join(config.paths.dailyMemoryDir, `${dateStamp}.md`);
+  const longTermFile = path.join(config.paths.longTermMemoryDir, 'MEMORY.md');
+  const daily = readTextFile(dailyFile);
+  const longTerm = readTextFile(longTermFile);
+
+  return [
+    '## CURRENT DAILY MEMORY',
+    daily || '（当前为空）',
+    '',
+    '## CURRENT LONG-TERM MEMORY',
+    longTerm || '（当前为空）',
+  ].join('\n');
+}
+
+export function buildMemoryDigestPrompt(config: WorkAllyConfig, dateStamp = todayStamp(), routineId = 'nightly-memory-digest'): string {
+  const archive = collectArchiveSections(config, dateStamp, [routineId]);
+  const memorySnapshot = currentMemorySnapshot(config, dateStamp);
+
+  return [
+    `你正在执行 work-ally 的 nightly memory digest，处理日期是 ${dateStamp}。`,
+    '禁止调用任何工具、命令或文件读取操作。下面已经提供你需要的全部原材料与当前记忆快照。',
+    '你的任务是只基于这些材料，输出三段内容：',
+    '- 摘要：适合通过系统消息告知用户这次记忆整理做了什么',
+    '- 当日日记：适合写入 journal/YYYY-MM-DD.md',
+    '- 长期记忆：适合覆盖 MEMORY.md',
+    '请严格按以下格式输出，不能有任何额外说明、前言或后记：',
+    `${SUMMARY_START}
+- 新增了什么
+- 更新了什么
+- 如果没有实质变化请明确写“无新增稳定记忆”
+${SUMMARY_END}
+${DAILY_START}
+# Journal - ${dateStamp}
+...
+${DAILY_END}
+${LONG_START}
+# MEMORY
+...
+${LONG_END}`,
+    'ARCHIVE MATERIALS 是目标日期的唯一事实来源；CURRENT MEMORY 只是参考快照，可能包含过时、低价值或上次失败产物。',
+    '摘要只写本次记忆整理的结果，不要复述全部对话，不要写实现过程。',
+    '重写每日记忆时，优先忠实反映当天 archive，不要沿袭旧摘要里的措辞或结论。',
+    '重写长期记忆时，只保留持久事实：用户偏好、工作空间规则、稳定流程、持续有效的操作约束、长期项目背景。',
+    '长期记忆不要重复通用的 work-ally 产品机制、默认目录结构、实现细节或例行任务说明，除非 archive 明确显示它们已经成为这个工作空间的稳定规则。',
+    '不要把以下内容继续写入长期记忆：一次性的寒暄、单次失败、调试噪音、thread/turn id、原始报错、例行任务运行元数据。',
+    '如果当天几乎没有实质活动，要明确写成“低活动日”，但不要臆造新事实。',
+    '如果当前没有可保留的长期事实，请输出一个极简的长期记忆，明确写出“暂无新增稳定事实”，不要为了凑内容重复系统常识。',
+    `原材料目录：${config.paths.archiveDir}`,
+    `日记输出目录：${config.paths.dailyMemoryDir}`,
+    `长期记忆输出目录：${config.paths.longTermMemoryDir}`,
+    `归档文件数量：${archive.fileCount}`,
+    memorySnapshot,
+    '## ARCHIVE MATERIALS',
+    archive.text,
+  ].join('\n\n');
+}
+
+
+function between(text: string, start: string, end: string): string | null {
+  const startIndex = text.indexOf(start);
+  if (startIndex < 0) {
+    return null;
+  }
+  const endIndex = text.indexOf(end, startIndex + start.length);
+  if (endIndex < 0) {
+    return null;
+  }
+  return text.slice(startIndex + start.length, endIndex).trim();
+}
+
+export function parseMemoryDigestReply(reply: string): { summary: string | null; daily: string; longTerm: string } | null {
+  const summary = between(reply, SUMMARY_START, SUMMARY_END);
+  const daily = between(reply, DAILY_START, DAILY_END);
+  const longTerm = between(reply, LONG_START, LONG_END);
+  if (!daily || !longTerm) {
+    return null;
+  }
+  return { summary, daily, longTerm };
+}

package/bridge/src/receiver-approval-autonomy.ts

@@ -0,0 +1,158 @@
+import path from 'node:path';
+import { commandApprovalRuleLabel, findMatchingCommandApprovalRule, type CommandApprovalRuleset, unwrapShellApprovalCommand } from './approval-rules.ts';
+import { HIGH_RISK_APPROVAL_COMMAND_RE, LOCAL_APPROVAL_COMMAND_RE } from './receiver-helpers.ts';
+import type { ApprovalRecord } from './types.ts';
+
+interface ApprovalAutonomyDeps {
+  workspaceRoot: string;
+  assistantHome?: string | null;
+  commandApprovalRules?: CommandApprovalRuleset | null;
+}
+
+export interface ApprovalAutonomyDecision {
+  action: 'accept' | 'decline';
+  reason: string;
+  policy: 'local_workspace_edit' | 'local_self_validation' | 'rules_allow' | 'rules_forbidden';
+  matchedRule?: string;
+  ruleSource?: 'global' | 'assistant';
+  commandForm?: 'raw' | 'unwrapped';
+}
+
+function autonomyRoots(deps: ApprovalAutonomyDeps): string[] {
+  const roots = [path.resolve(deps.workspaceRoot)];
+  const assistantHome = String(deps.assistantHome || '').trim();
+  if (assistantHome) {
+    roots.push(path.resolve(assistantHome));
+  }
+  return Array.from(new Set(roots));
+}
+
+function isWithinAutonomyRoots(deps: ApprovalAutonomyDeps, target: string | null | undefined): boolean {
+  const normalized = String(target || '').trim();
+  if (!normalized) {
+    return false;
+  }
+  const resolved = path.resolve(normalized);
+  return autonomyRoots(deps).some((root) => resolved === root || resolved.startsWith(`${root}${path.sep}`));
+}
+
+function splitApprovalCommandSegments(command: string): string[] | null {
+  const unwrapped = unwrapShellApprovalCommand(command);
+  if (!unwrapped) {
+    return null;
+  }
+  if (/[|;><`]/.test(unwrapped) || /\|\|/.test(unwrapped)) {
+    return null;
+  }
+  return unwrapped
+    .split(/\s*&&\s*/)
+    .map((segment) => segment.trim())
+    .filter(Boolean);
+}
+
+function isLocalSelfValidationCommand(command: string): boolean {
+  const segments = splitApprovalCommandSegments(command);
+  if (!segments?.length) {
+    return false;
+  }
+  return segments.every((segment) => LOCAL_APPROVAL_COMMAND_RE.test(segment));
+}
+
+function matchRuleDecision(
+  deps: ApprovalAutonomyDeps,
+  command: string,
+): ApprovalAutonomyDecision | null {
+  const ruleset = deps.commandApprovalRules;
+  if (!ruleset) {
+    return null;
+  }
+  const match = findMatchingCommandApprovalRule(ruleset, command);
+  if (!match) {
+    return null;
+  }
+  if (match.rule.decision === 'prompt') {
+    return null;
+  }
+  return {
+    action: match.rule.decision === 'forbidden' ? 'decline' : 'accept',
+    reason: match.rule.decision === 'forbidden'
+      ? '命中已记住的拒绝规则，本次命令将直接拒绝，不再向用户重复发审批卡。'
+      : '命中已记住的放行规则，本次命令将直接放行，不再向用户重复发审批卡。',
+    policy: match.rule.decision === 'forbidden' ? 'rules_forbidden' : 'rules_allow',
+    matchedRule: commandApprovalRuleLabel(match),
+    ruleSource: match.rule.source,
+    commandForm: match.commandForm,
+  };
+}
+
+export function approvalBoundaryReason(
+  deps: ApprovalAutonomyDeps,
+  approval: Pick<ApprovalRecord, 'kind' | 'grantRoot' | 'cwd' | 'command'>,
+): string {
+  if (approval.kind === 'file_change') {
+    if (approval.grantRoot && !isWithinAutonomyRoots(deps, approval.grantRoot)) {
+      return '这一步会写入当前项目或 assistant 办公桌之外的路径，需要你明确拍板。';
+    }
+    return '这一步涉及文件写入，但不属于默认放行的本地低风险范围，需要你明确拍板。';
+  }
+
+  const command = unwrapShellApprovalCommand(String(approval.command || ''));
+  if (HIGH_RISK_APPROVAL_COMMAND_RE.test(command)) {
+    return '这一步会对远端、真实环境或现有数据产生更高风险影响，需要你明确拍板。';
+  }
+  if (!isWithinAutonomyRoots(deps, approval.cwd || null)) {
+    return '这一步不在当前项目或 assistant 办公桌的默认自决范围内，需要你明确拍板。';
+  }
+  return '这一步超出了我可默认自决的本地验证范围，需要你明确拍板。';
+}
+
+export function evaluateApprovalAutonomy(
+  deps: ApprovalAutonomyDeps,
+  approval: ApprovalRecord,
+): ApprovalAutonomyDecision | null {
+  if (approval.kind === 'file_change') {
+    if (!approval.grantRoot || !isWithinAutonomyRoots(deps, approval.grantRoot)) {
+      return null;
+    }
+    return {
+      action: 'accept',
+      reason: '当前项目或 assistant 办公桌内的本地改动，默认不再逐条打断用户审批。',
+      policy: 'local_workspace_edit',
+    };
+  }
+
+  const cwd = String(approval.cwd || '').trim();
+  const command = String(approval.command || '').trim();
+  if (!command) {
+    return null;
+  }
+
+  const unwrapped = unwrapShellApprovalCommand(command);
+  if (HIGH_RISK_APPROVAL_COMMAND_RE.test(unwrapped)) {
+    return null;
+  }
+
+  if (cwd && isWithinAutonomyRoots(deps, cwd) && isLocalSelfValidationCommand(command)) {
+    return {
+      action: 'accept',
+      reason: '当前项目内的低风险本地验证或提交动作，不再默认逐条打断用户审批。',
+      policy: 'local_self_validation',
+    };
+  }
+
+  return matchRuleDecision(deps, command);
+}
+
+export function shouldAutoApproveLocalAction(
+  deps: ApprovalAutonomyDeps,
+  approval: ApprovalRecord,
+): { reason: string; policy: string } | null {
+  const decision = evaluateApprovalAutonomy(deps, approval);
+  if (!decision || decision.action !== 'accept') {
+    return null;
+  }
+  return {
+    reason: decision.reason,
+    policy: decision.policy,
+  };
+}

package/bridge/src/receiver-control-core.ts

@@ -0,0 +1,140 @@
+import { loadCodexConfigPreview } from './codex-config.ts';
+import { formatMcpToolApprovalRules, type WorkAllyConfig } from './config.ts';
+import { logInfo, logWarn } from './logger.ts';
+import type { OutboundEnvelope } from './channel-types.ts';
+import type { ControlCommand } from './router.ts';
+import type { SessionStore } from './session-store.ts';
+import { statusMessage } from './translator.ts';
+import type { InboundMessage, RuntimeThreadStatus, SessionMeta } from './types.ts';
+
+interface ControlRuntimeLike {
+  readThreadStatus(threadId: string): Promise<RuntimeThreadStatus | null>;
+  resolveApproval(requestId: string | number, decision: 'accept' | 'acceptForSession' | 'decline' | 'cancel'): Promise<void>;
+  interruptTurn(threadId: string, turnId: string): Promise<void>;
+}
+
+interface SendLike {
+  (
+    outbound: OutboundEnvelope,
+    extra?: Record<string, unknown>,
+    delivery?: { trackTurnId?: string | null },
+  ): Promise<boolean>;
+}
+
+interface HandleCoreControlDeps {
+  config: WorkAllyConfig;
+  runtime: ControlRuntimeLike;
+  sessionStore: SessionStore;
+  send: SendLike;
+  commandApprovalRulesStatusLines: string[];
+  noteUserRequestedStop(turnId: string): void;
+}
+
+interface HandleCoreControlArgs {
+  message: InboundMessage;
+  command: NonNullable<ControlCommand>;
+  session: SessionMeta;
+}
+
+export async function handleCoreControlCommand(
+  deps: HandleCoreControlDeps,
+  args: HandleCoreControlArgs,
+): Promise<boolean> {
+  const { message, command, session } = args;
+
+  if (command.type === 'status') {
+    logInfo('receiver', 'control_status', {
+      conversationId: message.conversationRef.conversationId,
+    });
+    let runtimeStatus: RuntimeThreadStatus | null = null;
+    if (session.threadId) {
+      try {
+        runtimeStatus = await deps.runtime.readThreadStatus(session.threadId);
+      } catch (error) {
+        logWarn('receiver', 'control_status_runtime_read_failed', {
+          conversationId: message.conversationRef.conversationId,
+          threadId: session.threadId,
+          error: error instanceof Error ? (error.stack || error.message) : String(error),
+        });
+      }
+    }
+    await deps.send({
+      type: 'status_reply',
+      conversationRef: message.conversationRef,
+      text: [
+        statusMessage(session, runtimeStatus, deps.config.assistant),
+        '',
+        '**Runtime**',
+        `- runtime approval policy: ${deps.config.runtime.approvalPolicy}`,
+        `- runtime sandbox mode: ${deps.config.runtime.sandboxMode}`,
+        `- runtime mcp tool approvals: ${formatMcpToolApprovalRules(deps.config.runtime.mcpToolApprovalRules)}`,
+        '',
+        '**Approval Rules**',
+        ...deps.commandApprovalRulesStatusLines,
+      ].join('\n'),
+    });
+    return true;
+  }
+
+  if (command.type === 'codex_configure') {
+    await deps.send({
+      type: 'status_reply',
+      conversationRef: message.conversationRef,
+      text: loadCodexConfigPreview(),
+    });
+    return true;
+  }
+
+  if (command.type === 'approve' || command.type === 'deny') {
+    logInfo('receiver', 'control_approval_resolution_requested', {
+      approvalId: command.approvalId,
+      decision: command.type,
+    });
+    const match = deps.sessionStore.findApproval(command.approvalId);
+    if (!match) {
+      await deps.send({
+        type: 'error_reply',
+        conversationRef: message.conversationRef,
+        text: `找不到审批：${command.approvalId}`,
+      });
+      return true;
+    }
+
+    const decision = command.type === 'approve' ? 'accept' : 'decline';
+    const resolvedStatus = command.type === 'approve' ? 'accepted' : 'declined';
+    await deps.runtime.resolveApproval(match.approval.requestId, decision);
+    deps.sessionStore.resolveApproval(match.meta.conversationRef, command.approvalId, resolvedStatus);
+    await deps.send({
+      type: 'status_reply',
+      conversationRef: message.conversationRef,
+      text: command.type === 'approve' ? '已提交同意。' : '已提交拒绝。',
+    });
+    return true;
+  }
+
+  if (command.type === 'stop') {
+    logInfo('receiver', 'control_stop_requested', {
+      conversationId: message.conversationRef.conversationId,
+      threadId: session.threadId,
+      activeTurnId: session.activeTurnId,
+    });
+    if (!session.threadId || !session.activeTurnId) {
+      await deps.send({
+        type: 'status_reply',
+        conversationRef: message.conversationRef,
+        text: '当前没有可停止的进行中 turn。',
+      });
+      return true;
+    }
+    deps.noteUserRequestedStop(session.activeTurnId);
+    await deps.runtime.interruptTurn(session.threadId, session.activeTurnId);
+    await deps.send({
+      type: 'status_reply',
+      conversationRef: message.conversationRef,
+      text: '已发送停止请求。',
+    });
+    return true;
+  }
+
+  return false;
+}

package/bridge/src/receiver-control-work-session.ts

@@ -0,0 +1,218 @@
+import type { WorkAllyConfig } from './config.ts';
+import type { OutboundEnvelope } from './channel-types.ts';
+import type { HandoffService } from './handoff-service.ts';
+import type { ControlCommand } from './router.ts';
+import type { SessionStore } from './session-store.ts';
+import { WorkSessionStore } from './work-session-store.ts';
+import { syncThreadConversationById } from './thread-sync.ts';
+import {
+  ambiguousTakeoverMessage,
+  busyNewThreadControlMessage,
+  codexBindingRequiredMessage,
+  codexHandoffMessage,
+  newWorkSessionCreatedMessage,
+  noLinkedOrAttachedWorkSessionMessage,
+  takeoverHandleNotFoundMessage,
+  unsupportedHandoffCommandInGroupMessage,
+  workSessionAlreadyOnChannelMessage,
+  workSessionOwnershipRejectedMessage,
+  workSessionTakenOverMessage,
+  workSessionThreadsMessage,
+} from './translator.ts';
+import type { ConversationRef, InboundMessage, SessionMeta, WorkSessionMeta } from './types.ts';
+
+interface ControlRuntimeLike {
+  startThread(cwd: string): Promise<{ id: string }>;
+  resumeThread(threadId: string, cwd: string): Promise<{ id: string }>;
+  readThreadWithTurns?(threadId: string): Promise<{ id: string; status: { type: string; activeFlags?: string[] } | null; turns: any[] }>;
+}
+
+interface SendLike {
+  (
+    outbound: OutboundEnvelope,
+    extra?: Record<string, unknown>,
+    delivery?: { trackTurnId?: string | null },
+  ): Promise<boolean>;
+}
+
+interface HandleWorkSessionControlDeps {
+  config: WorkAllyConfig;
+  runtime: ControlRuntimeLike;
+  sessionStore: SessionStore;
+  workSessionStore: WorkSessionStore;
+  handoffService: HandoffService;
+  send: SendLike;
+  assistantName: string;
+  assistantCodexHome: string | null;
+  resolveDeliveryConversationKey(ref: ConversationRef): string;
+  syncLinkedWorkSessionThread(ref: ConversationRef, runtimeThreadId: string | null | undefined): WorkSessionMeta | null;
+}
+
+function managedTakeoverCandidates(store: WorkSessionStore, assistantName: string): WorkSessionMeta[] {
+  return store.listWorkSessionsForAssistant(assistantName)
+    .filter((item) => item.activeSurface !== 'closed');
+}
+
+async function sendStatus(
+  send: SendLike,
+  message: InboundMessage,
+  text: string,
+): Promise<void> {
+  await send({
+    type: 'status_reply',
+    conversationRef: message.conversationRef,
+    text,
+  });
+}
+
+function resolveTakeoverTarget(
+  deps: HandleWorkSessionControlDeps,
+  args: HandleWorkSessionControlArgs,
+): { target: WorkSessionMeta | null; failureText?: string } {
+  const { message, command, linkedWorkSession } = args;
+  const candidates = managedTakeoverCandidates(deps.workSessionStore, deps.assistantName);
+
+  if (command.type !== 'takeover') {
+    return { target: null };
+  }
+
+  if (command.threadHandle) {
+    const byHandle = deps.workSessionStore.findWorkSessionByThreadHandle(deps.assistantName, command.threadHandle);
+    if (!byHandle || byHandle.archivedAt || byHandle.activeSurface === 'closed') {
+      return { target: null, failureText: takeoverHandleNotFoundMessage(command.threadHandle) };
+    }
+    return { target: byHandle };
+  }
+
+  if (!linkedWorkSession) {
+    if (candidates.length === 0) {
+      return { target: null, failureText: noLinkedOrAttachedWorkSessionMessage() };
+    }
+    if (candidates.length > 1) {
+      return { target: null, failureText: ambiguousTakeoverMessage(candidates) };
+    }
+    return { target: candidates[0] };
+  }
+
+  return { target: linkedWorkSession };
+}
+
+interface HandleWorkSessionControlArgs {
+  message: InboundMessage;
+  command: NonNullable<ControlCommand>;
+  session: SessionMeta;
+  linkedWorkSession: WorkSessionMeta | null;
+}
+
+export async function handleWorkSessionControlCommand(
+  deps: HandleWorkSessionControlDeps,
+  args: HandleWorkSessionControlArgs,
+): Promise<boolean> {
+  const { message, command, session, linkedWorkSession } = args;
+
+  if (command.type === 'new') {
+    if (session.threadId && session.activeTurnId) {
+      await deps.send({
+        type: 'status_reply',
+        conversationRef: message.conversationRef,
+        text: busyNewThreadControlMessage(),
+      });
+      return true;
+    }
+    if (session.threadId && typeof deps.runtime.readThreadWithTurns === 'function') {
+      await syncThreadConversationById(deps.config, deps.runtime, session.threadId);
+    }
+    const thread = await deps.runtime.startThread(deps.config.workspaceRoot);
+    deps.sessionStore.bindThread(message.conversationRef, thread.id);
+    deps.workSessionStore.createWorkSession({
+      assistantName: deps.assistantName,
+      assistantCodexHome: deps.assistantCodexHome,
+      workspaceRoot: deps.config.workspaceRoot,
+      runtimeThreadId: thread.id,
+      cliResumeRef: thread.id,
+      cliResumeRefType: 'session_id',
+      origin: 'work_ally',
+      deliveryChannel: message.conversationRef.channel,
+      deliveryConversationKey: deps.resolveDeliveryConversationKey(message.conversationRef),
+      activeSurface: 'work_ally_channel',
+      ownershipSource: 'new_session',
+    });
+    await deps.send({
+      type: 'status_reply',
+      conversationRef: message.conversationRef,
+      text: newWorkSessionCreatedMessage(),
+    });
+    return true;
+  }
+
+  if (command.type === 'takeover') {
+    if (message.conversationRef.chatType === 'group') {
+      await sendStatus(deps.send, message, unsupportedHandoffCommandInGroupMessage('/takeover'));
+      return true;
+    }
+
+    const resolved = resolveTakeoverTarget(deps, args);
+    if (!resolved.target) {
+      await sendStatus(deps.send, message, resolved.failureText || noLinkedOrAttachedWorkSessionMessage());
+      return true;
+    }
+
+    if (!command.threadHandle && linkedWorkSession?.workSessionId === resolved.target.workSessionId && linkedWorkSession.activeSurface === 'work_ally_channel') {
+      await sendStatus(deps.send, message, workSessionAlreadyOnChannelMessage());
+      return true;
+    }
+    if (resolved.target.activeSurface === 'closed') {
+      await sendStatus(deps.send, message, workSessionOwnershipRejectedMessage('closed'));
+      return true;
+    }
+
+    const switchedAt = new Date().toISOString();
+    const thread = await deps.runtime.resumeThread(resolved.target.runtimeThreadId, deps.config.workspaceRoot);
+    deps.sessionStore.bindThread(message.conversationRef, thread.id);
+    const rebound = thread.id !== resolved.target.runtimeThreadId
+      ? deps.workSessionStore.rebindRuntimeThread(resolved.target.workSessionId, thread.id)
+      : resolved.target;
+    const reboundWithDelivery = deps.workSessionStore.bindDeliveryWorkSession(
+      rebound.workSessionId,
+      message.conversationRef.channel,
+      deps.resolveDeliveryConversationKey(message.conversationRef),
+      switchedAt,
+    );
+    deps.workSessionStore.setAssistantActiveWorkSession(deps.assistantName, reboundWithDelivery.workSessionId, switchedAt);
+    deps.workSessionStore.updateWorkSession(reboundWithDelivery.workSessionId, {
+      activeSurface: 'work_ally_channel',
+      ownershipSource: 'explicit_channel_takeover',
+      lastSurfaceSwitchAt: switchedAt,
+    });
+    await sendStatus(deps.send, message, workSessionTakenOverMessage());
+    return true;
+  }
+
+  if (command.type === 'threads') {
+    if (message.conversationRef.chatType === 'group') {
+      await sendStatus(deps.send, message, unsupportedHandoffCommandInGroupMessage('/takeover'));
+      return true;
+    }
+    const sessions = managedTakeoverCandidates(deps.workSessionStore, deps.assistantName);
+    const highlighted = deps.workSessionStore.getAssistantIndex(deps.assistantName)?.activeWorkSessionId || null;
+    await sendStatus(deps.send, message, workSessionThreadsMessage(sessions, { highlightedWorkSessionId: highlighted }));
+    return true;
+  }
+
+  if (command.type === 'codex') {
+    if (message.conversationRef.chatType === 'group') {
+      await sendStatus(deps.send, message, unsupportedHandoffCommandInGroupMessage('/codex'));
+      return true;
+    }
+    const linked = deps.syncLinkedWorkSessionThread(message.conversationRef, args.session.threadId);
+    if (!linked) {
+      await sendStatus(deps.send, message, codexBindingRequiredMessage());
+      return true;
+    }
+    const payload = await deps.handoffService.exportCurrentWorkSession(linked);
+    await sendStatus(deps.send, message, codexHandoffMessage(payload));
+    return true;
+  }
+
+  return false;
+}