agentic-flow-kit 0.5.0 → 0.6.0

package/src/doctor.mjs

@@ -4,6 +4,11 @@ import path from 'node:path';
 import { execSync, spawnSync } from 'node:child_process';
 import net from 'node:net';
 import { createHash } from 'node:crypto';
+import { listTree, scriptTrusted } from './render.mjs';
+import { isOwned, HOSTS, pickStackVars } from './profiles.mjs';
+
+// 宿主目录映射（与 src/profiles.mjs#HOSTS 同源：装副本目录名前缀带点）
+const HOST_DIR = Object.fromEntries(Object.entries(HOSTS).map(([k, v]) => [k, v.dir]));
 
 function sh(cmd, cwd) {
   try {
@@ -55,6 +60,7 @@ export function doctor(args, pkgRoot) {
     '.agents/settings.json',
     '.agents/workflows/_TEMPLATE.md',
     '.agents/scripts/check-loop.mjs',
+    '.agents/scripts/confirm-doc.mjs',
     '.githooks/pre-commit',
     '.githooks/pre-push',
     '.githooks/commit-msg',
@@ -75,7 +81,20 @@ export function doctor(args, pkgRoot) {
   const isRepo = sh('git rev-parse --git-dir', target).ok;
   if (isRepo) {
     const hp = sh('git config core.hooksPath', target);
-    if (hp.ok && hp.out.trim() === '.githooks') add('PASS', 'core.hooksPath=.githooks（钩子已挂载）');
+    if (hp.ok && hp.out.trim() === '.githooks') {
+      add('PASS', 'core.hooksPath=.githooks（钩子已挂载）');
+      // 执行位检查（init-p1-batch P1-1）：POSIX 上 git 对不可执行钩子静默跳过、全部门禁失效且原不可发现；
+      // win32 无执行位语义（mode 恒 0666 系），跳过本检查
+      if (process.platform !== 'win32') {
+        try {
+          const hookDir = path.join(target, '.githooks');
+          const noExec = fs.readdirSync(hookDir)
+            .filter((f) => fs.statSync(path.join(hookDir, f)).isFile())
+            .filter((f) => !(fs.statSync(path.join(hookDir, f)).mode & 0o111));
+          if (noExec.length) add('FAIL', `钩子缺执行位（POSIX 上 git 静默跳过不可执行钩子，门禁全部失效）：${noExec.join('、')}——执行 chmod +x .githooks/*`);
+        } catch { /* .githooks 目录缺失由 §2 布局检查覆盖 */ }
+      }
+    }
     else add('FAIL', `core.hooksPath 当前为「${(hp.ok ? hp.out : '').trim() || '未设置'}」——执行 git config core.hooksPath .githooks`);
   } else {
     add('WARN', '不在 git 仓库内——钩子未挂载（git init 后执行 git config core.hooksPath .githooks）');
@@ -94,7 +113,7 @@ export function doctor(args, pkgRoot) {
       for (const f of kit.managed || []) {
         const p = path.join(target, f.rel);
         if (!fs.existsSync(p)) { gone.push(f.rel); continue; }
-        const h = createHash('sha256').update(fs.readFileSync(p)).digest('hex');
+        const h = createHash('sha256').update(fs.readFileSync(p, 'utf8').replace(/\r\n/g, '\n'), 'utf8').digest('hex'); // LF 归一（closing-coverage：跨 checkout 稳定，同 sync shaText 口径）
         if (h === f.sha256) ok++; else modified++;
       }
       add('PASS', `kit.json v${kit.version}：managed ${ok + modified} 份校验通过`);
@@ -105,6 +124,35 @@ export function doctor(args, pkgRoot) {
     }
   }
 
+  // 4.5 台账覆盖率（2026-09-26 managed-ledger-adopt）：§4 只遍历台账条目做双向校验，
+  //     从不反向问「盘上还有谁没登记」——15 份 managed 类文件曾因此长期游离台账外，sync 只报不修。
+  //     本项由 pkgRoot 包源枚举应有 managed 清单（排除 isOwned）与台账取差集，补上「盘上有、台账无」一侧。
+  //     首次引入用 WARN：doctor 的 pkgRoot 是包安装目录，装户可能落后于包版本（包内新增 managed 件
+  //     在装户 sync 前必然未登记），直接 FAIL 会让存量装户升级包后一跑 doctor 即挂。
+  //     沿用本仓库三次先例（doctor-owned-drift / workflows-check / adapter 薄适配漂移均先 WARN）。
+  {
+    const covRes = checkLedgerCoverage(target, pkgRoot);
+    if (covRes.skipped) {
+      add('PASS', `台账覆盖率检查跳过（${covRes.note || '无包源模板'}）`);
+    } else if (covRes.missing.length === 0) {
+      add('PASS', `台账覆盖率完整（${covRes.total} 份 managed 全在册）`);
+    } else {
+      const shown = covRes.missing.slice(0, 5).join('、');
+      add('WARN', `台账覆盖率缺口 ${covRes.missing.length} 份——盘上 managed 类文件未登记进 kit.json，包源改动不会同步到装副本；跑 node bin/flow-kit.mjs sync 收养（内容等于新版才登记）${covRes.missing.length > 5 ? `：${shown} …` : `：${shown}`}`);
+    }
+  }
+
+  // scriptGuard（init-p1-batch P1-3 供应链防线）：spawn 目标侧脚本前校验其与包源渲染值（LF 归一）一致——
+  // 失配说明预置/被改动，不可信：调用方记 WARN 跳过（fail-visible，不执行也不下通过结论）。
+  // 无 pkgRoot（理论路径）不设防；vars 从 kit.json options 重建（与 sync 同源构造）。
+  const scriptGuard = (rel) => {
+    if (!pkgRoot) return { ok: true, note: '' };
+    let opts = null;
+    try { opts = JSON.parse(fs.readFileSync(kitPath, 'utf8')).options; } catch { /* 无/坏台账→用默认 vars */ }
+    const vars = { BOARD_PORT: String(opts?.boardPort || '8933'), ...pickStackVars(opts?.stack) };
+    return scriptTrusted({ pkgRoot, target, rel, vars });
+  };
+
   // 5. 占位符残留
   const phFiles = ['AGENTS.md', 'workflow/README.md', '.agents/notes/runtime-env.md']
     .concat(fs.existsSync(path.join(target, '.agents/commands')) ? fs.readdirSync(path.join(target, '.agents/commands')).filter((f) => f.endsWith('.md')).map((f) => `.agents/commands/${f}`) : []);
@@ -119,15 +167,26 @@ export function doctor(args, pkgRoot) {
   else add('WARN', `占位符残留 ${phHits.length} 处（init 变量缺失或需手改）：${phHits.slice(0, 5).join('；')}${phHits.length > 5 ? ' …' : ''}`);
 
   // 6. workflow 索引漂移
-  const idx = spawnSync(process.execPath, ['.agents/scripts/gen-workflow-index.mjs', '--check'], { cwd: target, encoding: 'utf8' });
-  if (idx.status === 0) add('PASS', 'workflow/INDEX.md 无漂移');
-  else add('WARN', `workflow/INDEX.md 漂移——跑 node .agents/scripts/gen-workflow-index.mjs 重生成`);
+  const idxGuard = scriptGuard('.agents/scripts/gen-workflow-index.mjs');
+  if (!idxGuard.ok) {
+    add('WARN', `workflow/INDEX.md 漂移检查跳过——${idxGuard.note}（供应链防线）`);
+  } else {
+    const idx = spawnSync(process.execPath, ['.agents/scripts/gen-workflow-index.mjs', '--check'], { cwd: target, encoding: 'utf8' });
+    if (idx.status === 0) add('PASS', 'workflow/INDEX.md 无漂移');
+    else add('WARN', `workflow/INDEX.md 漂移——跑 node .agents/scripts/gen-workflow-index.mjs 重生成`);
+  }
 
   // 6.5 delegations 台账结构（量化层非门禁：结构漂移曾静默吞掉全部记录，2026-09-24）
+  // 存在性先行（复核 P2-2）：旧装户无此脚本 = 既有「静默跳过」语义，不产生防线 WARN 噪音
   if (fs.existsSync(path.join(target, '.agents/scripts/agg-delegations.cjs'))) {
-    const agg = spawnSync(process.execPath, ['.agents/scripts/agg-delegations.cjs'], { cwd: target, encoding: 'utf8' });
-    if (agg.status === 0) add('PASS', 'delegations 台账结构有效（agg 可解析）');
-    else add('WARN', `delegations 台账结构漂移——${String(agg.stderr || agg.stdout || '').split('\n')[0]}`);
+    const aggGuard = scriptGuard('.agents/scripts/agg-delegations.cjs');
+    if (!aggGuard.ok) {
+      add('WARN', `delegations 台账结构检查跳过——${aggGuard.note}（供应链防线）`);
+    } else {
+      const agg = spawnSync(process.execPath, ['.agents/scripts/agg-delegations.cjs'], { cwd: target, encoding: 'utf8' });
+      if (agg.status === 0) add('PASS', 'delegations 台账结构有效（agg 可解析）');
+      else add('WARN', `delegations 台账结构漂移——${String(agg.stderr || agg.stdout || '').split('\n')[0]}`);
+    }
   }
 
   // 6.6 owned 漂移校验（kit.owned 列表盘面 sha 不一致；engine 双源纪律对 owned 走「项目自持 + 哈希记账不约束」，
@@ -165,7 +224,16 @@ export function doctor(args, pkgRoot) {
   //     2026-09-25 workflows-linter 把 _TEMPLATE.md「解析校验先行」从 prose 变机器门。首次引入 WARN
   //     （沿用 wf-runtime 复盘「先 WARN 升级 FAIL」渐进路径），装户吃过警告后可升 FAIL。
   //     旧版装户 sync 前 .agents/scripts/workflows-check.mjs 不存在 → 自然跳过不误报）
-  if (fs.existsSync(path.join(target, '.agents/scripts/workflows-check.mjs')) && fs.existsSync(path.join(target, '.agents/workflows'))) {
+  // 6.8 workflows 编排脚本 lint（stages 表解析校验：role/step/after 引用、无环、三形态互斥、数值枚举；
+  //     2026-09-25 workflows-linter 把 _TEMPLATE.md「解析校验先行」从 prose 变机器门。首次引入 WARN
+  //     （沿用 wf-runtime 复盘「先 WARN 升级 FAIL」渐进路径），装户吃过警告后可升 FAIL。
+  //     旧版装户 sync 前 .agents/scripts/workflows-check.mjs 不存在 → 既有「静默跳过」语义保留（存在性先行，
+  //     复核 P2-2），防线只拦「存在但与包源不符」）
+  const wfExists = fs.existsSync(path.join(target, '.agents/scripts/workflows-check.mjs')) && fs.existsSync(path.join(target, '.agents/workflows'));
+  const wfGuard = wfExists ? scriptGuard('.agents/scripts/workflows-check.mjs') : { ok: true, note: '' };
+  if (wfExists && !wfGuard.ok) {
+    add('WARN', `workflows 编排脚本 lint 跳过——${wfGuard.note}（供应链防线）`);
+  } else if (wfExists) {
     const wf = spawnSync(process.execPath, ['.agents/scripts/workflows-check.mjs'], { cwd: target, encoding: 'utf8' });
     if (wf.status === 0) {
       const warnN = (String(wf.stdout || '').match(/- ⚠️ W\d/g) || []).length;
@@ -179,12 +247,17 @@ export function doctor(args, pkgRoot) {
   // 7. check-loop——2026-09-26 check-loop-node 起 node 实现直跑（sh 版曾需先探 sh 可用性：Windows
   //    PowerShell 常无 sh，ENOENT 曾被吞进 hard-block 分支报成空原因假警报，incident 2026-09-24-doctor-sh-enoent；
   //    迁移后无 sh 依赖，探针退役。check-loop.sh 为兼容 shim，pre-push 钩子路径照常）
-  const cl = spawnSync(process.execPath, ['.agents/scripts/check-loop.mjs'], { cwd: target, encoding: 'utf8' });
-  if (cl.status === 0) {
-    const warnTxt = String(cl.stderr || '').trim();
-    add('PASS', `check-loop 干净${warnTxt ? `（${warnTxt.split('\n').filter((l) => l.includes('WARN')).length} 条 advisory 警告）` : ''}`);
+  const clGuard = scriptGuard('.agents/scripts/check-loop.mjs');
+  if (!clGuard.ok) {
+    add('WARN', `check-loop 跳过——${clGuard.note}（供应链防线：目标侧脚本与包源渲染值不符，不执行不下结论）`);
   } else {
-    add('FAIL', `check-loop 有 hard-block：\n${String(cl.stderr || '').split('\n').slice(0, 8).join('\n')}`);
+    const cl = spawnSync(process.execPath, ['.agents/scripts/check-loop.mjs'], { cwd: target, encoding: 'utf8' });
+    if (cl.status === 0) {
+      const warnTxt = String(cl.stderr || '').trim();
+      add('PASS', `check-loop 干净${warnTxt ? `（${warnTxt.split('\n').filter((l) => l.includes('WARN')).length} 条 advisory 警告）` : ''}`);
+    } else {
+      add('FAIL', `check-loop 有 hard-block：\n${String(cl.stderr || '').split('\n').slice(0, 8).join('\n')}`);
+    }
   }
 
   // 8. 看板端口（信息级）
@@ -207,6 +280,34 @@ function print(results) {
   console.log(`\ndoctor：${results.length - fails - warns} PASS ｜ ${warns} WARN ｜ ${fails} FAIL`);
 }
 
+export function checkLedgerCoverage(target, pkgRoot) {
+  const kitPath = path.join(target, '.agents', 'kit.json');
+  if (!fs.existsSync(kitPath)) return { missing: [], total: 0, skipped: true, note: 'kit.json 不存在' };
+  let kit;
+  try {
+    kit = JSON.parse(fs.readFileSync(kitPath, 'utf8'));
+  } catch (e) {
+    return { missing: [], total: 0, skipped: true, note: `kit.json 解析失败：${e.message}` };
+  }
+  if (!Array.isArray(kit.managed)) return { missing: [], total: 0, skipped: true, note: 'kit.json 无 managed 条目' };
+  // 无包源 = 装户环境：盘上没有 templates/，无法枚举应有清单，跳过
+  const tmplRoot = path.join(pkgRoot || '', 'templates');
+  if (!pkgRoot || !fs.existsSync(tmplRoot)) return { missing: [], total: 0, skipped: true, note: '无包源模板（templates/ 不存在）' };
+
+  // 应有清单 = 模板树 + 台账宿主层，排除 owned（与 src/sync.mjs 的 fresh 计算口径一致）
+  const expected = new Set(listTree(tmplRoot));
+  const hosts = Array.isArray(kit.options?.hosts) ? kit.options.hosts : [];
+  for (const h of hosts) {
+    if (!HOST_DIR[h]) continue;
+    const hostRoot = path.join(pkgRoot, 'modules', 'hosts', h);
+    if (!fs.existsSync(hostRoot)) continue;
+    for (const rel of listTree(hostRoot)) expected.add(`${HOST_DIR[h]}/${rel}`);
+  }
+  const ledger = new Set(kit.managed.map((f) => f.rel));
+  const missing = [...expected].filter((rel) => !ledger.has(rel) && !isOwned(rel)).sort();
+  return { missing, total: ledger.size, skipped: false };
+}
+
 // owned 漂移校验（独立 export 供 doctor 主流程 + 单元测试共用；2026-09-25 wf-runtime 复盘）
 // 返回：{ drift, gone, total, skipped, error? }
 //   - skipped=true：kit.json 不存在或解析失败/无 owned 字段
@@ -229,7 +330,9 @@ export function checkOwnedDrift(target) {
   for (const f of owned) {
     const p = path.join(target, f.rel);
     if (!fs.existsSync(p)) { gone.push(f.rel); continue; }
-    const h = createHash('sha256').update(fs.readFileSync(p)).digest('hex');
+    // sha 按 LF 归一口径（同 rule-budgets「索引/HEAD 字节」约定）：盘面 CRLF（autocrlf 检出）与克隆检出 LF
+    // 须同值，否则跨环境必漂移（CI 克隆 §6.6 必红——2026-09-27 gate-coverage 复核 P1-1 根因；owned 均为文本件）
+    const h = createHash('sha256').update(fs.readFileSync(p, 'utf8').replace(/\r\n/g, '\n'), 'utf8').digest('hex');
     if (h !== f.sha256) drift++;
   }
   return { drift, gone, total: owned.length, skipped: false };
@@ -251,15 +354,15 @@ export function checkAdapterDrift(target) {
   if (fs.existsSync(path.join(target, 'templates', '_agents')) && fs.existsSync(path.join(target, 'modules', 'hosts'))) {
     return { drift: 0, total: 0, skipped: true, note: '包源环境（templates/ + modules/ 同时存在）——§7.x 仅在装户环境有意义' };
   }
-  // 4 宿主目录映射（与 src/profiles.mjs#HOSTS 同源：装副本目录名前缀带点）
-  const HOST_DIR = { zcode: '.zcode', omp: '.omp', opencode: '.opencode', trae: '.trae' };
+  // 4 宿主目录映射（与顶层 HOST_DIR 同源）
   const splitFm = (text) => {
     const m = String(text || '').match(/^---\r?\n([\s\S]*?\r?\n)---\r?\n?([\s\S]*)$/);
     if (!m) return { fm: '', body: String(text || '') };
     return { fm: `---\n${m[1]}---\n`, body: m[2] };
   };
   const bodySha = (p) => {
-    try { return createHash('sha256').update(splitFm(fs.readFileSync(p, 'utf8')).body).digest('hex'); } catch { return null; }
+    // 正文段 LF 归一后哈希（closing-coverage：与 sync-hosts bodySha 同口径，CRLF/LF 盘面不误报漂移）
+    try { return createHash('sha256').update(splitFm(fs.readFileSync(p, 'utf8')).body.replace(/\r\n/g, '\n'), 'utf8').digest('hex'); } catch { return null; }
   };
   let total = 0;
   let drift = 0;

package/src/gate-dotnet-ca.test.mjs

@@ -0,0 +1,124 @@
+#!/usr/bin/env node
+// gate-dotnet-ca.test.mjs — dotnet-ca 门禁模块判定回归（2026-09-27 host-gates-p1，incident 三件套「防复发验证」落点）
+// 方法：fixture 临时 git 仓构造 CONFIG 指向的最小目录树，复制包源 check-architecture.sh 并按场景改 CONFIG，
+//       spawn sh 跑门禁断言 exit 码与输出。三场景对位三个 P1：
+//       ①豁免清单多值生效（P1-B1：旧 tr ':' '|' 造 "A|B" BRE 字面量永不命中）
+//       ②CONTROLLERS_DIR 缺失 fail-closed（P1-B3：旧 2>/dev/null 静默放行）
+//       ③csproj 缺失 fail-closed（随 B3：旧 glob 展开失败静默放行）
+// 用法：node src/gate-dotnet-ca.test.mjs（npm test 随跑）
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { spawnSync } from 'node:child_process';
+import { fileURLToPath } from 'node:url';
+
+let pass = 0;
+let fail = 0;
+const check = (desc, cond, detail = '') => {
+  if (cond) { pass++; console.log(`PASS  ${desc}`); }
+  else { fail++; console.log(`FAIL  ${desc}${detail ? `\n${detail}` : ''}`); }
+};
+
+const PKG_ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
+const GATE_SRC = path.join(PKG_ROOT, 'modules', 'gates', 'dotnet-ca', 'check-architecture.sh');
+
+// mkfixture：最小 dotnet 目录树（Application/API/Domain/Infrastructure/Controllers）+ 可覆盖 CONFIG
+function mkfixture(configOverride = {}) {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'gate-ca-test-'));
+  const dirs = {
+    APP_DIR: 'backend/src/App.Application',
+    API_DIR: 'backend/src/App.API',
+    DBCTX_FILE: 'backend/src/App.Infrastructure/Data/AppDbContext.cs',
+    DOMAIN_ENTITIES_DIR: 'backend/src/App.Domain/Entities',
+    CONTROLLERS_DIR: 'backend/src/App.API/Controllers',
+  };
+  for (const rel of Object.values(dirs)) fs.mkdirSync(path.dirname(path.join(root, rel)), { recursive: true }); // 文件型键取父目录；目录型键随后显式建
+  fs.mkdirSync(path.join(root, dirs.APP_DIR), { recursive: true });
+  fs.mkdirSync(path.join(root, dirs.API_DIR), { recursive: true });
+  fs.mkdirSync(path.join(root, dirs.DOMAIN_ENTITIES_DIR), { recursive: true });
+  fs.mkdirSync(path.join(root, dirs.CONTROLLERS_DIR), { recursive: true });
+  fs.writeFileSync(path.join(root, dirs.DBCTX_FILE), 'class AppDbContext { }\n');
+  const cfg = {
+    ...Object.fromEntries(Object.entries(dirs).map(([k, v]) => [k, v])),
+    DBCTX_CLASS: 'AppDbContext',
+    INFRA_USING: 'using App.Infrastructure',
+    EXEMPT_CTRL: 'ExemptedA:ExemptedB',
+    SHARED_TYPES: '',
+    ...configOverride,
+  };
+  // 包源脚本 CONFIG 段替换：按「^KEY=" 任意到行尾」整行重写（值含 / 且行尾带注释——不用值内正则）；
+  // EXEMPT_CTRL/SHARED_TYPES 行尾有注释，重写时保留注释语义（测试值自带说明则省略）
+  let script = fs.readFileSync(GATE_SRC, 'utf8');
+  for (const [k, v] of Object.entries(cfg)) {
+    script = script.replace(new RegExp(`^${k}=.*$`, 'm'), `${k}="${v}"`);
+  }
+  const scriptPath = path.join(root, 'check-architecture.sh');
+  fs.writeFileSync(scriptPath, script);
+  // fixture 需为 git 仓（脚本首行 git rev-parse --show-toplevel）
+  spawnSync('git', ['init', '-q', '.'], { cwd: root });
+  return { root, scriptPath, dirs };
+}
+const runGate = (root, scriptPath) => spawnSync('sh', [scriptPath], { cwd: root, encoding: 'utf8' });
+// ctrlWrite：往 fixture 的 Controllers 目录写文件（目录可能尚未创建）
+const ctrlWrite = (root, dirs, name, content) => {
+  fs.mkdirSync(path.join(root, dirs.CONTROLLERS_DIR), { recursive: true });
+  fs.writeFileSync(path.join(root, dirs.CONTROLLERS_DIR, name), content);
+};
+// addCsproj：补干净 csproj（fail-closed 后红线 1 先查 csproj——不写则走不到目标断言）
+const addCsproj = (root, dirs) => fs.writeFileSync(path.join(root, dirs.APP_DIR, 'App.Application.csproj'), '<Project Sdk="Microsoft.NET.Sdk" />\n');
+
+// ---- ① 豁免清单多值（P1-B1）----
+{
+  const { root, scriptPath, dirs } = mkfixture();
+  addCsproj(root, dirs);
+  // API 层两处 DbContext 引用：一个在豁免 Controller 文件、一个在普通 Controller——豁免只应放过前者
+  ctrlWrite(root, dirs, 'ExemptedAController.cs', '// AppDbContext 直接引用（豁免）\n');
+  ctrlWrite(root, dirs, 'OrdersController.cs', '// AppDbContext 直接引用（应拦）\n');
+  const r = runGate(root, scriptPath);
+  check('①多值豁免生效：ExemptedA 文件行不出现、Orders 行出现（违例 exit 1）',
+    r.status === 1 && !r.stderr.includes('ExemptedAController') && r.stderr.includes('OrdersController'),
+    `exit=${r.status}\n${r.stdout}\n${r.stderr}`);
+  fs.rmSync(root, { recursive: true, force: true });
+}
+// ①附：干净树（豁免命中全部 DbContext 引用）→ 红线 3 不拦（整体 exit 0 需其余红线干净）
+{
+  const { root, scriptPath, dirs } = mkfixture();
+  addCsproj(root, dirs);
+  ctrlWrite(root, dirs, 'ExemptedAController.cs', '// AppDbContext\n');
+  ctrlWrite(root, dirs, 'ExemptedBController.cs', '// AppDbContext\n');
+  const r = runGate(root, scriptPath);
+  check('①两个豁免 Controller 全命中 → 红线 3 零输出 exit 0', r.status === 0 && !r.stderr, `exit=${r.status}\n${r.stderr}`);
+  fs.rmSync(root, { recursive: true, force: true });
+}
+
+// ---- ② CONTROLLERS_DIR 缺失 fail-closed（P1-B3）----
+{
+  const { root, scriptPath, dirs } = mkfixture({ CONTROLLERS_DIR: 'backend/src/App.API/NotThere' });
+  addCsproj(root, dirs);
+  const r = runGate(root, scriptPath);
+  check('②Controllers 目录缺失 → fail-closed exit 1 点名目标（旧代码静默放行）',
+    r.status === 1 && r.stderr.includes('NotThere') && r.stderr.includes('fail-closed'),
+    `exit=${r.status}\n${r.stderr}`);
+  fs.rmSync(root, { recursive: true, force: true });
+}
+
+// ---- ③ csproj 缺失 fail-closed（随 B3）----
+{
+  const { root, scriptPath } = mkfixture();
+  // Application 目录存在但无 .csproj（glob 展开失败形态）
+  const r = runGate(root, scriptPath);
+  check('③Application 无 csproj → fail-closed exit 1（旧代码静默放行）',
+    r.status === 1 && r.stderr.includes('csproj') && r.stderr.includes('fail-closed'),
+    `exit=${r.status}\n${r.stderr}`);
+  fs.rmSync(root, { recursive: true, force: true });
+}
+// ③附：有 csproj 且干净 → 过红线 1
+{
+  const { root, scriptPath, dirs } = mkfixture();
+  fs.writeFileSync(path.join(root, dirs.APP_DIR, 'App.Application.csproj'), '<Project Sdk="Microsoft.NET.Sdk" />\n');
+  const r = runGate(root, scriptPath);
+  check('③干净 csproj 存在 → 整体 exit 0', r.status === 0, `exit=${r.status}\n${r.stderr}`);  fs.rmSync(root, { recursive: true, force: true });
+}
+
+console.log(`\n合计: PASS ${pass} / FAIL ${fail}`);
+process.exit(fail ? 1 : 0);

package/src/init.mjs

@@ -4,7 +4,7 @@ import fs from 'node:fs';
 import path from 'node:path';
 import readline from 'node:readline';
 import { execSync, spawnSync } from 'node:child_process';
-import { renderTree, renderContent, sha256 } from './render.mjs';
+import { renderTree, renderContent, sha256, scriptTrusted, listTree } from './render.mjs';
 import { HOSTS, STACKS, STACK_ALIASES, settingsJson, commitCheckConfig, pickStackVars, isOwned } from './profiles.mjs';
 import { doctor } from './doctor.mjs';
 
@@ -112,7 +112,12 @@ async function interactive() {
       console.log(dim('  ⚠️ 没认出——序号或名称再来一次'));
     }
     console.log(`\n${cyan('── 3/3 · workflow 看板端口')}`);
-    const boardPort = (await p.ask(dim('  直接回车 = 8933'))) || '8933';
+    let boardPort = '';
+    for (;;) {
+      boardPort = (await p.ask(dim('  直接回车 = 8933'))) || '8933';
+      if (/^(0|[1-9]\d*)$/.test(String(boardPort)) && Number(boardPort) >= 1 && Number(boardPort) <= 65535) break;
+      console.log(dim('  ⚠️ 端口须为 1-65535 整数——再来一次'));
+    }
 
     console.log(`\n  ${bold(`宿主 ${hosts.join('、')}`)}${dim(' ｜ ')}${bold(`技术栈 ${stack}`)}${dim(' ｜ ')}${bold(`端口 ${boardPort}`)}`);
     const yes = await p.ask(dim('  确认安装到当前目录？(y/n，回车取消)'));
@@ -150,6 +155,10 @@ export async function init(args, pkgRoot) {
 
   opt.stack = normalizeStack(opt.stack);
   if (!STACKS[opt.stack]) fail(`未知技术栈：${opt.stack}（可选 dotnet | node（ts/js） | python | go | none——对应编译检查与自检验命令初值）`);
+  // 端口校验（2026-09-27 p2-batch1）：任意字符串曾直进 vars 渲染进 AGENTS.md（AI 每会话必读面）——1-65535 整数 fail-fast
+  if (!/^(0|[1-9]\d*)$/.test(String(opt.boardPort)) || Number(opt.boardPort) < 1 || Number(opt.boardPort) > 65535) {
+    fail(`--board-port 须为 1-65535 整数（现「${opt.boardPort}」）`);
+  }
   const hosts = opt.hosts.split(',').map((s) => s.trim()).filter(Boolean);
   for (const h of hosts) {
     if (!HOSTS[h]) fail(`未知宿主：${h}（可选 ${Object.keys(HOSTS).join(' | ')}）`);
@@ -167,12 +176,23 @@ export async function init(args, pkgRoot) {
   console.log(`${bold(cyan('▶ flow-kit init'))}${dim(' → ')}${target}`);
   console.log(`  宿主：${hosts.join(', ')} ｜ 技术栈：${opt.stack} ｜ 看板端口：${opt.boardPort}`);
 
-  // 1) 模板树（保守：已存在文件跳过，--force 覆盖）
-  const t = renderTree(path.join(pkgRoot, 'templates'), target, vars, { force: opt.force });
+  // 1) 模板树（保守：已存在文件跳过，--force 覆盖；p2-batch1：--force 下已存在 owned 仍跳过——
+  //    「项目自持」两态模型在重装路径的对齐，实测曾静默丢用户自定义「项目适配区」内容。
+  //    保护集 = 包源模板树内 isOwned 为真的 rel，现场枚举单源不另抄清单）
+  const protectSet = opt.force
+    ? new Set(listTree(path.join(pkgRoot, 'templates')).filter((rel) => isOwned(rel)))
+    : null;
+  const t = renderTree(path.join(pkgRoot, 'templates'), target, vars, { force: opt.force, protectSet });
+  for (const rel of t.protectedSkipped || []) {
+    console.log(`  跳过（owned 项目自持，--force 不覆盖）：${rel}——如需重置请手动删除后重跑`);
+  }
 
-  // 1.5) AGENTS.md 特例：已存在且无骨架标记 → 文末追加补齐（原内容保留）；带标记 → 保守跳过
+  // 1.5) AGENTS.md 特例：已存在且无骨架标记 → 文末追加补齐（原内容保留）；带标记 → 保守跳过。
+  //  门槛含 protectedSkipped（p2-batch1 复核 P1-2）：--force 下 owned 保护跳过也属「已存在不覆盖」，
+  //  无骨架时同样要追加（追加本就是非覆盖语义，与保护不冲突）——否则自带 AGENTS.md 的装户经
+  //  --force 重装永远拿不到工作流骨架且无感知
   let agentsMergedSha = null;
-  if (t.skipped.includes('AGENTS.md')) {
+  if (t.skipped.includes('AGENTS.md') || (t.protectedSkipped || []).includes('AGENTS.md')) {
     const agentsAbs = path.join(target, 'AGENTS.md');
     const existing = fs.readFileSync(agentsAbs, 'utf8');
     if (hasAgentsSkeleton(existing)) {
@@ -181,7 +201,8 @@ export async function init(args, pkgRoot) {
     } else {
       const incoming = renderContent(fs.readFileSync(path.join(pkgRoot, 'templates', 'AGENTS.md'), 'utf8'), vars);
       fs.writeFileSync(agentsAbs, mergeAgents(existing, incoming));
-      agentsMergedSha = sha256(fs.readFileSync(agentsAbs));
+      // LF 归一记账（init-p1-batch P1-4）：用户 CRLF 原文 + LF 追加的混合文件与 doctor §6.6 / sync ownedSha 同口径
+      agentsMergedSha = sha256(Buffer.from(fs.readFileSync(agentsAbs, 'utf8').replace(/\r\n/g, '\n'), 'utf8'));
       t.skipped = t.skipped.filter((r) => r !== 'AGENTS.md');
       console.log('  AGENTS.md 已存在但无工作流骨架——文末追加补齐（原内容保留，「项目适配区」照常自填）');
     }
@@ -192,6 +213,16 @@ export async function init(args, pkgRoot) {
   for (const h of hosts) {
     hostResults[h] = renderTree(path.join(pkgRoot, 'modules', 'hosts', h), path.join(target, HOSTS[h].dir), vars, { force: opt.force });
   }
+  // 换 --hosts 重装：旧宿主目录脱账提示（kit.json 只记新宿主，孤儿对 doctor §4.5 不可见——审查 P2-1 附带）
+  if (fs.existsSync(kitPath)) {
+    try {
+      const oldHosts = (JSON.parse(fs.readFileSync(kitPath, 'utf8')).options?.hosts) || [];
+      const removed = oldHosts.filter((h) => HOSTS[h] && !hosts.includes(h));
+      for (const h of removed) {
+        console.log(`  ⚠️ 旧宿主 ${HOSTS[h].dir}/ 不在新 --hosts 清单——其文件已脱账（成静默孤儿），如弃用请手动删除目录`);
+      }
+    } catch { /* 旧台账不可读（--force 重装修复场景），跳过提示 */ }
+  }
 
   // 3) 生成的 owned 基线配置（引擎按固定路径读取；存在则跳过，永不覆盖；技术栈命令由项目在文件内自填）
   const generated = {
@@ -231,13 +262,49 @@ export async function init(args, pkgRoot) {
     console.log('  ⚠️ 目标不是 git 仓库——钩子未挂载；git init 后手动执行：git config core.hooksPath .githooks');
   }
 
-  // 6) kit.json：managed（模板/适配层，升级可覆盖）与 owned（基线配置+起步文档，升级不动）台账
+  // 6) 生成器首跑（幂等）：workflow/INDEX.md 活跃层索引 + wiki 速览计数与看板 DATA
+  //    先于 kit.json 记账（init-p1-batch P1-2：生成器会重写 owned 起步文档，先跑后记账则 doctor §6.6 对账即绿，
+  //    fresh init 不再必现 owned FAIL / exit 1）；执行前过供应链防线（P1-3）——目标侧脚本与包源渲染值
+  //    sha 一致才执行（目标目录预置脚本不可信，「已存在保守跳过」语义下预置件会被原样保留）
+  const guardRun = (rel) => {
+    const g = scriptTrusted({ pkgRoot, target, rel, vars });
+    if (!g.ok) {
+      console.log(`  ⚠️ 跳过执行 ${rel}——${g.note}（供应链防线：只执行与包源渲染值一致的目标侧脚本）`);
+      return false;
+    }
+    return true;
+  };
+  if (guardRun('.agents/scripts/gen-workflow-index.mjs')) {
+    const genIndex = runNode(target, '.agents/scripts/gen-workflow-index.mjs');
+    console.log(genIndex.ok ? '  已生成 workflow/INDEX.md（活跃层索引）' : `  ⚠️ gen-workflow-index 失败：${genIndex.out.split('\n')[0]}`);
+  }
+  if (guardRun('.agents/scripts/gen-wiki-board.mjs')) {
+    const genBoard = runNode(target, '.agents/scripts/gen-wiki-board.mjs');
+    console.log(genBoard.ok ? '  已生成 wiki 速览计数与知识沉淀总览 DATA' : `  ⚠️ gen-wiki-board 失败：${genBoard.out.split('\n')[0]}`);
+  }
+
+  // 7) kit.json：managed（模板/适配层，升级可覆盖）与 owned（基线配置+起步文档，升级不动）台账
+  //    owned 的生成器目标按生成后盘面重记（P1-2）；记账一律 LF 归一 sha（P1-4——render 写盘已归一，
+  //    生成器重写目标与用户合并文件两侧同口径，跨 checkout 字节稳定）
+  const shaText = (p) => sha256(Buffer.from(fs.readFileSync(p, 'utf8').replace(/\r\n/g, '\n'), 'utf8'));
+  const GEN_TARGETS = new Set(['workflow/INDEX.md', 'wiki/INDEX.md', 'wiki/知识沉淀总览.html']); // 新增生成器目标须同步本清单
   const managed = [
     ...t.written.filter((f) => !isOwned(f.rel)),
     // 宿主文件渲染时相对宿主根，入台账须还原为项目根相对路径
     ...hosts.flatMap((h) => hostResults[h].written.map((f) => ({ ...f, rel: `${HOSTS[h].dir}/${f.rel}` }))),
   ];
-  const owned = [...t.written.filter((f) => isOwned(f.rel)), ...ownedGenerated];
+  const owned = [...t.written.filter((f) => isOwned(f.rel)), ...ownedGenerated]
+    .map((f) => (GEN_TARGETS.has(f.rel) && fs.existsSync(path.join(target, f.rel))
+      ? { ...f, sha256: shaText(path.join(target, f.rel)) }
+      : f));
+  // protectedSkipped 件按盘面 LF 归一 sha 补记（p2-batch1 复核 P2-3）：--force 重装受保护 owned
+  // 不补记会让 doctor §6.6 的漂移可见性静默消失（台账缺口对体检不可见）
+  for (const rel of t.protectedSkipped || []) {
+    if (!isOwned(rel) || !fs.existsSync(path.join(target, rel))) continue;
+    if (rel === 'AGENTS.md' && agentsMergedSha) continue; // 追加特例已记（agentsMergedSha），避免台账重复条目（复核收口 P2）
+    if (owned.some((f) => f.rel === rel)) continue;
+    owned.push({ rel, sha256: shaText(path.join(target, rel)) });
+  }
   if (agentsMergedSha) owned.push({ rel: 'AGENTS.md', sha256: agentsMergedSha });
   const pkg = JSON.parse(fs.readFileSync(path.join(pkgRoot, 'package.json'), 'utf8'));
   fs.mkdirSync(path.dirname(kitPath), { recursive: true });
@@ -251,14 +318,9 @@ export async function init(args, pkgRoot) {
   }, null, 2)}\n`);
   console.log(`  kit.json 台账：managed ${managed.length} 份 ｜ owned ${owned.length} 份（版本 ${pkg.version}）`);
 
-  // 7) 生成器首跑（幂等）：workflow/INDEX.md 活跃层索引 + wiki 速览计数与看板 DATA
-  const genIndex = runNode(target, '.agents/scripts/gen-workflow-index.mjs');
-  console.log(genIndex.ok ? '  已生成 workflow/INDEX.md（活跃层索引）' : `  ⚠️ gen-workflow-index 失败：${genIndex.out.split('\n')[0]}`);
-  const genBoard = runNode(target, '.agents/scripts/gen-wiki-board.mjs');
-  console.log(genBoard.ok ? '  已生成 wiki 速览计数与知识沉淀总览 DATA' : `  ⚠️ gen-wiki-board 失败：${genBoard.out.split('\n')[0]}`);
-
-  // 8) 自检
-  console.log('▶ flow-kit doctor');
+  // 8) 自检（kit.json 已按生成后盘面记账——doctor §6.6 应全绿，fresh init 以 exit 0 收场）
+  // 输出语义（p2-batch1 P2-4）：doctor 打印在异步端口回调里、晚于本横幅——脚本化消费方按退出码判定
+  console.log('▶ flow-kit doctor（安装产物已就位；体检 FAIL 时本命令 exit 1，产物无损——按 FAIL 项处置）');
   doctor(['--dir', target], pkgRoot);
 
   if (t.skipped.length) console.log(`  跳过（已存在，未覆盖）：${t.skipped.join('、')}`);

package/src/init.test.mjs

@@ -5,7 +5,8 @@
 //       ③非法输入返回 null（就地重问信号）；④空输入回默认（EOF/直接回车安全回退）；⑥装户面含 runner/workflows。
 // 用法：node src/init.test.mjs
 import { normalizeStack, parseChoices, hasAgentsSkeleton, mergeAgents } from './init.mjs';
-import { renderTree } from './render.mjs';
+import { renderTree, scriptTrusted, listTree } from './render.mjs';
+import { sha256 } from './render.mjs';
 import fs from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
@@ -71,6 +72,64 @@ check('合并：原内容为空时骨架即全文', mergeAgents('', '<!-- m -->\
   fs.rmSync(tmp, { recursive: true, force: true });
 }
 
+// ---- ⑦ 钩子执行位 + 供应链防线 + 记账归一（2026-09-27 init-p1-batch 复核条件①）----
+{
+  const tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'init-p1-'));
+  const pkgRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
+  const vars = { BOARD_PORT: '8933' };
+  const t = renderTree(path.join(pkgRoot, 'templates'), tmp, vars, { force: true });
+  // P1-1：renderTree 落盘执行位——win32 下 statSync().mode 无 0o111 语义（恒 0666 系），
+  // 断言「writeFileSync 带 mode 参数不炸 + POSIX 语义表达」；真值在 POSIX CI 腿验证
+  const hookStat = fs.statSync(path.join(tmp, '.githooks', 'pre-commit'));
+  const hookHasExecBit = (hookStat.mode & 0o111) !== 0;
+  check('钩子落盘执行位：writeFileSync mode=0755 不炸且 POSIX 语义下可执行位为真（win32 平台分支容忍）',
+    hookHasExecBit || process.platform === 'win32',
+    `mode=${(hookStat.mode & 0o777).toString(8)} platform=${process.platform}`);
+  // P1-3：scriptTrusted——一致放行 / 预置拒绝 / 包源无模板拒绝
+  const ok1 = scriptTrusted({ pkgRoot, target: tmp, rel: '.agents/scripts/gen-workflow-index.mjs', vars });
+  check('scriptTrusted：与包源渲染值一致 → ok', ok1.ok, ok1.note);
+  fs.writeFileSync(path.join(tmp, '.agents/scripts/gen-workflow-index.mjs'), 'require("fs").writeFileSync("MARKER","pwned")\n');
+  const bad1 = scriptTrusted({ pkgRoot, target: tmp, rel: '.agents/scripts/gen-workflow-index.mjs', vars });
+  check('scriptTrusted：预置/被改动 → 拒绝且 note 可见', !bad1.ok && bad1.note.includes('不符'), bad1.note);
+  const bad2 = scriptTrusted({ pkgRoot, target: tmp, rel: '.agents/scripts/not-in-pkg.mjs', vars });
+  check('scriptTrusted：包源无模板 → fail-closed 拒绝', !bad2.ok, bad2.note);
+  // P1-4：owned 记账 LF 归一——CRLF 盘面与 LF 内容同 sha（与 doctor §6.6 比较口径一致）
+  const crlfFile = path.join(tmp, 'crlf-owned.txt');
+  fs.writeFileSync(crlfFile, '行甲\r\n行乙\r\n');
+  const normSha = sha256(Buffer.from('行甲\n行乙\n', 'utf8'));
+  const rawSha = sha256(Buffer.from('行甲\r\n行乙\r\n', 'utf8'));
+  const readNorm = sha256(Buffer.from(fs.readFileSync(crlfFile, 'utf8').replace(/\r\n/g, '\n'), 'utf8'));
+  check('记账口径：LF 归一 sha == LF 内容 sha != 原始字节 sha（CRLF 盘面跨 checkout 稳定）',
+    readNorm === normSha && readNorm !== rawSha);
+  fs.rmSync(tmp, { recursive: true, force: true });
+}
+
+// ---- ⑧ --force owned 保护 + 端口校验（2026-09-27 p2-batch1）----
+{
+  const tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'init-protect-'));
+  const pkgRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
+  const vars = { BOARD_PORT: '8933' };
+  // 预置「用户已自定义」的 owned 文件（内容 != 模板渲染值）
+  const agPath = path.join(tmp, 'AGENTS.md');
+  fs.writeFileSync(agPath, '# 我的项目\n\n自定义适配区命令行，p2b1-marker-keep。\n');
+  const lpPath = path.join(tmp, '.agents', 'hooks', 'local-pre-commit');
+  fs.mkdirSync(path.dirname(lpPath), { recursive: true });
+  fs.writeFileSync(lpPath, '#!/bin/sh\nset -e\nsh .agents/hooks/check-architecture.sh  # add-gate 接线行 p2b1-marker-keep\n');
+  const t = renderTree(path.join(pkgRoot, 'templates'), tmp, vars, { force: true, protectSet: new Set([...listTree(path.join(pkgRoot, 'templates')).filter((rel) => rel === 'AGENTS.md' || rel === '.agents/hooks/local-pre-commit')]) });
+  check('⑧--force owned 保护：自定义 AGENTS.md 不被覆盖（marker 保留 + protectedSkipped 记录）',
+    fs.readFileSync(agPath, 'utf8').includes('p2b1-marker-keep') && (t.protectedSkipped || []).includes('AGENTS.md'),
+    JSON.stringify({ ps: t.protectedSkipped }));
+  check('⑧--force owned 保护：local-pre-commit 接线行保留',
+    fs.readFileSync(lpPath, 'utf8').includes('p2b1-marker-keep') && (t.protectedSkipped || []).includes('.agents/hooks/local-pre-commit'),
+    JSON.stringify({ ps: t.protectedSkipped }));
+  // managed 文件不受保护（--force 照常覆盖）
+  const cmd = path.join(tmp, '.agents', 'commands', 'plan.md');
+  check('⑧managed 文件 --force 照常覆盖（不在 protectedSkipped）',
+    fs.existsSync(cmd) && !(t.protectedSkipped || []).includes('.agents/commands/plan.md'),
+    JSON.stringify({ ps: t.protectedSkipped }));
+  fs.rmSync(tmp, { recursive: true, force: true });
+}
+
 console.log(`\n合计: PASS ${pass} / FAIL ${fail}`);
 if (fail) {
   console.log('\n用法：node src/init.test.mjs');