@tea-agent/loop-agent 0.44.0-next.13 → 0.44.0-next.14

package/CHANGELOG.md

@@ -1,9 +1,16 @@
 # 更新日志
 
 ## [Unreleased]
+- 修复 GitHub Actions Linux 上工作台浏览器起不来的问题：CI 没有可用 Chromium sandbox 时不再强制沙箱，桌面端仍保持沙箱以免出现 "unsupported command-line flag" 提示条。
+- 对话预约漏填预算时，默认最多 5 次目标尝试、5 次任务执行和 4 次监督，执行窗口 240 分钟；确认卡会展示这些上限，第一次没通过还可以在预算内继续修。显式指定更小预算或更短窗口不会被抬高；写保护、无进展或监督决定停止时仍会停。已确认的旧预约不受影响。
+- Operator Console 新增桌面宠物：移植 dsh-pet 的状态机、好感度、互动冷却、任务奖励与零食结算，宠物会跟随 Chat 的思考、工具调用、回复、完成和失败状态切换动画；支持拖动、摸摸、喂食及持久化；默认关闭，可在对话设置的「宠物」页开启。首个素材不复用 dsh 图片，改为仓库内脚本确定性生成的原创矢量橙色小精灵「小橘灵」：圆滚滚身体、小短手小短腿、叶子呆毛和火焰尾巴，嘴、手、尾巴、头部按对话状态做关节动画。
+- 上下文洞察剪枝精确化：压缩/剪枝事件现在按 `shadowedSeqs` 或 `firstKeptEntryId` 锚点从活账本中精确移除对应消息（用户/助手/工具结果），并同步扣减组合占比与上下文浏览器行；事件卡新增 `removedIds`/`removalBasis`，趋势图在剪枝后反映真实净值而非按比例估算。同时引入 dsh 风格工具结果中段剪枝（overflow 时自动 armed，确定性保头尾），并修复洞察面板在部分事件序列下的类型问题。
 
 ### 新增
 
+- 工作台浏览器预览新增「镜像外部窗口」视图：外部受控浏览器登录后，右侧预览直接展示同一页面的登录态（不再显示独立登录页），外部窗口的导航与操作实时同步到预览；预览里的地址栏、前进/后退/刷新也直接驱动外部窗口。镜像流只在页面变化时产生画面、只在浏览器已启动时工作，浏览器未运行时自动回退到原有的独立 iframe 预览（可点击工具栏按钮手动切换）。
+- Context pressure 现在会在压力触发后对超大 Pi 工具结果做确定性的 DSH 风格头/标记/尾剪枝：按 Unicode 码点限制文本、保留图片等富内容顺序、原始会话记录不变，并通过 telemetry 记录剪枝条目与移除量；Console 与 DAG Pi executor 均支持配置开关和预算。
+
 - Console Chat 浏览器控制补齐页面 JavaScript、登录态导入导出、带行上下文的元素查找、Markdown 内容抽取和外部窗口人工点选；条件等待可确认文本、元素或网址变化，多个对话保持各自选中的标签页，旧页面快照不会被误用于其他页面。
 - 浏览器截图可指定标签页和完整页面，作为图片发送给支持视觉的模型，并在工具详情中查看保存的截图；不支持视觉或图片过大时明确提示。右侧网页预览明确标注为独立页面，避免与实际受控窗口的登录态、操作混淆。
 - 登录态文件保存在仓库外，默认不把 cookie 值写入工具结果；导入显式合并 cookies/localStorage，保留未列出的现有数据。页面脚本超时后提示等待恢复或关闭该标签页；现有 Chrome 接管和 frontend-test 自动加载登录态仍为后续能力。
@@ -150,6 +157,9 @@
 
 ### 改进
 
+- 项目初始化改为最小接入：不再改写 README、AGENTS，也不再复制整套文档、脚本和内置技能。目标项目只保留本机运行配置与一个外部智能体入口，通用能力会随 Loop Agent 程序更新，不需要逐个项目同步。
+- 旧项目升级会清理仍未修改的初始化副本；用户改过的文档、脚本和技能会原样保留。升级前若还有任务运行或需要人工判断的内容，会停止写入并给出下一步，原有 DAG 使用方式不变。
+- Console 对话浏览器新增 `LOOP_BROWSER_HEADLESS=1` 可选后台（headless）运行：不弹窗口、不抢焦点，导航、快照、点选、表单、截图、控制台/网络诊断等能力全部保留，右侧网页面板预览不受影响；后台模式下点选与「聚焦外部窗口」会明确提示原因。默认仍为可见窗口，人工点选开箱即用。同时不再向 Chrome 传递 `--no-sandbox`，启动时的「不受支持的命令行标记」黄条消失。
 - Console「浅色」主题改为 DeepSeek Harness 浅色家族：白底、侧栏冷灰、近黑正文、发送与主操作为 DeepSeek 蓝，用户气泡为淡蓝；默认暖纸和深色主题不变。
 - 对话时间线的「紧凑 / 完整」改为 DSH 文字 Tab：去掉小卡片边框与全局 34px 按钮高度，选中项用品牌色下划线。
 - DAG 运行时内部按职责拆开：模型配置、领域工具、分段会话、模板族、终态判定与检查点各自独立维护，测试也按行为分成可单独调度的文件。命令、任务流程与用户可见结果不变。本机默认测试并行下整池耗时未证实变快。
