annotatable-html 0.0.0-stage → 1.45.3

package/bin/cli.js

@@ -0,0 +1,323 @@
+#!/usr/bin/env node
+'use strict';
+
+/* annotatable-html 命令行入口
+ *   annotatable init [dir]                    导出目录内工具、模板与主题
+ *   annotatable new <名称.html> [--template 路径]
+ *                                           新建可批注文档（自动应用目录内主题/自定义模板）
+ *   annotatable md <文件.md> [-o 输出.html] [--title 标题] [--template 路径]
+ *                                           一键 Markdown → 可批注 HTML（正文遵照原文，仅加批注层）
+ *   annotatable theme                       导出默认主题文件（annotatable.theme.css）供微调
+ *   annotatable studio [--port 端口]        打开可视化主题工坊（配色/字体/字号/页宽，实时预览）
+ *   annotatable template [名称.html]        导出内置模板供深度改造
+ *   annotatable template --use <文件.html>  把你的 HTML 一键设为全局默认模板（整页保留原样式）
+ *   annotatable template --reset            撤销全局默认模板，恢复内置
+ *   annotatable read <file.html>            列出待回应批注
+ *   annotatable reply <file.html> <replies.json>
+ *                                           写回 AI 回复（追加ai轮次+快照+rev+1）
+ *   annotatable poll <file.html> [--timeout 秒] [--interval 秒] [--exit-code N] [--exit-code-timeout N]
+ *                                           阻塞等待新批注（配后台任务：出批注即退出唤醒；退出码按 harness 选——zcode 默认 0/3，Claude Code 等非零才唤醒 → --exit-code 1）
+ *   annotatable poll <file.html> --codex      用官方会话接口通知当前 Codex（Node.js 22+）
+ */
+
+var path = require('path');
+var core = require('../lib/core.js');
+
+var args = process.argv.slice(2);
+/* 短旗标 -o 等价 --out。 */
+args = args.map(function (a) { return a === '-o' ? '--out' : a; });
+var cmd = args[0] || 'help';
+var positional = [], flags = {};
+var boolFlags = { zcode: true, claude: true, codex: true, opencode: true, reset: true, stdin: true, go: true, force: true, status: true, stop: true, listen: true, hook: true };
+for (var i = 1; i < args.length; i++) {
+  if (args[i].indexOf('--') === 0) {
+    var k = args[i].slice(2);
+    if (boolFlags[k]) { flags[k] = true; }
+    else if (args[i + 1] && args[i + 1].indexOf('--') !== 0) { flags[k] = args[i + 1]; i++; }   // 下一个是旗标时不当成值（--stream --id x）
+    else { flags[k] = ''; }
+  } else positional.push(args[i]);
+}
+
+/* 长文本（流式段落）经管道进：annotatable reply f.html --stream --stdin < 段落.txt */
+function readStdinSync() {
+  try { return require('fs').readFileSync(0, 'utf8'); } catch (e) { return ''; }
+}
+
+function usage() {
+  console.log([
+    'annotatable-html — 可批注 HTML：人类划线批注，AI agent 读批注回答',
+    '',
+    '用法:',
+    '  annotatable init [目录]                  导出 agent 工具、模板与主题；批注协议通过 skill 安装',
+    '  annotatable new <名称.html> [--template 路径] [--lang en]',
+    '                                           新建可批注文档（自动应用主题/自定义模板）',
+    '  annotatable md <文件.md> [-o 输出.html] [--title 标题] [--lang en]',
+    '                                           一键 Markdown → 可批注 HTML（正文遵照原文，仅加批注层）',
+    '  annotatable theme                        导出主题文件 annotatable.theme.css 供微调',
+    '  annotatable studio [--port 端口]          打开可视化主题工坊（配色/字体/字号/页宽，实时预览）',
+    '  annotatable template [名称.html]         导出内置模板供深度改造',
+    '  annotatable template --use <文件.html>   把你的 HTML 一键设为全局默认模板（整页保留原样式）',
+    '  annotatable template --reset             撤销全局默认模板，恢复内置',
+    '  annotatable skill [--zcode] [--claude] [--codex] [--opencode]   安装 skill（v1.40.0 默认投主流四家 harness',
+    '                                           的 skill 目录；slash 命令仅 zcode/claude）+ /html4agent 命令（任意目录触发）',
+    '  annotatable serve [目录] [--port N]      启动本地服务器（全自动保存，全浏览器支持；--port 0=系统挑空闲端口）',
+    '  annotatable inject <file.html>           给任意 HTML 注入批注层',
+  '  annotatable regen <活页.html> <图纸.html> [--go]  图纸页安全重建：报表手改清单，--go 上盘（store/DOC_ID 保留）',
+  '  annotatable upgrade <文件或目录>          旧层页批量静默换新层（read/reply/poll/serve 触达时也会自动做）',
+    '  annotatable read <file.html>             列出待回应批注（含对话线＋结构体检）',
+    '  annotatable reply <file.html> <replies.json>  写回 AI 回复（json 是文件路径，非内联）：[{"id":"..","reply":".."}]',
+    '  annotatable reply <file.html> --stream \'<段落>\' --id <批注id>',
+    '                                           流式追加一段回答（值守协议；不带 --id 自动接最近打开的流式轮；退出码 4=被打断 5=目标已删 6=人类编辑中，让路 7=没有打开中的流式轮）',
+    '  annotatable reply <file.html> --stream-end \'<全文>\' [--id <批注id>]',
+    '                                           收尾流式回答（全文替换段落累计，落快照）',
+    '  annotatable edit <file.html> <edits.json>   按批注指令改正文（json 是文件路径）：[{"id":"..","newText":".."}]',
+    '  annotatable answer <file.html> [json]    兼容既有 answers-store 数据（显式调用；非默认回复流程）',
+    '  annotatable poll <file.html> [--timeout 秒] [--interval 秒] [--exit-code N] [--exit-code-timeout N]',
+    '                                           阻塞等待新批注：有新批注打印 POLL_HIT 并退出唤醒 agent（默认命中 0/超时 3；',
+    '                                           Claude Code 等非零才唤醒的 harness → --exit-code 1，超时轮空不叫人再加 --exit-code-timeout 0），',
+    '  annotatable poll <file.html> --codex [--codex-thread ID] [--codex-bin 原生CLI路径]',
+    '                                           默认取 CODEX_THREAD_ID；桌面会话优先使用继承的本机工具连接，',
+    '                                           --codex-transport auto|desktop|app-server 选择入口；--codex-turn ID 指定来源轮次',
+    '  annotatable poll <file.html> --opencode [--opencode-url URL] [--opencode-session ID]',
+    '                                           OpenCode 异步会话通知；上下文插件自动传递地址和会话 ID',
+    '  annotatable duty <file.html> --codex|--claude|--opencode [--port N]  注册原会话自动续接（Windows、Node.js 22+）',
+    '                                           原宿主在线通知，确认退出后才无头回复；输出保存服务的页面地址',
+    '                                           Claude 用原生后台任务启动；可加 --claude-session ID、--claude-bin 路径',
+    '                                           Claude 的项目启动/结束钩子自动接回通知，重开原会话无需手动重挂',
+    '  annotatable duty <file.html> --status   查看注册、处理者与待办状态，不启动模型',
+    '  annotatable duty <file.html> --stop     停止续接；已有无头轮次完成后退出',
+    '',
+    '图纸页维护：纯文字改动直接 edit/手改，别整页重生成；必须重生成（改图/大改版）时走 regen：',
+    '先报表（默认），把手改同步进图纸后 --go 上盘。人类编辑模式中，回复退出码 6、regen 退出码 3——让路等收笔。',
+    'read/reply/edit/poll 可使用本机 localhost 页面地址；需要新版 annotatable serve 正在运行。',
+    '',
+    '典型循环: 人类在浏览器批注 → AI 运行 read → 生成 replies.json → 运行 reply → 人类刷新可见。'
+  ].join('\n'));
+}
+
+function runCommand() {
+try {
+  /* skill 副本过期自检（skill 命令自身就会刷新升级，不再提示） */
+  if (!flags.hook && ['init', 'new', 'md', 'theme', 'template', 'studio', 'inject', 'upgrade', 'regen', 'read', 'reply', 'edit', 'answer', 'poll', 'duty', 'serve'].indexOf(cmd) !== -1) {
+    var notice = core.staleSkillNotice(path.join(__dirname, '..'));
+    if (notice) (cmd === 'duty' && flags.claude && !flags.status && !flags.stop ? console.error : console.log)(notice);
+  }
+  if (cmd === 'init') {
+    if (Object.keys(flags).some(function (flag) { return /^agents-md(?:=|$)/.test(flag); })) {
+      throw new Error('init 不再写入 AGENTS.md；请运行 annotatable skill 安装批注工作流。');
+    }
+    core.initKit(positional[0] || process.cwd(), path.join(__dirname, '..'));
+  } else if (cmd === 'new') {
+    if (!positional[0]) { usage(); process.exit(2); }
+    core.newDoc(process.cwd(), positional[0], path.join(__dirname, '..'), { template: flags.template, lang: flags.lang });
+  } else if (cmd === 'md') {
+    if (!positional[0]) { usage(); process.exit(2); }
+    core.mdDoc(positional[0], { out: flags.out, title: flags.title, template: flags.template, lang: flags.lang }, path.join(__dirname, '..'));
+  } else if (cmd === 'theme') {
+    core.exportTheme(process.cwd(), path.join(__dirname, '..'));
+  } else if (cmd === 'template') {
+    if (flags.use) {
+      core.templateUse(flags.use, path.join(__dirname, '..'), {});
+    } else if (flags.reset) {
+      core.templateReset({});
+    } else {
+      core.exportTemplate(process.cwd(), positional[0], path.join(__dirname, '..'));
+    }
+  } else if (cmd === 'studio') {
+    var sServe = require('../lib/serve.js');
+    var sPort = parseInt(flags.port, 10);
+    if (isNaN(sPort)) sPort = 8974;
+    var sPkg = path.join(__dirname, '..');
+    sServe.start(process.cwd(), sPort, { studioProvider: function () { return core.studioHtml(sPkg); } })
+      .then(function (info) {
+        var url = info.url + '/__annot/studio';
+        console.log('🎨 主题工坊已启动: ' + url);
+        console.log('  左侧调配色/字体/字号/页宽，右侧实时预览（批注、导航窗格可直接试）。');
+        console.log('  调好后点「保存到当前目录」或「设为全局默认」，之后 new / md 自动应用。按 Ctrl+C 停止。');
+        try {
+          if (!process.env.ANNOT_NO_OPEN) {   // e2e 等无人值守场景置 1 跳过自动开浏览器
+            var opener = process.platform === 'win32' ? 'start "" "' + url + '"'
+              : process.platform === 'darwin' ? 'open "' + url + '"' : 'xdg-open "' + url + '"';
+            require('child_process').exec(opener, function () { /* 打不开就手动复制地址 */ });
+          }
+        } catch (e) { /* 同上 */ }
+      });
+  } else if (cmd === 'skill') {
+    core.installSkill({ zcode: flags.zcode, claude: flags.claude, codex: flags.codex, opencode: flags.opencode }, path.join(__dirname, '..'), flags.dir);
+  } else if (cmd === 'serve') {
+    var fs = require('fs');
+    var serve = require('../lib/serve.js');
+    var dir = positional[0] || process.cwd();
+    var port = parseInt(flags.port, 10);
+    if (isNaN(port)) port = 8973;   // --port 0 = 系统挑空闲端口（合法值，不能用 || 吞掉）
+    serve.start(dir, port).then(function (info) {
+      console.log('可批注文档服务器已启动: ' + info.url);
+      console.log('伺服目录: ' + info.root);
+      core.upgradeDir(info.root);   // v1.36.0 开服即扫目录：旧层页静默换新层（有升级会各打一行）
+      try {
+        fs.readdirSync(info.root).forEach(function (f) {
+          if (/\.html?$/i.test(f)) console.log('  文档 → ' + info.url + '/' + encodeURIComponent(f));
+        });
+      } catch (e) { /* 目录尚为空或未创建，浏览器访问时再列 */ }
+      console.log('服务器模式：批注自动保存进文件，无需绑定/授权。按 Ctrl+C 停止。');
+    });
+  } else if (cmd === 'inject') {
+    if (!positional[0]) { usage(); process.exit(2); }
+    core.injectHtml(positional[0], path.join(__dirname, '..'), { lang: flags.lang });
+  } else if (cmd === 'upgrade') {
+    if (!positional[0]) { usage(); process.exit(2); }
+    var fsU = require('fs');
+    var upT = path.resolve(positional[0]);
+    var upIsDir;
+    try { upIsDir = fsU.statSync(upT).isDirectory(); } catch (e) { throw new Error('路径不存在: ' + upT); }
+    if (upIsDir) {
+      var upN = core.upgradeDir(upT);
+      console.log(upN ? '✅ 静默升级完成：' + upN + ' 个旧层页已换新层。' : '没有需要升级的旧层页（已是最新或不可自动换装）。');
+    } else {
+      var upR = core.silentUpgrade(upT);
+      if (!upR || upR.status === 'skip') console.log('未升级：' + ((upR && upR.note) || '定位失败') + '（正文未动）');
+      else if (upR.status === 'current') console.log('✅ 已是当前层 v' + core.pkgVersion(path.join(__dirname, '..')) + '，无需升级');
+      else if (upR.status === 'error') console.log('⚠ ' + (upR.note || '升级失败'));
+    }
+  } else if (cmd === 'regen') {
+    if (!positional[0] || !positional[1]) { usage(); process.exit(2); }
+    var rg = core.regenDoc(positional[0], positional[1], { go: !!flags.go, force: !!flags.force });
+    if (rg.status === 'wordmode') {
+      console.log('WORD_MODE 人类编辑中（wordLock 旗鲜活）：重生成挂起，等收笔再跑');
+      process.exitCode = 3;
+    } else if (rg.status === 'manual-edits') {
+      console.log('MANUAL_EDITS 盘上有 ' + rg.lost.length + ' 行手改内容是图纸里没有的——直接上盘会盖掉它们：');
+      rg.lost.slice(0, 20).forEach(function (l) { console.log('  · ' + l.slice(0, 90)); });
+      console.log('  把手改同步进图纸、重出 fresh 后再 --go；确要丢弃手改加 --force（此报表已记名）');
+      process.exitCode = 2;
+    } else if (rg.status === 'clean') {
+      console.log('CLEAN 图纸与盘面对齐、无手改残留——加 --go 即可安全上盘');
+    } else if (rg.status === 'swapped') {
+      console.log('✅ 重生成上盘完成：store rev=' + rg.rev + '（' + rg.ann + ' 条批注）逐字节保留 · 备份 ' + rg.bak);
+    } else if (rg.status === 'stale' || rg.status === 'error') {
+      console.log('⚠ ' + (rg.note || rg.status));
+      process.exitCode = 1;
+    }
+  } else if (cmd === 'read') {
+    if (!positional[0]) { usage(); process.exit(2); }
+    core.readPending(positional[0]);
+  } else if (cmd === 'reply') {
+    var streaming = flags.stream !== undefined || flags['stream-end'] !== undefined;
+    if (positional.length > (streaming ? 1 : 2)) throw new Error('回复参数被拆成多段；长文本请通过 UTF-8 JSON 文件或 --stdin 传入。');
+    if (!positional[0]) { usage(); process.exit(2); }
+    var sText, sEnd = false;
+    if (flags.stream !== undefined) { sText = flags.stream; }
+    else if (flags['stream-end'] !== undefined) { sText = flags['stream-end']; sEnd = true; }
+    if (sText !== undefined) {
+      if (flags.stdin || sText === '--stdin') sText = readStdinSync();
+      var sr = core.streamReply(positional[0], { text: sText, id: flags.id, end: sEnd });
+      if (sr.status === 'ok') {
+        console.log((sr.done ? '✅ 回答完成' : sr.started ? '▶️ 流式回答开始' : '➕ 已追加段落') + ' · 批注 ' + sr.annId + ' · rev=' + sr.rev);
+        if (sr.closed && sr.closed.length) console.log('ℹ️ 顺手封轮（未收尾的遗留流式轮，文本保留）: ' + sr.closed.join(', '));
+      } else if (sr.status === 'wordmode') {
+        console.log('WORD_MODE 人类编辑中（wordLock 旗鲜活）：回答挂起不落盘，等收笔再发');
+        process.exitCode = 6;
+      } else if (sr.status === 'interrupted') {
+        console.log('INTERRUPTED 人类已按⏹停止（批注 ' + sr.annId + ' · rev=' + sr.rev + '）——本轮作答终止，不要再追加');
+        if (sr.closed && sr.closed.length) console.log('ℹ️ 顺手封轮（未收尾的遗留流式轮，文本保留）: ' + sr.closed.join(', '));
+        process.exitCode = 4;
+      } else if (sr.status === 'target-gone') {
+        console.log('TARGET_GONE 批注 ' + sr.annId + ' 已被删除——本轮作答终止');
+        process.exitCode = 5;
+      } else if (sr.status === 'empty') {
+        console.log('空段落：--stream 需要文本或 --stdin');
+        process.exitCode = 2;
+      } else {
+        console.log('NO_STREAM 没有打开中的流式回答——首段请带 --id 批注id（退出码 7）');
+        process.exitCode = 7;
+      }
+    } else {
+      if (!positional[1]) { usage(); process.exit(2); }
+      core.applyReplies(positional[0], positional[1]);
+    }
+  } else if (cmd === 'edit') {
+    if (!positional[0] || !positional[1]) { usage(); process.exit(2); }
+    core.applyEdits(positional[0], positional[1]);
+  } else if (cmd === 'duty') {
+    if (flags.hook) {
+      if (!flags.claude || flags.codex || flags.opencode || flags.listen || flags.stop || flags.status) throw new Error('--hook 只用于 Claude 原生事件');
+      var chunks = [], bytes = 0;
+      process.stdin.on('data', function (chunk) { bytes += chunk.length; if (bytes > 1024 * 1024) { console.error('DUTY_ERROR: hook 输入过大'); process.exit(1); } chunks.push(chunk); });
+      process.stdin.on('end', function () {
+        Promise.resolve().then(function () { return require('../lib/claude').resumeHook(JSON.parse(Buffer.concat(chunks).toString('utf8'))); })
+          .catch(function (error) { console.error('DUTY_ERROR: ' + error.message); process.exitCode = 1; });
+      });
+      return;
+    }
+    if (!positional[0]) { usage(); process.exit(2); }
+    var duty = require('../lib/duty.js');
+    if (flags.status) console.log(JSON.stringify(duty.status(positional[0]), null, 2));
+    else if (flags.stop) console.log(JSON.stringify(duty.stop(positional[0]), null, 2));
+    else {
+      var hosts = ['codex', 'claude', 'opencode'].filter(function (name) { return flags[name]; });
+      if (hosts.length !== 1) throw new Error('自动续接需显式选择一个宿主：--codex、--claude 或 --opencode');
+      var host = hosts[0];
+      if (flags.listen && host !== 'claude') throw new Error('--listen 只用于 Claude 的通知任务');
+      (flags.listen ? duty.listen : duty.register)(positional[0], { host: host, events: host === 'claude', codexThread: flags['codex-thread'], codexTurn: flags['codex-turn'],
+        codexBin: flags['codex-bin'], codexPipe: flags['codex-pipe'], claudeSession: flags['claude-session'], claudeBin: flags['claude-bin'],
+        opencodeUrl: flags['opencode-url'], opencodeSession: flags['opencode-session'], opencodeBin: flags['opencode-bin'], port: flags.port, pageContext: flags.dutyContext })
+        .then(function (result) {
+          if (result.stopped) { console.error('DUTY_STOPPED 用户已停止，不自动重新启动'); return; }
+          (host === 'claude' ? console.error : console.log)(host.toUpperCase() + '_DUTY_READY ' + JSON.stringify(result));
+          if (host === 'claude' && !result.alreadyListening) return duty.events(positional[0]);
+        })
+        .catch(function (error) { console.error('DUTY_ERROR: ' + error.message); process.exitCode = 1; });
+    }
+  } else if (cmd === 'answer') {
+    if (!positional[0]) { usage(); process.exit(2); }
+    if (!positional[1]) core.listAnswers(positional[0]);       // 旧数据的显式兼容入口
+    else core.applyAnswers(positional[0], positional[1]);
+  } else if (cmd === 'teach') {
+    throw new Error('教学模式已从批注工具移出；请使用独立教学工作流。批注回复使用 annotatable reply。');
+  } else if (cmd === 'poll') {
+    if (!positional[0]) { usage(); process.exit(2); }
+    if (flags.codex && flags.opencode) throw new Error('poll 一次只能选择 Codex 或 OpenCode');
+    var pollOpts = {
+      timeout: flags.timeout, interval: flags.interval,
+      exitCode: parseInt(flags['exit-code'], 10) || 0,
+      timeoutExitCode: flags['exit-code-timeout'] !== undefined ? parseInt(flags['exit-code-timeout'], 10) : undefined
+    };
+    if (flags.codex) {
+      pollOpts.codexThread = flags['codex-thread'];
+      pollOpts.codexBin = flags['codex-bin'];
+      pollOpts.codexTransport = flags['codex-transport'];
+      pollOpts.codexTurn = flags['codex-turn'];
+      require('../lib/codex.js').pollAnnotations(positional[0], pollOpts).catch(function (err) {
+        console.error('CODEX_NOTIFY_ERROR ' + (err.message || err));
+        process.exitCode = 1;
+      });
+    } else if (flags.opencode) {
+      pollOpts.opencodeUrl = flags['opencode-url'];
+      pollOpts.opencodeSession = flags['opencode-session'];
+      require('../lib/opencode.js').pollAnnotations(positional[0], pollOpts).catch(function (err) {
+        console.error('OPENCODE_NOTIFY_ERROR ' + (err.message || err));
+        process.exitCode = 1;
+      });
+    } else core.pollAnnotations(positional[0], pollOpts);
+  } else {
+    usage();
+  }
+} catch (e) {
+  console.error('错误: ' + (e.message || e));
+  process.exit(1);
+}
+}
+
+if (['read', 'reply', 'edit', 'answer', 'poll', 'duty'].indexOf(cmd) !== -1 && /^https?:\/\//i.test(positional[0] || '')) {
+  require('../lib/document.js').resolveDocument(positional[0], { includeContext: cmd === 'duty' }).then(function (file) {
+    if (cmd === 'duty') {
+      flags.dutyContext = file;
+      if (flags.port === undefined) flags.port = file.port;
+      positional[0] = file.file;
+    } else positional[0] = file;
+    runCommand();
+  }).catch(function (err) {
+    console.error('DOCUMENT_RESOLVE_ERROR ' + (err.message || err));
+    process.exitCode = 1;
+  });
+} else runCommand();

