@harness-mix/cli 0.1.3

package/src/main/shared-contracts/interaction.js

@@ -0,0 +1,37 @@
+const { newInteractionId } = require('./ids');
+const { createNativeRef, validateNativeRef } = require('./native-ref');
+
+// Interaction：approval / question / permission / confirmation / input / select
+// 统一建模（PR 8 的 InteractionRouter 以此为协议）。第一阶段仅定义契约。
+const INTERACTION_TYPES = ['approval', 'question', 'permission', 'confirmation', 'input', 'select'];
+const INTERACTION_STATUS = ['pending', 'responded', 'cancelled', 'expired'];
+
+function createInteraction({ id, threadId, turnId, type, title, message, options, allowTextInput, nativeRef, status = 'pending' } = {}, now = Date.now()) {
+  return {
+    id: id ?? newInteractionId(),
+    threadId: threadId ?? null,
+    turnId: turnId ?? null,
+    type,
+    title: title ?? '',
+    message: message ?? '',
+    options: Array.isArray(options) ? options.map((o) => ({ id: String(o?.id ?? o), label: String(o?.label ?? o?.id ?? o) })) : [],
+    allowTextInput: allowTextInput === true,
+    nativeRef: createNativeRef(nativeRef),
+    status,
+    createdAt: now,
+    updatedAt: now,
+  };
+}
+
+function validateInteraction(interaction) {
+  const errors = [];
+  if (!interaction || typeof interaction !== 'object') return ['interaction must be an object'];
+  if (typeof interaction.id !== 'string' || !interaction.id) errors.push('interaction.id is required');
+  if (!INTERACTION_TYPES.includes(interaction.type)) errors.push(`interaction.type must be one of ${INTERACTION_TYPES.join('/')}`);
+  if (!INTERACTION_STATUS.includes(interaction.status)) errors.push(`interaction.status must be one of ${INTERACTION_STATUS.join('/')}`);
+  if (!Array.isArray(interaction.options)) errors.push('interaction.options must be an array');
+  errors.push(...validateNativeRef(interaction.nativeRef));
+  return errors;
+}
+
+module.exports = { INTERACTION_TYPES, INTERACTION_STATUS, createInteraction, validateInteraction };

package/src/main/shared-contracts/item.js

@@ -0,0 +1,51 @@
+const { newItemId } = require('./ids');
+const { createNativeRef, validateNativeRef } = require('./native-ref');
+
+// Item：Turn 内的最小呈现单元。第一阶段类型清单（后续只增不改语义）。
+const ITEM_TYPES = [
+  'user_message',
+  'agent_message',
+  'reasoning',
+  'tool_call',
+  'file_change',
+  'approval',
+  'question',
+  'plan',
+  'usage',
+  'notice',
+  'context_compaction',
+];
+
+// started：刚建立；streaming：持续接收 delta；completed/cancelled/error：终态。
+const ITEM_STATUS = ['started', 'streaming', 'completed', 'cancelled', 'error'];
+const TERMINAL_ITEM_STATUS = ['completed', 'cancelled', 'error'];
+
+function createItem({ id, threadId, turnId, type, status = 'started', nativeRef, ...rest } = {}, now = Date.now()) {
+  return {
+    id: id ?? newItemId(),
+    threadId: threadId ?? null,
+    turnId: turnId ?? null,
+    type,
+    status,
+    createdAt: now,
+    updatedAt: now,
+    nativeRef: createNativeRef(nativeRef),
+    ...rest,
+  };
+}
+
+function validateItem(item) {
+  const errors = [];
+  if (!item || typeof item !== 'object') return ['item must be an object'];
+  if (typeof item.id !== 'string' || !item.id) errors.push('item.id is required');
+  if (typeof item.threadId !== 'string' || !item.threadId) errors.push('item.threadId is required');
+  if (item.turnId != null && typeof item.turnId !== 'string') errors.push('item.turnId must be a string or null');
+  if (!ITEM_TYPES.includes(item.type)) errors.push(`item.type must be one of ${ITEM_TYPES.join('/')}`);
+  if (!ITEM_STATUS.includes(item.status)) errors.push(`item.status must be one of ${ITEM_STATUS.join('/')}`);
+  if (typeof item.createdAt !== 'number') errors.push('item.createdAt must be a number');
+  if (typeof item.updatedAt !== 'number') errors.push('item.updatedAt must be a number');
+  errors.push(...validateNativeRef(item.nativeRef));
+  return errors;
+}
+
+module.exports = { ITEM_TYPES, ITEM_STATUS, TERMINAL_ITEM_STATUS, createItem, validateItem };

