annotatable-html 0.0.0-stage → 1.45.3

package/lib/document.js

@@ -0,0 +1,56 @@
+'use strict';
+
+// Resolve a page served on this machine to its document. No registry or background scan.
+var fs = require('fs');
+var path = require('path');
+var core = require('./core.js');
+
+function resolveDocument(source, options) {
+  var page;
+  try { page = new URL(source); } catch (_) { return Promise.reject(new Error('页面地址无效')); }
+  if (!/^https?:$/.test(page.protocol) || ['localhost', '127.0.0.1', '[::1]'].indexOf(page.hostname) === -1) {
+    return Promise.reject(new Error('只支持本机 localhost 或回环地址的批注页面'));
+  }
+  if (page.username || page.password) return Promise.reject(new Error('页面地址不要包含用户名或密码'));
+  var rel;
+  try { rel = decodeURIComponent(page.pathname); } catch (_) { return Promise.reject(new Error('页面路径编码无效')); }
+  if (!/\.html?$/i.test(rel)) return Promise.reject(new Error('请提供具体的 HTML 页面地址'));
+  var endpoint = new URL('/__annot/context', page.origin);
+  endpoint.searchParams.set('path', rel);
+  if (endpoint.hostname === 'localhost') endpoint.hostname = '127.0.0.1';
+  return new Promise(function (resolve, reject) {
+    var client = require(endpoint.protocol === 'https:' ? 'https' : 'http');
+    var req = client.get(endpoint, function (res) {
+      var chunks = [], size = 0;
+      res.on('data', function (chunk) {
+        size += chunk.length;
+        if (size > 65536) { req.destroy(new Error('页面定位信息过大')); return; }
+        chunks.push(chunk);
+      });
+      res.on('error', reject);
+      res.on('end', function () {
+        if (res.statusCode !== 200) {
+          reject(new Error('无法定位文档（HTTP ' + res.statusCode + '）；旧服务请更新后重启 annotatable serve'));
+          return;
+        }
+        try {
+          var info = JSON.parse(Buffer.concat(chunks).toString('utf8'));
+          if (info.service !== 'annotatable-html' || !path.isAbsolute(info.file || '') || !path.isAbsolute(info.root || '')) {
+            throw new Error('该地址未返回批注服务的文档信息');
+          }
+          var relative = path.relative(info.root, info.file);
+          if (relative === '..' || relative.indexOf('..' + path.sep) === 0 || path.isAbsolute(relative)) {
+            throw new Error('文档定位结果超出服务目录');
+          }
+          var html = fs.readFileSync(info.file, 'utf8');
+          if (!core.readStore(html) || core.docIdOf(html) !== info.docId) throw new Error('本机文档与页面标识不一致');
+          resolve(options && options.includeContext ? { file: info.file, root: info.root, pagePath: rel, port: Number(page.port || (page.protocol === 'https:' ? 443 : 80)), protocol: page.protocol } : info.file);
+        } catch (err) { reject(err); }
+      });
+    });
+    req.setTimeout(5000, function () { req.destroy(new Error('页面服务连接超时')); });
+    req.on('error', reject);
+  });
+}
+
+module.exports = { resolveDocument: resolveDocument };

package/lib/duty-process.js

