ai_co_discuss 0.3.80 → 0.3.82

package/docs/runner.md

@@ -116,7 +116,7 @@ API 成员可以担任专家或主持人。房间指定了项目目录时，它
 - **保存**：在“工作流”一行点“添加”，选“新建”，或导入别人分享的 zip 或文件夹（手机、平板上同样可用）。导入的内容先在编辑页预览，点保存才写入。选中一个工作流后，下方显示它的描述，可“查看说明”（做法说明与成员卡片）或“编辑”，删除在编辑页底部。编辑页可以“从当前房间成员导入”卡片，提示词保持原文。想让主持人起草，打开下面的“允许主持人自建工作流”。
 - **让主持人自己建**：建房时（第 3 节“协作方式”）或在“成员与设置 → 协作设置”勾选“允许主持人自建工作流”后，直接对主持人说要什么分工（或“把这个房间的做法存成工作流”），它会自己保存、在本房间启用，并邀请工作流里的成员，接着就按流程派活，不需要你导入或添加成员。之后让它改流程，改动从成员下一次执行起生效。打开这个开关后，也可以在输入框输入 `/` 选一个已保存的工作流，输入框里会写好“启用工作流「名称」（ID），”，补上要做的事发给主持人，它就启用这个工作流并带来成员（没打开时该项灰显）。主持人带来的成员项目权限最高为可写；只有本地软件担任的主持人能这样做，API 主持人不行。
 - **分享**：工作流存在本机服务目录的 `workflows` 文件夹，一个工作流一个文件夹；编辑页可复制路径，把整个文件夹（或打成 zip）发给对方即可分享。导入时会列出每张卡片的提示词和项目权限；要求写文件的卡片默认按只读导入，逐张勾选后才放开。
-- **修改与结束**：修改工作流会作用于所有启用它的房间，成员下一次执行就按新内容；新增的卡片不会自动进入房间，主持人用到时会自己补上，也可以在右栏工作流一行点“刷新”立即补齐（删掉的卡片，其成员留作普通成员）；工作流卡片的提示词只读，在“工作流”一行点“编辑”修改。工作流进行中时，主持人只在请求和它的用途相符（或你说按工作流做）时才用，其他请求照常处理。用完在右栏点“请离成员”：工作流带来的成员离开（主持人保留），正在进行的工作随之停止，工作流结束，右栏这一块消失；成员会话保留，下次在输入框打 `/` 选它就把原成员请回来，接着原来的上下文。换工作流时直接选另一个，原来的成员留作普通成员。
+- **修改与结束**：修改工作流会作用于所有启用它的房间，成员下一次执行就按新内容；新增的卡片不会自动进入房间，主持人用到时会自己补上，也可以在右栏工作流一行点刷新图标立即补齐（删掉的卡片，其成员留作普通成员；与库一致时不显示该图标）；工作流卡片的提示词只读，在“工作流”一行点“编辑”修改。工作流进行中时，主持人只在请求和它的用途相符（或你说按工作流做）时才用，其他请求照常处理。用完在“成员与设置 → 协作设置”的工作流一行点请离成员图标（或逐个让成员离开）：工作流带来的成员离开（主持人保留），正在进行的工作随之停止，工作流结束，右栏这一块消失；成员会话保留，下次在输入框打 `/` 选它就把原成员请回来，接着原来的上下文。换工作流时直接选另一个，原来的成员留作普通成员。
 
 ## 朗读与语音输入（可选）
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ai_co_discuss",
-  "version": "0.3.80",
+  "version": "0.3.82",
   "bin": {
     "codiscuss": "runner/codiscuss.mjs"
   },

package/runner/adapters/claude.mjs