package/src/main/shared-contracts/native-ref.js

@@ -0,0 +1,24 @@
+// NativeRef：Core 实体与 Harness 原生身份之间的桥。
+// 所有字段均可选，但绝不允许丢失已知的原生 ID（执行约束 #8/#9）。
+const NATIVE_REF_FIELDS = ['sessionId', 'turnId', 'itemId', 'toolCallId', 'interactionId', 'checkpointId'];
+
+function createNativeRef(ref = {}) {
+  const out = {};
+  for (const field of NATIVE_REF_FIELDS) {
+    if (typeof ref[field] === 'string' && ref[field]) out[field] = ref[field];
+  }
+  return out;
+}
+
+function validateNativeRef(ref) {
+  const errors = [];
+  if (ref == null) return errors; // 整体可选
+  if (typeof ref !== 'object' || Array.isArray(ref)) return ['nativeRef must be an object'];
+  for (const [key, value] of Object.entries(ref)) {
+    if (!NATIVE_REF_FIELDS.includes(key)) errors.push(`nativeRef.${key} is not a known field`);
+    else if (typeof value !== 'string' || !value) errors.push(`nativeRef.${key} must be a non-empty string`);
+  }
+  return errors;
+}
+
+module.exports = { NATIVE_REF_FIELDS, createNativeRef, validateNativeRef };

package/src/main/shared-contracts/thread.js

@@ -0,0 +1,36 @@
+const { newThreadId } = require('./ids');
+const { createNativeRef, validateNativeRef } = require('./native-ref');
+
+// Thread：一次任务会话的 Core 侧身份。与具体 Harness 无关。
+const THREAD_STATUS = ['idle', 'running', 'waiting', 'error'];
+
+function createThread({ id, workspaceId, harnessId, nativeSessionRef, status = 'idle', metadata } = {}, now = Date.now()) {
+  return {
+    id: id ?? newThreadId(),
+    workspaceId: workspaceId ?? null,
+    harnessId: harnessId ?? null,
+    nativeSessionRef: createNativeRef(nativeSessionRef),
+    status,
+    activeTurnId: null,
+    createdAt: now,
+    updatedAt: now,
+    metadata: metadata && typeof metadata === 'object' ? { ...metadata } : {},
+  };
+}
+
+function validateThread(thread) {
+  const errors = [];
+  if (!thread || typeof thread !== 'object') return ['thread must be an object'];
+  if (typeof thread.id !== 'string' || !thread.id) errors.push('thread.id is required');
+  if (thread.workspaceId != null && typeof thread.workspaceId !== 'string') errors.push('thread.workspaceId must be a string');
+  if (thread.harnessId != null && typeof thread.harnessId !== 'string') errors.push('thread.harnessId must be a string');
+  if (!THREAD_STATUS.includes(thread.status)) errors.push(`thread.status must be one of ${THREAD_STATUS.join('/')}`);
+  if (thread.activeTurnId != null && typeof thread.activeTurnId !== 'string') errors.push('thread.activeTurnId must be a string or null');
+  if (typeof thread.createdAt !== 'number') errors.push('thread.createdAt must be a number');
+  if (typeof thread.updatedAt !== 'number') errors.push('thread.updatedAt must be a number');
+  if (thread.metadata != null && (typeof thread.metadata !== 'object' || Array.isArray(thread.metadata))) errors.push('thread.metadata must be an object');
+  errors.push(...validateNativeRef(thread.nativeSessionRef));
+  return errors;
+}
+
+module.exports = { THREAD_STATUS, createThread, validateThread };