@@ -0,0 +1,190 @@
+'use strict';
+
+// Process identity is evidence of release; a socket timeout is never evidence.
+var cp = require('child_process');
+var fs = require('fs');
+var path = require('path');
+var readline = require('readline');
+var EventEmitter = require('events');
+
+function literal(value) { return "'" + String(value).replace(/'/g, "''") + "'"; }
+function powershell(script) {
+  return new Promise(function (resolve, reject) {
+    cp.execFile('powershell.exe', ['-NoProfile', '-NonInteractive', '-Command',
+      '[Console]::OutputEncoding = New-Object System.Text.UTF8Encoding($false); ' + script],
+    { windowsHide: true, encoding: 'utf8', timeout: 15000, maxBuffer: 1024 * 1024 }, function (error, stdout, stderr) {
+      if (error) { reject(new Error('无法确认宿主进程状态：' + (stderr || error.message).trim())); return; }
+      try { resolve(stdout.trim() ? JSON.parse(stdout.trim()) : null); }
+      catch (_) { reject(new Error('宿主进程检查未返回有效 JSON')); }
+    });
+  });
+}
+function fields() { return 'ProcessId,ParentProcessId,Name,CreationDate,ExecutablePath,CommandLine'; }
+async function processInfo(pid) {
+  if (!Number.isInteger(pid) || pid < 1) throw new Error('无效的进程编号');
+  if (process.platform !== 'win32') throw new Error('此版本仅在 Windows 验证了桌面所有权检查');
+  return powershell('Get-CimInstance Win32_Process -Filter ' + literal('ProcessId=' + pid) + ' | Select-Object ' + fields() + ' | ConvertTo-Json -Compress');
+}
+function sameProcess(expected, actual) {
+  return !!(expected && actual && expected.CreationDate && expected.ExecutablePath && expected.ProcessId === actual.ProcessId &&
+    expected.CreationDate === actual.CreationDate &&
+    String(expected.ExecutablePath).toLowerCase() === String(actual.ExecutablePath).toLowerCase());
+}
+function identity(p) {
+  if (!p) return null;
+  return { ProcessId: p.ProcessId, ParentProcessId: p.ParentProcessId, Name: p.Name, CreationDate: p.CreationDate, ExecutablePath: p.ExecutablePath };
+}
+function agentEnv(extra) {
+  var env = Object.assign({}, process.env, extra || {});
+  for (var key of ['CODEX_APP_TOOLS_PIPE_PATH', 'CODEX_THREAD_ID', 'CODEX_TURN_ID', 'CODEX_SESSION_ID', 'CODEX_TOOL_CALL_ID',
+    'CLAUDECODE', 'CLAUDE_CODE_SESSION_ID', 'CLAUDE_SESSION_ID', 'CLAUDE_CODE_ENTRYPOINT',
+    'ANNOTATABLE_OPENCODE_SESSION_ID', 'ANNOTATABLE_OPENCODE_SERVER_URL', 'ANNOTATABLE_OPENCODE_DIRECTORY']) delete env[key];
+  return env;
+}
+function tailRows(file) {
+  var fd = fs.openSync(file, 'r'), buffer;
+  try { var size = fs.fstatSync(fd).size; buffer = Buffer.alloc(Math.min(size, 4 * 1024 * 1024)); fs.readSync(fd, buffer, 0, buffer.length, size - buffer.length); }
+  finally { fs.closeSync(fd); }
+  return buffer.toString('utf8').split(/\r?\n/).flatMap(line => { try { return [JSON.parse(line)]; } catch (_) { return []; } });
+}
+function fileStamp(file) { try { var s = fs.statSync(file); return { file: file, size: s.size, mtimeMs: s.mtimeMs }; } catch (e) { if (e.code === 'ENOENT') return { file: file, missing: true }; throw e; } }
+function configStamps(cwd, relativeNames, extra) {
+  var files = (extra || []).slice();
+  for (var at = cwd;; at = path.dirname(at)) {
+    for (var name of relativeNames) files.push(path.join(at, name));
+    if (path.dirname(at) === at) break;
+  }
+  return Array.from(new Set(files)).map(fileStamp);
+}
+async function parents(pid) {
+  if (!Number.isInteger(pid) || pid < 1) throw new Error('无效的进程编号');
+  return powershell('$taskPs=@(Get-CimInstance Win32_Process); $taskNext=' + pid + '; $taskResult=@(); for($taskI=0;$taskI -lt 20;$taskI++) { $taskP=$taskPs | Where-Object ProcessId -eq $taskNext; if(-not $taskP){break}; $taskResult+=($taskP | Select-Object ' + fields() + '); $taskNext=$taskP.ParentProcessId }; ConvertTo-Json -InputObject @($taskResult) -Compress');
+}
+async function ownersExited(owners) {
+  if (!Array.isArray(owners) || !owners.length) return { released: false, reason: 'missing-owner-evidence' };
+  for (var owner of owners) if (sameProcess(owner, await processInfo(owner.ProcessId))) return { released: false, reason: 'host-process-alive', pid: owner.ProcessId };
+  return { released: true, reason: 'recorded-host-processes-exited' };
+}
+async function argumentsFor(pid) {
+  if (!Number.isInteger(pid) || pid < 1) throw new Error('无效的进程编号');
+  var source = 'using System; using System.Runtime.InteropServices; public static class AnnotatableArgs { [DllImport("shell32.dll",SetLastError=true)] static extern IntPtr CommandLineToArgvW([MarshalAs(UnmanagedType.LPWStr)] string s,out int n); [DllImport("kernel32.dll")] static extern IntPtr LocalFree(IntPtr p); public static string[] Read(string s){int n;IntPtr p=CommandLineToArgvW(s,out n);if(p==IntPtr.Zero)throw new Exception("argv unavailable");try{string[] a=new string[n];for(int i=0;i<n;i++)a[i]=Marshal.PtrToStringUni(Marshal.ReadIntPtr(p,i*IntPtr.Size));return a;}finally{LocalFree(p);}} }';
+  return powershell('Add-Type -TypeDefinition ' + literal(source) + '; $taskP=Get-CimInstance Win32_Process -Filter ' + literal('ProcessId=' + pid) + '; if(-not $taskP){throw "Host exited"}; ConvertTo-Json -InputObject @([AnnotatableArgs]::Read($taskP.CommandLine)) -Compress');
+}
+async function listeners(binary) {
+  var filter = binary ? ' | Where-Object { $_.ExecutablePath -eq ' + literal(binary) + ' }' : '';
+  return powershell('$taskPs=@(Get-CimInstance Win32_Process' + filter + '); $taskPorts=@(Get-NetTCPConnection -State Listen -ErrorAction SilentlyContinue); ' +
+    '@($taskPs | ForEach-Object { $taskP=$_; $taskOwn=@($taskPorts | Where-Object OwningProcess -eq $taskP.ProcessId); if($taskOwn.Count){ @{ process=($taskP | Select-Object ' + fields() + '); ports=@($taskOwn | Select-Object -ExpandProperty LocalPort -Unique) } } }) | ConvertTo-Json -Depth 5 -Compress');
+}
+async function portOwner(port) {
+  var all = await listeners();
+  var found = (Array.isArray(all) ? all : all ? [all] : []).filter(x => x.ports.includes(Number(port)));
+  if (found.length !== 1) throw new Error('无法唯一确认本机服务进程');
+  return found[0].process;
+}
+async function released(owners) {
+  if (!Array.isArray(owners) || !owners.length) return { released: false, reason: 'missing-owner-evidence' };
+  for (var owner of owners) {
+    var current = await processInfo(owner.ProcessId);
+    if (sameProcess(owner, current)) return { released: false, reason: 'desktop-process-alive', pid: owner.ProcessId };
+  }
+  var main = owners[0];
+  var present = await powershell('Get-CimInstance Win32_Process -Filter ' + literal("Name='" + String(main.Name).replace(/'/g, '') + "'") +
+    ' | Where-Object { $_.ExecutablePath -eq ' + literal(main.ExecutablePath) +
+    ' -or $_.ExecutablePath -match "[\\\\/]OpenAI\\.Codex_" } | Select-Object ' + fields() + ' | ConvertTo-Json -Compress');
+  if (present && (!Array.isArray(present) || present.length)) return { released: false, reason: 'desktop-starting-or-reopened' };
+  return { released: true, reason: 'recorded-desktop-processes-exited' };
+}
+async function pipeOwners(pipePath) {
+  if (process.platform !== 'win32' || !/^\\\\\.\\pipe\\/.test(pipePath || '')) throw new Error('需要可识别的 Windows 桌面管道');
+  var script = [
+    'Add-Type -TypeDefinition ' + literal('using System; using System.Runtime.InteropServices; using Microsoft.Win32.SafeHandles; public static class AnnotatablePipeOwner { [DllImport("kernel32.dll", SetLastError=true)] public static extern bool GetNamedPipeServerProcessId(SafePipeHandle handle, out uint pid); }') + ';',
+    '$taskName=[IO.Path]::GetFileName(' + literal(pipePath) + ');',
+    '$taskPipe=New-Object System.IO.Pipes.NamedPipeClientStream(".",$taskName,[System.IO.Pipes.PipeDirection]::InOut,[System.IO.Pipes.PipeOptions]::Asynchronous);',
+    'try { $taskPipe.Connect(2000); [uint32]$taskServerPid=0; if(-not [AnnotatablePipeOwner]::GetNamedPipeServerProcessId($taskPipe.SafePipeHandle,[ref]$taskServerPid)){ throw "Pipe owner unavailable" } } finally { $taskPipe.Dispose() };',
+    '$taskAll=@(Get-CimInstance Win32_Process); $taskServer=$taskAll | Where-Object ProcessId -eq $taskServerPid;',
+    '$taskMain=$taskServer; for($taskI=0;$taskI -lt 12;$taskI++){ if($taskMain.Name -match "^(ChatGPT|Codex)\\.exe$" -and $taskMain.CommandLine -notmatch "app-server|exec-server"){ break }; $taskParent=$taskAll | Where-Object ProcessId -eq $taskMain.ParentProcessId; if(-not $taskParent){break}; $taskMain=$taskParent };',
+    'if($taskMain.Name -notmatch "^(ChatGPT|Codex)\\.exe$" -or $taskMain.CommandLine -match "app-server|exec-server"){throw "Desktop main process not identified"};',
+    '$taskRuntimes=@($taskAll | Where-Object { $_.ParentProcessId -eq $taskMain.ProcessId -and $_.CommandLine -match "\\bapp-server\\b" -and $_.CommandLine -notmatch "managed-daemon" });',
+    'if($taskRuntimes.Count -eq 0){throw "Desktop runtime process not identified"};',
+    '@{ main=($taskMain | Select-Object ' + fields() + '); runtime=@($taskRuntimes | Select-Object ' + fields() + '); pipeServer=($taskServer | Select-Object ' + fields() + ') } | ConvertTo-Json -Depth 6 -Compress'
+  ].join(' ');
+  var result = await powershell(script);
+  result.owners = [result.main].concat(result.runtime);
+  return result;
+}
+function pipeCandidates(initialPipe) {
+  if (process.platform !== 'win32') return [initialPipe];
+  var directory = '\\\\.\\pipe\\';
+  var name = String(initialPipe || '').slice(directory.length);
+  // The application prefix is stable; process numbers and restart suffixes are not.
+  var prefix = name.replace(/[-_][a-f0-9]{8}-(?:[a-f0-9]{4}-){3}[a-f0-9]{12}$/i, '');
+  if (prefix === name) prefix = name.replace(/(?:[-_](?:\d+|[a-f0-9]{8,}))+$/i, '');
+  if (!prefix || prefix === name) prefix = name.split(/[-_]/).slice(0, 3).join('-');
+  var entries;
+  try { entries = fs.readdirSync(directory); } catch (_) { return [initialPipe]; }
+  return Array.from(new Set([initialPipe].concat(entries.filter(function (entry) {
+    return entry.indexOf(prefix) === 0;
+  }).map(function (entry) { return directory + entry; }))));
+}
+function windowsArgument(value) {
+  value = String(value);
+  return '"' + value.replace(/(\\*)"/g, '$1$1\\"').replace(/(\\+)$/, '$1$1') + '"';
+}
+async function spawnIndependent(executable, args, cwd) {
+  if (process.platform !== 'win32') throw new Error('独立后台启动尚未在此系统验证');
+  var command = [executable].concat(args).map(windowsArgument).join(' ');
+  var result = await powershell([
+    '$taskEnv=[string[]]@([Environment]::GetEnvironmentVariables("Process").GetEnumerator() | ForEach-Object { "$($_.Key)=$($_.Value)" });',
+    '$taskStartup=New-CimInstance -ClassName Win32_ProcessStartup -ClientOnly -Property @{ShowWindow=[uint16]0;CreateFlags=[uint32]1032;EnvironmentVariables=$taskEnv};',
+    '$taskCreated=Invoke-CimMethod -ClassName Win32_Process -MethodName Create -Arguments @{CommandLine=' + literal(command) + ';CurrentDirectory=' + literal(cwd) + ';ProcessStartupInformation=$taskStartup};',
+    '$taskCreated | Select-Object ReturnValue,ProcessId | ConvertTo-Json -Compress'
+  ].join(' '));
+  if (!result || result.ReturnValue !== 0 || !result.ProcessId) throw new Error('独立后台程序未启动：' + (result && result.ReturnValue));
+  return result.ProcessId;
+}
+
+// Shared framing, timeouts and lifecycle; each harness supplies only its wire format.
+class JsonProcess extends EventEmitter {
+  constructor(binary, args, options) {
+    super(); options = options || {}; this.protocol = options.protocol || {};
+    this.pending = new Map(); this.nextId = 0; this.stderr = '';
+    this.child = cp.spawn(binary, args, { cwd: options.cwd, env: options.env || process.env, windowsHide: true, stdio: ['pipe', 'pipe', 'pipe'] });
+    this.child.stderr.on('data', b => { this.stderr = (this.stderr + b.toString('utf8')).slice(-6000); });
+    readline.createInterface({ input: this.child.stdout }).on('line', line => this.receive(line));
+    this.child.on('error', error => this.fail(error)); this.child.stdin.on('error', error => this.fail(error));
+    this.child.on('close', code => { this.ended = true; this.fail(new Error('宿主进程已退出：' + code)); this.emit('exit', code); });
+  }
+  fail(error) { this.failure = error; for (var p of this.pending.values()) { clearTimeout(p.timer); p.reject(error); } this.pending.clear(); }
+  send(message) { if (this.failure) throw this.failure; this.child.stdin.write(JSON.stringify(message) + '\n'); }
+  receive(line) {
+    var m; try { m = JSON.parse(line); } catch (_) { return; }
+    var response = this.protocol.response ? this.protocol.response(m) : (m.id !== undefined && !m.method ? { id: m.id, result: m.result, error: m.error } : null);
+    if (response) {
+      var p = this.pending.get(String(response.id)); if (!p) return;
+      this.pending.delete(String(response.id)); clearTimeout(p.timer);
+      if (response.error) p.reject(new Error('宿主请求失败：' + JSON.stringify(response.error))); else p.resolve(response.result);
+    } else if (this.protocol.isRequest ? this.protocol.isRequest(m) : m.id !== undefined) this.emit('serverRequest', m);
+    else this.emit('notification', m);
+  }
+  request(method, params) {
+    if (this.failure) return Promise.reject(this.failure);
+    return new Promise((resolve, reject) => {
+      var id = String(++this.nextId), timer = setTimeout(() => { this.pending.delete(id); reject(new Error(method + ' 超时，结果不确定')); }, 30000);
+      this.pending.set(id, { resolve: resolve, reject: reject, timer: timer });
+      try { this.send(this.protocol.request ? this.protocol.request(id, method, params) : { id: Number(id), method: method, params: params }); }
+      catch (error) { clearTimeout(timer); this.pending.delete(id); reject(error); }
+    });
+  }
+  async close() {
+    if (this.ended) return;
+    var done = new Promise(resolve => this.child.once('close', resolve));
+    this.child.stdin.end();
+    var timeout = setTimeout(() => { this.child.kill(); }, 3000); timeout.unref();
+    await done; clearTimeout(timeout);
+  }
+}
+
+module.exports = { processInfo: processInfo, sameProcess: sameProcess, released: released,
+  pipeOwners: pipeOwners, pipeCandidates: pipeCandidates, spawnIndependent: spawnIndependent,
+  identity: identity, ownersExited: ownersExited, argumentsFor: argumentsFor, listeners: listeners, portOwner: portOwner,
+  powershell: powershell, literal: literal, JsonProcess: JsonProcess, tailRows: tailRows, fileStamp: fileStamp, configStamps: configStamps, parents: parents, agentEnv: agentEnv };

package/lib/duty-worker.js

@@ -0,0 +1,5 @@
+'use strict';
+require('./duty').runWorker(process.argv[2]).catch(function (error) {
+  try { require('fs').appendFileSync(process.argv[2] + '.worker.log', new Date().toISOString() + ' pid=' + process.pid + ' ' + error.stack + '\n'); } catch (_) {}
+  console.error(error.message); process.exitCode = 1;
+});

package/lib/duty.js

@@ -0,0 +1,334 @@
+'use strict';
+
+// Explicit, page-scoped continuation. No global registry or system startup item.
+var fs = require('fs');
+var path = require('path');
+var core = require('./core');
+var processes = require('./duty-process');
+function canonicalPath(value) { return path.resolve(value).replace(/\\/g, '/').toLowerCase(); }
+function hostModule(host) {
+  if (!['codex', 'claude', 'opencode'].includes(host)) throw new Error('未知续接宿主');
+  return require('./' + host);
+}
+function publicHit(hit) { var result = Object.assign({}, hit); delete result.signature; return result; }
+function prompt(binding, hit, options) {
+  var cli = JSON.stringify(path.join(__dirname, '../bin/cli.js').replace(/\\/g, '/'));
+  var file = JSON.stringify(binding.file.replace(/\\/g, '/'));
+  var message = '【指定页面批注自动续接】本轮只处理用户指定页面，沿用原会话。\nPOLL_HIT ' + JSON.stringify(publicHit(hit)) + '\n' +
+    '用内置本地命令工具运行 node ' + cli + ' read ' + file + '，读取完整待回应批注。' +
+    '用文件写入工具将完整回复保存为当前目录 UTF-8 JSON 数组文件，格式 [{"id":"批注id","reply":"完整回复"}]；' +
+    '再运行 node ' + cli + ' reply ' + file + ' 回复文件路径。核对实际落盘后结束本轮。' +
+    '长文不要嵌进 shell 参数，不要手改 HTML 数据。明确要求改正文时使用同一 CLI 的 edit 命令。' +
+    '不改设置、不换模型、不扩大权限、不处理其他页面或聊天、不运行 Git。后台程序负责持续监听，不要重挂 poll 或启动第二个控制器。';
+  if (binding.host === 'claude' && binding.bridge && binding.bridge.nativeHook && !(options && options.headless)) {
+    message += '原生钩子会自动接回后续通知。答完结束本轮，不运行 duty、--listen 或安装设置。';
+  } else if (binding.host === 'claude' && !(options && options.headless)) {
+    message += '本通知进程以退出码 1 结束是正常命中。答完用 Bash 的 run_in_background=true 重新执行 node ' + cli + ' duty ' + file +
+      ' --claude --listen --claude-session ' + binding.threadId + '，接回当前原会话的通知。若返回 DUTY_STOPPED，表示用户已停止，结束监听，不重新注册。';
+  }
+  return message;
+}
+
+function alive(pid) { if (!Number.isInteger(pid) || pid < 1) return false; try { process.kill(pid, 0); return true; } catch (e) { return e.code !== 'ESRCH'; } }
+function readJson(file) { try { return JSON.parse(fs.readFileSync(file, 'utf8')); } catch (e) { if (e.code === 'ENOENT') return null; throw e; } }
+function atomicJson(file, value) {
+  fs.mkdirSync(path.dirname(file), { recursive: true });
+  var temp = file + '.tmp-' + process.pid;
+  fs.writeFileSync(temp, JSON.stringify(value, null, 2) + '\n');
+  fs.renameSync(temp, file);
+}
+function pathsFor(file) {
+  var base = path.join(path.dirname(file), '.annotatable', path.basename(file));
+  var legacy = base + '.codex-duty'; base += '.duty';
+  if (!fs.existsSync(base + '.json') && fs.existsSync(legacy + '.json')) base = legacy;
+  return { binding: base + '.json', state: base + '.state.json' };
+}
+function docId(file) { var id = core.docIdOf(fs.readFileSync(file, 'utf8')); if (!id) throw new Error('页面缺少文档标识'); return id; }
+function mutateBinding(file, change) {
+  return core.withDocLock(file, function () {
+    var target = pathsFor(file).binding, current = readJson(target), next = change(current);
+    if (next) atomicJson(target, next);
+    return next || current;
+  });
+}
+function pending(file) {
+  var store = core.readStore(fs.readFileSync(file, 'utf8'));
+  if (!store) throw new Error('NO_STORE');
+  var annotations = store.annotations.filter(a => a.status !== 'answered' && core.hasUserText(a));
+  var replay = store.control && store.control.replay;
+  var signature = JSON.stringify({ questions: annotations.map(a => ({ id: a.id, user: (a.thread || []).filter(t => t.role === 'user').map(t => t.text), comment: a.comment })), replay: replay || null });
+  return { file: file, rev: store.rev, pending: annotations.length, ids: annotations.map(a => a.id), created: annotations.map(a => a.created || 0), replay: replay || null, signature: signature };
+}
+function completed(file, ids) {
+  var store = core.readStore(fs.readFileSync(file, 'utf8'));
+  return !!store && ids.every(id => {
+    var a = store.annotations.find(a => a.id === id);
+    if (!a) return true; // A human may delete a question while it is being handled.
+    var last = (a.thread || []).slice(-1)[0];
+    return a.status === 'answered' && last && last.role === 'ai' && !last.streaming && !!String(last.text || '').trim();
+  });
+}
+function acquire(file, metadata) {
+  fs.mkdirSync(path.dirname(file), { recursive: true });
+  for (var i = 0; i < 2; i++) {
+    try {
+      var fd = fs.openSync(file, 'wx');
+      fs.writeFileSync(fd, JSON.stringify(Object.assign({}, metadata, { pid: process.pid }))); fs.closeSync(fd);
+      return function () { var owner = readJson(file); if (owner && owner.pid === process.pid) fs.unlinkSync(file); };
+    } catch (error) {
+      if (error.code !== 'EEXIST') throw error;
+      var owner = readJson(file);
+      if (!owner || !Number.isInteger(owner.pid) || alive(owner.pid)) throw new Error('此会话已有续接进程或锁状态不明');
+      fs.unlinkSync(file);
+    }
+  }
+  throw new Error('无法获得会话处理权');
+}
+async function register(file, options) {
+  options = options || {};
+  if (process.platform !== 'win32') throw new Error('自动续接目前只在 Windows 验证；其他系统请继续使用 poll');
+  if (typeof WebSocket !== 'function' || typeof fetch !== 'function') throw new Error('自动续接需要 Node.js 22+');
+  if (options.pageContext && options.pageContext.protocol !== 'http:') throw new Error('自动续接目前只支持本机 HTTP 页面；HTTPS 请用本地文件路径注册');
+  var port = options.port === undefined ? 0 : Number(options.port);
+  if (!Number.isInteger(port) || port < 0 || port > 65535) throw new Error('--port 必须是 0 到 65535 的整数');
+  file = fs.realpathSync(path.resolve(file));
+  var files = pathsFor(file), old = readJson(files.binding), oldState = readJson(files.state);
+  if (oldState && oldState.headless && alive(oldState.headless.pid)) throw new Error('无头任务仍在运行；完成后才能交还原宿主');
+  var host = options.host || 'codex', details = await hostModule(host).dutyBinding(file, options);
+  var threadId = details.threadId;
+  if (old && (old.threadId !== threadId || (old.host || 'codex') !== host) && oldState && alive(oldState.pid)) throw new Error('该页面已绑定另一条运行中的聊天');
+  var serverRoot = fs.realpathSync(options.pageContext ? options.pageContext.root : (old && old.serverRoot || path.dirname(file)));
+  var pagePath = options.pageContext ? options.pageContext.pagePath : (old && old.pagePath || '/' + path.basename(file));
+  var relative = path.relative(serverRoot, file);
+  if (relative === '..' || relative.startsWith('..' + path.sep) || path.isAbsolute(relative) ||
+      !pagePath.startsWith('/') || canonicalPath(path.resolve(serverRoot, '.' + pagePath)) !== canonicalPath(file)) throw new Error('页面地址与服务目录不一致');
+  if (oldState && alive(oldState.pid) && ((port && port !== oldState.serverPort) ||
+      serverRoot !== (old.serverRoot || path.dirname(file)) || pagePath !== (old.pagePath || '/' + path.basename(file)))) throw new Error('请先停止该页续接，再更改服务地址或端口');
+  var binding = Object.assign({}, details, { host: host, file: file, docId: docId(file), port: port, serverRoot: serverRoot, pagePath: pagePath,
+    generation: (old && old.generation || 0) + 1, stopRequested: false,
+    lockFile: old && (old.host || 'codex') === host && old.threadId === threadId ? old.lockFile :
+      path.join(details.settings.cwd, '.annotatable', 'duty-' + host + '-' + threadId + '.lock'), registeredAt: Date.now() });
+  var locked = readJson(binding.lockFile);
+  if (locked && alive(locked.pid) && (!oldState || oldState.pid !== locked.pid)) throw new Error('此聊天已有其他页面的续接控制器；不会并行启动');
+  var bridgeOwner = details.claude && details.claude.owners[0];
+  var alreadyListening = !!(old && old.bridge && alive(old.bridge.ProcessId) && (!bridgeOwner || processes.sameProcess(old.bridge.owner, bridgeOwner)));
+  if (options.events) binding.bridge = alreadyListening ? old.bridge : Object.assign(processes.identity(await processes.processInfo(process.pid)),
+    { owner: bridgeOwner, deliveredSequence: old && old.bridge && processes.sameProcess(old.bridge.owner, bridgeOwner) ? old.bridge.deliveredSequence || 0 : 0 });
+  mutateBinding(file, function (latest) {
+    if ((latest && latest.generation) !== (old && old.generation)) throw new Error('续接绑定已被其他操作更改，请重新检查状态');
+    if (host === 'claude') hostModule(host).installResumeHooks(binding);
+    if (locked && oldState && locked.pid === oldState.pid && alive(locked.pid)) atomicJson(binding.lockFile, Object.assign({}, locked, { bindingFile: files.binding }));
+    return binding;
+  });
+  if (oldState && oldState.phase !== 'stopped' && alive(oldState.pid)) return { attached: true, pid: oldState.pid, binding: files.binding, pageUrl: oldState.pageUrl, alreadyListening: alreadyListening };
+  var pid = await processes.spawnIndependent(process.execPath, [path.join(__dirname, 'duty-worker.js'), files.binding], details.settings.cwd);
+  var deadline = Date.now() + 10000;
+  for (;;) {
+    var started = readJson(files.state);
+    if (started && started.pid === pid && started.pageUrl) break;
+    if (!alive(pid) || Date.now() > deadline) throw new Error('后台续接程序未确认启动；请查看 --status');
+    await new Promise(resolve => setTimeout(resolve, 200));
+  }
+  return { attached: false, pid: pid, binding: files.binding, pageUrl: started.pageUrl, alreadyListening: alreadyListening };
+}
+function status(file) {
+  var files = pathsFor(path.resolve(file));
+  var binding = readJson(files.binding), state = readJson(files.state);
+  return { registered: !!binding, running: !!(state && alive(state.pid)), threadId: binding && binding.threadId, state: state };
+}
+function stop(file) {
+  var binding = mutateBinding(path.resolve(file), function (current) {
+    if (!current) return;
+    current.stopRequested = true; current.generation++; return current;
+  });
+  return binding ? { stopRequested: true, waitsForActiveRun: true } : { registered: false };
+}
+async function listen(file, options) {
+  file = fs.realpathSync(path.resolve(file)); options = options || {};
+  var files = pathsFor(file), initial = readJson(files.binding);
+  if (!initial || initial.stopRequested) return { stopped: true };
+  if (initial.host !== 'claude') throw new Error('--listen 只用于 Claude 原会话的通知任务');
+  var details = await hostModule('claude').dutyBinding(file, options);
+  if (details.threadId !== initial.threadId) throw new Error('通知任务与已注册的原会话不一致');
+  var bridge = Object.assign(processes.identity(await processes.processInfo(process.pid)), { owner: details.claude.owners[0], nativeHook: !!options.nativeHook });
+  var oldBridge = initial.bridge && await processes.processInfo(initial.bridge.ProcessId);
+  var stopped = false, alreadyListening = false;
+  var binding = mutateBinding(file, function (current) {
+    if (!current || current.stopRequested) { stopped = true; return; }
+    if (current.threadId !== details.threadId || current.host !== 'claude') throw new Error('续接绑定已改变');
+    var state = readJson(files.state);
+    if (!state || !alive(state.pid)) throw new Error('续接控制器已停止；请检查状态后显式注册');
+    if (current.generation !== initial.generation && current.bridge && alive(current.bridge.ProcessId) && processes.sameProcess(current.bridge.owner, bridge.owner)) { alreadyListening = true; return; }
+    alreadyListening = !!(current.bridge && processes.sameProcess(current.bridge, oldBridge) && processes.sameProcess(current.bridge.owner, bridge.owner));
+    if (alreadyListening) return;
+    bridge.deliveredSequence = current.bridge && processes.sameProcess(current.bridge.owner, bridge.owner) ? current.bridge.deliveredSequence || 0 : 0;
+    current.bridge = bridge; current.generation++; return current;
+  });
+  return { stopped: stopped, alreadyListening: alreadyListening, threadId: binding && binding.threadId };
+}
+
+class DutyController {
+  constructor(binding, adapters) {
+    this.binding = binding; this.adapters = adapters; this.state = adapters.previous || {};
+    this.state.host = binding.host || 'codex'; this.state.pid = process.pid; this.state.threadId = binding.threadId; this.state.file = binding.file;
+    this.state.phase = 'starting'; this.state.runs = this.state.runs || [];
+    this.registration(binding);
+    this.generation = binding.generation; this.offlineObservations = 0;
+  }
+  persist() { this.state.updatedAt = Date.now(); this.adapters.save(this.state); }
+  registration(binding) {
+    if (binding.registeredAt !== this.state.registeredAt) {
+      this.state.blockedSignature = null; this.state.notifiedSignature = null; delete this.state.error;
+      this.state.registeredAt = binding.registeredAt;
+    }
+  }
+  async tick() {
+    if (this.busy) return;
+    this.busy = true;
+    try {
+      var binding = this.adapters.load();
+      if (!binding || binding.threadId !== this.binding.threadId || binding.file !== this.binding.file || binding.docId !== this.binding.docId) throw new Error('续接绑定发生变化，停止自动处理');
+      this.binding = binding;
+      this.registration(binding); this.generation = binding.generation;
+      if (this.state.headless && alive(this.state.headless.pid)) { this.state.phase = 'waiting-for-existing-headless'; this.persist(); return; }
+      if (binding.stopRequested) { this.state.phase = 'stopped'; this.state.owner = 'none'; this.persist(); return; }
+      if (docId(binding.file) !== binding.docId) throw new Error('文档标识已改变，保留批注并停止处理');
+      var hit = this.adapters.pending();
+      var desktop = await this.adapters.online();
+      if (this.adapters.load().stopRequested) { this.state.phase = 'stopped'; this.state.owner = 'none'; this.persist(); return; }
+      if (desktop && desktop.available) {
+        this.offlineObservations = 0; this.state.phase = 'desktop'; this.state.owner = 'desktop';
+        if (hit.pending || hit.replay) {
+          if (desktop.active) this.state.phase = 'waiting-for-desktop-turn';
+          else if (hit.signature !== this.state.notifiedSignature && hit.signature !== this.state.blockedSignature) {
+            // Mark before sending: uncertain delivery must not cause duplicates.
+            this.state.notifiedSignature = hit.signature;
+            this.state.notification = { sequence: (this.state.notification && this.state.notification.sequence || 0) + 1, signature: hit.signature, hit: publicHit(hit) }; this.persist();
+            await desktop.notify(publicHit(hit));
+            this.state.lastNotificationAt = Date.now();
+          }
+        } else this.state.notifiedSignature = null;
+        this.persist(); return;
+      }
+      var release = await this.adapters.released();
+      if (!release.released) { this.state.phase = 'waiting-for-desktop-release'; this.state.reason = release.reason; this.persist(); return; }
+      this.offlineObservations++;
+      this.state.owner = 'none'; this.state.phase = 'desktop-offline';
+      if (hit.signature === this.state.blockedSignature) { this.state.phase = 'needs-attention'; this.persist(); return; }
+      if (!(hit.pending || hit.replay) || this.offlineObservations < 2) { this.persist(); return; }
+      // A second probe immediately precedes taking ownership.
+      var returned = await this.adapters.online();
+      if (returned && returned.available) { this.offlineObservations = 0; this.persist(); return; }
+      if (!(await this.adapters.released()).released) { this.persist(); return; }
+      if (this.adapters.load().stopRequested) { this.state.phase = 'stopped'; this.state.owner = 'none'; this.persist(); return; }
+      hit = this.adapters.pending();
+      if (!(hit.pending || hit.replay)) { this.persist(); return; }
+      if (hit.signature === this.state.blockedSignature) { this.state.phase = 'needs-attention'; this.persist(); return; }
+      this.state.owner = 'headless'; this.state.phase = 'headless'; this.state.notifiedSignature = null; this.persist();
+      try {
+        var run = await this.adapters.headless(hit, info => { this.state.headless = info; this.persist(); });
+        this.state.runs.push(run);
+        if (!this.adapters.completed(hit.ids) || (hit.replay && this.adapters.pending().replay)) throw new Error('无头轮次结束，但页面仍无完整落盘回复或正文重做仍未处理');
+        this.state.phase = 'desktop-offline'; this.state.lastReplyAt = Date.now(); this.state.blockedSignature = null; delete this.state.error;
+      } catch (error) {
+        if (error.dutyRun) this.state.runs.push(error.dutyRun);
+        this.state.error = error.message; this.state.phase = 'needs-attention'; this.state.blockedSignature = hit.signature;
+      } finally { this.state.headless = null; this.state.owner = 'none'; this.persist(); }
+    } finally { this.busy = false; }
+  }
+}
+
+class PageService {
+  constructor(binding, previous) {
+    this.binding = binding; this.root = binding.serverRoot || path.dirname(binding.file);
+    this.pagePath = binding.pagePath || '/' + path.basename(binding.file);
+    this.port = binding.port || (previous && previous.serverPort) || 0;
+  }
+  get url() { return 'http://localhost:' + this.port + this.pagePath.split('/').map(encodeURIComponent).join('/'); }
+  async ensure() {
+    if (this.owned) return;
+    if (this.port) {
+      try {
+        var response = await fetch('http://127.0.0.1:' + this.port + '/__annot/context?path=' + encodeURIComponent(this.pagePath), { signal: AbortSignal.timeout(1500) });
+        if (response.ok) {
+          var context = await response.json();
+          if (canonicalPath(context.file) !== canonicalPath(this.binding.file) || context.docId !== this.binding.docId ||
+              canonicalPath(context.root) !== canonicalPath(this.root)) throw new Error('指定端口属于其他文档或服务目录，停止续接');
+          return;
+        }
+        throw new Error('指定端口不是此页面的批注服务');
+      } catch (error) { if (/指定端口/.test(error.message)) throw error; }
+    }
+    this.owned = await require('./serve').start(this.root, this.port, { managed: true });
+    this.port = this.owned.port;
+  }
+  async close() { if (this.owned) { await this.owned.close(); this.owned = null; } }
+}
+
+async function events(file, options) {
+  options = options || {};
+  var files = pathsFor(path.resolve(file)), last = 0;
+  var initial = readJson(files.binding), owner = initial && initial.bridge && initial.bridge.owner;
+  for (;;) {
+    var binding = readJson(files.binding), state = readJson(files.state);
+    if (binding && binding.stopRequested) { if (!options.hook) console.error('DUTY_STOPPED 用户已停止，不自动重新启动'); return; }
+    if (!binding || !binding.bridge || binding.bridge.ProcessId !== process.pid) return;
+    if (owner && !alive(owner.ProcessId)) return;
+    if (!state || !alive(state.pid)) throw new Error('续接控制器已停止');
+    var notification = state.notification;
+    if (notification && notification.sequence !== last) {
+      last = notification.sequence;
+      var hit = pending(binding.file);
+      if (notification.sequence > (binding.bridge.deliveredSequence || 0) && (hit.pending || hit.replay) && hit.signature === notification.signature) {
+        var claimed;
+        mutateBinding(binding.file, function (current) {
+          if (!current || current.stopRequested || !current.bridge || current.bridge.ProcessId !== process.pid ||
+              (current.bridge.deliveredSequence || 0) >= notification.sequence || pending(current.file).signature !== notification.signature) return;
+          current.bridge.deliveredSequence = notification.sequence; current.generation++; claimed = current; return current;
+        });
+        if (!claimed) continue;
+        console.log(prompt(claimed, hit).replace(/\n/g, ' '));
+        process.exitCode = options.exitCode || 1; return;
+      }
+    }
+    await new Promise(resolve => setTimeout(resolve, 500));
+  }
+}
+async function runWorker(configFile) {
+  var binding = readJson(configFile);
+  if (!binding) throw new Error('缺少续接绑定');
+  var files = pathsFor(binding.file), releaseLock = acquire(binding.lockFile, { bindingFile: configFile });
+  var previous = readJson(files.state), pageServer = new PageService(binding, previous);
+  function updateBinding(next) {
+    var updated = false;
+    binding = mutateBinding(binding.file, function (latest) {
+      if (!latest || latest.generation !== next.generation) return;
+      updated = true; return next;
+    });
+    return updated;
+  }
+  var host = hostModule(binding.host || 'codex').createDutyAdapter(() => binding, updateBinding);
+  var onSignal = () => stop(binding.file);
+  process.on('SIGTERM', onSignal); process.on('SIGINT', onSignal);
+  var controller = new DutyController(binding, { previous: previous, load: () => (binding = readJson(configFile)),
+    pending: () => pending(binding.file), completed: ids => completed(binding.file, ids),
+    online: () => host.online(), released: () => host.released(),
+    headless: (hit, onStart) => host.run(hit, onStart), save: state => { atomicJson(files.state, state); } });
+  try {
+    await pageServer.ensure();
+    controller.state.serverPort = pageServer.port; controller.state.pageUrl = pageServer.url; controller.persist();
+    while (controller.state.phase !== 'stopped') {
+      try { await pageServer.ensure(); await controller.tick(); }
+      catch (error) { controller.state.phase = 'needs-attention'; controller.state.error = error.message; controller.persist(); }
+      core.writeWatchBeat(binding.file, ['needs-attention', 'stopped'].includes(controller.state.phase) ? 'handoff' : 'watching', controller.state.startedAt || (controller.state.startedAt = Date.now()));
+      if (controller.state.phase !== 'stopped') await new Promise(resolve => setTimeout(resolve, 2000));
+    }
+  } finally {
+    try { host.close(); } finally { releaseLock(); await pageServer.close(); core.writeWatchBeat(binding.file, 'handoff'); }
+    process.removeListener('SIGTERM', onSignal); process.removeListener('SIGINT', onSignal);
+  }
+}
+
+module.exports = { register: register, status: status, stop: stop, listen: listen, runWorker: runWorker,
+  DutyController: DutyController, pending: pending, completed: completed, pathsFor: pathsFor,
+  acquire: acquire, atomicJson: atomicJson, alive: alive, PageService: PageService, events: events, prompt: prompt, publicHit: publicHit, canonicalPath: canonicalPath };