@givolt/i3-composer-agent 3.1.0 → 4.0.0

package/evals/fixtures/i3-ui-prototype/admin-list/readme.md

@@ -1,52 +0,0 @@
-# 管理列表内容模板
-
-双击 `index.html` 可离线查看；直接修改 HTML，再刷新页面即可预览。安装包中的文件是起点，日常编辑项目里的 `ui-templates/admin-list/` 工作副本；重新准备模板不会覆盖已有副本。
-
-## 首期内容投影
-
-同步后，新建的 Vue＋antDv-next 原型会把以下内容写入自己的 `app/public/prototype-config.json`，由真实组件读取并展示：
-
-- 页面首个 `h1` 标题，以及 `data-content-id="page-description"` 的说明。
-- 两个区域的首个 `h2`，分别作为列表与编辑标题。
-- 现有表头、筛选字段与编辑字段的可见标签。支持包裹式 `label`、`label for`、嵌套文字和 HTML 字符实体；`data-label` 可明确覆盖标签。
-- 已有输入框的 placeholder；设备名称必填规则继续保留。
-- 查询、重置、批量停用、编辑、保存、取消、上一页和下一页的可见文案。
-
-`page-id`、`region-id`、`field-id`、`action-id` 是稳定身份，改文案时保留它们。内容绑定在生成实例时固定；之后再改模板，只影响明确使用新模板创建的候选，不会更新已有原型。
-
-首期不是通用 HTML 到 Vue 编译器。新增或删除页面、区域、字段、操作，改字段含义、枚举值、数据模式、列顺序或行为参数时，需要主会话执行者明确适配框架代码、能力映射与验收。未知字段/操作、缺少首期必需项和删除名称必填会阻止初始化，避免内容静默消失。HTML 的 CSS 与普通 JS 只服务内容参考；生成工程采用真实框架样式和行为。
-
-示例行、选择框和数据状态下拉用于参考预览；固定 21 条设备数据及其状态逻辑由原型演示需求定义。分类、状态文案与数据枚举的变更需要显式业务映射，不凭选项文字自动猜测。
-
-## 同步与生成
-
-修改 HTML 后先执行 `sync-template.cjs <模板工作目录>`；只读核对使用 `--check`。不同宿主通过 i3-ui-prototype Skill 提供的统一入口运行这些步骤。同步会重新检查身份、能力参数和索引摘要；通过后才能创建新候选。索引是派生产物，不直接编辑。
-
-## 按本次需求启用四主题
-
-默认 HTML 不绑定主题，旧 HTML、v1 和未绑定主题的 v2 实例保持原行为。本次用户要求“明亮、暗黑、清新、科技，默认明亮，页面内选择”时，先准备项目工作副本，在 `devices/device-list` 下找到 `OPTIONAL_FOUR_THEMES` 注释，仅去掉包住 `aside` 的注释边界，保留这段内容：
-
-```html
-<aside data-capability-id="theme" data-capability-parameters='{"defaultTheme":"light","presets":["light","dark","fresh","tech"]}'>
-  页面主题：明亮、暗黑、清新、科技；首次默认明亮。
-</aside>
-```
-
-在本次 `scope.json` 的 `requirements` 中保留已有需求并追加下列结构；`source.reference` 填本次真实用户消息或需求文件的准确定位，`statement` 保留确认的需求原意：
-
-```json
-{
-  "id": "THEME-01",
-  "text": "页面可选择明亮、暗黑、清新、科技四主题，首次默认明亮",
-  "source": {
-    "type": "user",
-    "reference": "<本次真实需求的准确定位>",
-    "statement": "本次生成原型四主题可页面选择：明亮、暗黑、清新、科技，默认明亮"
-  },
-  "capabilities": [{"pageId":"devices","regionId":"device-list","capabilityId":"theme"}]
-}
-```
-
-同步、只读检查工作模板，再用该工作目录和 `--scope <本次scope.json>` 创建新实例。生成结果读取固定绑定，使用真实 antDv-next `ConfigProvider`、`Select` 和语义 token；页面与抽屉内均有主题选择，浮层跟随主题。离线 HTML 仍可双击编辑，这段文字本身不模拟原生换肤。
-
-固定验收从基础 20 项增加到 23 项；额外三项验证四主题效果、偏好持久化与隔离、可访问性，并核对第二页、筛选、选择和抽屉未保存输入保持。新模板不会更新旧实例；已有实例新增主题必须按已授权范围显式 `revise --accept-inputs`，不能只改运行配置。

package/evals/fixtures/i3-ui-prototype/admin-list/template.json

@@ -1,8 +0,0 @@
-{
-  "schemaVersion": 1,
-  "id": "admin-list",
-  "version": "1.0.0",
-  "title": "管理列表内容模板",
-  "entry": "index.html",
-  "definition": "capability-definition.json"
-}

package/evals/fixtures/i3-ui-prototype/business-brief.md

@@ -1,7 +0,0 @@
-# 设备采购申请原型
-
-用户明确选择模板模式。比较三套模板，并以企业管理后台模板制作可操作原型。
-申请包含设备名称、申请部门、数量、单价和用途。数量为正整数，单价大于零，计算总金额。
-申请人可编辑自己的草稿、提交申请；审批人可审批待审批记录，退回时必须填写原因；只读人员只能查看。
-覆盖表单校验、提交失败内容保留、审批通过和退回、无权限操作、空列表、键盘焦点与窄屏场景。
-交付需求映射、设计契约、启动方式和实际检查记录。没有浏览器条件时标记待验证。当前没有用户对任何原型版本的认可。

package/evals/zh-CN/cases/i3-ui-prototype.json