package/src/main/shared-contracts/turn.js

@@ -0,0 +1,54 @@
+const { newTurnId } = require('./ids');
+const { createNativeRef, validateNativeRef } = require('./native-ref');
+
+// Turn：一次独立执行。生命周期只能由 TurnManager 推进（执行约束：状态不得由
+// Renderer / Transcript / Adapter 推断）。
+const TURN_STATUS = ['created', 'starting', 'running', 'waiting_interaction', 'completed', 'cancelled', 'error'];
+const TERMINAL_TURN_STATUS = ['completed', 'cancelled', 'error'];
+
+// 合法状态机。终态不允许再迁移（例如 completed → running 必须拒绝）。
+const TURN_TRANSITIONS = {
+  created: ['starting', 'cancelled', 'error'],
+  starting: ['running', 'waiting_interaction', 'completed', 'cancelled', 'error'],
+  running: ['waiting_interaction', 'completed', 'cancelled', 'error'],
+  waiting_interaction: ['running', 'completed', 'cancelled', 'error'],
+  completed: [],
+  cancelled: [],
+  error: [],
+};
+
+function canTransition(from, to) {
+  return (TURN_TRANSITIONS[from] ?? []).includes(to);
+}
+
+function createTurn({ id, threadId, nativeTurnRef, status = 'created', itemIds, lastSequence, error } = {}, now = Date.now()) {
+  return {
+    id: id ?? newTurnId(),
+    threadId: threadId ?? null,
+    nativeTurnRef: createNativeRef(nativeTurnRef),
+    status,
+    startedAt: null,
+    completedAt: null,
+    itemIds: Array.isArray(itemIds) ? [...itemIds] : [],
+    lastSequence: typeof lastSequence === 'number' ? lastSequence : 0,
+    error: error ?? null,
+    createdAt: now,
+    updatedAt: now,
+  };
+}
+
+function validateTurn(turn) {
+  const errors = [];
+  if (!turn || typeof turn !== 'object') return ['turn must be an object'];
+  if (typeof turn.id !== 'string' || !turn.id) errors.push('turn.id is required');
+  if (typeof turn.threadId !== 'string' || !turn.threadId) errors.push('turn.threadId is required');
+  if (!TURN_STATUS.includes(turn.status)) errors.push(`turn.status must be one of ${TURN_STATUS.join('/')}`);
+  if (turn.startedAt != null && typeof turn.startedAt !== 'number') errors.push('turn.startedAt must be a number or null');
+  if (turn.completedAt != null && typeof turn.completedAt !== 'number') errors.push('turn.completedAt must be a number or null');
+  if (!Array.isArray(turn.itemIds)) errors.push('turn.itemIds must be an array');
+  if (typeof turn.lastSequence !== 'number') errors.push('turn.lastSequence must be a number');
+  errors.push(...validateNativeRef(turn.nativeTurnRef));
+  return errors;
+}
+
+module.exports = { TURN_STATUS, TERMINAL_TURN_STATUS, TURN_TRANSITIONS, canTransition, createTurn, validateTurn };

package/src/main/workspace/core-review.js

