made-bridge 0.0.0-stage → 0.2.1

package/src/installed.mjs

@@ -0,0 +1,291 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { randomUUID } from 'node:crypto';
+import { pathToFileURL } from 'node:url';
+import { BUILTIN_ROOT, packageRoots, packagesHome } from './config.mjs';
+import { loadConfiguredPlugins, validatePlugin } from './plugins/registry.mjs';
+import { isPackageEntry, packageDirectories, readPackageSettings, writePackageSettings } from './plugin-package.mjs';
+
+const PLUGIN_ID = /^[a-z0-9][a-z0-9_-]{0,39}$/;
+const THEME_NAME = /^[A-Za-z0-9_-]{1,64}$/;
+const MODULE_NAME = /^[A-Za-z0-9_-]+\.(?:mjs|js)$/;
+const fail = (message) => {
+  const error = new Error(message);
+  error.preserveMessage = true;
+  return error;
+};
+
+/** 用户插件目录：市场装到这里，工作台也只允许从这里移除。 */
+function pluginsDir(config) {
+  return path.join(packagesHome(config), 'plugins');
+}
+
+/** 用户主题目录：同上。 */
+function themesDir(config) {
+  return path.join(packagesHome(config), 'themes');
+}
+
+/** 插件查找顺序：内置在前、用户目录在后（同名时用户目录覆盖内置）。 */
+function pluginsDirs(config) {
+  return packageRoots(config).map((root) => path.join(root, 'plugins'));
+}
+
+/** 主题查找顺序：同上。 */
+function themesDirs(config) {
+  return packageRoots(config).map((root) => path.join(root, 'themes'));
+}
+
+function contained(root, target) {
+  if (!fs.existsSync(root) || !fs.existsSync(target)) return false;
+  const base = fs.realpathSync(root);
+  const file = fs.realpathSync(target);
+  const relative = path.relative(base, file);
+  return relative !== '' && !relative.startsWith('..') && !path.isAbsolute(relative);
+}
+
+function moduleFiles(config) {
+  // 同名条目以用户目录为准：内置在前，后写入的覆盖前面的。
+  const found = new Map();
+  for (const directory of pluginsDirs(config)) {
+    if (!fs.existsSync(directory) || !fs.statSync(directory).isDirectory()) continue;
+    for (const item of packageDirectories(directory)) {
+      if (!contained(directory, item.entry)) continue;
+      found.set(item.name, item.entry);
+    }
+    for (const name of fs.readdirSync(directory).sort()) {
+      if (!MODULE_NAME.test(name)) continue;
+      const filename = path.join(directory, name);
+      if (!fs.statSync(filename).isFile() || !contained(directory, filename)) continue;
+      found.set(name, filename);
+    }
+  }
+  return [...found.values()];
+}
+
+function displayName(filename) {
+  return isPackageEntry(filename) ? path.basename(path.dirname(filename)) : path.basename(filename);
+}
+
+function packageInfo(filename, pluginId) {
+  if (!isPackageEntry(filename)) return { settingsSpec: [], settings: {}, settingsError: '' };
+  const pack = readPackageSettings(path.dirname(filename));
+  const mismatch = pack.id && pluginId && pack.id !== pluginId;
+  const error = mismatch ? '插件配置规范与插件 ID 不一致' : pack.error;
+  return {
+    settingsSpec: error ? [] : pack.fields,
+    settings: error ? {} : pack.values,
+    settingsError: error,
+  };
+}
+
+async function describeModule(filename, config) {
+    const file = displayName(filename);
+    try {
+    const exported = (await import(pathToFileURL(filename).href)).default;
+    const bundle = Array.isArray(exported) ? exported : [exported];
+      return bundle.map((plugin) => {
+      validatePlugin(plugin);
+      if (plugin.kind !== 'coding-agent' && plugin.kind !== 'board-plugin') {
+        throw new Error('外部插件仅支持助手或管控');
+      }
+      const pack = packageInfo(filename, plugin.id);
+      let available = false;
+      try {
+        const result = plugin.probe(config);
+        available = Boolean(result && typeof result === 'object' && !(result instanceof Promise) && result.available === true);
+      } catch { /* Availability is display-only. */ }
+      return {
+        id: plugin.id,
+        label: plugin.label,
+        kind: plugin.kind,
+        file,
+        available,
+        enabled: !(config.disabledPlugins || []).includes(plugin.id),
+        events: plugin.kind === 'board-plugin' ? [...plugin.events] : [],
+        commands: plugin.kind === 'board-plugin' ? [...plugin.commands] : [],
+        ...pack,
+      };
+    });
+  } catch {
+    return [{ file, id: '', label: file, kind: '', available: false, enabled: false, events: [], commands: [], settingsSpec: [], settings: {}, settingsError: '', error: '插件无法加载' }];
+  }
+}
+
+export async function listInstalled(config) {
+  const plugins = [];
+  for (const filename of moduleFiles(config)) plugins.push(...await describeModule(filename, config));
+  return { plugins, themes: listThemes(config) };
+}
+
+export function listThemes(config) {
+  const found = new Map();
+  for (const directory of themesDirs(config)) {
+    if (!fs.existsSync(directory) || !fs.statSync(directory).isDirectory()) continue;
+    for (const name of fs.readdirSync(directory).sort()) {
+      if (!THEME_NAME.test(name)) continue;
+      const dir = path.join(directory, name);
+      const manifestPath = path.join(dir, 'theme.json');
+      if (!fs.statSync(dir).isDirectory() || !contained(directory, dir) || !fs.existsSync(manifestPath)) continue;
+      let title = name;
+      try {
+        const raw = JSON.parse(fs.readFileSync(manifestPath, 'utf8'));
+        if (typeof raw.title === 'string' && raw.title.trim()) title = raw.title.trim();
+      } catch { /* A broken manifest still shows the folder name. */ }
+      const files = fs.readdirSync(dir).filter((item) => {
+        const file = path.join(dir, item);
+        return /^[A-Za-z0-9_.-]+$/.test(item) && fs.statSync(file).isFile();
+      });
+      found.set(name, {
+        name,
+        title,
+        sound: files.includes('chime.wav'),
+        icon: files.includes('icon.bin'),
+        background: files.includes('bg.bin'),
+      });
+    }
+  }
+  return [...found.values()];
+}
+
+function writeConfig(config, mutate) {
+  const file = config.configFile;
+  if (!file || path.basename(file) === 'config.example.json') throw fail('请先复制 config.example.json 为 config.local.json');
+  const raw = JSON.parse(fs.readFileSync(file, 'utf8'));
+  mutate(raw);
+  const temporary = path.join(path.dirname(file), `.config-${process.pid}-${randomUUID()}.json`);
+  fs.writeFileSync(temporary, `${JSON.stringify(raw, null, 2)}\n`, { mode: 0o600 });
+  fs.renameSync(temporary, file);
+}
+
+async function reload(config) {
+  config.pluginsRuntime = await loadConfiguredPlugins(config);
+}
+
+function covers(targetReal, candidateReal) {
+  if (candidateReal === targetReal) return true;
+  const relative = path.relative(targetReal, candidateReal);
+  return relative !== '' && !relative.startsWith('..') && !path.isAbsolute(relative);
+}
+
+function pluginPathInConfig(config, filename) {
+  const target = fs.realpathSync(filename);
+  return (config.plugins || []).filter((entry) => {
+    if (typeof entry !== 'string' || !entry || /^[a-z]+:/i.test(entry)) return true;
+    const resolved = path.resolve(config.configDirectory, entry);
+    return !fs.existsSync(resolved) || !covers(target, fs.realpathSync(resolved));
+  });
+}
+
+function removalTarget(config, filename) {
+  const root = pluginsDir(config);
+  const dir = path.dirname(filename);
+  const base = path.basename(filename);
+  if ((base === 'plugin.mjs' || base === 'plugin.js') && contained(root, dir) && path.dirname(fs.realpathSync(dir)) === fs.realpathSync(root)) return dir;
+  return filename;
+}
+
+export async function setPluginEnabled(config, id, enabled) {
+  if (!PLUGIN_ID.test(id || '')) throw fail('插件不存在');
+  const installed = (await listInstalled(config)).plugins;
+  if (!installed.some((plugin) => plugin.id === id)) throw fail('插件不存在');
+  const previous = [...(config.disabledPlugins || [])];
+  const next = new Set(previous);
+  if (enabled) next.delete(id);
+  else next.add(id);
+  config.disabledPlugins = [...next];
+  try {
+    await reload(config);
+  } catch (error) {
+    config.disabledPlugins = previous;
+    throw error;
+  }
+  try {
+    writeConfig(config, (raw) => { raw.disabledPlugins = config.disabledPlugins; });
+  } catch (error) {
+    config.disabledPlugins = previous;
+    await reload(config);
+    throw error;
+  }
+  return listInstalled(config);
+}
+
+export async function savePluginSettings(config, id, values) {
+  if (!PLUGIN_ID.test(id || '') || !values || typeof values !== 'object' || Array.isArray(values)) throw fail('插件配置无效');
+  const filename = await entryForId(config, id);
+  if (!filename || !isPackageEntry(filename)) throw fail('插件没有可保存的配置');
+  const dir = path.dirname(filename);
+  const resolved = writePackageSettings(dir, values);
+  config.pluginSettings = { ...(config.pluginSettings || {}), [id]: resolved };
+  if (config.pluginPackages?.[id]) config.pluginPackages[id] = { ...config.pluginPackages[id], values: resolved, error: '' };
+  return listInstalled(config);
+}
+
+async function entryForId(config, id) {
+  for (const candidate of moduleFiles(config)) {
+    const described = await describeModule(candidate, config);
+    if (described.some((plugin) => plugin.id === id)) return candidate;
+  }
+  return '';
+}
+
+export async function removePlugin(config, { id = '', file = '' } = {}) {
+  const filename = moduleFiles(config).find((candidate) => {
+    if (file) return displayName(candidate) === file;
+    return false;
+  });
+  let target = filename;
+  if (!target && id) {
+    for (const candidate of moduleFiles(config)) {
+      const described = await describeModule(candidate, config);
+      if (described.some((plugin) => plugin.id === id)) target = candidate;
+    }
+  }
+  if (!target) throw fail('插件不存在');
+  if (!contained(pluginsDir(config), target)) throw fail('内置插件不能移除，只能移除用户目录里的插件');
+  target = removalTarget(config, target);
+  const described = await describeModule(target, config);
+  const ids = described.map((plugin) => plugin.id).filter((item) => PLUGIN_ID.test(item));
+  const previousDisabled = [...(config.disabledPlugins || [])];
+  const previousPlugins = [...(config.plugins || [])];
+  config.disabledPlugins = [...new Set([...previousDisabled, ...ids])];
+  config.plugins = pluginPathInConfig(config, target);
+  try {
+    await reload(config);
+    writeConfig(config, (raw) => {
+      raw.disabledPlugins = config.disabledPlugins;
+      if (Array.isArray(raw.plugins)) raw.plugins = config.plugins;
+    });
+  } catch (error) {
+    config.disabledPlugins = previousDisabled;
+    config.plugins = previousPlugins;
+    await reload(config).catch(() => {});
+    throw error;
+  }
+  fs.rmSync(target, { recursive: true, force: true });
+  config.disabledPlugins = previousDisabled.filter((item) => !ids.includes(item));
+  try {
+    await reload(config);
+    writeConfig(config, (raw) => { raw.disabledPlugins = config.disabledPlugins; });
+  } catch {
+    // The file is already gone. Leaving it disabled still lets the bridge start.
+  }
+  return listInstalled(config);
+}
+
+export function removeTheme(config, name) {
+  if (!THEME_NAME.test(name || '')) throw fail('主题不存在');
+  const directory = themesDir(config);
+  const target = path.join(directory, name);
+  if (!fs.existsSync(target) || !fs.statSync(target).isDirectory() || !contained(directory, target)) {
+    // 用户目录里没有，但内置目录里有：说清楚为什么删不掉。
+    if (fs.existsSync(path.join(BUILTIN_ROOT, 'themes', name, 'theme.json'))) throw fail('内置主题不能移除，只能移除用户目录里的主题');
+    throw fail('主题不存在');
+  }
+  if (!fs.existsSync(path.join(target, 'theme.json'))) throw fail('主题不存在');
+  fs.rmSync(target, { recursive: true, force: true });
+  return listThemes(config);
+}
+
+export function themeExists(config, name) {
+  return listThemes(config).some((theme) => theme.name === name);
+}