@@ -1,165 +0,0 @@
-{
-  "skill_name": "i3-ui-prototype",
-  "trigger": {
-    "positive": [
-      {
-        "prompt": "选择 UI 原型模板，制作一个可操作的申请审批交互原型供评审。",
-        "top_k": 1
-      },
-      {
-        "prompt": "根据业务需求生成可审查的交互原型，记录原型模板选择。",
-        "top_k": 1
-      },
-      {
-        "prompt": "检查原型一致性，与已确认的原型基线比较。",
-        "top_k": 1
-      },
-      {
-        "prompt": "根据评审反馈迭代交互原型，保留已确认的原型基线。",
-        "top_k": 1
-      },
-      {
-        "prompt": "参考这份可编辑 HTML 内容模板，用 Vue 3 和 antDv-next 生成设备管理交互原型。",
-        "top_k": 1
-      },
-      {
-        "prompt": "先分析内容模板与业务需求如何形成交互原型方案，不修改文件。",
-        "top_k": 1
-      },
-      {
-        "prompt": "根据反馈修改交互原型，保留我手改的代码并检查抽屉退出动画。",
-        "top_k": 1
-      },
-      {
-        "prompt": "请当前会话直接使用原型技能检查待评审候选，不启动其他智能体。",
-        "top_k": 1
-      },
-      {
-        "prompt": "请主会话根据 HTML 内容参考和业务说明分析交互原型方案，保持只读。",
-        "top_k": 1
-      }
-    ],
-    "negative": [
-      {
-        "prompt": "开发一个响应式前端页面，做好组件布局和无障碍交互。",
-        "owner": "i3-frontend-ui-engineering"
-      },
-      {
-        "prompt": "产品页面有一千条数据渲染很慢，请定位性能瓶颈并优化。",
-        "owner": "i3-performance-optimization"
-      },
-      {
-        "prompt": "昨天通过的测试现在失败，请复现并定位根因。",
-        "owner": "i3-debugging-and-error-recovery"
-      }
-    ]
-  },
-  "evals": [
-    {
-      "id": 1001,
-      "prompt": "根据提供的业务说明制作申请审批交互原型。明确使用模板模式，比较模板并生成待评审候选。不要自行批准原型。",
-      "expected_output": "A runnable business-specific prototype with traceability and pending-review status",
-      "files": [
-        "i3-ui-prototype"
-      ],
-      "expectations": [
-        "Selected template and template mode are recorded without claiming UI/UX Pro Max was used",
-        "Business fields, role visibility, status transitions and review scenarios follow the supplied brief",
-        "A runnable prototype and verification evidence are produced; absent browser evidence is marked pending",
-        "The prototype remains pending human review and no approved baseline is invented",
-        "人类可读的追问、说明、进度、报告与生成文档使用简体中文；保留代码、路径、工具参数、JSON 协议及机器状态的原始格式。"
-      ]
-    },
-    {
-      "id": 1002,
-      "kind": "dialogue",
-      "prompt": "请当前会话直接使用 i3-ui-prototype 技能，分析可编辑 HTML 内容模板和通用能力清单如何生成 Vue 3＋antDv-next 设备列表原型。仅分析：不改文件、不安装升级、不持久化设计结果、不启动另一个智能体。",
-      "expected_output": "A read-only prototype analysis that keeps direct Skill execution valid and states the framework, content, capability and acceptance boundaries",
-      "expectations": [
-        "The current executor runs the shared preflight without redispatching to an Agent, command or meta-skill",
-        "The response preserves analysis-only scope and does not initialize, install, persist design output or update project execution state",
-        "Editable content reference, reusable capabilities and target-framework behavior are explained as separate inputs",
-        "Unavailable provider, host or browser capabilities remain explicitly unverified rather than reported as executed",
-        "The analysis deliverable is the conversation; it does not invent prototype completion or human approval",
-        "人类可读的追问、说明、进度、报告与生成文档使用简体中文；保留代码、路径、工具参数、JSON 协议及机器状态的原始格式。"
-      ]
-    },
-    {
-      "id": 1003,
-      "prompt": "请使用 admin-list 可编辑内容模板，创建独立的 Vue 3＋antDv-next 原生组件设备列表原型，本例明确选择 template 模式。要求：固定 21 条设备，每页 10 条；筛选或翻页清空当前页选择；批量状态变更仅影响选中记录；编辑抽屉校验必填名称，模拟保存失败时保留输入，重试后更新正确行。有真实浏览器时验证当前构建的抽屉退出动效和遮罩模糊。保留已有原型，交付待人工评审候选。",
-      "expected_output": "An isolated native component prototype with fixed capability inputs, reproducible local data, current-build verification or a truthful verification gap",
-      "files": [
-        "i3-ui-prototype"
-      ],
-      "expectations": [
-        "The instance uses the native framework runtime and fixed template, capability, scope and framework inputs rather than converting an existing legacy instance",
-        "Real antDv-next components implement filtering, current-page selection, pagination and the edit flow with deterministic isolated mock state",
-        "Required capability bindings remain independently checkable and are not removed or arbitrarily marked inapplicable to make checks pass",
-        "The executor distinguishes source inspection, successful build and real browser execution; unavailable checks remain unverified",
-        "Browser evidence, when present, refers to the current candidate and actual build, with drawer motion and blur verified separately from static screenshots",
-        "Template mode is explicit and does not claim UIUX use; existing prototypes remain unchanged and no human baseline approval is invented",
-        "人类可读的追问、说明、进度、报告与生成文档使用简体中文；保留代码、路径、工具参数、JSON 协议及机器状态的原始格式。"
-      ]
-    },
-    {
-      "id": 1004,
-      "kind": "dialogue",
-      "prompt": "请只读检查这份原型验收声明：测试后源码已改，服务仍展示上一版构建，证据只有一张截图和手动填 passed 的报告。同事建议删除分页能力并标为不适用，以便批准候选。请说明正确的后续动作；不改文件、不执行新测试、不确认基线。",
-      "expected_output": "A read-only rejection of stale evidence and unsupported exemption, with concrete required revalidation and pending human review",
-      "expectations": [
-        "The changed candidate and previous build invalidate the supplied acceptance claim",
-        "A screenshot or manually passed report is not treated as proof of current-build browser execution or drawer animation",
-        "Pagination remains required unless an explicit requirement or scope-change source justifies an exemption",
-        "The response proposes rebuilding and revalidating against fixed inputs without claiming those actions already occurred",
-        "No files are changed, no tests are pretended, and human baseline approval remains separate",
-        "人类可读的追问、说明、进度、报告与生成文档使用简体中文；保留代码、路径、工具参数、JSON 协议及机器状态的原始格式。"
-      ]
-    },
-    {
-      "id": 1005,
-      "kind": "dialogue",
-      "prompt": "请在主会话中分析可编辑 admin-list HTML 参考和业务说明，形成 Vue 3＋antDv-next 评审原型方案。保持只读。宿主没有原型专责角色，也没有父子 JSON 传输机制。请交付有用的分析和后续步骤，不安装工具，不执行创建阶段的检查。",
-      "expected_output": "A complete read-only main-session analysis with useful coverage and a truthful acceptance plan",
-      "expectations": [
-        "The main session directly applies the shared prototype preflight without requiring or simulating a dedicated Agent",
-        "The analysis delivers requirement and bound-capability coverage, template and framework selection, acceptance planning and concrete gaps",
-        "No initialization, installation, persisted design, project state update, build, browser run or creation-stage UIUX adoption gate occurs",
-        "No parent-child JSON, PROTOTYPE_RESULT_V1 marker or validate-result execution is made a prerequisite for the natural-language deliverable",
-        "Unavailable capabilities and fixed-parameter conflicts remain visible; analysis completion is distinct from implemented coverage and human approval",
-        "人类可读的追问、说明、进度、报告与生成文档使用简体中文；保留代码、路径、工具参数、JSON 协议及机器状态的原始格式。"
-      ]
-    },
-    {
-      "id": 1006,
-      "prompt": "请根据可编辑 admin-list 参考创建独立的 Vue 3＋antDv-next 原生组件设备列表评审候选，明确使用 template 模式。我授权页面内四种主题：明亮、暗黑、清新、科技，首次默认明亮。请在我的 HTML 工作副本中启用并固定主题需求，切换时保留业务状态，保留全部已有原型和手改内容。不要再次询问是否需要主题。保持固定必需能力，指定浏览器工具可用时验证当前构建。",
-      "expected_output": "A main-session native review candidate with explicitly fixed four-theme inputs, preserved state and truthful current-build evidence or gaps",
-      "files": [
-        "i3-ui-prototype"
-      ],
-      "expectations": [
-        "The main session uses the prototype workflow and supporting frontend and version-matched official framework knowledge for actual implementation, without requiring a dedicated persona",
-        "The authorized theme capability is bound in the user HTML working copy and fixed with its requirement source rather than left disabled or sent for repeat confirmation",
-        "The generated framework implements the four exact theme names, defaults to 明亮, and verifies that business state survives theme changes",
-        "Existing or unrequested-theme instances, user edits and approved baselines remain unchanged",
-        "Template mode does not claim UIUX use; fixed required capabilities and applicable acceptance scenarios are retained",
-        "Build, actual browser Skill and DevTools observations, supplemental regression and current delivery evidence are distinguished; unavailable checks remain incomplete",
-        "The final natural-language delivery identifies the candidate, current evidence and gaps, and leaves human review pending without requiring a parent-child result envelope",
-        "人类可读的追问、说明、进度、报告与生成文档使用简体中文；保留代码、路径、工具参数、JSON 协议及机器状态的原始格式。"
-      ]
-    },
-    {
-      "id": 1007,
-      "kind": "dialogue",
-      "prompt": "请比较三种请求的处理方式：只读分析原型方案；为评审修改原型抽屉交互；把已认可抽屉实现为可复用生产组件。说明各自适用的技能和证据，不执行这些请求。",
-      "expected_output": "Operation-specific support and a clear boundary between prototype work and production frontend engineering",
-      "expectations": [
-        "Read-only prototype analysis uses only material needed for coverage and selection and plans later verification without executing it",
-        "Prototype interaction revision stays within prototype workflow ownership and uses frontend, official framework and browser capabilities when the revision requires them",
-        "Professional UIUX lookup, adoption and effect verification remain distinct and apply to professional design work, with no silent downgrade to template mode",
-        "Approved production component implementation follows the frontend implementation method and the existing engineering workflow rather than creating a new review prototype",
-        "No claim of completed runtime checks or human baseline approval is made",
-        "人类可读的追问、说明、进度、报告与生成文档使用简体中文；保留代码、路径、工具参数、JSON 协议及机器状态的原始格式。"
-      ]
-    }
-  ]
-}