@@ -0,0 +1,53 @@
+const { diff } = require('./diff');
+
+// Snapshot acquisition/undo stay in Workspace. Core stores their presentation.
+async function projectReview(runtime, thread, message, record) {
+  const core = runtime.core;
+  if (!core?.getTurn(message.coreTurnId)) throw new Error('审查记录缺少 Core Turn，请重新加载任务完成历史迁移');
+
+  const hasNativePatch = Boolean(
+    runtime.getCapabilities?.(thread.harnessId)?.conversation?.nativePatch ||
+    runtime.adapters?.get(thread.harnessId)?.manifest?.capabilities?.nativePatch
+  );
+
+  let changes = record.changes;
+  if (hasNativePatch) {
+    // 原生 Codex 协议直通：若该会话有原生 patch 能力，当前轮次文件变更以原生汇报为准，消除同目录并发干扰
+    const nativeItems = core.getItemsForTurn(message.coreTurnId).filter(item => item.type === 'file_change' && item.source === 'native');
+    const nativePaths = new Set(nativeItems.map(item => item.path));
+    changes = changes.filter(change => nativePaths.has(change.path));
+  }
+
+  core.dispatch({ threadId: thread.id, turnId: message.coreTurnId, type: 'files.updated', payload: {
+    source: 'snapshot', replace: true,
+    changes: changes.map(change => ({
+      path: change.path, changeType: !change.before ? 'added' : !change.after ? 'deleted' : 'modified',
+      before: change.before?.text ?? '', after: change.after?.text ?? '',
+      patch: diff(change.before?.text, change.after?.text), complete: true,
+      added: change.added, removed: change.removed, undone: change.undone === true,
+    })),
+  } });
+  message.coreItems = structuredClone(core.getItemsForTurn(message.coreTurnId));
+  const summaryRecord = { ...record, changes };
+  const summary = { ...runtime.reviews.summary(summaryRecord), files: message.coreItems.filter(item => item.type === 'file_change') };
+  message.coreReview = structuredClone(summary);
+  return summary;
+}
+
+async function readReview(runtime, thread, message, file) {
+  const id = message.review?.id ?? message.reviewId;
+  let record;
+  for (let attempt = 0; ; attempt++) {
+    const revision = thread.fileRevision;
+    record = await runtime.reviews.preview(id);
+    if (revision === thread.fileRevision) break;
+    if (attempt === 4) throw new Error('文件仍在变化，请稍后刷新审查');
+  }
+  const summary = await projectReview(runtime, thread, message, record);
+  if (!file) return summary;
+  const item = summary.files.find(item => item.path === file);
+  if (!item) throw new Error('文件不在本轮审查记录中');
+  return { path: item.path, undone: item.undone, ...(item.patch?.rows ? item.patch : diff(item.before, item.after)) };
+}
+
+module.exports = { projectReview, readReview };

package/src/main/workspace/diff.js

@@ -0,0 +1,27 @@
+// Bounded line LCS; large inputs use a content-exact coarse replacement.
+function diff(before = '', after = '') {
+  const lines = s => s ? s.match(/[^\n]*\n|[^\n]+$/g) ?? [] : [];
+  const a = lines(before), b = lines(after), rows = [];
+  let old = 1, next = 1;
+  const add = (kind, text) => rows.push({ kind, text: text.replace(/\r?\n$/, ''), old: kind === 'add' ? null : old++, next: kind === 'remove' ? null : next++ });
+  let start = 0;
+  while (start < a.length && start < b.length && a[start] === b[start]) { add('same', a[start]); start++; }
+  let x = a.length, y = b.length;
+  while (x > start && y > start && a[x - 1] === b[y - 1]) { x--; y--; }
+  const n = x - start, m = y - start, coarse = n * m > 1_000_000;
+  if (coarse) {
+    a.slice(start, x).forEach(s => add('remove', s)); b.slice(start, y).forEach(s => add('add', s));
+  } else {
+    const table = Array.from({ length: n + 1 }, () => new Uint32Array(m + 1));
+    for (let i = n - 1; i >= 0; i--) for (let j = m - 1; j >= 0; j--) table[i][j] = a[start + i] === b[start + j] ? table[i + 1][j + 1] + 1 : Math.max(table[i + 1][j], table[i][j + 1]);
+    let i = 0, j = 0;
+    while (i < n || j < m) {
+      if (i < n && j < m && a[start + i] === b[start + j]) { add('same', a[start + i++]); j++; }
+      else if (j < m && (i === n || table[i][j + 1] > table[i + 1][j])) add('add', b[start + j++]);
+      else add('remove', a[start + i++]);
+    }
+  }
+  a.slice(x).forEach(s => add('same', s));
+  return { rows, added: rows.filter(r => r.kind === 'add').length, removed: rows.filter(r => r.kind === 'remove').length, coarse };
+}
+module.exports = { diff };

package/src/main/workspace/file-changes.js