package/src/jobs.mjs

@@ -0,0 +1,369 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { randomUUID } from 'node:crypto';
+import { SessionStore, validAgentSessionId, VIBE_SESSION_ID } from './sessions.mjs';
+import { builtinAgent } from './agents/index.mjs';
+
+const ACTIVE = new Set(['waiting_confirmation', 'queued', 'running']);
+
+function now() {
+  return new Date().toISOString();
+}
+
+export class JobStore {
+  constructor({ file, projects, defaultProject, defaultProvider, workspaceRoot, maxParallel, run, providerAvailable, pluginsRuntime, hooks }) {
+    this.agent = pluginsRuntime ? (id) => pluginsRuntime.agent(id) : run.agent || builtinAgent;
+    this.hooks = hooks || null;
+    this.file = file;
+    this.projects = projects;
+    this.workspaceRoot = workspaceRoot || '';
+    this.defaultProject = defaultProject;
+    this.defaultProvider = defaultProvider;
+    this.run = run;
+    this.providerAvailable = providerAvailable;
+    // 同时执行的会话数。缺省 1 = 完全串行（保持既有语义，便于测试与降级）。
+    const lanes = Number(maxParallel);
+    this.maxParallel = Number.isFinite(lanes) ? Math.min(Math.max(Math.trunc(lanes), 1), 4) : 1;
+    // 正在占用车道的会话 ID。一个会话同时只会有一条指令在跑，所以按会话占位即可。
+    this.lanes = new Set();
+    this.sessions = new SessionStore({
+      file: path.join(path.dirname(file), 'sessions.json'), projects, defaultProject, defaultProvider, agent: this.agent,
+    });
+    this.jobs = [];
+    this.controllers = new Map();
+    this.progressSavedAt = new Map();
+    this.pumping = false;
+    this.handoffRefresh = null;
+    this.nextHandoffPollAt = 0;
+    this.handoffIndex = 0;
+    this.load();
+  }
+
+  load() {
+    fs.mkdirSync(path.dirname(this.file), { recursive: true, mode: 0o700 });
+    if (fs.existsSync(this.file)) {
+      const parsed = JSON.parse(fs.readFileSync(this.file, 'utf8'));
+      this.jobs = Array.isArray(parsed) ? parsed : [];
+      for (const job of this.jobs) {
+        if (!job.vibeSessionId || !this.sessions.get(job.vibeSessionId)) {
+          const session = this.sessions.create({
+            provider: job.provider, projectId: job.projectId, legacy: true,
+            cliSessionId: job.sessionId || '',
+          });
+          this.sessions.recordTurn(session.id, job.instruction || '历史任务');
+          job.vibeSessionId = session.id;
+        }
+        if (job.status === 'running' || job.status === 'queued') {
+          job.status = 'failed';
+          job.error = '桥接客户端重启，任务执行已中断。请检查代码目录后重新提交。';
+          job.updatedAt = now();
+        }
+        this.run.syncJobState?.(job);
+        if (job.status === 'handed_off' && job.handoff?.readState === 'unavailable') {
+          // A fresh process may have newly authorized credentials.
+          job.handoff.readState = 'retrying';
+        }
+      }
+      this.save();
+    }
+  }
+
+  save() {
+    for (const job of this.jobs) this.run.syncJobState?.(job);
+    const temp = `${this.file}.${process.pid}.tmp`;
+    fs.writeFileSync(temp, JSON.stringify(this.jobs, null, 2), { mode: 0o600 });
+    fs.renameSync(temp, this.file);
+  }
+
+  list() {
+    // Both the desktop and the device read through this method. A throttled
+    // refresh makes handed-off replies available to both without a UI timer.
+    void this.refreshHandoffs();
+    return [...this.jobs].reverse();
+  }
+
+  refreshHandoffs({ force = false } = {}) {
+    if (typeof this.run.readUpdates !== 'function') return Promise.resolve();
+    if (this.handoffRefresh) return this.handoffRefresh;
+    if (!force && Date.now() < this.nextHandoffPollAt) return Promise.resolve();
+    const jobs = this.jobs.filter((job) =>
+      job.status === 'handed_off' && job.handoff?.cursor &&
+      !['unavailable', 'ambiguous'].includes(job.handoff.readState) &&
+      (this.run.canReadUpdates?.(job) ?? true)
+    ).reverse().slice(0, 8);
+    if (!jobs.length) return Promise.resolve();
+    const job = jobs[this.handoffIndex % jobs.length];
+    this.handoffIndex += 1;
+    this.nextHandoffPollAt = Date.now() + 8000;
+    this.handoffRefresh = this.pollHandoff(job).finally(() => {
+      this.handoffRefresh = null;
+    });
+    return this.handoffRefresh;
+  }
+
+  async pollHandoff(job) {
+    try {
+      const update = await this.run.readUpdates(job);
+      if (job.status !== 'handed_off' || !update) return;
+      let changed = false;
+      if (update.handoff && typeof update.handoff === 'object') {
+        job.handoff = { ...job.handoff, ...update.handoff };
+        changed = true;
+      }
+      if (typeof update.appendResult === 'string' && update.appendResult) {
+        job.result = `${job.result}\n\n${update.appendResult}`.slice(-12000);
+        changed = true;
+      }
+      if (changed) {
+        delete job.handoffReadError;
+        job.updatedAt = now();
+        this.save();
+      }
+    } catch (error) {
+      // Reading a reply never undoes a successful dispatch.
+      if (job.status === 'handed_off') {
+        job.handoff = { ...job.handoff, readState: 'retrying' };
+        job.handoffReadError = error instanceof Error ? error.message : String(error);
+        this.save();
+      }
+    }
+  }
+
+  get(id) {
+    return id ? this.jobs.find((job) => job.id === id) : this.jobs.at(-1);
+  }
+
+  listSessions(provider) {
+    return this.sessions.list(provider).map((session) => {
+      const latest = [...this.jobs].reverse().find((job) => job.vibeSessionId === session.id);
+      return { ...session, status: latest?.status || 'empty' };
+    });
+  }
+
+  createSession(payload) {
+    const session = this.sessions.create(payload);
+    return { ...session, status: 'empty' };
+  }
+
+  renameSession(id, title) {
+    this.sessions.rename(id, title);
+    return this.listSessions().find((session) => session.id === id);
+  }
+
+  deleteSession(id) {
+    if (!VIBE_SESSION_ID.test(id || '') || !this.sessions.get(id)) throw new Error('任务不存在');
+    const turns = this.jobs.filter((job) => job.vibeSessionId === id);
+    if (turns.some((job) => job.status === 'running' && !this.agent(job.provider)?.capabilities.cancel)) {
+      throw new Error('这个编程工具不支持撤回正在执行的任务，请先在工具中结束执行');
+    }
+    for (const job of turns) {
+      if (ACTIVE.has(job.status)) this.cancel(job.id);
+      // A handoff poll or an agent that finishes after abort must not write a
+      // removed turn back into the bridge's task history.
+      job.status = 'deleted';
+      this.progressSavedAt.delete(job.id);
+    }
+    this.jobs = this.jobs.filter((job) => job.vibeSessionId !== id);
+    // Persist jobs first: a crash between files leaves an empty session,
+    // rather than an orphan turn that load() would recreate as a new session.
+    this.save();
+    this.sessions.delete(id);
+    return { id, deleted: true };
+  }
+
+  submit({ instruction, sessionId, provider, projectId, source = 'voice' }) {
+    const text = String(instruction || '').trim();
+    if (!VIBE_SESSION_ID.test(sessionId || '')) throw new Error('请先新建任务');
+    const session = this.sessions.get(sessionId);
+    if (!session) throw new Error('任务不存在');
+    const selectedProvider = provider || session.provider;
+    const selectedProject = projectId || session.projectId;
+    if (selectedProvider !== session.provider || selectedProject !== session.projectId) {
+      throw new Error('任务与编程工具或项目不匹配');
+    }
+    if (text.length < 3 || text.length > 2000) {
+      throw new Error('任务内容需在 3 到 2000 字之间');
+    }
+    if (!this.agent(selectedProvider)) {
+      throw new Error('不支持的编程工具');
+    }
+    if (!this.projects.some((project) => project.id === selectedProject)) {
+      throw new Error('项目不在本机允许列表中');
+    }
+    if (this.jobs.some((item) => item.vibeSessionId === session.id && ACTIVE.has(item.status))) {
+      throw new Error('请先完成或取消当前任务的上一条指令');
+    }
+    if (session.contextMode === 'native' &&
+        this.jobs.some((item) => item.vibeSessionId === session.id && item.status === 'completed') &&
+        !session.cliSessionId) {
+      throw new Error('编程工具未返回可恢复的会话 ID，无法继续此任务；请新建任务');
+    }
+    const job = {
+      id: randomUUID().slice(0, 12),
+      vibeSessionId: session.id,
+      sessionId: session.cliSessionId || undefined,
+      instruction: text,
+      provider: selectedProvider,
+      projectId: selectedProject,
+      source,
+      status: 'waiting_confirmation',
+      createdAt: now(),
+      updatedAt: now(),
+      result: '',
+      progress: '',
+      progressAt: '',
+      error: '',
+    };
+    this.sessions.recordTurn(session.id, text);
+    this.jobs.push(job);
+    this.save();
+    this.hooks?.notify('created', job);
+    return job;
+  }
+
+  confirm(id) {
+    const job = this.get(id);
+    if (!job) throw new Error('任务不存在');
+    if (job.status !== 'waiting_confirmation') throw new Error('当前任务不能确认');
+    const capability = this.providerAvailable(job.provider);
+    if (!capability?.available) {
+      const error = new Error(capability?.reason || '编程工具尚未就绪');
+      if (capability?.preserveMessage && capability.reason) error.preserveMessage = true;
+      throw error;
+    }
+    job.error = '';
+    job.progress = '';
+    job.progressAt = '';
+    delete job.retryPending;
+    job.status = 'queued';
+    job.updatedAt = now();
+    this.save();
+    this.hooks?.notify('confirmed', job);
+    void this.pump();
+    return job;
+  }
+
+  cancel(id) {
+    const job = this.get(id);
+    if (!job) throw new Error('任务不存在');
+    if (!ACTIVE.has(job.status)) throw new Error('当前任务不能取消');
+    if (job.status === 'running' && !this.agent(job.provider)?.capabilities.cancel) {
+      throw new Error('这个编程工具不支持撤回正在执行的任务，请在工具中处理');
+    }
+    job.status = 'cancelled';
+    delete job.retryPending;
+    job.updatedAt = now();
+    this.controllers.get(job.id)?.abort();
+    this.save();
+    this.hooks?.notify('cancelled', job);
+    return job;
+  }
+
+  async pump() {
+    if (this.pumping) return;
+    this.pumping = true;
+    try {
+      // 派活：每个会话占一条车道。会话之间可以并行，同一会话仍然串行——编程工具按
+      // 会话线程加写锁，两个进程写同一线程必然冲突，所以并行的粒度只能是"会话"。
+      for (const sessionId of this.jobs.map((item) => item.vibeSessionId)) {
+        if (this.lanes.size >= this.maxParallel) break;
+        if (this.lanes.has(sessionId)) continue;
+        if (!this.jobs.some((item) => item.status === 'queued' && item.vibeSessionId === sessionId)) continue;
+        this.lanes.add(sessionId);
+        void this.lane(sessionId).catch(() => {}).finally(() => {
+          this.lanes.delete(sessionId);
+          void this.pump();
+        });
+      }
+    } finally {
+      this.pumping = false;
+    }
+  }
+
+  /** 单条车道：把这个会话里排队的指令依次跑完。 */
+  async lane(sessionId) {
+    try {
+      while (true) {
+        const job = this.jobs.find((item) => item.status === 'queued' && item.vibeSessionId === sessionId);
+        if (!job) break;
+        const controller = new AbortController();
+        this.controllers.set(job.id, controller);
+        job.status = 'running';
+        job.updatedAt = now();
+        this.save();
+        this.hooks?.notify('started', job);
+        try {
+          const configured = this.projects.find((item) => item.id === job.projectId);
+          const project = this.workspaceRoot
+            ? { ...configured, path: path.join(this.workspaceRoot, job.vibeSessionId) }
+            : configured;
+          // 回合输入管道：插件可以改写本轮实际执行的指令；存储里的任务原文保持不变。
+          const instruction = this.hooks ? await this.hooks.turnIn(job) : job.instruction;
+          const effectiveJob = instruction === job.instruction ? job : { ...job, instruction };
+          const outcome = await this.run(effectiveJob, project, controller.signal, (text) => {
+            if (job.status === 'running' && this.agent(job.provider)?.capabilities.progress) {
+              const progress = String(text || '').replace(/[\x00-\x1f\x7f]+/g, ' ').trim().slice(0, 80);
+              if (!progress || progress === job.progress) return;
+              job.progress = progress;
+              job.progressAt = now();
+              job.updatedAt = job.progressAt;
+              const current = Date.now();
+              if (current - (this.progressSavedAt.get(job.id) || 0) >= 750) {
+                this.progressSavedAt.set(job.id, current);
+                this.save();
+                this.hooks?.notify('progress', job);
+              }
+            }
+          }, (sessionId) => {
+            const plugin = this.agent(job.provider);
+            if (job.status === 'running' && plugin?.capabilities.session === 'native' &&
+                validAgentSessionId(plugin, sessionId) &&
+                (!job.sessionId || job.sessionId === sessionId)) {
+              job.sessionId = sessionId;
+              this.sessions.setCliSession(job.vibeSessionId, sessionId);
+              job.updatedAt = now();
+              this.save();
+            }
+          });
+          if (job.status === 'running') {
+            if (!outcome || !['completed', 'handed_off'].includes(outcome.status || 'completed')) {
+              throw new Error('编程工具插件返回了无效的任务状态');
+            }
+            job.status = outcome.status || 'completed';
+            let result = outcome.result || job.result;
+            // 回合输出管道：仅在任务完成时调用，插件返回新字符串即改写结果。
+            if (job.status === 'completed') result = this.hooks ? await this.hooks.turnOut(job, result) : result;
+            job.result = result;
+            if (outcome.handoff && typeof outcome.handoff === 'object') job.handoff = { ...outcome.handoff };
+            if (job.status === 'completed' && typeof outcome.gitSnapshot === 'string') {
+              this.sessions.setGitSnapshot(job.vibeSessionId, outcome.gitSnapshot);
+            }
+            job.updatedAt = now();
+            this.save();
+            this.hooks?.notify(job.status, job);
+          }
+        } catch (error) {
+          if (job.status === 'running') {
+            const retryableConflict = error?.retryable === true;
+            job.status = retryableConflict ? 'waiting_confirmation' : 'failed';
+            job.retryPending = retryableConflict;
+            job.error = error instanceof Error ? error.message : String(error);
+            if (retryableConflict) {
+              job.progress = '';
+              job.progressAt = '';
+            }
+            job.updatedAt = now();
+            this.save();
+            this.hooks?.notify('failed', job);
+          }
+        } finally {
+          this.controllers.delete(job.id);
+          this.progressSavedAt.delete(job.id);
+        }
+      }
+    } finally {
+      this.lanes.delete(sessionId);
+      void this.pump();
+    }
+  }
+}