wtt-connect 0.2.8 → 0.2.10

package/README.md

@@ -101,6 +101,13 @@ Important settings:
 - `WTT_CONNECT_SHELL_MODE=unsafe|readonly|off`; default `unsafe` runs one-shot shell commands without command filtering. The interactive Terminal always opens a real PTY shell on the agent host.
 - `WTT_CONNECT_SHELL_TIMEOUT_SECONDS` and `WTT_CONNECT_SHELL_MAX_OUTPUT_CHARS` only bound legacy one-shot command execution and returned output
 
+Session continuity:
+
+- `wtt-connect` uses the WTT topic/task id as the local session key, for example `wtt:topic:<topic_id>`.
+- Codex stores `codexThreadId` and resumes with `codex exec resume`.
+- Claude Code stores `claudeSessionId` and resumes the same topic with `claude --resume <session_id> -p ...`.
+- Keep `WTT_CONNECT_STATE_DIR`, `WTT_CONNECT_STORE_FILE`, and `WTT_CONNECT_WORKDIR` stable per claimed agent. If they are changed or deleted, the adapter cannot resume previous local sessions.
+
 A JSON config may also be supplied:
 
 ```bash
@@ -293,7 +300,7 @@ Uninstall one identity with:
 ./scripts/uninstall-systemd-user.sh --name alice-codex
 ```
 
-Discussion/collaborative topics are mention-gated: `wtt-connect` only replies when the message targets its `WTT_AGENT_ID`, one of `WTT_CONNECT_AGENT_ALIASES`, backend-resolved `runner_agent_id`, or a multi-mention `mention_target_agent_ids` entry. P2P and task topics still run normally.
+Discussion/collaborative topics are mention-gated: `wtt-connect` only replies when the message targets its `WTT_AGENT_ID`, one of `WTT_CONNECT_AGENT_ALIASES`, backend-resolved `runner_agent_id`, a multi-mention `mention_target_agent_ids` entry, or a broadcast mention (`@all`, `@everyone`, `@全体`, `@所有人`). P2P and task topics still run normally.
 
 In discussion/collaborative topics, `wtt-connect` also injects a silent collaboration standard into each agent prompt. Agents should treat the topic as a shared workboard, preserve shared state, split non-trivial work into owned tasks, state concrete done criteria, report execution evidence, challenge weak assumptions, and only @mention the next specific agent when handoff is required.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wtt-connect",
-  "version": "0.2.8",
+  "version": "0.2.10",
   "private": false,
   "description": "WTT-native connector daemon for Codex, Claude Code, Cursor, Gemini, ACP, and other coding agent surfaces.",
   "type": "module",

package/src/adapters/claude-code.js