@@ -227,20 +227,22 @@ function result_text(content) {
 
 /**
  * One stream-json event as execution-detail entries: a tool call and its result share the call's id. Claude Code
- * streams thinking as signed blocks with empty text, so thinking shows only when it carries text.
+ * streams thinking as signed blocks with empty text, so thinking shows only when it carries text. Its assistant and
+ * user events carry an ISO `timestamp` (seen on 2.1.312), which becomes a step's `at` and its result's `ended_at`.
  */
 function claude_detail(event) {
   const blocks = Array.isArray(event.message?.content) ? event.message.content : [];
+  const at = event.timestamp || undefined;
   if (event.type === 'assistant') return blocks.flatMap(block => {
-    if (block.type === 'text' && block.text?.trim()) return [{ kind: 'message', body: block.text }];
-    if (block.type === 'thinking' && block.thinking?.trim()) return [{ kind: 'thinking', body: block.thinking }];
+    if (block.type === 'text' && block.text?.trim()) return [{ kind: 'message', body: block.text, at }];
+    if (block.type === 'thinking' && block.thinking?.trim()) return [{ kind: 'thinking', body: block.thinking, at }];
     if (block.type !== 'tool_use') return [];
     const kind = /^(Bash|PowerShell)$/.test(block.name) ? 'command' : EDIT_TOOL_NAMES.test(block.name) ? 'edit'
       : /^Web(Search|Fetch)$/.test(block.name) ? 'search' : 'tool';
-    return [{ id: `tool-${block.id}`, kind, title: kind === 'command' ? tool_subject(block) : `${block.name} ${tool_subject(block)}`, state: 'running' }];
+    return [{ id: `tool-${block.id}`, kind, title: kind === 'command' ? tool_subject(block) : `${block.name} ${tool_subject(block)}`, state: 'running', at }];
   });
   if (event.type === 'user') return blocks.filter(block => block.type === 'tool_result')
-    .map(block => ({ id: `tool-${block.tool_use_id}`, body: result_text(block.content), state: block.is_error ? 'failed' : 'done' }));
+    .map(block => ({ id: `tool-${block.tool_use_id}`, body: result_text(block.content), state: block.is_error ? 'failed' : 'done', ended_at: at }));
   if (event.type === 'result' && event.is_error) return [{ kind: 'error', body: String(event.result || event.subtype || '本轮失败') }];
   return [];
 }

package/runner/adapters/index.mjs

@@ -95,8 +95,9 @@ const DETAIL_BODY_LIMIT = 4000;
 /**
  * What an agent did in one execution, rebuilt from the raw event log its adapter's process wrote: messages, commands
  * with their output, searches, edits and tool calls in order. Each adapter's `events.detail(event)` turns one event into
- * entries `{id?, kind, title?, body?, append?, state?}`; an entry with a known id updates the earlier one in place
- * (a command's result fills in its start), `append` extends its body. Returns null when the adapter keeps no such log.
+ * entries `{id?, kind, title?, body?, append?, state?, at?, ended_at?}`; an entry with a known id updates the earlier
+ * one in place (a command's result fills in its start), `append` extends its body. `at` / `ended_at` are ISO times, given
+ * only by software whose log carries them; without them no step time shows. Returns null when the adapter keeps no such log.
  */
 export function execution_details(adapter_id, text) {
   const adapter = adapter_of(adapter_id);

package/runner/discussion_launch.mjs

@@ -357,12 +357,15 @@ export async function room_models(home, raw, { read_defaults = profile => cached
     api_max_requests: config.api_max_requests ?? DEFAULT_API_MAX_REQUESTS };
 }
 
-/** The room's workflow as the right column shows it; `available` is false when its folder is gone or broken. */
+/**
+ * The room's workflow as the right column shows it; `available` is false when its folder is gone or broken, and
+ * `cards` lists the card IDs the library has now, so the page offers a refresh only when the room differs from it.
+ */
 function room_workflow_status(config, home) {
   if (!config.workflow?.id) return null;
   const loaded = load_room_workflow({ ...config, api_home: config.api_home || home, workflow: { ...config.workflow, enabled: true } });
   return { id: config.workflow.id, label: loaded.label || config.workflow.id, enabled: Boolean(config.workflow.enabled),
-    available: !loaded.error, members: config.workflow.members || {} };
+    available: !loaded.error, members: config.workflow.members || {}, cards: Object.keys(loaded.cards || {}) };
 }
 
 /**

package/runner/free_runner.mjs

@@ -45,6 +45,11 @@ export function review_capability_version(profile, member, config) {
   return createHash('sha256').update(JSON.stringify(facts)).digest('hex');
 }
 
+/** Whether a process with this pid exists; signal 0 only checks, and EPERM means it exists under another user. */
+function process_alive(pid) {
+  try { process.kill(pid, 0); return true; } catch (error) { return error.code === 'EPERM'; }
+}
+
 /** Identify a working directory consistently, so executions in the same cwd can be compared. */
 export function cwd_key(directory) {
   if (!directory) return '';
@@ -251,6 +256,8 @@ export class FreeRoomRunner {
     this.members = new Map();
     // An empty set proves every tracked handle for this execution closed; a missing set proves nothing after restart.
     this.execution_processes = new Map();
+    // Marks the handles this runner process tracks (`owner:ID` in metadata), so a later runner can tell inherited executions.
+    this.instance = randomUUID();
     // Execution id -> why its session ended on its own, such as a command refused in unattended mode ('' when unknown).
     this.exited = new Map();
     // Executions whose software failed before any turn ran, as its adapter reported; safe to deliver again.
@@ -886,6 +893,7 @@ export class FreeRoomRunner {
     }
     const execution = active.get(row.execution_id);
     if (!execution) {
+      this.forget_owner(row.execution_id);
       this.activity.delete(row.execution_id);
       await this.report_segments(row.execution_id, true);
       this.stop_member(member.name);
@@ -902,6 +910,10 @@ export class FreeRoomRunner {
     }
     // A restart between persisting and invoking cannot prove non-delivery, so it never resends.
     if (row.status === 'delivering') return this.fail(member.name, execution.id, '上次投递结果不明，未自动重发；请核对原会话后重新发送');
+    // Inherited from a runner that stopped or crashed: once its software processes are gone, no answer can come.
+    if (row.status === 'running' && this.orphan(execution.id)?.alive === false) {
+      return this.fail(member.name, execution.id, '本机接入程序重启或异常退出，这次执行的软件进程已结束，未提交回答；请重新发送');
+    }
     if (row.error) return this.retry_or_fail(member.name, execution, row.error);
     if (this.exited.has(execution.id)) {
       const latest = await api(this.config, `/executions/${execution.id}`);
@@ -954,7 +966,7 @@ export class FreeRoomRunner {
     const value = this.store.db.prepare('SELECT value FROM metadata WHERE key=?').get(key)?.value;
     if (!value) return;
     const delivery = stored_delivery(value), processes = this.execution_processes.get(execution_id);
-    const ended = processes ? processes.size === 0 : this.exited.has(execution_id);
+    const ended = processes ? processes.size === 0 : this.exited.has(execution_id) || this.orphan(execution_id)?.alive === false;
     const result = delivery.pending_result && delivery.pending_result !== 'unconfirmed' ? delivery.pending_result
       : !delivery.stoppable ? 'unstoppable' : ended ? 'stopped' : 'unconfirmed';
     if (delivery.stop_result === result) return;
@@ -985,8 +997,27 @@ export class FreeRoomRunner {
       // The site's bounded hold now controls the next delivery; retain handles to observe and retry termination.
       for (const child of processes || []) this.members.get(name)?.delete(child);
     }
-    else { this.store.db.prepare('DELETE FROM metadata WHERE key=?').run(key); this.execution_processes.delete(execution_id); }
+    else { this.store.db.prepare('DELETE FROM metadata WHERE key=?').run(key); this.execution_processes.delete(execution_id); this.forget_owner(execution_id); }
+  }
+  /**
+   * An execution whose handles an earlier runner process tracked and this one does not: `{alive}` says whether any of its
+   * recorded software processes still runs. A handle without a pid lived inside that runner, so it ended with it.
+   */
+  orphan(execution_id) {
+    if (this.execution_processes.has(execution_id)) return null;
+    const saved = JSON.parse(this.store.db.prepare('SELECT value FROM metadata WHERE key=?').get(`owner:${execution_id}`)?.value || 'null');
+    if (!saved || saved.instance === this.instance) return null;
+    return { alive: saved.pids.some(process_alive) };
+  }
+  /** Record that this runner process tracks a handle of the execution, with its pid when it is a separate process. */
+  record_owner(execution_id, pid) {
+    const key = `owner:${execution_id}`;
+    const saved = JSON.parse(this.store.db.prepare('SELECT value FROM metadata WHERE key=?').get(key)?.value || 'null');
+    const pids = saved?.instance === this.instance ? saved.pids : [];
+    if (Number.isInteger(pid) && !pids.includes(pid)) pids.push(pid);
+    this.store.db.prepare('INSERT OR REPLACE INTO metadata VALUES (?,?)').run(key, JSON.stringify({ instance: this.instance, pids }));
   }
+  forget_owner(execution_id) { this.store.db.prepare('DELETE FROM metadata WHERE key=?').run(`owner:${execution_id}`); }
   /** Once a new task received the stop reminders, retire acknowledged unconfirmed reports for its old turns. */
   clear_stopped(name) {
     for (const id of this.stopped_executions(name)) {
@@ -1065,6 +1096,7 @@ export class FreeRoomRunner {
     catch (error) { if (!/HTTP 409/.test(error.message)) throw error; }
     this.save(name, { status: 'idle', error: reason });
     this.stop_member(name);
+    this.forget_owner(execution_id);
   }
   /**
    * Hand the owner's pending interjections to the software running each execution, in order, through the steer handle
@@ -1167,6 +1199,8 @@ export class FreeRoomRunner {
     if (!this.execution_processes.has(execution_id)) this.execution_processes.set(execution_id, new Set());
     const processes = this.execution_processes.get(execution_id);
     processes.add(child);
+    // A handle only the owner may stop keeps running in the user's software, so a later runner must not fail it.
+    if (Number.isInteger(execution_id) && child.stop_on_shutdown !== false) this.record_owner(execution_id, child.pid);
     child.once('close', () => { processes.delete(child); this.children.delete(child); this.members.get(name).delete(child); });
   }
   /** Request termination; only a later close event proves it happened. */