@@ -0,0 +1,21 @@
+const path = require('node:path');
+const { diff } = require('./diff');
+
+function canonicalChanges(cwd, changes = [], previous = []) {
+  return changes.map(change => {
+    const absolute = path.resolve(cwd, change.path);
+    const relative = path.relative(cwd, absolute).replace(/\\/g, '/');
+    if (!relative || relative === '..' || relative.startsWith('../') || path.isAbsolute(relative)) throw new Error('FileChange is outside the workspace');
+    const old = previous.find(item => item.path === relative);
+    if (old && typeof old.before === 'string' && typeof old.after === 'string') {
+      if (change.before === old.after) {
+        change = { ...change, before: old.before, changeType: old.changeType === 'added' && change.changeType !== 'deleted' ? 'added' : change.changeType };
+      } else if (change.before !== old.before) {
+        change = { ...change, complete: false };
+      }
+    }
+    const patch = typeof change.before === 'string' && typeof change.after === 'string' ? diff(change.before, change.after) : change.patch;
+    return { ...change, path: relative, ...(patch ? { patch, added: patch.added, removed: patch.removed } : {}) };
+  });
+}
+module.exports = { canonicalChanges };

package/src/main/workspace/files.js

@@ -0,0 +1,76 @@
+const fs = require('node:fs/promises');
+const path = require('node:path');
+const { createHash } = require('node:crypto');
+const OMIT = /^(node_modules|\.git|\.venv|venv|dist|build|output|__pycache__|\.next|\.idea)$/i;
+const PRIVATE = /(^\.env($|\.)|^\.ssh$|^\.aws$|credentials|secrets?|^auth\.json$|^settings\.json$|^id_rsa|\.(pem|key|pfx|p12)$)/i;
+const hash = data => createHash('sha256').update(data).digest('hex');
+const inside = (root, target) => { const relative = path.relative(root, target); return !relative.startsWith('..' + path.sep) && relative !== '..' && !path.isAbsolute(relative); };
+
+async function resolveFile(root, relative = '') {
+  root = await fs.realpath(root);
+  if (typeof relative !== 'string' || path.isAbsolute(relative) || relative.includes(':')) throw Error('仅允许项目内相对路径');
+  const target = path.resolve(root, relative);
+  if (!inside(root, target)) throw Error('路径超出项目范围');
+  let cursor = root;
+  for (const part of path.relative(root, target).split(path.sep).filter(Boolean)) {
+    if (PRIVATE.test(part) || OMIT.test(part)) throw Error('该路径不参与桌面文件预览与快照');
+    cursor = path.join(cursor, part);
+    try { if ((await fs.lstat(cursor)).isSymbolicLink()) throw Error('不跟随符号链接或目录联接'); }
+    catch (e) { if (e.code !== 'ENOENT') throw e; }
+  }
+  return target;
+}
+
+async function readText(root, relative) {
+  const target = await resolveFile(root, relative);
+  const stat = await fs.stat(target);
+  if (!stat.isFile() || stat.size > 1024 * 1024) throw Error('仅预览 1 MB 以内文本文件');
+  const buffer = await fs.readFile(target);
+  const text = buffer.toString('utf8');
+  if (buffer.includes(0) || !Buffer.from(text).equals(buffer)) throw Error('二进制或非 UTF-8 文件不参与预览');
+  return { text, hash: hash(buffer), mode: stat.mode, mtimeMs: stat.mtimeMs, size: stat.size };
+}
+
+async function list(root, relative = '') {
+  const entries = await fs.readdir(await resolveFile(root, relative), { withFileTypes: true });
+  return entries.filter(e => !e.isSymbolicLink() && !OMIT.test(e.name) && !PRIVATE.test(e.name))
+    .sort((a, b) => Number(b.isDirectory()) - Number(a.isDirectory()) || a.name.localeCompare(b.name))
+    .slice(0, 1500).map(e => ({ name: e.name, path: path.join(relative, e.name), directory: e.isDirectory() }));
+}
+
+async function snapshot(root, previousFiles = null) {
+  const names = [], files = Object.create(null), skipped = [];
+  let bytes = 0, entries = 0;
+  async function walk(relative) {
+    const all = await fs.readdir(await resolveFile(root, relative), { withFileTypes: true });
+    for (const entry of all) {
+      if (++entries > 15000) throw Error('项目超过 15,000 个目录项，未建立完整快照');
+      if (OMIT.test(entry.name) || PRIVATE.test(entry.name) || entry.isSymbolicLink()) continue;
+      const file = path.join(relative, entry.name);
+      if (entry.isDirectory()) await walk(file);
+      else if (entry.isFile()) {
+        names.push(file);
+        try {
+          const prev = previousFiles ? previousFiles[file] : null;
+          if (prev && Number.isFinite(prev.mtimeMs) && Number.isFinite(prev.size)) {
+            const target = await resolveFile(root, file);
+            const stat = await fs.stat(target);
+            if (stat.isFile() && stat.mtimeMs === prev.mtimeMs && stat.size === prev.size) {
+              bytes += Buffer.byteLength(prev.text);
+              if (bytes > 24 * 1024 * 1024) throw Error('快照超过 24 MB');
+              files[file] = prev;
+              continue;
+            }
+          }
+          const value = await readText(root, file);
+          bytes += Buffer.byteLength(value.text);
+          if (bytes > 24 * 1024 * 1024) throw Error('快照超过 24 MB');
+          files[file] = value;
+        } catch (e) { skipped.push(file); }
+      }
+    }
+  }
+  await walk('');
+  return { names, files, skipped };
+}
+module.exports = { resolveFile, readText, list, snapshot, hash };