@@ -165,6 +175,8 @@
 
 ### 修复
 
+- 修复旧项目升级在 Windows 执行 `npm` 验证时可能因命令 shim 启动方式报 `EINVAL` 的问题；升级器也能正确比较当前 beta/prerelease 与更新的稳定版本，不再把可用更新误判为“已是最新”。
+- `agent-worker console` 第一次 Ctrl+C 仍会尝试正常关闭；若关闭卡住（例如主线程正在序列化超大会话），第二次 Ctrl+C 或约 2 秒超时会强制退出，不再出现连按几十次都不退、端口一直被占的情况。
 - Console Chat 的浏览器搜索工具在更多真实站点上可用：现代搜索框（`textarea`、`role=searchbox`、`name=search`）不再报“找不到搜索框”；对只在页面内更新结果、不发生跳转的搜索表单也不会超时失败；提交时只在搜索框所属表单内查找提交按钮，不再误点页面上无关的按钮导致“已输入但未提交”。
 - 浏览器导航在页面于加载完成后才发生跳转（如搜索引擎跳转到区域站点）时，不再把后续操作带入上一页；跳转后会等待短暂稳定再返回。
 - 浏览器搜索的默认搜索引擎改为 Bing（可从参数改写）。此前默认的百度对自动化已不可用（新版为文本框加验证码），模型不指定引擎时搜索会直接失败。

package/README.md

@@ -48,37 +48,36 @@ npm install -g @tea-agent/loop-agent@0.37.5          # 精确、可复现
 ```bash
 loop-agent init instructions --repo-root .
 loop-agent init model-catalog --repo-root . --json
-loop-agent init --repo-root . --profile full --merge \
+loop-agent init --repo-root . --merge \
   --low-model <provider/model> --med-model <provider/model> --high-model <provider/model>
 loop-agent init doctor --repo-root .
 loop-agent inspect --repo-root .
 ```
 
-`init model-catalog` 会通过 Pi runtime 与 OpenCode 的非 verbose 列表发现本机可用模型，只输出白名单模型元数据、Pi setup 状态和 provider 凭据就绪状态，不输出原始配置或凭据。已有 LOW/MED/HIGH 只要仍存在于 Pi 就保持不变；只有已移除或缺失的档位才由模型结合项目、能力、成本和上下文窗口重选。对于 `wizard-local` provider，目录会识别 `aicoder-default < aicoder-plus < aicoder-pro < aicoder-max` 的家族内相对能力顺序，但不会把它机械绑定为固定三档。如果 Pi 没有模型定义，初始化模型会先向用户补齐 provider/model、API/base URL、上下文窗口、最大输出等无法推断的信息并协助配置；如果只是凭据缺失，则保留 harness 选择并修复认证。初始化会保留已有用户内容，并补充 `AGENTS.md`、`harness.json`、`ai_workspace/loop-agent/`、`.agents/skills/`、`.harness/` 和验证脚本等治理入口。
+初始化不会改写项目的 `README.md` 或 `AGENTS.md`，也不会复制整套治理文档、脚本、模板和内置 Skills。它只维护本机 `harness.json`、最小 `.gitignore` 块、`.harness/init-surface.json`，以及供外部 Agent 发现 loop-agent 的 `.agents/skills/loop-agent/SKILL.md` 桥。DAG 所需的通用 Skills、模板和规则直接从当前 npm 包读取；项目自己的 `AGENTS.md` 和自定义 Skills 保持原样。
 
-控制器升级后，旧项目可能仍使用过期的 repo-local skills、模板、managed blocks 和治理说明。普通安全仓库命令结束时会自动检测目标项目是否需要对齐：非 TTY 只向 stderr 输出提示且不写入目标；TTY 且无 human decisions、无活跃 DAG/Worker 时，可经明确 `y/yes` 同意后应用 deterministic safe actions；也可手动运行统一入口：
+`init model-catalog` 只返回可用模型的必要元数据与就绪状态，不输出原始配置或凭据。已有 LOW/MED/HIGH 只要仍可用就保持不变；缺失档位才需要重选。`--profile` 和 `--client-recovery` 已移除，传入时会给出明确错误；客户端适配不再随初始化隐式安装。
+
+控制器升级后，可先只读检查目标项目：
 
 ```bash
-loop-agent init reconcile --repo-root .
+loop-agent init check-update --repo-root . --json
 ```
 