package/lib/claude.js

@@ -0,0 +1,242 @@
+'use strict';
+
+var fs = require('fs'), path = require('path'), os = require('os'), util = require('util');
+var processes = require('./duty-process');
+var canonical = value => path.resolve(value).replace(/\\/g, '/').toLowerCase();
+function registrations(home, sessionId) {
+  var dir = path.join(home, 'sessions');
+  if (!fs.existsSync(dir)) return [];
+  return fs.readdirSync(dir).filter(n => /^\d+\.json$/.test(n)).flatMap(n => {
+    try { var r = JSON.parse(fs.readFileSync(path.join(dir, n), 'utf8')); return (!sessionId || r.sessionId === sessionId) ? [r] : []; } catch (_) { return []; }
+  });
+}
+async function liveRegistrations(home, id) {
+  var live = [];
+  for (var r of registrations(home, id)) {
+    var p = await processes.processInfo(r.pid);
+    if (p && /^claude(?:\.exe)?$/i.test(p.Name) && Number(p.CreationDate.replace(/\/Date\((\d+)\)\//, '$1')) <= r.startedAt + 2000) live.push({ registration: r, process: p });
+  }
+  return live;
+}
+function transcript(home, id) {
+  var dir = path.join(home, 'projects');
+  var found = fs.existsSync(dir) ? fs.readdirSync(dir).map(n => path.join(dir, n, id + '.jsonl')).filter(n => fs.existsSync(n)) : [];
+  if (found.length !== 1) throw new Error('无法唯一定位指定 Claude 会话记录');
+  return found[0];
+}
+function savedTurn(file, id) {
+  var rows = processes.tailRows(file).filter(r => r.sessionId === id && !r.isSidechain);
+  var user = rows.findLast(r => r.type === 'user' && r.permissionMode);
+  var assistant = rows.findLast(r => r.type === 'assistant' && r.message && r.message.model);
+  if (!user || !assistant || !user.cwd) throw new Error('Claude 会话缺少可核对的模型、目录或权限');
+  return { model: assistant.message.model, cwd: user.cwd, permissionMode: user.permissionMode };
+}
+function resumeFlags(argv, cwd) {
+  var values = ['--allowedTools', '--allowed-tools', '--disallowedTools', '--disallowed-tools', '--add-dir', '--tools', '--settings', '--setting-sources', '--effort', '--agent', '--mcp-config', '--append-system-prompt', '--system-prompt', '--plugin-dir', '--betas'];
+  var boolean = ['--strict-mcp-config']; var result = [], files = [];
+  for (var i = 1; i < argv.length; i++) {
+    if (boolean.includes(argv[i])) { result.push(argv[i]); continue; }
+    var flag = argv[i].split('=')[0]; if (!values.includes(flag)) continue;
+    var inline = argv[i].includes('='), items = inline ? [argv[i].slice(flag.length + 1)] : [];
+    if (!inline && argv[i + 1] && !argv[i + 1].startsWith('-')) items.push(argv[++i]);
+    if (['--allowedTools', '--allowed-tools', '--disallowedTools', '--disallowed-tools', '--add-dir', '--tools', '--mcp-config', '--betas'].includes(flag)) {
+      while (!inline && argv[i + 1] && !argv[i + 1].startsWith('-')) items.push(argv[++i]);
+    }
+    if (!items.length) throw new Error('原 Claude 参数缺少值：' + flag);
+    if (flag === '--settings') {
+      items = items.map(value => {
+        if (value.trim().startsWith('{')) {
+          var parsed = JSON.parse(value);
+          if (parsed.env) {
+            if (Object.keys(parsed.env).some(k => process.env[k] !== String(parsed.env[k]))) throw new Error('请在原 Claude 会话内注册，以保留临时环境设置');
+            delete parsed.env; // Credentials stay in inherited memory, never in the binding file.
+          }
+          return JSON.stringify(parsed);
+        }
+        var file = path.resolve(cwd, value); files.push(file); return file;
+      });
+    }
+    if (flag === '--mcp-config') items = items.map(value => {
+      if (value.trim().startsWith('{')) throw new Error('临时内联 MCP 配置可能含凭据；请使用配置文件后在原会话重新注册');
+      var file = path.resolve(cwd, value); files.push(file); return file;
+    });
+    result.push(flag, ...items);
+  }
+  return { args: result, files: files };
+}
+function profileFiles(home, cwd, extra) {
+  return processes.configStamps(cwd, ['.claude/settings.json', '.claude/settings.local.json'], [path.join(home, 'settings.json')].concat(extra || []));
+}
+function providerContext(env) {
+  var base = new URL(env.ANTHROPIC_BASE_URL || 'https://api.anthropic.com');
+  if (base.username || base.password || base.search || base.hash) throw new Error('Claude 提供方地址不能含内嵌凭据或查询参数');
+  return { baseURL: base.href, bedrock: env.CLAUDE_CODE_USE_BEDROCK || '', vertex: env.CLAUDE_CODE_USE_VERTEX || '',
+    foundry: env.CLAUDE_CODE_USE_FOUNDRY || '', region: env.AWS_REGION || env.AWS_DEFAULT_REGION || '',
+    vertexProject: env.ANTHROPIC_VERTEX_PROJECT_ID || '', vertexRegion: env.CLOUD_ML_REGION || '' };
+}
+var hookStatus = 'annotatable-html duty listener';
+function hookCommand() {
+  return [process.execPath, path.join(__dirname, '../bin/cli.js'), 'duty', '--claude', '--hook'].map(value =>
+    "'" + value.replace(/\\/g, '/').replace(/'/g, "'\"'\"'") + "'").join(' ');
+}
+function updateHooks(binding, install) {
+  var core = require('./core'), file = path.join(binding.settings.cwd, '.claude', 'settings.local.json');
+  return core.withDocLock(file, function () {
+    var before = fs.existsSync(file) ? fs.readFileSync(file, 'utf8') : null, config = before ? JSON.parse(before) : {};
+    if (!config || Array.isArray(config) || typeof config !== 'object') throw new Error('Claude 项目设置必须为 JSON 对象');
+    if (install && (config.disableAllHooks || config.allowManagedHooksOnly)) throw new Error('原项目策略禁用了本地钩子，无法自动接回通知');
+    var events = ['SessionStart', 'Stop'], command = hookCommand(), changed = false;
+    config.hooks = config.hooks || {};
+    for (var event of events) {
+      var entries = config.hooks[event] || [], next = [];
+      for (var entry of entries) {
+        var hooks = entry.hooks.filter(h => !(h.type === 'command' && h.statusMessage === hookStatus));
+        if (hooks.length !== entry.hooks.length) changed = true;
+        if (hooks.length) next.push(Object.assign({}, entry, { hooks: hooks }));
+      }
+      if (install) {
+        var entry = { hooks: [{ type: 'command', command: command, asyncRewake: true, timeout: 2147483, statusMessage: hookStatus }] };
+        if (event === 'SessionStart') entry.matcher = 'startup|resume';
+        next.push(entry); changed = true;
+      }
+      if (next.length) config.hooks[event] = next; else delete config.hooks[event];
+    }
+    if (!Object.keys(config.hooks).length) delete config.hooks;
+    if (changed) {
+      var text = JSON.stringify(config, null, 2) + '\n';
+      if (before !== text) core.writeDocAtomic(file, text);
+    }
+    return { file: file, command: command };
+  });
+}
+function installResumeHooks(binding) {
+  binding.claude.resumeHook = updateHooks(binding, true);
+  binding.claude.files = binding.claude.files.map(x => processes.fileStamp(x.file));
+}
+function removeResumeHooks(binding) {
+  if (!binding.claude || !binding.claude.resumeHook) return;
+  var dir = path.dirname(binding.lockFile), duty = require('./duty');
+  for (var name of fs.existsSync(dir) ? fs.readdirSync(dir) : []) {
+    if (!/^duty-claude-[a-f0-9-]+\.lock$/i.test(name) || path.join(dir, name) === binding.lockFile) continue;
+    var lock = JSON.parse(fs.readFileSync(path.join(dir, name), 'utf8'));
+    if (duty.alive(lock.pid)) return; // A project uses one pair of hooks for all its registered sessions.
+  }
+  updateHooks(binding, false);
+}
+async function resumeHook(input) {
+  if (!input || !['SessionStart', 'Stop'].includes(input.hook_event_name) || !/^[a-f0-9]{8}-(?:[a-f0-9]{4}-){3}[a-f0-9]{12}$/i.test(input.session_id || '') || !input.cwd) return;
+  if (process.env.ANNOTATABLE_DUTY_HEADLESS_SESSION === input.session_id) return;
+  var lockFile = path.join(input.cwd, '.annotatable', 'duty-claude-' + input.session_id + '.lock');
+  if (!fs.existsSync(lockFile)) return;
+  var lock = JSON.parse(fs.readFileSync(lockFile, 'utf8')), duty = require('./duty');
+  if (!duty.alive(lock.pid) || !lock.bindingFile || !fs.existsSync(lock.bindingFile)) return;
+  var binding = JSON.parse(fs.readFileSync(lock.bindingFile, 'utf8'));
+  if (binding.host !== 'claude' || binding.threadId !== input.session_id || binding.stopRequested ||
+      !binding.claude.resumeHook || canonical(binding.settings.cwd) !== canonical(input.cwd) ||
+      canonical(binding.lockFile) !== canonical(lockFile) || canonical(duty.pathsFor(binding.file).binding) !== canonical(lock.bindingFile)) return;
+  var deadline = Date.now() + 10000, connected;
+  for (;;) {
+    try { connected = await duty.listen(binding.file, { claudeSession: input.session_id, events: true, nativeHook: true }); break; }
+    catch (error) { if (Date.now() >= deadline) throw error; await new Promise(resolve => setTimeout(resolve, 200)); }
+  }
+  if (!connected.stopped && !connected.alreadyListening) await duty.events(binding.file, { exitCode: 2, hook: true });
+}
+async function dutyBinding(file, options) {
+  var home = process.env.CLAUDE_CONFIG_DIR || path.join(os.homedir(), '.claude');
+  var id = options.claudeSession || process.env.CLAUDE_CODE_SESSION_ID || process.env.CLAUDE_SESSION_ID;
+  if (!id) {
+    var chain = await processes.parents(process.pid);
+    var candidates = registrations(home).filter(r => chain.some(p => p.ProcessId === r.pid));
+    if (candidates.length === 1) id = candidates[0].sessionId;
+  }
+  if (!/^[a-f0-9]{8}-(?:[a-f0-9]{4}-){3}[a-f0-9]{12}$/i.test(id || '')) throw new Error('Claude 续接需要明确的原会话编号；使用 --claude-session ID');
+  var matches = await liveRegistrations(home, id);
+  if (matches.length !== 1) throw new Error('请在原 Claude 会话仍运行时注册，无法确认唯一处理进程');
+  var owner = matches[0], record = transcript(home, id), saved = savedTurn(record, id);
+  var ancestry = chain || await processes.parents(process.pid), originalIndex = ancestry.findIndex(p => p.ProcessId === owner.process.ProcessId);
+  if (options.events && originalIndex < 0) throw new Error('请从原 Claude 会话的后台命令工具接上通知');
+  var bash = ancestry.slice(1, originalIndex < 0 ? 1 : originalIndex).find(p => /^bash(?:\.exe)?$/i.test(p.Name));
+  if (canonical(saved.cwd) !== canonical(owner.registration.cwd)) throw new Error('Claude 会话目录不一致');
+  var flags = resumeFlags(await processes.argumentsFor(owner.process.ProcessId), saved.cwd);
+  return { threadId: id, binary: options.claudeBin || owner.process.ExecutablePath, settings: saved,
+    claude: { home: home, transcript: record, args: flags.args, gitBashPath: bash && bash.ExecutablePath || process.env.CLAUDE_CODE_GIT_BASH_PATH || null,
+      provider: providerContext(process.env), files: profileFiles(home, saved.cwd, flags.files), owners: [processes.identity(owner.process)] } };
+}
+class ClaudeRpc extends processes.JsonProcess {
+  constructor(binding, options) {
+    var env = processes.agentEnv({ CLAUDE_CONFIG_DIR: binding.claude.home });
+    if (options && options.headless) env.ANNOTATABLE_DUTY_HEADLESS_SESSION = binding.threadId;
+    if (binding.claude.gitBashPath) env.CLAUDE_CODE_GIT_BASH_PATH = binding.claude.gitBashPath;
+    super(binding.binary, ['-p', options && options.fresh ? '--session-id' : '--resume', binding.threadId, '--input-format', 'stream-json', '--output-format', 'stream-json', '--verbose',
+      '--permission-prompt-tool', 'stdio', ...binding.claude.args, '--model', binding.settings.model, '--permission-mode', binding.settings.permissionMode], {
+      cwd: binding.settings.cwd, env: env,
+      protocol: { request: (id, subtype, params) => ({ type: 'control_request', request_id: id, request: Object.assign({ subtype: subtype }, params) }),
+        response: m => m.type === 'control_response' ? { id: m.response.request_id, result: m.response.response, error: m.response.subtype === 'error' ? m.response.error : null } : null,
+        isRequest: m => m.type === 'control_request' }
+    });
+  }
+}
+async function runHeadless(binding, hit, options) {
+  options = options || {};
+  if (!util.isDeepStrictEqual(savedTurn(binding.claude.transcript, binding.threadId), binding.settings) ||
+      !util.isDeepStrictEqual(binding.claude.files.map(x => processes.fileStamp(x.file)), binding.claude.files)) throw new Error('Claude 模型、权限或配置已改变，请重新注册');
+  if (!(await options.released()).released) throw new Error('原 Claude 进程尚未退出');
+  var rpc = options.rpc || new ClaudeRpc(binding, { headless: true }), record = { host: 'claude', threadId: binding.threadId, pid: rpc.child.pid, startedAt: Date.now() }, timer;
+  if (options.onStart) options.onStart(record);
+  var refusal, complete;
+  var done = new Promise((resolve, reject) => { complete = { resolve: resolve, reject: reject }; }); done.catch(function () {});
+  rpc.on('serverRequest', message => {
+    record.approval = { subtype: message.request.subtype, tool: message.request.tool_name || null };
+    rpc.send({ type: 'control_response', response: { subtype: 'success', request_id: message.request_id,
+      response: { behavior: 'deny', message: '无人值守保留待办，不扩大权限' } } });
+    refusal = 'Claude 需要人工审批或原宿主工具，保留待办'; rpc.request('interrupt', {}).catch(function () {});
+  });
+  rpc.on('notification', message => {
+    if (message.session_id && message.session_id !== binding.threadId) { complete.reject(new Error('Claude 返回其他会话')); return; }
+    if (message.type === 'system' && message.subtype === 'init') {
+      record.restored = { model: message.model, cwd: message.cwd, permissionMode: message.permissionMode };
+      record.shellTools = (message.tools || []).filter(name => ['Bash', 'PowerShell'].includes(name));
+      if (message.model !== binding.settings.model || message.permissionMode !== binding.settings.permissionMode || canonical(message.cwd) !== canonical(binding.settings.cwd)) { refusal = 'Claude 恢复设置不一致'; rpc.request('interrupt', {}).catch(function () {}); }
+    }
+    if (message.type === 'result') complete.resolve(message);
+  });
+  rpc.on('exit', () => complete.reject(new Error('Claude 在回复结束前退出')));
+  try {
+    await rpc.request('initialize', {});
+    var settings = await rpc.request('get_settings', {});
+    if (!settings.applied || settings.applied.model !== binding.settings.model || settings.errors && settings.errors.length) throw new Error('Claude 配置或模型预检失败');
+    if (binding.claude.provider && !util.isDeepStrictEqual(providerContext(Object.assign({}, process.env, settings.effective && settings.effective.env)), binding.claude.provider)) throw new Error('Claude 提供方不一致，保留待办');
+    if (!(await options.released(rpc.child.pid)).released) throw new Error('原 Claude 会话已重开，暂停无头执行');
+    record.effectivePermissions = settings.effective && settings.effective.permissions;
+    var turnPrompt = require('./duty').prompt(binding, hit, { headless: true });
+    if (binding.claude.gitBashPath) turnPrompt += '原会话使用 Bash；继续用 Bash 运行上述 node 命令，不切换命令工具。';
+    rpc.send({ type: 'user', session_id: binding.threadId, parent_tool_use_id: null,
+      message: { role: 'user', content: turnPrompt } });
+    timer = setTimeout(() => { refusal = 'Claude 回复超时'; rpc.request('interrupt', {}).catch(function () {}); complete.reject(new Error(refusal)); }, options.timeoutMs || 300000);
+    var result = await done;
+    if (refusal || !record.restored || result.is_error || result.subtype !== 'success') throw new Error(refusal || 'Claude 未成功完成回复');
+    record.outcome = 'completed'; return record;
+  } catch (error) { record.outcome = 'failed'; record.error = error.message; throw Object.assign(error, { dutyRun: record }); }
+  finally { clearTimeout(timer); await rpc.close(); record.finishedAt = Date.now(); }
+}
+function createDutyAdapter(getBinding, updateBinding) {
+  async function live() { var b = getBinding(); return liveRegistrations(b.claude.home, b.threadId); }
+  async function released(excludePid) {
+    var matches = (await live()).filter(x => x.process.ProcessId !== excludePid);
+    if (matches.length) return { released: false, reason: 'claude-session-process-alive' };
+    return processes.ownersExited(getBinding().claude.owners);
+  }
+  return {
+    online: async () => {
+      var b = getBinding(), matches = await live(); if (matches.length !== 1) return null;
+      if (!processes.sameProcess(b.claude.owners[0], matches[0].process)) updateBinding(Object.assign({}, b, { claude: Object.assign({}, b.claude, { owners: [processes.identity(matches[0].process)] }) }));
+      var connected = b.bridge && processes.sameProcess(b.bridge, await processes.processInfo(b.bridge.ProcessId));
+      return { available: true, active: !connected, notify: async () => {} }; // The original host consumes its own background task output.
+    },
+    released: released, run: (hit, onStart) => runHeadless(getBinding(), hit, { onStart: onStart, released: released }),
+    close: () => { var b = getBinding(); if (b.stopRequested) removeResumeHooks(b); }
+  };
+}
+module.exports = { dutyBinding: dutyBinding, createDutyAdapter: createDutyAdapter, ClaudeRpc: ClaudeRpc,
+  runHeadless: runHeadless, savedTurn: savedTurn, resumeFlags: resumeFlags, liveRegistrations: liveRegistrations,
+  installResumeHooks: installResumeHooks, removeResumeHooks: removeResumeHooks, resumeHook: resumeHook };