package/src/main/workspace/review-controller.js

@@ -0,0 +1,102 @@
+const fs = require('node:fs/promises');
+const { projectReview, readReview } = require('./core-review');
+
+// Owns workspace review settlement, live refresh and undo. It never decides Turn state.
+class ReviewController {
+  constructor(runtime, { save, broadcast }) {
+    this.runtime = runtime; this.save = save; this.broadcast = broadcast;
+  }
+  get threads() { return this.runtime.threads; }
+  get reviews() { return this.runtime.reviews; }
+  get listeners() { return this.runtime.listeners; }
+  get settlements() { return this.runtime.settlements; }
+  get reviewMonitors() { return this.runtime.reviewMonitors; }
+  async settle(thread, message) {
+    if (this.settlements.has(thread.id)) return;
+    this.settlements.add(thread.id);
+    const monitor = this.reviewMonitors.get(thread.id);
+    if (monitor) { monitor.closed = true; clearInterval(monitor.timer); this.reviewMonitors.delete(thread.id); }
+    thread.reviewPending = true;
+    try {
+      if (message?.reviewId) {
+        if (message.concurrent) {
+          const loaded = await this.reviews.load(message.reviewId);
+          loaded.concurrent = true;
+          loaded.note = '此轮执行期间存在同项目并发任务，文件变更可能包含其他任务的修改。';
+          await this.reviews.save(loaded);
+        }
+        message.review = await this.reviews.finish(message.reviewId);
+        if (message.concurrent && message.review) {
+          message.review.concurrent = true;
+          message.review.note = '此轮执行期间存在同项目并发任务，文件变更可能包含其他任务的修改。';
+        }
+      }
+      if (message?.review) {
+        const record = await this.reviews.load(message.reviewId);
+        if (message.concurrent) record.concurrent = true;
+        const summary = await projectReview(this.runtime, thread, message, record);
+        if (message.concurrent) summary.concurrent = true;
+        message.review = summary;
+        this.emitReviewUpdate(thread, message, summary);
+      }
+    } catch (e) { if (message) message.reviewError = '文件审查暂不可用：' + e.message; }
+    finally {
+      thread.reviewPending = false;
+      this.settlements.delete(thread.id);
+      await this.save(); this.broadcast();
+    }
+  }
+
+  readReview(thread, message, file) { return readReview(this.runtime, thread, message, file); }
+
+  reviewMessage(threadId, messageId) {
+    const thread = this.threads.find(t => t.id === threadId);
+    const message = thread.messages.find(m => m.id === messageId);
+    if (!message?.review) throw Error('该轮没有可审查的文件快照（旧历史无法补建）');
+    return { thread, message };
+  }
+
+  // The UI subscribes to a turn-scoped event; workspace snapshots stay in Main.
+  startReviewUpdates(thread, message) {
+    if (!message.reviewId || this.reviewMonitors.has(thread.id)) return;
+    const monitor = { busy: false, closed: false };
+    const tick = async () => {
+      if (monitor.closed || monitor.busy || !message.streaming) return;
+      monitor.busy = true;
+      try {
+        const fileRevision = thread.fileRevision;
+        const record = await this.reviews.preview(message.reviewId);
+        if (!monitor.closed && message.streaming && fileRevision === thread.fileRevision) {
+          if (message.concurrent) record.concurrent = true;
+          const review = await projectReview(this.runtime, thread, message, record);
+          if (message.concurrent) review.concurrent = true;
+          message.liveReview = review;
+          this.emitReviewUpdate(thread, message, review);
+        }
+      } catch (e) {
+        if (!monitor.closed) for (const listener of this.listeners) listener({ type: 'turn/diff/updated', threadId: thread.id, turnId: message.id, error: e.message });
+      } finally { monitor.busy = false; }
+    };
+    monitor.timer = setInterval(() => void tick(), 3000);
+    monitor.timer.unref?.();
+    this.reviewMonitors.set(thread.id, monitor);
+    void tick();
+  }
+
+  emitReviewUpdate(thread, message, review) {
+    for (const listener of this.listeners) listener({ type: 'turn/diff/updated', threadId: thread.id, turnId: message.id, review });
+  }
+
+  async undoFile(threadId, messageId, file) {
+    const { thread, message } = this.reviewMessage(threadId, messageId);
+    if (this.threads.some(t => t.cwd.toLowerCase() === thread.cwd.toLowerCase() && (this.runtime.execution.isRunning(t.id) || t.status === 'working' || t.reviewPending))) throw Error('项目任务执行或结算中，暂不能撤回');
+    const record = await this.reviews.load(message.review.id);
+    if ((await fs.realpath(thread.cwd)).toLowerCase() !== record.root.toLowerCase()) throw Error('任务目录已移动，禁止从新目录撤回旧项目文件');
+    message.review = await this.reviews.undo(message.review.id, file);
+    await projectReview(this.runtime, thread, message, await this.reviews.load(message.review.id));
+    await this.save(); this.broadcast();
+    return message.review;
+  }
+
+}
+module.exports = { ReviewController };