-`init reconcile` 在 surface 缺失、存在 human decisions、存在活跃 DAG/Worker 或无法确认 Worker 状态时零写入，并返回 `needs-baseline`、`needs-human-decision` 或 `blocked-active-runtime`；其余情况复用 `init update --apply-safe` 的安全动作并复查返回 `clean`、`needs-model-merge` 或 `needs-safe-update`。
-
-写入型自然语言请求「`loop-agent初始化更新`」或「`loop-agent 初始化更新`」必须进入可恢复的统一闭环，而不是只做检查：
+旧版完整初始化项目使用可恢复升级入口：
 
 ```bash
 loop-agent init upgrade --repo-root . --json
-# controller 返回当前单文件 merge task 后（其余任务已在同一次计划中排队）：
 loop-agent init upgrade --repo-root . --run-id <run-id> --continue --json
 ```
 
-它在 `.harness/init-upgrades/<run-id>/` 保存身份、一次性模型目录与 surface 计划、动作收据、合并队列、验证与报告。固定投影文件按 recorded ownership 确定性新增、更新或安全删除；用户改过的文件和项目自适应内容才进入模型合并。多个合并仍逐文件限制 `allowedPaths`，但接受后直接激活下一项，不重复版本发现和全量规划；全部处理完只执行一次最终验证。`harness.json` 按属性结构新增/删除字段并保留项目值，同时同步 schema。已完成的 `--status` / `--report` 只读取控制器哈希锚定的证据，不重新执行项目脚本。默认管理项目 `.opencode/plugins/`、`.pi/extensions/` 和 `.pi/settings.json`，不会默认写 `~/.pi/agent/settings.json`。旧项目首次执行后需 reload 宿主会话。明确「检查初始化更新」「只检查，不要修改」仍只运行 `init check-update`。
+升级会删除仍与控制器记录完全一致的旧投影；用户改过的 docs、scripts 和 Skills 会保留并解除初始化所有权。README/AGENTS 只移除精确 managed block，块外内容不变。升级完成后 DAG 的命令与运行事实路径不变，内置能力改从当前 package 加载。存在运行中或可恢复任务、身份不一致或需要人工取舍时，升级会停止写入并返回下一步。
 
 完整说明见[初始化目标项目](website/docs/quick-start/init-target-project.md)。
 
 ### 运行第一个任务
 