package/hooks/PROTOTYPE.md

@@ -1,31 +0,0 @@
-# 原型审计 Hooks 退役与旧注册清理
-
-<!-- i3:zh-guide:start -->
-## 中文使用说明
-
-按下文完整工程步骤、检查项与验证条件执行。根据任务选择适用步骤，保留证据、风险和退出条件；正文示例中的英文标签在面向用户输出时译为中文。
-
-默认使用简体中文解释、追问及生成报告；用户明确要求其他语言时可切换。原方法正文、引用、阈值和审批条件完整保留。代码标识、路径、命令、工具参数、JSON 键/枚举与原文引用保持原样。
-<!-- i3:zh-guide:end -->
-
-原型审计 Hook 已移除。CodeBuddy／WorkBuddy 的新安装不注册 prototype 组，旧回调入口只返回空结果，不再采集调用、拦截写入、发起补调或阻止 Stop。原型 Skill 继续负责制作、修订和验收 UI。
-
-安装或升级时，统一管理器精确清理本包拥有的旧 prototype 注册。清理同时覆盖该范围内共享的 Buddy 注册，保留权限、用户 Hook、原版三组、已有原型和审计历史。被手改的注册、缺归属记录或无效配置会停止清理并报告原因，不能强行覆盖。清理后的旧 installation.json 存入 `state/i3-prototype/history/retired-<digest>.json`，不删除原会话记录。
-
-只读检查：
-
-```sh
-npx --yes @givolt/i3-composer-agent hooks check --host codebuddy --scope project --project .
-```
-
-已安装入口可显式清理旧注册：
-
-```sh
-node .codebuddy/i3-composer-agent/hooks/manage.cjs disable --host codebuddy --scope project --project . --groups prototype
-```
-
-全局改用对应全局入口和 `--scope global`；WorkBuddy 使用 `--host workbuddy`。旧 `--prototype-hooks` 和 `prototype-hooks.cjs` 只保留检查／清理兼容，不能重新 enable。只读 check 不清理设置、不扫描会话日志；输出中的 retired／cleanupRequired 描述旧配置，不代表调用或业务验收通过。清理后重载受影响宿主。
-
-原版 `session-start`、`sdd-cache`、`simplify-ignore` 按需显式启用，原脚本和条件不变。启用必须明确指定组，不再默认指向 prototype。
-
-正常原型流程保留实际 Skill 加载、固定业务断言、构建、业务场景和浏览器证据校验；移除对审计 Hook 会话绑定的专属前置。自动调用审计标为未验证，不伪报通过。旧 execution-* 数据与显式回放入口仅供历史兼容；合成回放不能冒充真实宿主调用或人工验收。详见 [调用记录兼容说明](../skills/i3-ui-prototype/references/execution-evidence.md)。