@@ -3,31 +3,72 @@ import readline from 'node:readline';
 import { log } from '../logger.js';
 
 export class ClaudeCodeAdapter {
-  constructor(config) {
+  constructor(config, deps = {}) {
     this.config = config;
+    this.store = deps.store;
     this.name = 'claude-code';
+    this.sessionByKey = new Map();
   }
 
   async run(prompt, context = {}) {
+    const sessionKey = context.sessionKey || 'default';
     if (context.images?.length && this.config.codexBin) {
-      log('info', 'claude-code image fallback via codex', { sessionKey: context.sessionKey || 'default', images: context.images.length });
+      log('info', 'claude-code image fallback via codex', { sessionKey, images: context.images.length });
       return runCodexVision(this.config.codexBin, prompt, context.images, this.config.workDir, this.config.taskTimeoutSeconds * 1000, this.config, context.onProgress);
     }
+    const stored = this.store?.getSession(sessionKey) || {};
+    const sessionId = this.sessionByKey.get(sessionKey) || stored.claudeSessionId;
+    const args = this.buildArgs(prompt, sessionId);
+    log('info', 'claude-code launch', { sessionKey, resume: Boolean(sessionId) });
+    let result;
+    try {
+      result = await runClaude(this.config.claudeBin, args, this.config.workDir, this.config.taskTimeoutSeconds * 1000, context.onProgress);
+    } catch (err) {
+      if (!sessionId || !shouldRetryFreshSession(err)) throw err;
+      log('warn', 'claude-code resume failed; retrying with fresh session', { sessionKey, sessionId, error: err.message });
+      this.sessionByKey.delete(sessionKey);
+      this.store?.patchSession(sessionKey, { claudeSessionId: '', adapter: this.name });
+      result = await runClaude(this.config.claudeBin, this.buildArgs(prompt, ''), this.config.workDir, this.config.taskTimeoutSeconds * 1000, context.onProgress);
+    }
+    if (result.sessionId) {
+      this.sessionByKey.set(sessionKey, result.sessionId);
+      this.store?.patchSession(sessionKey, { claudeSessionId: result.sessionId, adapter: this.name });
+    }
+    return result.text.trim();
+  }
+
+  buildArgs(prompt, sessionId = '') {
     // Claude Code 2.x requires --verbose when stream-json is used with --print/-p.
-    const args = ['-p', prompt, '--output-format', 'stream-json', '--verbose'];
+    const args = [];
+    if (sessionId) args.push('--resume', sessionId);
+    args.push('-p', prompt, '--output-format', 'stream-json', '--verbose');
     if (this.config.mode === 'yolo') args.push('--dangerously-skip-permissions', '--permission-mode', 'bypassPermissions');
     if (this.config.model) args.push('--model', this.config.model);
-    log('info', 'claude-code launch', { sessionKey: context.sessionKey || 'default' });
-    return runClaude(this.config.claudeBin, args, this.config.workDir, this.config.taskTimeoutSeconds * 1000, context.onProgress);
+    return args;
   }
 }
 
+function shouldRetryFreshSession(err) {
+  const message = String(err?.message || err || '').toLowerCase();
+  return [
+    'resume',
+    'session',
+    'conversation',
+    'not found',
+    'does not exist',
+    'invalid',
+    'timed out',
+    'timeout',
+  ].some((needle) => message.includes(needle));
+}
+
 function runClaude(bin, args, cwd, timeoutMs, onEvent) {
   return new Promise((resolve, reject) => {
     const child = spawn(bin, args, { cwd, stdio: ['ignore', 'pipe', 'pipe'], env: { ...process.env } });
     let stderr = '';
     let finalResult = '';
     let streamError = '';
+    let sessionId = '';
     const rawLines = [];
     const assistantTexts = [];
     const timer = setTimeout(() => { child.kill('SIGTERM'); reject(new Error(`${bin} timed out`)); }, timeoutMs);
@@ -39,6 +80,8 @@ function runClaude(bin, args, cwd, timeoutMs, onEvent) {
         rawLines.push(line);
         if (rawLines.length > 20) rawLines.shift();
         const ev = JSON.parse(line);
+        const eventSessionId = extractSessionId(ev);
+        if (eventSessionId) sessionId = eventSessionId;
         if (onEvent) Promise.resolve(onEvent(ev)).catch(() => {});
         const evError = extractEventError(ev);
         if (evError) streamError = evError;
@@ -53,11 +96,26 @@ function runClaude(bin, args, cwd, timeoutMs, onEvent) {
     child.on('close', (code) => {
       clearTimeout(timer);
       if (code !== 0) reject(new Error(`${bin} exited ${code}: ${errorDetail({ stderr, streamError, finalResult, rawLines })}`));
-      else resolve((finalResult || dedupeAdjacent(assistantTexts).join('\n')).trim());
+      else resolve({ text: (finalResult || dedupeAdjacent(assistantTexts).join('\n')).trim(), sessionId });
     });
   });
 }
 
+function extractSessionId(ev) {
+  if (!ev) return '';
+  return ev.session_id
+    || ev.sessionId
+    || ev.conversation_id
+    || ev.conversationId
+    || ev.thread_id
+    || ev.threadId
+    || ev.message?.session_id
+    || ev.message?.sessionId
+    || ev.result?.session_id
+    || ev.result?.sessionId
+    || '';
+}
+
 async function runCodexVision(bin, prompt, images, cwd, timeoutMs, config = {}, onEvent) {
   const args = ['exec', '--skip-git-repo-check', '--json', '--cd', cwd];
   if (config.mode === 'yolo') args.push('--dangerously-bypass-approvals-and-sandbox');

package/src/runner.js

@@ -21,6 +21,7 @@ import { buildOpenDesignPrompt, buildOpenDesignRepairPrompt, chooseOpenDesignSki
 const TERMINAL_STATUSES = new Set(['review', 'done', 'approved', 'cancelled']);
 const GENERATED_FILE_EXTENSIONS = new Set(['.doc', '.docx', '.ppt', '.pptx', '.xls', '.xlsx', '.pdf', '.csv', '.md', '.txt', '.zip']);
 const AUTO_DETECTED_FILE_EXTENSIONS = '(?:docx?|pptx?|xlsx?|pdf|csv|zip)';
+const BROADCAST_MENTIONS = new Set(['all', 'everyone', '全体', '所有人']);
 
 export class Runner {
   constructor(config) {
@@ -566,13 +567,14 @@ function renderDiscussionRoutingInstruction(m, config) {
   return [
     'Internal WTT group-discussion routing rule. Follow it silently and do not explain it:',
     '- In discussion/collaborative topics, another agent will only run if your visible reply explicitly @mentions that agent.',
+    '- A visible @all / @everyone / @全体 / @所有人 in the triggering message is a broadcast mention. If you were triggered by it, reply once with your own useful contribution.',
     `- Your current agent identity is ${currentAgentName ? `${currentAgentName} (${currentAgentId || 'unknown id'})` : (currentAgentId || 'unknown')}. Never @mention yourself, your own display name, or your own agent id.`,
     senderIsSelf
       ? '- The triggering sender appears to be yourself. Do not @mention the sender; answer normally or @mention a different agent only if that specific other agent should act next.'
       : `- If you want the sender agent to continue, challenge, verify, or answer, include ${directMention} in the visible reply.`,
     '- If you want a different agent to continue, @mention only that other agent by its exact visible name or agent id from the conversation.',
     '- If your reply is a final answer, summary, or no further agent action is needed, do not @mention anyone.',
-    '- Do not use @all or vague mentions; mention only the specific next agent that should act.',
+    '- Do not propagate @all in your own reply. Use @all only if the human explicitly asks you to broadcast, otherwise mention only the specific next agent that should act.',
     '',
     'Internal WTT group-collaboration operating standard. Use it silently to structure useful replies:',
     '- Treat the topic as a shared workboard. Preserve shared state: goal, assumptions, decisions, owners, artifacts, blockers, and evidence.',
@@ -600,6 +602,7 @@ function shouldTriggerChatInference(m, config) {
   if (topicType === 'broadcast') return false;
   if (topicType === 'p2p') return shouldTriggerP2PChatInference(m, config);
   if (topicType === 'discussion' || topicType === 'collaborative') {
+    if (hasBroadcastMention(String(m.content || ''))) return true;
     if (messageTargetsAgent(m.mention_target_agent_ids || m.mentionTargetAgentIds, config)) return true;
     if (matchesAgentIdentity(m.runner_agent_id || m.runnerAgentId, config)) return true;
     if (matchesAgentIdentity(m.runner_agent_name || m.runnerAgentName, config)) return true;
@@ -657,6 +660,10 @@ function mentionMatchesAgent(content, config) {
   return false;
 }
 
+function hasBroadcastMention(content) {
+  return extractMentionChunks(content).some((mention) => BROADCAST_MENTIONS.has(mention));
+}
+
 function matchesAgentIdentity(candidate, config) {
   const normalized = normalizeMentionToken(String(candidate || ''));
   if (!normalized) return false;