package/src/main/workspace/review.js

@@ -0,0 +1,88 @@
+const fs = require('node:fs/promises');
+const path = require('node:path');
+const { randomUUID } = require('node:crypto');
+const { snapshot, resolveFile, readText } = require('./files');
+const { diff } = require('./diff');
+
+class ReviewStore {
+  constructor(directory) { this.directory = path.join(directory, 'reviews'); this.locks = new Set(); this.cache = new Map(); }
+  file(id) { if (!/^[\da-f-]{36}$/.test(id)) throw Error('无效审查 ID'); return path.join(this.directory, id + '.json'); }
+  async save(record) {
+    this.cache.set(record.id, record);
+    await fs.mkdir(this.directory, { recursive: true });
+    const file = this.file(record.id);
+    await fs.writeFile(file + '.tmp', JSON.stringify(record));
+    await fs.rename(file + '.tmp', file);
+  }
+  async load(id) {
+    if (this.cache.has(id)) return this.cache.get(id);
+    const record = JSON.parse(await fs.readFile(this.file(id), 'utf8'));
+    for (const change of record.changes) change.path = change.path.replace(/\\/g, '/');
+    this.cache.set(id, record);
+    return record;
+  }
+  async begin(root) {
+    const baseline = await snapshot(root);
+    const record = { id: randomUUID(), root: await fs.realpath(root), baseline, at: Date.now(), changes: [] };
+    await this.save(record);
+    return record.id;
+  }
+  async preview(id) {
+    const record = await this.load(id);
+    if (!record.baseline) return record;
+    const after = await snapshot(record.root, record.lastSnapshot?.files || record.baseline.files);
+    record.lastSnapshot = after;
+    record.changes = [];
+    const previousNames = new Set(record.baseline.names), currentNames = new Set(after.names);
+    for (const file of new Set([...record.baseline.names, ...after.names])) {
+      const before = record.baseline.files[file], next = after.files[file];
+      // A skipped/binary/oversized file is not a deletion or an addition.
+      if ((!before && previousNames.has(file)) || (!next && currentNames.has(file))) continue;
+      if (before?.hash === next?.hash) continue;
+      const delta = diff(before?.text, next?.text);
+      record.changes.push({ path: file.replace(/\\/g, '/'), before: before ?? null, after: next ?? null, added: delta.added, removed: delta.removed, coarse: delta.coarse });
+    }
+    record.skipped = record.baseline.skipped.length + after.skipped.length;
+    return record;
+  }
+  async finish(id) {
+    const record = await this.preview(id);
+    delete record.baseline;
+    delete record.lastSnapshot;
+    record.endedAt = Date.now();
+    await this.save(record);
+    return this.summary(record);
+  }
+  summary(record) {
+    return { id: record.id, at: record.at, endedAt: record.endedAt, live: !record.endedAt, skipped: record.skipped,
+      ...(record.concurrent ? { concurrent: true, ...(record.note ? { note: record.note } : {}) } : {}),
+      files: record.changes.map(c => ({ path: c.path, added: c.added, removed: c.removed, undone: c.undone, kind: !c.before ? 'added' : !c.after ? 'deleted' : 'modified' })) };
+  }
+  async detail(id, file) {
+    const record = await this.preview(id), change = record.changes.find(c => c.path === file);
+    if (!change) throw Error('文件不在本轮审查记录中');
+    return { path: file, undone: change.undone, ...diff(change.before?.text, change.after?.text) };
+  }
+  async undo(id, file) {
+    if (this.locks.has(id)) throw Error('撤回正在进行');
+    this.locks.add(id);
+    try {
+      const record = await this.load(id), change = record.changes.find(c => c.path === file);
+      if (!record.endedAt || !change || change.undone) throw Error('该文件不可撤回');
+      const target = await resolveFile(record.root, file);
+      let current = null;
+      try { current = await readText(record.root, file); } catch (e) { if (e.code !== 'ENOENT') throw e; }
+      if (current?.hash !== change.after?.hash) throw Error('文件在任务结束后已发生变化，拒绝覆盖。请先手动处理冲突。');
+      // The review journal retains both revisions even for a removed new file.
+      if (change.before) {
+        await fs.mkdir(path.dirname(target), { recursive: true });
+        await resolveFile(record.root, file);
+        await fs.writeFile(target, change.before.text, { flag: current ? 'w' : 'wx', mode: change.before.mode });
+      } else await fs.unlink(target);
+      change.undone = true;
+      await this.save(record);
+      return this.summary(record);
+    } finally { this.locks.delete(id); }
+  }
+}
+module.exports = { ReviewStore };

package/src/native-ui/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 BytePioneer-AI
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/src/native-ui/README.md

@@ -0,0 +1,16 @@
+# Harness Mix native Desktop boundary
+
+The renderer-extension, desktop-control and shared-contracts source directories
+are derived from BytePioneer-AI/codex-host v0.6.1, commit
+da97fa7b447d03bd3626bb8f782234d5fa519141 (MIT, see LICENSE).
+They are maintained and built in this repository. No upstream Host Runtime,
+ProtocolCore, adapter or account store is imported. Upstream wire names are
+retained solely for compatibility with this renderer boundary.
+
+Execution is owned by src/main/host/runtime.js and src/main/protocol-core.
+Launcher and Shim sources live in src/main/native. Project icons are compiled
+directly from src/assets/icons. Generated artifacts live in output/native-build.
+
+## CodeBuddy、Kiro 与 Cursor
+
+默认 Agent 列表与 Host 注册表同步，三者分别保存模型偏好并使用独立插件路由。Workbuddy 已更名为 CodeBuddy，旧模型/分组偏好在读取时兼容迁移。原生协议、安装与验证边界见 [原生 ACP 深度适配](../../docs/native-acp.md)。