package/hooks/codebuddy-upstream.cjs

@@ -1,93 +0,0 @@
-#!/usr/bin/env node
-'use strict';
-// Original scripts stay unchanged; this adapter only maps host paths and input fields.
-const fs=require('node:fs'),path=require('node:path'),os=require('node:os'),assert=require('node:assert/strict');
-const M=require('./manage.cjs');
-function projectKey(project){return (path.basename(project).replace(/[^a-zA-Z0-9_-]/g,'-').slice(0,32)||'project')+'-'+M.sha(project).slice(0,16);}
-function effective({project,product,group,home=os.homedir(),env=process.env,read=file=>M.modules().R.fileIO.read(file),load=base=>registration(base)}) {
- const projectBase=path.join(project,'.codebuddy'),globalBase=M.modules().P.globalBase({home,env});
- const projectText=read(path.join(projectBase,'settings.json')),local=read(path.join(projectBase,'settings.local.json'));
- if(local){const settings=M.config(local);assert.ok(!settings.hooks&&!settings.disableAllHooks&&!settings.allowManagedHooksOnly,'Local Hook override requires review');}
- for(const base of [projectBase,globalBase]){const settings=M.config(read(path.join(base,'settings.json')));assert.ok(!settings.disableAllHooks&&!settings.allowManagedHooksOnly,'Host policy prevents Hooks');}
- const bases=product==='ide'&&projectText!==null?[projectBase]:[projectBase,globalBase];
- for(const base of [...new Set(bases)]){const record=load(base);if(record?.groups[group]){assert.equal(record.product,product,'Conflicting CodeBuddy products');return record;}}
- return null;
-}
-function projectFor(options,payload,env=process.env,real=file=>fs.realpathSync(file),callbackCwd=process.cwd(),workspace=(file,session)=>require(path.join(M.modules().scripts,'execution-evidence.cjs')).ideWorkspace(file,session)) {
- // CLI 2.169 omits cwd on SessionStart. Use the actual startup Hook process
- // directory only for that event; other events still require native cwd.
- const cwd=payload.cwd||(payload.hook_event_name==='SessionStart'?callbackCwd:null);
- assert.ok(path.isAbsolute(cwd||''),'Native Hook cwd required');
- const ideRoot=options.product==='ide'&&payload.client==='CodeBuddyIDE'&&cwd==='/';
- const project=real(options.scope==='project'?path.dirname(options.base):ideRoot?workspace(payload.transcript_path,payload.session_id):env.CODEBUDDY_PROJECT_DIR||env.CLAUDE_PROJECT_DIR||cwd);
- const relative=path.relative(project,real(ideRoot?project:cwd));assert.ok(relative!=='..'&&!relative.startsWith('..'+path.sep)&&!path.isAbsolute(relative),'Hook working directory is outside the registered project');return project;
-}
-function invocation({group,event,project,cwd=project,base,payload},source) {
- const value=structuredClone(payload),cache=path.join(base,'cache/i3-composer-agent/hooks',projectKey(project));
- if(group==='sdd-cache') {
-  if(value.tool_name!=='WebFetch'||!['PreToolUse','PostToolUse'].includes(event))return null;
-  const before='${CLAUDE_PROJECT_DIR:-$PWD}/.claude/sdd-cache';assert.equal(source.split(before).length,3,'Upstream cache path changed; review the adapter');
-  source=source.replaceAll(before,'${I3_HOOK_CACHE}/sdd-cache');
- } else if(group==='simplify-ignore') {
-  if(event==='Stop')value.tool_name='';
-  if(event!=='Stop') {
-   if(event==='PreToolUse'?value.tool_name!=='Read':!['Edit','Write'].includes(value.tool_name))return null;
-   const file=value.tool_input?.file_path||value.tool_input?.filePath;if(typeof file!=='string')return null;
-   const resolved=path.resolve(cwd,file),relative=path.relative(project,resolved);
-   if(relative==='..'||relative.startsWith('..'+path.sep)||path.isAbsolute(relative))return null;
-   value.tool_input.file_path=resolved;
-  }
-  const before='${CLAUDE_PROJECT_DIR:-.}/.claude/.simplify-ignore-cache';assert.equal(source.split(before).length,2,'Upstream simplify cache path changed; review the adapter');
-  source=source.replace(before,'${I3_HOOK_CACHE}/simplify-ignore');
- }else assert.ok(group==='session-start'&&event==='SessionStart','Unknown upstream Hook event');
- return {source,payload:value,cache,env:{CLAUDE_PROJECT_DIR:project,CODEBUDDY_PROJECT_DIR:project,I3_HOOK_CACHE:cache}};
-}
-function bundle(directory=__dirname) {
- const files=['manage.cjs','codebuddy-upstream.cjs','session-start.sh','sdd-cache-pre.sh','sdd-cache-post.sh','simplify-ignore.sh'];
- return M.sha(JSON.stringify(files.map(file=>{let text=fs.readFileSync(path.join(directory,file),'utf8');if(file==='session-start.sh')text=text.replace(/^SKILLS_DIR=.*$/m,'SKILLS_DIR=<native-layout>');return [file,M.sha(text)];})));
-}
-function registration(base) {
- const io=M.modules().R.fileIO,raw=io.read(path.join(base,'state/i3-composer-agent/hooks.json'));if(raw===null)return null;
- const record=JSON.parse(raw),settingsText=io.read(path.join(base,'settings.json'));
- M.validateOwned(M.config(settingsText),record,base,record.scope);
- for(const item of Object.values(record.groups))assert.equal(item.scriptDigest,bundle(),'Upstream Hook adapter changed; refresh registration');
- return {...record,settingsDigest:M.sha(settingsText)};
-}
-function observe(base,project,group,payload,record,result) {
- const io=M.modules().R.fileIO,file=path.join(base,'state/i3-composer-agent/hook-observations',projectKey(project),group+'.json'),unlock=io.lock(file);
- try {
-  const before=io.read(file),old=before?JSON.parse(before):null;
-  const same=old?.settingsDigest===record.settingsDigest&&old?.scriptDigest===record.groups[group].scriptDigest;
-  const value={schemaVersion:1,group,base,project,sessionId:payload.session_id||null,event:payload.hook_event_name,at:new Date().toISOString(),
-   events:[...new Set([...(same?old.events:[]),payload.hook_event_name])],exitCode:result.status,settingsDigest:record.settingsDigest,scriptDigest:record.groups[group].scriptDigest,invocationVerified:false};
-  io.write(file,M.json(value),M.digest(before));
- }finally{unlock();}
-}
-function main(argv=process.argv.slice(2),raw=fs.readFileSync(0,'utf8')) {
- assert.ok(Buffer.byteLength(raw)<=4*1024*1024,'Hook input too large');const options={};
- while(argv.length){const flag=argv.shift();assert.ok(flag.startsWith('--')&&argv.length,'Invalid Hook argument');assert.ok(['registration','group','base','scope','product','event'].includes(flag.slice(2)),'Unknown Hook argument');options[flag.slice(2)]=argv.shift();}
- assert.equal(options.registration,M.OWNER,'Invalid Hook registration');assert.ok(path.isAbsolute(options.base||''),'Absolute Hook base required');assert.ok(['project','global'].includes(options.scope),'Invalid Hook scope');
- const item=M.catalog.find(x=>x.id===options.group&&x.origin==='upstream');assert.ok(item?.events.includes(options.event),'Invalid Hook group/event');
- const payload=JSON.parse(raw);assert.equal(payload.hook_event_name,options.event,'Hook payload event differs');const project=projectFor(options,payload);
- const expected=options.scope==='project'?path.join(project,'.codebuddy'):M.modules().P.globalBase();assert.equal(options.base,expected,'Hook installation scope differs');
- const record=registration(options.base);
- if(!record?.groups[options.group])return {status:0,stdout:'{"continue":true}\n',stderr:''};
- assert.equal(record.product,options.product,'Hook product differs');
- if(effective({project,product:options.product,group:options.group})?.base!==options.base)return {status:0,stdout:'{"continue":true}\n',stderr:''};
- const filename=options.group==='session-start'?'session-start.sh':options.group==='simplify-ignore'?'simplify-ignore.sh':options.event==='PreToolUse'?'sdd-cache-pre.sh':'sdd-cache-post.sh';
- const cwd=options.product==='ide'&&payload.client==='CodeBuddyIDE'&&payload.cwd==='/'?project:payload.cwd||project;
- const script=path.join(__dirname,filename),prepared=invocation({...options,project,cwd,payload},fs.readFileSync(script,'utf8'));
- if(!prepared)return {status:0,stdout:'{"continue":true}\n',stderr:''};
- if(options.group==='simplify-ignore'&&options.event!=='Stop'&&fs.existsSync(prepared.payload.tool_input.file_path)) {
-  const real=fs.realpathSync(prepared.payload.tool_input.file_path),relative=path.relative(project,real);assert.ok(relative!=='..'&&!relative.startsWith('..'+path.sep)&&!path.isAbsolute(relative),'Protected file symlink escapes the project');
- }
- const unlock=M.modules().R.fileIO.lock(path.join(prepared.cache,'.'+options.group+'.event'));
- let result;try {
-  result=require('node:child_process').spawnSync(record.groups[options.group].bashPath,['-c',prepared.source,script],{cwd:project,env:{...process.env,...prepared.env},input:JSON.stringify(prepared.payload),encoding:'utf8',timeout:15000,maxBuffer:8*1024*1024});
-  if(result.error||result.status===null)throw new Error(result.error?.message||'Upstream Hook did not complete');
- }finally{unlock();}
- try{observe(options.base,project,options.group,payload,record,result);}catch(error){result.stderr=(result.stderr||'')+`\ni3 Hook observation unavailable: ${error.message}\n`;}
- return result;
-}
-module.exports={projectKey,projectFor,effective,invocation,bundle,registration,observe,main};
-if(require.main===module)try{const result=main();process.stdout.write(result.stdout||'');process.stderr.write(result.stderr||'');process.exitCode=result.status;}catch(error){process.stderr.write(`i3 CodeBuddy Hook unavailable: ${error.message}\n`);process.exitCode=1;}