-初始化后，在已初始化的目标项目中你可以直接对宿主 agent 说「**loop-agent 帮我完成 XXX 需求**」（或「帮我实现 / 帮我修复 / 帮我开发 XXX」「使用 loop-agent 完成 XXX」「按 loop-agent 流程处理 XXX」），初始化写入的 `AGENTS.md` 与 `.agents/skills/loop-agent/` 会把这类通用需求表达确定性地路由进 Agent DAG，**无需**追加额外的 `cli` 关键词。主会话只负责编排与验证，业务实现由受治理 DAG writer 完成。
+初始化后，在目标项目中可以直接对宿主 Agent 说「**loop-agent 帮我完成 XXX 需求**」。`.agents/skills/loop-agent/SKILL.md` 只负责发现和路由；完整工作流规则、内置 Skills 与模板由当前 npm 包提供。主会话只负责编排与验证，业务实现由受治理 DAG writer 完成。
 
 ```bash
 # 标准单任务路径：唯一 mutation 入口 task advance + 可选只读 task status
@@ -140,8 +139,9 @@ Console Chat 支持直接用自然语言预约工作流，例如：“请预约3
 ## 核心边界
 
 - `.harness/` 保存任务、DAG run、one-shot run、可选 Task Pool 与 `init-upgrades/` 可恢复升级运行事实。
-- `ai_workspace/loop-agent/` 保存目标项目的长期治理资料。
-- `.agents/skills/` 保存目标项目可审计的 repo-local skills。
+- `harness.json` 保存本机模型与运行设置；可提交的项目覆盖位于可选 `.loop-agent/project.json`。
+- `.agents/skills/loop-agent/SKILL.md` 是外部 Agent 桥；内置 Skills、模板和通用治理资料由 npm 包提供。
+- 项目自己的 `AGENTS.md`、文档、脚本和自定义 Skills 仍由项目维护，不属于 init surface。
 - `agent-worker` 通过已发布的 `loop-agent` 子进程执行 DAG，不维护第二套 runtime kernel。
 - 当前不内置远程 Task Pool、云 Worker 集群、自动 push、自动创建或合并 PR、生产凭据管理。
 

package/dist/adapters/loop-agent.js

@@ -160,6 +160,40 @@ function commandFromScript(repoRoot, label, command) {
 function getManifestVerifyCommands(repoRoot, preset) {
     try {
         const manifest = JSON.parse(readFileSync(path.join(repoRoot, 'harness.json'), 'utf-8'));
+        let tracked = {};
+        try {
+            tracked = JSON.parse(readFileSync(path.join(repoRoot, '.loop-agent', 'project.json'), 'utf-8'));
+        }
+        catch {
+            // Tracked overrides are optional. Invalid JSON is rejected by manifest loading.
+        }
+        const commandsFor = (source, key) => {
+            const value = source?.[key];
+            return Array.isArray(value)
+                ? value.filter((item) => typeof item === 'string' && item.trim().length > 0)
+                : [];
+        };
+        const unique = (items) => [...new Set(items)];
+        const quickV2 = unique([
+            ...commandsFor(tracked.verification, 'quick'),
+            ...commandsFor(manifest.verification, 'quick'),
+        ]);
+        const standardV2 = unique([
+            ...commandsFor(tracked.verification, 'standard'),
+            ...commandsFor(manifest.verification, 'standard'),
+        ]);
+        const fullV2 = unique([
+            ...commandsFor(tracked.verification, 'full'),
+            ...commandsFor(manifest.verification, 'full'),
+        ]);
+        if (quickV2.length + standardV2.length + fullV2.length > 0) {
+            const selected = preset === 'quick'
+                ? quickV2
+                : preset === 'standard'
+                    ? [...quickV2, ...standardV2]
+                    : [...quickV2, ...standardV2, ...fullV2];
+            return selected.map((command) => commandFromScript(repoRoot, 'project verification', command));
+        }
         const quick = typeof manifest.scripts?.quickVerify === 'string'
             ? manifest.scripts.quickVerify
             : undefined;

package/dist/build-stamp.json

@@ -1,6 +1,6 @@
 {
   "schemaVersion": 1,
-  "version": "0.44.0-next.13",
-  "gitSha": "03e91c507b0ab0f87e6dd376bb7bb735b8e5590e",
-  "builtAt": "2026-09-18T01:29:28.992Z"
+  "version": "0.44.0-next.14",
+  "gitSha": "f4063ecbd9640174f9975da1096408f432aa7c1b",
+  "builtAt": "2026-09-19T10:49:42.503Z"
 }

package/dist/cli/command-definitions.js

@@ -149,7 +149,7 @@ const DAG_SUBCOMMANDS = [
     "decision",
 ];
 const TASK_SUBCOMMANDS = ["advance", "status", "source"];
-const OPERATOR_SUBCOMMANDS = ["capabilities"];
+const OPERATOR_SUBCOMMANDS = ["capabilities", "guide"];
 const WORKFLOW_SUBCOMMANDS = [
     "list",
     "inspect",
@@ -234,8 +234,8 @@ export const COMMAND_DEFINITIONS = [
         name: "init",
         adapter: "none",
         tier: "primary",
-        intent: "Initialize a target repository with loop-agent harness capabilities. Run INSIDE the target repo, or pass the global --repo-root <path> BEFORE this subcommand (e.g. `loop-agent --repo-root . init --profile full --merge`).",
-        usage: "init [instructions|model-catalog|doctor|check-update|update|reconcile|upgrade] [--profile full|minimal] [--merge] [--model provider/model | --low-model provider/model --med-model provider/model --high-model provider/model] [--json|--markdown] [--bootstrap-surface|--apply-safe] [--client-recovery=auto|project|user|off] [--run-id <id> --status|--continue|--report]",
+        intent: "Initialize a target repository with the minimal loop-agent runtime surface. Run inside the target repo, or pass the global --repo-root <path> before this subcommand.",
+        usage: "init [instructions|model-catalog|doctor|check-update|update|reconcile|upgrade] [--merge] [--model provider/model | --low-model provider/model --med-model provider/model --high-model provider/model] [--json|--markdown] [--bootstrap-surface|--apply-safe|--legacy-audit] [--run-id <id> --status|--continue|--report]",
         subcommands: [...INIT_SUBCOMMANDS],
         handler: async ({ repoRoot, subcommand, rest }) => {
             await runInit(repoRoot, [subcommand, ...rest].filter(Boolean), { readRuntimeActivity: readInitRuntimeActivity });
@@ -288,10 +288,10 @@ export const COMMAND_DEFINITIONS = [
     },
     {
         name: "operator",
-        adapter: "required",
+        adapter: "none",
         tier: "operator",
         intent: "Operator machine envelope capabilities registry for Console/CLI negotiation.",
-        usage: "operator capabilities [--json]",
+        usage: "operator <capabilities|guide> [--json|--markdown]",
         subcommands: [...OPERATOR_SUBCOMMANDS],
         handler: async ({ repoRoot, subcommand, rest }) => {
             await runOperator(repoRoot, [subcommand, ...rest].filter((arg) => Boolean(arg)));

package/dist/cli/program.js

@@ -667,8 +667,6 @@ export function buildLoopAgentProgram(options) {
                 .allowExcessArguments(true)
                 .argument("[args...]", "init arguments")
                 .option("--project-name <name>", "target project name")
-                .option("--governance-root <path>", "governance root")
-                .option("--profile <profile>", "full|minimal", "full")
                 .option("--merge", "merge existing files")
                 .option("--no-merge", "skip existing files")
                 .option("--provider <provider>", "provider paired with a bare --model (otherwise use provider/model)")
@@ -679,8 +677,7 @@ export function buildLoopAgentProgram(options) {
                 .option("--json", "print JSON")
                 .option("--markdown", "print Markdown")
                 .option("--bootstrap-surface", "write an inferred .harness/init-surface.json baseline")
-                .option("--apply-safe", "apply deterministic safe init updates")
-                .option("--client-recovery <mode>", "auto|project|user|off — OpenCode transient+overflow plugins, Pi overflow extension, optional Pi user retry config", "auto");
+                .option("--apply-safe", "apply deterministic safe init updates");
             command.action(async (args, _options, actionCommand) => runInitCommand(args, actionCommand, options.defaultRepoRoot));
             addStandaloneSubcommands(command, entry.subcommands ?? [], (args, actionCommand) => runInitCommand(args, actionCommand, options.defaultRepoRoot));
             program.addCommand(command);

package/dist/commands/init-legacy-audit.js

@@ -0,0 +1,330 @@
+import { execFile } from "node:child_process";
+import { createHash } from "node:crypto";
+import { lstat, readFile, realpath, unlink } from "node:fs/promises";
+import path from "node:path";
+import { z } from "zod";
+const SHA256 = /^[a-f0-9]{64}$/;
+const CATALOG_PATH = "resources/init-history/legacy-surface.v1.json";
+const catalogEntrySchema = z.object({
+    id: z.string().regex(/^[a-z0-9][a-z0-9-]*$/),
+    path: z.string().min(1),
+    mode: z.enum(["generated", "copied", "managed-block"]),
+    releaseFamily: z.string().min(1),
+    templateIdentity: z.string().min(1),
+    rawSha256: z.array(z.string().regex(SHA256)).default([]),
+    canonicalTextSha256: z.array(z.string().regex(SHA256)).default([]),
+    retirement: z.enum(["remove", "replace", "strip-block"]),
+}).strict();
+const catalogSchema = z.object({
+    schemaVersion: z.literal(1),
+    catalogVersion: z.number().int().positive(),
+    entries: z.array(catalogEntrySchema),
+}).strict().superRefine((catalog, ctx) => {
+    const ids = new Set();
+    const paths = new Set();
+    for (const [index, entry] of catalog.entries.entries()) {
+        if (!isSafeRelativePath(entry.path)) {
+            ctx.addIssue({ code: "custom", path: ["entries", index, "path"], message: "legacy path must be a normalized repo-relative file path" });
+        }
+        if (ids.has(entry.id))
+            ctx.addIssue({ code: "custom", path: ["entries", index, "id"], message: "duplicate legacy id" });
+        if (paths.has(entry.path))
+            ctx.addIssue({ code: "custom", path: ["entries", index, "path"], message: "duplicate legacy path" });
+        ids.add(entry.id);
+        paths.add(entry.path);
+    }
+});
+function sha256(value) {
+    return createHash("sha256").update(value).digest("hex");
+}
+function isSafeRelativePath(value) {
+    if (!value || value.includes("\\") || path.posix.isAbsolute(value))
+        return false;
+    const parts = value.split("/");
+    return parts.every((part) => part !== "" && part !== "." && part !== ".." && !part.includes("\0"));
+}
+function canonicalTextSha256(bytes) {
+    const text = bytes.toString("utf8");
+    if (!Buffer.from(text, "utf8").equals(bytes))
+        return undefined;
+    return sha256(Buffer.from(text.replace(/\r\n/g, "\n"), "utf8"));
+}
+function candidateId(catalogVersion, entry, rawSha256) {
+    return `legacy-v${catalogVersion}-${sha256(`${entry.id}\0${entry.path}\0${rawSha256}`).slice(0, 24)}`;
+}
+async function loadCatalog(assetRoot) {
+    const file = path.join(assetRoot, ...CATALOG_PATH.split("/"));
+    const parsed = JSON.parse(await readFile(file, "utf8"));
+    return catalogSchema.parse(parsed);
+}
+function execGit(repoRoot, args) {
+    return new Promise((resolve, reject) => {
+        execFile("git", ["-C", repoRoot, ...args], { encoding: "buffer", windowsHide: true, maxBuffer: 16 * 1024 * 1024 }, (error, stdout) => {
+            if (error)
+                reject(error);
+            else
+                resolve(stdout);
+        });
+    });
+}
+function parseObjectInventory(bytes) {
+    const result = new Map();
+    for (const record of bytes.toString("utf8").split("\0")) {
+        if (!record)
+            continue;
+        const tab = record.indexOf("\t");
+        if (tab < 0)
+            continue;
+        const metadata = record.slice(0, tab).trim().split(/\s+/);
+        const file = record.slice(tab + 1).replaceAll("\\", "/");
+        const treeRecord = metadata[1] === "blob";
+        const hash = treeRecord ? metadata[2] : metadata[1];
+        const stage = treeRecord ? undefined : metadata[2];
+        if (hash && (treeRecord || stage === "0"))
+            result.set(file, hash);
+    }
+    return result;
+}
+function parseChangedPaths(bytes, candidates) {
+    const changed = new Set();
+    for (const record of bytes.toString("utf8").split("\0")) {
+        if (!record)
+            continue;
+        for (const candidate of candidates) {
+            if (record === `? ${candidate}` || record.endsWith(` ${candidate}`) || record.endsWith(`\t${candidate}`))
+                changed.add(candidate);
+        }
+    }
+    return changed;
+}
+async function gitStates(repoRoot, paths) {
+    const result = new Map();
+    if (paths.length === 0)
+        return result;
+    try {
+        const pathArgs = ["--", ...paths];
+        const [headBytes, indexBytes, statusBytes] = await Promise.all([
+            execGit(repoRoot, ["ls-tree", "-rz", "HEAD", ...pathArgs]),
+            execGit(repoRoot, ["ls-files", "--stage", "-z", ...pathArgs]),
+            execGit(repoRoot, ["status", "--porcelain=v2", "-z", "--untracked-files=all", ...pathArgs]),
+        ]);
+        const head = parseObjectInventory(headBytes);
+        const index = parseObjectInventory(indexBytes);
+        const changed = parseChangedPaths(statusBytes, paths);
+        for (const candidatePath of paths) {
+            const headBlob = head.get(candidatePath);
+            const indexBlob = index.get(candidatePath);
+            const tracked = Boolean(headBlob && indexBlob);
+            const clean = tracked && headBlob === indexBlob && !changed.has(candidatePath);
+            result.set(candidatePath, {
+                tracked,
+                clean,
+                ...(headBlob ? { headBlob } : {}),
+                ...(indexBlob ? { indexBlob } : {}),
+                ...(!clean ? { status: changed.has(candidatePath) ? "changed" : tracked ? "index-head-mismatch" : "untracked-or-missing-index" } : {}),
+            });
+        }
+    }
+    catch (error) {
+        const status = `git-state-unavailable: ${error instanceof Error ? error.message : String(error)}`;
+        for (const candidatePath of paths)
+            result.set(candidatePath, { tracked: false, clean: false, status });
+    }
+    return result;
+}
+export async function inspectContainedRegularFile(repoRoot, relativePath) {
+    if (!isSafeRelativePath(relativePath))
+        return { conflict: "candidate path is not a normalized repo-relative file path" };
+    const absolute = path.join(repoRoot, ...relativePath.split("/"));
+    const info = await lstat(absolute).catch((error) => error.code === "ENOENT" ? undefined : Promise.reject(error));
+    if (!info)
+        return undefined;
+    if (!info.isFile() || info.isSymbolicLink())
+        return { conflict: "candidate is not a regular non-symlink file" };
+    let current = repoRoot;
+    for (const segment of relativePath.split("/").slice(0, -1)) {
+        current = path.join(current, segment);
+        const parent = await lstat(current);
+        if (parent.isSymbolicLink())
+            return { conflict: "candidate path crosses a symlink or junction" };
+    }
+    const [repoReal, fileReal] = await Promise.all([realpath(repoRoot), realpath(absolute)]);
+    const relative = path.relative(repoReal, fileReal);
+    if (!relative || relative === ".." || relative.startsWith(`..${path.sep}`) || path.isAbsolute(relative)) {
+        return { conflict: "candidate resolves outside repoRoot" };
+    }
+    return { bytes: await readFile(absolute) };
+}
+export async function removeContainedRegularFileWithSha256Cas(input) {
+    const inspected = await inspectContainedRegularFile(path.resolve(input.repoRoot), input.relativePath);
+    if (!inspected)
+        return "missing";
+    if ("conflict" in inspected || sha256(inspected.bytes) !== input.expectedSha256) {
+        return "rejected";
+    }
+    await unlink(path.join(path.resolve(input.repoRoot), ...input.relativePath.split("/")));
+    return "removed";
+}
+function hasLegacyProvenance(surface, catalog) {
+    if (!surface)
+        return false;
+    const catalogPaths = new Set(catalog.entries.map((entry) => entry.path));
+    if (Object.keys(surface.files).some((file) => catalogPaths.has(file)))
+        return true;
+    if ((surface.dispositions ?? []).some((receipt) => (receipt.disposition === "removed" || receipt.disposition === "detached-as-project-content") &&
+        catalogPaths.has(receipt.path)))
+        return true;
+    return (surface.actionReceipts ?? []).some((receipt) => (receipt.type === "remove-owned-file" ||
+        receipt.type === "migrate-owned-file" ||
+        receipt.type === "replace-owned-file") &&
+        catalogPaths.has(receipt.path));
+}
+async function trackedTextFiles(repoRoot) {
+    try {
+        return (await execGit(repoRoot, ["ls-files", "-z"]))
+            .toString("utf8")
+            .split("\0")
+            .filter((file) => isSafeRelativePath(file.replaceAll("\\", "/")))
+            .map((file) => file.replaceAll("\\", "/"));
+    }
+    catch {
+        return [];
+    }
+}
+async function referenceGraph(input) {
+    const result = new Map(input.candidates.map((candidate) => [candidate.path, []]));
+    const candidatesByPath = new Map(input.candidates.map((candidate) => [candidate.path, candidate]));
+    const files = await trackedTextFiles(input.repoRoot);
+    const nestedWorkspaceRoots = files
+        .filter((file) => /^[^/]+\/harness\.json$/.test(file))
+        .map((file) => `${file.slice(0, -"harness.json".length)}`);
+    for (const sourcePath of files) {
+        if (sourcePath.startsWith(".git/") || sourcePath.startsWith(".harness/init-upgrades/"))
+            continue;
+        if (nestedWorkspaceRoots.some((root) => sourcePath.startsWith(root)))
+            continue;
+        const absolute = path.join(input.repoRoot, ...sourcePath.split("/"));
+        const info = await lstat(absolute).catch(() => undefined);
+        if (!info?.isFile() || info.isSymbolicLink() || info.size > 1024 * 1024)
+            continue;
+        const bytes = await readFile(absolute);
+        if (bytes.includes(0))
+            continue;
+        const text = bytes.toString("utf8");
+        for (const candidate of input.candidates) {
+            if (!text.includes(candidate.path) && !text.includes(candidate.path.replaceAll("/", "\\")))
+                continue;
+            const sourceCandidate = candidatesByPath.get(sourcePath);
+            if (sourceCandidate && input.initiallyAutomatic.has(sourceCandidate.path))
+                continue;
+            result.get(candidate.path).push(sourcePath);
+        }
+    }
+    for (const consumers of result.values())
+        consumers.sort();
+    return result;
+}
+export async function auditLegacyInitSurface(input) {
+    const repoRoot = path.resolve(input.repoRoot);
+    const catalog = await loadCatalog(input.assetRoot);
+    const provenanceConfirmed = hasLegacyProvenance(input.surface, catalog);
+    const candidates = [];
+    const paths = [];
+    const retainedReceipts = new Map((input.surface?.dispositions ?? [])
+        .filter((receipt) => receipt.disposition === "retained-project-content" || receipt.disposition === "preserved-unproven-legacy" || receipt.disposition === "detached-as-project-content")
+        .map((receipt) => [receipt.path, receipt]));
+    for (const entry of catalog.entries) {
+        const inspected = await inspectContainedRegularFile(repoRoot, entry.path);
+        if (!inspected)
+            continue;
+        paths.push(entry.path);
+        if ("conflict" in inspected) {
+            candidates.push({ candidateId: candidateId(catalog.catalogVersion, entry, sha256(entry.path)), catalogEntryId: entry.id, path: entry.path, rawSha256: sha256(entry.path), evidenceClass: "path-conflict", git: { tracked: false, clean: false, status: inspected.conflict }, consumers: [], reason: inspected.conflict });
+            continue;
+        }
+        const raw = sha256(inspected.bytes);
+        const canonical = canonicalTextSha256(inspected.bytes);
+        const receipt = retainedReceipts.get(entry.path);
+        const receiptMatches = receipt && (receipt.resultSha256 === raw || receipt.recordedSha256 === raw);
+        const fingerprintMatch = entry.rawSha256.includes(raw) || Boolean(canonical && entry.canonicalTextSha256.includes(canonical));
+        const evidenceClass = receiptMatches
+            ? "project-content"
+            : fingerprintMatch && provenanceConfirmed
+                ? "historical-template-match"
+                : fingerprintMatch
+                    ? "legacy-shaped-unproven"
+                    : "recorded-owned-modified";
+        candidates.push({
+            candidateId: candidateId(catalog.catalogVersion, entry, raw),
+            catalogEntryId: entry.id,
+            path: entry.path,
+            rawSha256: raw,
+            ...(canonical ? { canonicalTextSha256: canonical } : {}),
+            evidenceClass,
+            git: { tracked: false, clean: false, status: "git-state-pending" },
+            consumers: [],
+            ...(receiptMatches ? { terminalDisposition: receipt.disposition === "preserved-unproven-legacy" ? "preserved-unproven-legacy" : "retained-project-content" } : {}),
+            reason: receiptMatches
+                ? "a hash-bound disposition already retains this file as project content"
+                : fingerprintMatch && provenanceConfirmed
+                    ? "path and historical fingerprint match, with independent legacy initialization evidence"
+                    : fingerprintMatch
+                        ? "historical bytes match, but independent legacy initialization provenance is unavailable"
+                        : "catalog path exists but bytes differ from every historical template fingerprint",
+        });
+    }
+    const states = await gitStates(repoRoot, paths);
+    for (const candidate of candidates)
+        candidate.git = states.get(candidate.path) ?? candidate.git;
+    const initiallyAutomatic = new Set(candidates
+        .filter((candidate) => candidate.evidenceClass === "historical-template-match" && candidate.git.clean && !candidate.terminalDisposition)
+        .map((candidate) => candidate.path));
+    const references = await referenceGraph({ repoRoot, candidates, initiallyAutomatic });
+    for (const candidate of candidates) {
+        candidate.consumers = references.get(candidate.path) ?? [];
+        if (candidate.terminalDisposition)
+            continue;
+        if (candidate.evidenceClass === "historical-template-match" && candidate.git.clean && candidate.consumers.length === 0) {
+            candidate.automaticAction = "remove-owned-file";
+        }
+        else if (candidate.evidenceClass === "historical-template-match" && !candidate.git.clean) {
+            candidate.evidenceClass = "recorded-owned-modified";
+            candidate.reason = `historical template match is not clean in Git (${candidate.git.status ?? "unknown"}); preserve until explicitly decided`;
+        }
+        else if (candidate.consumers.length > 0) {
+            candidate.reason = `external consumers must be migrated before retirement: ${candidate.consumers.join(", ")}`;
+        }
+    }
+    const automatic = candidates.filter((candidate) => candidate.automaticAction).length;
+    const retained = candidates.filter((candidate) => candidate.terminalDisposition).length;
+    const pending = candidates.length - automatic - retained;
+    const candidateSetSha256 = sha256(JSON.stringify(candidates.map((candidate) => ({ id: candidate.candidateId, path: candidate.path, rawSha256: candidate.rawSha256, evidenceClass: candidate.evidenceClass, consumers: candidate.consumers }))));
+    const migrationState = pending > 0
+        ? "review-required"
+        : automatic > 0
+            ? "in-progress"
+            : retained > 0
+                ? "retained"
+                : "clean";
+    return {
+        schemaVersion: 1,
+        catalogVersion: catalog.catalogVersion,
+        candidateSetSha256,
+        provenanceConfirmed,
+        migrationState,
+        candidates,
+        summary: { classified: candidates.length, automatic, retained, pending },
+    };
+}
+export function legacyAuditReceipt(report, removedCount) {
+    return {
+        catalogVersion: report.catalogVersion,
+        completedAt: new Date().toISOString(),
+        candidateSetSha256: report.candidateSetSha256,
+        classifiedCount: report.summary.classified,
+        removedCount,
+        retainedCount: report.summary.retained,
+        pendingCount: report.summary.pending,
+        migrationState: report.summary.pending > 0 ? "review-required" : report.summary.retained > 0 ? "retained" : report.summary.automatic > removedCount ? "in-progress" : "clean",
+    };
+}