package/hooks/i3-prototype.cjs

@@ -1,7 +0,0 @@
-#!/usr/bin/env node
-'use strict';
-// Retired callback kept inert for settings that have not yet been upgraded.
-// Do not read transcripts, write audit state, deny tools or block Stop.
-function main() { return {code:0,output:{}}; }
-module.exports={main};
-if(require.main===module)process.stdout.write('{}\n');

package/hooks/manage.cjs

@@ -1,169 +0,0 @@
-#!/usr/bin/env node
-'use strict';
-// CodeBuddy settings protocol: https://www.codebuddy.cn/docs/cli/hooks
-// IDE override semantics: https://www.codebuddy.cn/docs/ide/Features/Hooks
-const fs=require('node:fs'),path=require('node:path'),os=require('node:os'),crypto=require('node:crypto'),assert=require('node:assert/strict');
-const OWNER='i3-composer-agent-codebuddy-v1';
-const catalog=[
- {id:'session-start',name:'Skill 发现与路由',origin:'upstream',files:['session-start.sh'],events:['SessionStart'],dependencies:['bash','jq'],condition:'明确 skill-routing=hook；原生路由使用 native，避免重复注入'},
- {id:'sdd-cache',name:'官方文档请求缓存',origin:'upstream',files:['sdd-cache-pre.sh','sdd-cache-post.sh'],events:['PreToolUse','PostToolUse'],dependencies:['bash','jq','curl','sha256'],condition:'实际 WebFetch；仅源站 304 复用'},
- {id:'simplify-ignore',name:'代码块简化保护',origin:'upstream',files:['simplify-ignore.sh'],events:['PreToolUse','PostToolUse','Stop'],dependencies:['bash','jq','sha1'],condition:'使用 simplify-ignore 标记；会在运行期间替换标记块并在 Stop 恢复'},
-];
-const digest=value=>crypto.createHash('sha256').update(JSON.stringify(value)).digest('hex');
-const sha=bytes=>crypto.createHash('sha256').update(bytes).digest('hex');
-const json=value=>JSON.stringify(value,null,2)+'\n';
-function selection(value,action='check') {
- if(action==='enable')assert.ok(value!==undefined,'Choose explicit Hook groups before enabling; no groups are enabled by default');
- const ids=value===undefined?(['check','list'].includes(action)?catalog.map(x=>x.id):action==='disable'?['prototype']:[]):value==='all'?catalog.map(x=>x.id):value.split(',');
- assert.ok(ids.every(id=>id==='prototype'||catalog.some(item=>item.id===id)),'Unknown Hook group; choose session-start,sdd-cache,simplify-ignore or all');
- assert.ok(action!=='enable'||!ids.includes('prototype'),'Prototype audit Hooks are retired and cannot be enabled');
- return [...new Set(ids)];
-}
-function quote(value){assert.ok(typeof value==='string'&&!/[\x00\r\n]/.test(value),'Unsafe Hook argument');return "'"+value.replaceAll("'","'\\''")+"'";}
-function config(raw){const value=raw===null?{}:JSON.parse(raw);assert.ok(value&&typeof value==='object'&&!Array.isArray(value),'Settings must be an object');assert.ok(value.hooks===undefined||value.hooks&&typeof value.hooks==='object'&&!Array.isArray(value.hooks),'Invalid hooks configuration');for(const groups of Object.values(value.hooks||{})){assert.ok(Array.isArray(groups),'Invalid Hook groups');for(const group of groups)assert.ok(group&&Array.isArray(group.hooks),'Invalid Hook group');}return value;}
-function modules() {
- const roots=[path.resolve(__dirname,'..'),path.resolve(__dirname,'../..')];
- const candidates=roots.flatMap(root=>['i3-ui-prototype',['ui','prototype'].join('-')].map(id=>path.join(root,'skills',id,'scripts')));
- const scripts=candidates.find(dir=>fs.existsSync(path.join(dir,'prototype-hooks.cjs')));assert.ok(scripts,'Prototype audit implementation is missing; install the complete package');
- return {scripts,R:require(path.join(scripts,'codebuddy-registration.cjs')),P:require(path.join(scripts,'prototype-hooks.cjs'))};
-}
-function owned(group){return group.hooks.some(h=>typeof h.command==='string'&&h.command.includes(OWNER));}
-function validateOwned(settings,record,base,scope) {
- if(record){assert.equal(record.owner,OWNER,'Unknown Hook ownership');assert.equal(record.schemaVersion,1,'Unsupported Hook ownership');assert.equal(record.base,base,'Hook base differs');assert.equal(record.scope,scope,'Hook scope differs');assert.ok(record.groups&&typeof record.groups==='object'&&!Array.isArray(record.groups),'Invalid owned Hook groups');
-  for(const [id,item] of Object.entries(record.groups)){const known=catalog.find(x=>x.id===id&&x.origin==='upstream');assert.ok(known&&item&&item.groups,'Unknown owned Hook group');assert.deepEqual(Object.keys(item.groups).sort(),[...known.events].sort(),'Owned Hook events changed');}
- }
- const found=new Set();
- for(const [event,groups] of Object.entries(settings.hooks||{}))for(const group of groups.filter(owned)) {
-  const ids=Object.keys(record?.groups||{}).filter(id=>record.groups[id].groups[event]&&group.hooks.some(h=>h.command?.includes(`--group' '${id}'`)));
-  assert.equal(ids.length,1,'Hook ownership is missing; preserve the unknown command');const key=ids[0]+':'+event;
-  assert.ok(!found.has(key),'Duplicate owned Hook');assert.deepEqual(group,record.groups[ids[0]].groups[event],'Owned Hook was modified; preserve user changes');found.add(key);
- }
- for(const [id,item] of Object.entries(record?.groups||{}))for(const event of Object.keys(item.groups))assert.ok(found.has(id+':'+event),'Owned Hook registration is missing');
-}
-function requirements(id,deps) {
- for(const name of catalog.find(x=>x.id===id).dependencies){if(name==='sha256')assert.ok(deps.shasum||deps.sha256sum,'Missing shasum or sha256sum');else if(name==='sha1')assert.ok(deps.shasum||deps.sha1sum,'Missing shasum or sha1sum');else assert.ok(deps[name],`Missing ${name}; install it separately before enabling ${id}`);}
-}
-function planUpstream(options) {
- const {base,scope,product,action,record=null,settingsText=null,nodePath,hookDirectory,scriptDigest,dependencies={},skillRouting}=options;
- assert.ok(['keep','enable','disable'].includes(action),'Invalid Hook action');assert.ok(['project','global'].includes(scope),'Specify project or global scope');
- const settings=config(settingsText);validateOwned(settings,record,base,scope);
- const chosen=selection(options.groups,action).filter(id=>id!=='prototype'),enabled=new Set(Object.keys(record?.groups||{}));
- if(action==='enable')for(const id of chosen){if(id==='session-start')assert.equal(skillRouting,'hook','session-start requires explicit skill-routing=hook; native routing must not be duplicated');requirements(id,dependencies);enabled.add(id);}
- if(action==='disable')for(const id of chosen)enabled.delete(id);
- if(enabled.size){assert.ok(['ide','cli'].includes(product),'Specify CodeBuddy product ide or cli');if(record)assert.equal(product,record.product,'Disable the previous product profile before changing it');assert.match(scriptDigest,/^[a-f0-9]{64}$/);for(const p of [base,nodePath,hookDirectory])assert.ok(path.isAbsolute(p),'Absolute registration paths required');}
- // Remove only exact owned groups after validation. All user Hook groups survive.
- for(const event of Object.keys(settings.hooks||{}))settings.hooks[event]=settings.hooks[event].filter(g=>!owned(g));
- const groups={};
- for(const item of catalog.filter(x=>enabled.has(x.id))) {
-  const entry={product,scriptDigest,nodePath,bashPath:dependencies.bash||record?.groups[item.id]?.bashPath,skillRouting:item.id==='session-start'?'hook':null,groups:{}};
-  for(const event of item.events) {
-   const matcher=item.id==='sdd-cache'?'^WebFetch$':event==='PreToolUse'?'^Read$':'^(Edit|Write)$';
-   const argv=[nodePath,path.join(hookDirectory,'codebuddy-upstream.cjs'),'--registration',OWNER,'--group',item.id,'--base',base,'--scope',scope,'--product',product,'--event',event];
-   const group={...(event.endsWith('ToolUse')?{matcher}:{}),hooks:[{type:'command',command:argv.map(quote).join(' '),timeout:item.id==='sdd-cache'?15:20}]};
-   entry.groups[event]=group;settings.hooks||={};(settings.hooks[event]||=[]).push(group);
-  }
-  groups[item.id]=entry;
- }
- const recordAfter=enabled.size?{schemaVersion:1,owner:OWNER,base,scope,product,productVersion:options.productVersion||record?.productVersion||'unreported',groups}:null;
- const afterText=!record&&!chosen.length||!record&&action!=='enable'?settingsText:json(settings);
- return {afterText,recordAfter};
-}
-function apply(change,io=modules().R.fileIO) {
- const unlock=io.lock?io.lock(change.changes[0].file):()=>{},written=[];
- try {
-  for(const entry of change.changes)assert.equal(digest(io.read(entry.file)),digest(entry.before),'Hook configuration changed after planning');
-  try {for(const entry of change.changes)if(entry.before!==entry.after){io.write(entry.file,entry.after,digest(entry.before));written.push(entry);}}
-  catch(error){for(const entry of written.reverse())if(io.read(entry.file)===entry.after)io.write(entry.file,entry.before,digest(entry.after));throw error;}
-  return change.summary;
- }finally{unlock();}
-}
-function executable(name,env=process.env) {
- for(const folder of (env.PATH||'').split(path.delimiter)){const file=path.resolve(folder,name);try{if(fs.statSync(file).isFile()){fs.accessSync(file,fs.constants.X_OK);return file;}}catch{}}
- return null;
-}
-function dependencies(){return Object.fromEntries(['bash','jq','curl','shasum','sha256sum','sha1sum'].map(name=>[name,executable(name)]));}
-function location(options) {
- assert.ok(['codebuddy','workbuddy'].includes(options.host||'codebuddy'),'Hook management supports CodeBuddy and WorkBuddy');assert.ok(['project','global'].includes(options.scope),'Specify project or global scope');
- const project=fs.realpathSync(path.resolve(options.project||'.'));assert.ok(fs.statSync(project).isDirectory(),'Project must be a directory');
- return {project,base:options.scope==='project'?path.join(project,'.codebuddy'):modules().P.globalBase(options)};
-}
-function unmanaged(settings) {
- const files={ 'session-start':['session-start.sh'],'sdd-cache':['sdd-cache-pre.sh','sdd-cache-post.sh'],'simplify-ignore':['simplify-ignore.sh'] },result=[];
- for(const [event,groups] of Object.entries(settings.hooks||{}))for(const group of groups)for(const hook of group.hooks) {
-  if(typeof hook.command!=='string'||hook.command.includes(OWNER))continue;
-  for(const [id,names] of Object.entries(files))if(names.some(name=>hook.command.includes(name)))result.push({id,event,command:hook.command});
- }
- return result;
-}
-function pendingSimplify(base) {
- const parent=path.join(base,'cache/i3-composer-agent/hooks');if(!fs.existsSync(parent))return [];
- return fs.readdirSync(parent,{withFileTypes:true}).filter(entry=>entry.isDirectory()&&!entry.isSymbolicLink()).flatMap(entry=>{
-  const dir=path.join(parent,entry.name,'simplify-ignore');if(!fs.existsSync(dir))return [];
-  assert.ok(!fs.lstatSync(dir).isSymbolicLink(),'Simplify cache symlink requires review');return fs.readdirSync(dir).filter(file=>file.endsWith('.bak')).map(file=>path.join(dir,file));
- });
-}
-function prepare(options,runtime={}) {
- const {P,R}=runtime.modules||modules(),{project,base}=runtime.location||location(options),io=R.fileIO,requested=options.action||'keep',ids=selection(options.groups,requested),host=options.host||'codebuddy';
- const action=requested==='default'?'keep':requested;
- const settingsPath=path.join(base,'settings.json'),recordPath=path.join(base,'state/i3-composer-agent/hooks.json'),prototypePath=path.join(base,'state/i3-prototype/installation.json');
- const before=io.read(settingsPath),recordText=io.read(recordPath),record=recordText?JSON.parse(recordText):null,prototypeText=io.read(prototypePath);
- const settings=config(before);
- if(action==='enable') {
-  assert.ok(process.platform!=='win32','Buddy Hook quoting on Windows has not been validated');
-  assert.ok(!settings.disableAllHooks&&!settings.allowManagedHooksOnly,'Host policy prevents automatic Hooks; preserve the policy');
-  assert.equal(host,'codebuddy','WorkBuddy upstream Hook adapters are not supported');
-  for(const id of ids)assert.ok(!unmanaged(settings).some(item=>item.id===id),`Unmanaged ${id} Hook already exists; preserve it and resolve the duplicate before enabling`);
- }
- if(ids.includes('simplify-ignore')&&['enable','disable'].includes(action)) {
-  for(const candidate of [...new Set([base,path.join(project,'.codebuddy'),P.globalBase?P.globalBase(options):path.join(options.home||os.homedir(),'.codebuddy')])])assert.equal((runtime.pendingSimplify||pendingSimplify)(candidate).length,0,'Simplify protection is still active; finish the session and restore blocks before changing Hooks');
- }
- // Retire the entire prototype group, including shared Buddy registrations.
- // The legacy planner validates exact ownership; unknown/user-modified entries stop here.
- const prototypeChange=P.prepare({...options,project,action:'disable',hosts:[],entryPath:path.join(base,'i3-composer-agent/hooks/i3-prototype.cjs')});
- const upstream=planUpstream({...options,base,product:record?.product||options.product,action,record,settingsText:prototypeChange.unchanged?before:prototypeChange.afterText,nodePath:process.execPath,
-  hookDirectory:path.join(base,'i3-composer-agent/hooks'),scriptDigest:runtime.scriptDigest||require('./codebuddy-upstream.cjs').bundle(),dependencies:runtime.dependencies||dependencies()});
- const changes=[{file:settingsPath,before,after:upstream.afterText},{file:recordPath,before:recordText,after:upstream.recordAfter?json(upstream.recordAfter):null}];
- if(prototypeText&&!prototypeChange.unchanged) {
-  const archive=path.join(base,'state/i3-prototype/history','retired-'+sha(prototypeText)+'.json'),previous=io.read(archive);
-  assert.ok(previous===null||previous===prototypeText,'Retired registration history differs; preserve it for review');
-  changes.push({file:archive,before:previous,after:prototypeText});
- }
- changes.push({file:prototypePath,before:prototypeText,after:prototypeChange.unchanged?prototypeText:null});
- return {changes,summary:{host,scope:options.scope,base,product:record?.product||options.product||'auto',action,requestedAction:requested,groups:ids.filter(id=>id!=='prototype'),enabledHosts:[],
-  changed:changes.some(item=>item.before!==item.after),enabledGroups:Object.keys(upstream.recordAfter?.groups||{}),retiredGroups:['prototype'],prototypeRegistrationRemoved:!!prototypeText&&!prototypeChange.unchanged,
-  next:'Prototype audit Hooks are retired. Existing owned callbacks are removed; other Hook groups and user settings are preserved. Reload an affected host after cleanup.'}};
-}
-function check(options) {
- const {P,R}=modules(),{project,base}=location(options),io=R.fileIO,ids=selection(options.groups,options.action||'check'),settingsText=io.read(path.join(base,'settings.json')),settings=config(settingsText),deps=dependencies(),items=[];
- let record=null,error=null;try{record=require('./codebuddy-upstream.cjs').registration(base);}catch(e){error=e.message;}
- for(const id of ids) {
-  if(id==='prototype')continue;
-  const item=catalog.find(x=>x.id===id),entry=path.join(base,'i3-composer-agent/hooks','codebuddy-upstream.cjs');
-  const missingFiles=[entry,...item.files.map(file=>path.join(base,'i3-composer-agent/hooks',file))].filter(file=>!fs.existsSync(file));
-  const row={...item,entryPath:entry,filesPresent:missingFiles.length===0,missingFiles,status:missingFiles.length?'not-installed':'files-present',invocationVerified:false,nativeValidation:'pending-user'};
-  try{requirements(id,deps);}catch(e){row.dependencyIssue=e.message;}
-  if(error){row.status='failed';row.reason=error;}
-  else if(record?.groups[id])try {
-   const U=require('./codebuddy-upstream.cjs'),selected=U.effective({project,product:record.product,group:id,home:options.home,env:options.env});row.effective=selected?.base===base;
-   row.status=!row.effective?'shadowed':record.product==='cli'?'pending-host-review':'registered';
-   const raw=io.read(path.join(base,'state/i3-composer-agent/hook-observations',U.projectKey(project),id+'.json'));
-   if(raw){const observation=JSON.parse(raw);if(observation.settingsDigest===record.settingsDigest&&observation.scriptDigest===record.groups[id].scriptDigest){row.observation=observation;row.status=row.effective?'triggered':row.status;}}
-   row.product=record.product;row.productVersion=record.productVersion;
-  }catch(e){row.status='failed';row.reason=e.message;}
-  items.push(row);
- }
- const retired=P.check({...options,project});
- return {host:options.host||'codebuddy',scope:options.scope,base,readOnly:true,changed:false,status:items.some(item=>item.status==='failed')||retired.status==='failed'?'failed':'checked',hooks:items,retiredHooks:[{id:'prototype',...retired}],unmanagedHooks:unmanaged(settings),
-  next:'files-present is not enabled; registered is not triggered; triggered is not business acceptance. CLI: review /hooks; IDE: reload.'};
-}
-function configure(options){const change=prepare(options);return options.preview?change.summary:apply(change);}
-function main(argv=process.argv.slice(2)) {
- if(argv.includes('--help'))return {usage:'node manage.cjs list|check|enable|disable --host codebuddy|workbuddy --scope project|global --project <directory> [--groups <ids>|all] [--product auto|ide|cli] [--skill-routing hook] [--transcript-root <native-directory>|auto]',hooks:catalog,default:'No automatic Hook registration. Enable requires explicit upstream groups; prototype audit is retired and its old registrations are cleaned during upgrades',nativeValidation:'pending-user'};
- const options={action:argv.shift()||'list',host:'codebuddy',project:process.cwd()};
- assert.ok(['list','check','enable','disable','keep'].includes(options.action),'Choose list, check, enable or disable');
- while(argv.length){const arg=argv.shift();assert.ok(arg.startsWith('--')&&argv[0]&&!argv[0].startsWith('--'),'Hook option needs a value');const key=arg.slice(2).replace(/-([a-z])/g,(_,c)=>c.toUpperCase());assert.ok(['host','scope','project','product','productVersion','transcriptRoot','groups','skillRouting'].includes(key),'Unknown Hook option');options[key]=argv.shift();}
- if(options.skillRouting!==undefined)assert.ok(['native','hook'].includes(options.skillRouting),'skill-routing must be native or hook');
- return ['list','check'].includes(options.action)?check(options):configure(options);
-}
-module.exports={OWNER,catalog,digest,sha,json,quote,config,selection,modules,validateOwned,requirements,planUpstream,apply,dependencies,location,unmanaged,pendingSimplify,prepare,check,configure,main};
-if(require.main===module)try{const result=main();process.stdout.write(json(result));if(result.status==='failed')process.exitCode=1;}catch(error){process.stderr.write(error.message+'\n');process.exitCode=1;}