@pieai/pro-gov 0.4.3 → 0.4.5

package/dist/cli.js

@@ -93,6 +93,7 @@ function createNpxSkillsMaintenancePlan(options) {
   if (options.operation === "update") {
     assertNoReportedPartialUpdateFailure(result.stdout, result.stderr);
   }
+  assertNoDeprecatedMattSkills(tempRoot);
   const after = snapshotFiles(tempRoot);
   const changes = diffSnapshots(before, after);
   return {
@@ -117,6 +118,16 @@ ${stderr}`.replace(/\u001B\[[0-?]*[ -/]*[@-~]/g, "");
     throw new Error(`npx skills update reported a partial failure: ${failure[0]}`);
   }
 }
+function assertNoDeprecatedMattSkills(npxRoot) {
+  const lockPath = join3(npxRoot, "skills-lock.json");
+  const lock = JSON.parse(readFileSync2(lockPath, "utf8"));
+  const deprecated = Object.entries(lock.skills ?? {}).filter(
+    ([, entry]) => entry.source === "mattpocock/skills" && entry.skillPath?.startsWith("skills/deprecated/")
+  ).map(([name]) => name).sort();
+  if (deprecated.length > 0) {
+    throw new Error(`npx skills plan contains deprecated mattpocock skills: ${deprecated.join(", ")}`);
+  }
+}
 function assertNativeNpxRoot(npxRoot) {
   if (!existsSync3(join3(npxRoot, "skills-lock.json"))) {
     throw new Error(`npx skills root is missing skills-lock.json: ${npxRoot}`);
@@ -1638,7 +1649,7 @@ function printNpxUsage() {
 
 // src/commands/doctor.ts
 import { spawnSync as spawnSync2 } from "node:child_process";
-import { existsSync as existsSync12, readFileSync as readFileSync8 } from "node:fs";
+import { existsSync as existsSync12 } from "node:fs";
 import { createRequire } from "node:module";
 import { dirname as dirname6, join as join12 } from "node:path";
 var REQUIRED_ASSETS = [
@@ -1650,11 +1661,9 @@ var REQUIRED_ASSETS = [
   "profiles/doc-only/profile.md"
 ];
 function runDoctor(_args) {
-  const strictHooks = _args.includes("--strict-hooks");
   const assets = listAssets();
   const assetPaths = new Set(assets.map((asset) => asset.path));
   const missing = REQUIRED_ASSETS.filter((assetPath) => !assetPaths.has(assetPath));
-  const hookIssues = strictHooks ? checkStrictHostHooks(process.cwd()) : [];
   console.log("pro-gov doctor");
   console.log(`assets: ${assets.length}`);
   if (missing.length > 0) {
@@ -1665,13 +1674,7 @@ function runDoctor(_args) {
     console.log("assets: required project-governance assets found");
   }
   console.log(checkDocGov());
-  for (const issue of hookIssues) {
-    console.error(issue);
-  }
-  if (strictHooks && hookIssues.length === 0) {
-    console.log("host-hooks: PGS Compound Gate hooks wired");
-  }
-  return missing.length > 0 || hookIssues.length > 0 ? 1 : 0;
+  return missing.length > 0 ? 1 : 0;
 }
 function checkDocGov() {
   const fromPath = spawnSync2("doc-gov", ["--help"], {
@@ -1704,424 +1707,10 @@ function resolveDocGovDependencyCli() {
     return null;
   }
 }
-function checkStrictHostHooks(root) {
-  if (!isEngineeringRuntimeProject(root)) {
-    return [];
-  }
-  const expected = [
-    { path: ".codex/hooks.json", host: "codex" },
-    { path: ".claude/settings.json", host: "claude-code" },
-    { path: ".agents/hooks.json", host: "antigravity" }
-  ];
-  const issues = [];
-  for (const entry of expected) {
-    const absolutePath = join12(root, entry.path);
-    if (!existsSync12(absolutePath)) {
-      issues.push(`host-hooks: missing ${entry.path}`);
-      continue;
-    }
-    const content = readFileSync8(absolutePath, "utf8");
-    if (!content.includes("pro-gov host-hook") || !content.includes(`--host ${entry.host}`)) {
-      issues.push(`host-hooks: ${entry.path} does not call pro-gov host-hook for ${entry.host}`);
-    }
-    if (entry.host === "antigravity" && !content.includes("PGS_HOST_HOOK_DEBUG=1")) {
-      issues.push(`host-hooks: ${entry.path} does not enable PGS_HOST_HOOK_DEBUG=1 for Antigravity diagnostics`);
-    }
-  }
-  return issues;
-}
-function isEngineeringRuntimeProject(root) {
-  return existsSync12(join12(root, "docs/governance/agents-routing/engineering-runtime-v0.9.md"));
-}
-
-// src/commands/host-hook.ts
-import { spawnSync as spawnSync3 } from "node:child_process";
-import { existsSync as existsSync13, mkdirSync as mkdirSync4, readFileSync as readFileSync10, writeFileSync as writeFileSync3 } from "node:fs";
-import { tmpdir as tmpdir2 } from "node:os";
-import { basename as basename3, join as join13, resolve as resolve3 } from "node:path";
-
-// src/host-hooks/host-hook-runner.ts
-import { closeSync, openSync, readFileSync as readFileSync9, readSync, statSync as statSync3 } from "node:fs";
-var gateMarkerPattern = /Compound Gate:\s*(ran ce-compound|ran fallback capture|skipped)\s*->/i;
-var completionSignalPatterns = [
-  /\b(done|completed|implemented|fixed|verified|validated|shipped|pushed|committed)\b/i,
-  /\b(tests?|typecheck|build|lint|doctor|pack)\b.*\b(pass|passed|green|succeed|succeeded|ok)\b/i,
-  /\b(changed|updated|modified|created|deleted|refactored)\b.*\b(files?|docs?|tests?|hooks?|configs?)\b/i,
-  /已完成|完成了|修好了|实现了|验证通过|测试通过|已经提交|已经推送|提交并推送|已提交|已推送/
-];
-var negativeCompletionSignalPatterns = [
-  /\b(not done|not completed|not implemented|not fixed|did not complete|didn't complete|have not completed|haven't completed)\b/i,
-  /没有完成|未完成|还没完成|没有改动|未改动|没有修改|未修改/
-];
-var compoundGateInstruction = [
-  "Before final reporting, pass the PGS Compound Gate.",
-  "If this completed work produced reusable learning, run compound-engineering:ce-compound and report:",
-  "Compound Gate: ran ce-compound -> <path>",
-  "If the Compound Engineering plugin is unavailable in this host, use PGS fallback capture:",
-  'pro-gov learn capture --title "<learning title>" --summary "<reusable lesson>"',
-  "Compound Gate: ran fallback capture -> <path>",
-  "If there is no reusable learning, report:",
-  "Compound Gate: skipped -> <reason>"
-].join("\n");
-var liteCompoundGateInstruction = [
-  "Pass the PGS Compound Gate before final reporting.",
-  "Report one line:",
-  "Compound Gate: ran ce-compound -> <path>",
-  "Compound Gate: ran fallback capture -> <path>",
-  "Compound Gate: skipped -> <reason>"
-].join("\n");
-var maxTranscriptBytes = 2 * 1024 * 1024;
-function evaluateHostHook(request) {
-  const mode = request.compoundGateMode ?? "off";
-  if (mode === "off") {
-    return { action: "allow" };
-  }
-  if (request.event !== "Stop" && request.event !== "SubagentStop") {
-    return { action: "allow" };
-  }
-  const input = normalizeStopInput(request.input);
-  if (input.stopHookActive) {
-    return { action: "allow" };
-  }
-  if (!input.lastAssistantMessage) {
-    return { action: "allow" };
-  }
-  if (gateMarkerPattern.test(input.lastAssistantMessage)) {
-    return { action: "allow" };
-  }
-  if (!looksLikeCompletedEngineeringWork(input.lastAssistantMessage)) {
-    return { action: "allow" };
-  }
-  return { action: "continue", reason: compoundGateInstructionForMode(mode) };
-}
-function compoundGateInstructionForMode(mode) {
-  return mode === "lite" ? liteCompoundGateInstruction : compoundGateInstruction;
-}
-function formatHostHookOutput(host, event, decision) {
-  if (decision.action === "allow") {
-    return {};
-  }
-  if (host === "codex") {
-    if (event === "Stop" || event === "SubagentStop") {
-      return { decision: "block", reason: decision.reason };
-    }
-    if (decision.action === "block") {
-      return {
-        hookSpecificOutput: {
-          hookEventName: event,
-          permissionDecision: "deny",
-          permissionDecisionReason: decision.reason
-        },
-        systemMessage: decision.reason
-      };
-    }
-    return { systemMessage: decision.reason };
-  }
-  if (host === "claude" || host === "claude-code") {
-    if (event === "Stop" || event === "SubagentStop") {
-      return { decision: "block", reason: decision.reason };
-    }
-    if (decision.action === "block") {
-      return {
-        hookSpecificOutput: {
-          hookEventName: event,
-          permissionDecision: "deny",
-          permissionDecisionReason: decision.reason
-        }
-      };
-    }
-    return { systemMessage: decision.reason };
-  }
-  if (host === "antigravity") {
-    if (event === "Stop" || event === "SubagentStop") {
-      return { decision: "continue", reason: decision.reason };
-    }
-    if (decision.action === "block") {
-      return { decision: "deny", reason: decision.reason };
-    }
-    return { decision: "allow", reason: decision.reason };
-  }
-  return {};
-}
-function normalizeStopInput(input) {
-  if (!isRecord(input)) {
-    return { lastAssistantMessage: void 0, stopHookActive: false };
-  }
-  return {
-    lastAssistantMessage: findString(input, ["last_assistant_message", "lastAssistantMessage", "message", "text"]) ?? findLastAssistantMessageFromTranscript(findString(input, ["agent_transcript_path", "agentTranscriptPath"])) ?? findLastAssistantMessageFromTranscript(findString(input, ["transcript_path", "transcriptPath"])),
-    stopHookActive: findBoolean(input, ["stop_hook_active", "stopHookActive"]) ?? false
-  };
-}
-function looksLikeCompletedEngineeringWork(message) {
-  if (negativeCompletionSignalPatterns.some((pattern) => pattern.test(message))) {
-    return false;
-  }
-  return completionSignalPatterns.some((pattern) => pattern.test(message));
-}
-function findString(input, keys) {
-  for (const key of keys) {
-    const value = input[key];
-    if (typeof value === "string" && value.trim().length > 0) {
-      return value;
-    }
-  }
-  return void 0;
-}
-function findBoolean(input, keys) {
-  for (const key of keys) {
-    const value = input[key];
-    if (typeof value === "boolean") {
-      return value;
-    }
-  }
-  return void 0;
-}
-function findLastAssistantMessageFromTranscript(path) {
-  if (!path || path.startsWith("~/")) {
-    return void 0;
-  }
-  let content;
-  try {
-    content = readTranscriptTail(path);
-  } catch {
-    return void 0;
-  }
-  const lines = content.split(/\r?\n/);
-  for (let index = lines.length - 1; index >= 0; index -= 1) {
-    const line = lines[index]?.trim();
-    if (!line) {
-      continue;
-    }
-    let record;
-    try {
-      record = JSON.parse(line);
-    } catch {
-      continue;
-    }
-    const message = extractAssistantText(record);
-    if (message) {
-      return message;
-    }
-  }
-  return void 0;
-}
-function readTranscriptTail(path) {
-  const size = statSync3(path).size;
-  if (size <= maxTranscriptBytes) {
-    return readFileSync9(path, "utf8");
-  }
-  const fd = openSync(path, "r");
-  try {
-    const buffer = Buffer.allocUnsafe(maxTranscriptBytes);
-    readSync(fd, buffer, 0, maxTranscriptBytes, size - maxTranscriptBytes);
-    return buffer.toString("utf8");
-  } finally {
-    closeSync(fd);
-  }
-}
-function extractAssistantText(value) {
-  if (!isRecord(value)) {
-    return void 0;
-  }
-  const nested = value.message;
-  const role = findString(value, ["role", "type"]);
-  if (isRecord(nested)) {
-    const nestedRole = findString(nested, ["role", "type"]);
-    if (nestedRole === "assistant") {
-      return extractTextContent(nested.content);
-    }
-  }
-  if (role === "assistant") {
-    return extractTextContent(value.content) ?? extractTextContent(value.text);
-  }
-  return void 0;
-}
-function extractTextContent(value) {
-  if (typeof value === "string" && value.trim().length > 0) {
-    return value;
-  }
-  if (!Array.isArray(value)) {
-    return void 0;
-  }
-  const parts = [];
-  for (const item of value) {
-    if (typeof item === "string") {
-      parts.push(item);
-      continue;
-    }
-    if (isRecord(item) && typeof item.text === "string") {
-      parts.push(item.text);
-    }
-  }
-  const text = parts.join("\n").trim();
-  return text.length > 0 ? text : void 0;
-}
-function isRecord(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-
-// src/host-hooks/types.ts
-function isHostHookHost(value) {
-  return value === "antigravity" || value === "claude" || value === "claude-code" || value === "codex";
-}
-function isHostHookEvent(value) {
-  return value === "PostToolUse" || value === "PreToolUse" || value === "Stop" || value === "SubagentStop" || value === "UserPromptSubmit";
-}
-function isCompoundGateMode(value) {
-  return value === "off" || value === "lite" || value === "strict";
-}
-
-// src/commands/host-hook.ts
-var defaultStdinTimeoutMs = 750;
-var maxDebugRawInputBytes = 256 * 1024;
-async function runHostHook(args) {
-  const host = readOption(args, "--host");
-  const event = readOption(args, "--event");
-  const compoundGateMode = readCompoundGateMode(args);
-  if (!isHostHookHost(host)) {
-    console.error("Expected --host <codex|claude-code|antigravity>");
-    return 1;
-  }
-  if (!isHostHookEvent(event)) {
-    console.error("Expected --event <Stop|SubagentStop|PreToolUse|PostToolUse|UserPromptSubmit>");
-    return 1;
-  }
-  const rawInput = await readStdinText(defaultStdinTimeoutMs);
-  const input = parseStdinJson(rawInput);
-  const decision = evaluateHostHook({ compoundGateMode, host, event, input });
-  const output = formatHostHookOutput(host, event, decision);
-  writeDebugLogIfRequested(args, {
-    compoundGateMode,
-    decision,
-    event,
-    host,
-    input,
-    output,
-    rawInput
-  });
-  console.log(`${JSON.stringify(output)}
-`);
-  return 0;
-}
-function readCompoundGateMode(args) {
-  const value = readOption(args, "--compound-gate-mode") ?? process.env.PGS_COMPOUND_GATE_MODE ?? "off";
-  if (isCompoundGateMode(value)) return value;
-  return "off";
-}
-function readOption(args, name) {
-  const index = args.indexOf(name);
-  if (index < 0) return void 0;
-  return args[index + 1];
-}
-function parseStdinJson(raw) {
-  if (!raw) return {};
-  try {
-    return JSON.parse(raw);
-  } catch {
-    return {};
-  }
-}
-function readStdinText(timeoutMs) {
-  if (process.stdin.isTTY) {
-    return Promise.resolve("");
-  }
-  process.stdin.setEncoding("utf8");
-  return new Promise((resolveText) => {
-    let settled = false;
-    let content = "";
-    const settle = () => {
-      if (settled) return;
-      settled = true;
-      clearTimeout(timer);
-      process.stdin.off("data", onData);
-      process.stdin.off("end", settle);
-      process.stdin.off("error", settle);
-      process.stdin.pause();
-      resolveText(content.trim());
-    };
-    const onData = (chunk) => {
-      content += chunk.toString();
-    };
-    const timer = setTimeout(settle, timeoutMs);
-    timer.unref();
-    process.stdin.on("data", onData);
-    process.stdin.on("end", settle);
-    process.stdin.on("error", settle);
-    process.stdin.resume();
-  });
-}
-function writeDebugLogIfRequested(args, record) {
-  const explicitPath = readOption(args, "--debug-log");
-  const enabled = explicitPath !== void 0 || process.env.PGS_HOST_HOOK_DEBUG === "1";
-  if (!enabled) return;
-  const debugDir = explicitPath && explicitPath.trim().length > 0 ? explicitPath : defaultDebugDir();
-  try {
-    mkdirSync4(debugDir, { recursive: true });
-    const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
-    const fileName = `${timestamp}-${process.pid}-${record.host}-${record.event}.json`;
-    writeFileSync3(
-      join13(debugDir, fileName),
-      `${JSON.stringify(
-        {
-          schemaVersion: 1,
-          cwd: process.cwd(),
-          compoundGateMode: record.compoundGateMode,
-          event: record.event,
-          host: record.host,
-          nodeVersion: process.version,
-          packageVersion: readPackageVersion(),
-          rawInput: truncateDebugRawInput(record.rawInput),
-          input: record.input,
-          decision: record.decision,
-          output: record.output
-        },
-        null,
-        2
-      )}
-`,
-      "utf8"
-    );
-  } catch {
-  }
-}
-function defaultDebugDir() {
-  const gitPath = spawnSync3("git", ["rev-parse", "--git-path", "pro-gov-hook-debug"], {
-    encoding: "utf8",
-    stdio: ["ignore", "pipe", "ignore"]
-  });
-  const value = gitPath.status === 0 ? gitPath.stdout.trim() : "";
-  if (value) {
-    return resolve3(process.cwd(), value);
-  }
-  return join13(tmpdir2(), "pro-gov-hook-debug", basename3(process.cwd()));
-}
-function readPackageVersion() {
-  const packageJsonPath = resolvePackageJsonPath();
-  if (!packageJsonPath) return void 0;
-  try {
-    const parsed = JSON.parse(readFileSync10(packageJsonPath, "utf8"));
-    return typeof parsed.version === "string" ? parsed.version : void 0;
-  } catch {
-    return void 0;
-  }
-}
-function resolvePackageJsonPath() {
-  const candidates = [
-    resolve3(process.cwd(), "packages/pro-gov/package.json"),
-    resolve3(process.cwd(), "node_modules/@pieai/pro-gov/package.json")
-  ];
-  return candidates.find((candidate) => existsSync13(candidate));
-}
-function truncateDebugRawInput(value) {
-  const buffer = Buffer.from(value);
-  if (buffer.byteLength <= maxDebugRawInputBytes) return value;
-  return `${buffer.subarray(0, maxDebugRawInputBytes).toString("utf8")}
-[truncated]`;
-}
 
 // src/commands/init.ts
-import { existsSync as existsSync14, mkdirSync as mkdirSync5, readFileSync as readFileSync11, writeFileSync as writeFileSync4 } from "node:fs";
-import { basename as basename4, dirname as dirname7, join as join14 } from "node:path";
+import { existsSync as existsSync13, mkdirSync as mkdirSync4, readFileSync as readFileSync8, writeFileSync as writeFileSync3 } from "node:fs";
+import { basename as basename3, dirname as dirname7, join as join13 } from "node:path";
 
 // src/commands/shared.ts
 function planStarterFiles(profile) {
@@ -2129,7 +1718,6 @@ function planStarterFiles(profile) {
     const targetPath = starterTargetPath(asset.path);
     if (!targetPath) return [];
     if (profile && isOtherProfileRouting(targetPath, profile)) return [];
-    if (profile && isEngineeringOnlyGuardrail(targetPath) && profile !== "engineering-runtime") return [];
     return [
       {
         sourcePath: asset.path,
@@ -2152,12 +1740,6 @@ function classifyOwnership(targetPath) {
 function isOtherProfileRouting(targetPath, profile) {
   return targetPath.startsWith("docs/governance/agents-routing/") && targetPath !== `docs/governance/agents-routing/${profile}-v0.9.md`;
 }
-function isHostHookTargetPath(targetPath) {
-  return targetPath === ".codex/hooks.json" || targetPath === ".claude/settings.json" || targetPath === ".agents/hooks.json";
-}
-function isEngineeringOnlyGuardrail(targetPath) {
-  return isHostHookTargetPath(targetPath);
-}
 function starterTargetPath(sourcePath) {
   if (sourcePath === "starter/AGENTS.template.md") return "AGENTS.md";
   if (sourcePath === "starter/CLAUDE.template.md") return "CLAUDE.md";
@@ -2196,7 +1778,7 @@ function runInit(args) {
 }
 function applyStarterFiles(files, profile) {
   const root = process.cwd();
-  const conflicts = files.filter((file) => existsSync14(join14(root, file.targetPath)));
+  const conflicts = files.filter((file) => existsSync13(join13(root, file.targetPath)));
   if (conflicts.length > 0) {
     console.error("pro-gov init is refusing to overwrite existing project files:");
     for (const file of conflicts) console.error(`  ${file.targetPath}`);
@@ -2204,11 +1786,11 @@ function applyStarterFiles(files, profile) {
     return 1;
   }
   for (const file of files) {
-    const targetPath = join14(root, file.targetPath);
-    mkdirSync5(dirname7(targetPath), { recursive: true });
-    const source = readFileSync11(file.absoluteSourcePath);
-    const content = file.targetPath === "AGENTS.md" ? renderAgentsTemplate(source.toString("utf8"), basename4(root), profile) : source;
-    writeFileSync4(targetPath, content);
+    const targetPath = join13(root, file.targetPath);
+    mkdirSync4(dirname7(targetPath), { recursive: true });
+    const source = readFileSync8(file.absoluteSourcePath);
+    const content = file.targetPath === "AGENTS.md" ? renderAgentsTemplate(source.toString("utf8"), basename3(root), profile) : source;
+    writeFileSync3(targetPath, content);
   }
   console.log("pro-gov init APPLIED");
   console.log(`profile: ${profile}`);
@@ -2236,8 +1818,8 @@ function readFlag(args, flag) {
 }
 
 // src/learning/recall.ts
-import { existsSync as existsSync15, readdirSync as readdirSync6, readFileSync as readFileSync12 } from "node:fs";
-import { basename as basename5, join as join15, relative as relative5 } from "node:path";
+import { existsSync as existsSync14, readdirSync as readdirSync6, readFileSync as readFileSync9 } from "node:fs";
+import { basename as basename4, join as join14, relative as relative5 } from "node:path";
 function recallLearnings(root, options) {
   const query = options.query.trim();
   const terms = tokenize(query);
@@ -2259,14 +1841,14 @@ function recallLearnings(root, options) {
 }
 function loadLearningRecords(root) {
   const records = [];
-  const solutionsDir = join15(root, "docs/solutions");
-  if (existsSync15(solutionsDir)) {
+  const solutionsDir = join14(root, "docs/solutions");
+  if (existsSync14(solutionsDir)) {
     for (const path of listMarkdownFiles(solutionsDir)) {
       records.push(readLearningRecord(root, path));
     }
   }
-  const conceptsPath = join15(root, "CONCEPTS.md");
-  if (existsSync15(conceptsPath)) {
+  const conceptsPath = join14(root, "CONCEPTS.md");
+  if (existsSync14(conceptsPath)) {
     records.push(readLearningRecord(root, conceptsPath));
   }
   return records;
@@ -2274,7 +1856,7 @@ function loadLearningRecords(root) {
 function listMarkdownFiles(dir) {
   const files = [];
   for (const entry of readdirSync6(dir, { withFileTypes: true })) {
-    const absolutePath = join15(dir, entry.name);
+    const absolutePath = join14(dir, entry.name);
     if (entry.isDirectory()) {
       files.push(...listMarkdownFiles(absolutePath));
     } else if (entry.isFile() && entry.name.endsWith(".md")) {
@@ -2284,7 +1866,7 @@ function listMarkdownFiles(dir) {
   return files.sort();
 }
 function readLearningRecord(root, absolutePath) {
-  const content = readFileSync12(absolutePath, "utf8");
+  const content = readFileSync9(absolutePath, "utf8");
   const parsed = splitFrontmatter(content);
   const body = parsed.body;
   return {
@@ -2316,7 +1898,7 @@ function findTitle(frontmatter, body) {
   return heading ? heading.slice(2).trim() : void 0;
 }
 function titleFromPath(path) {
-  return basename5(path, ".md").split(/[-_]/).filter(Boolean).map((part) => part.charAt(0).toUpperCase() + part.slice(1)).join(" ");
+  return basename4(path, ".md").split(/[-_]/).filter(Boolean).map((part) => part.charAt(0).toUpperCase() + part.slice(1)).join(" ");
 }
 function scoreRecord(record, terms) {
   const title = record.title.toLowerCase();
@@ -2367,92 +1949,55 @@ function cleanMarkdownLine(input) {
 }
 
 // src/learning/capture.ts
-import { existsSync as existsSync16, mkdirSync as mkdirSync6, writeFileSync as writeFileSync5 } from "node:fs";
-import { join as join16, relative as relative6 } from "node:path";
-function captureFallbackLearning(root, options) {
+import { existsSync as existsSync15, mkdirSync as mkdirSync5, writeFileSync as writeFileSync4 } from "node:fs";
+import { join as join15, relative as relative6 } from "node:path";
+function captureLearning(root, options) {
   const title = options.title.trim();
   const summary = options.summary.trim();
   if (!title) throw new Error("title is required");
   if (!summary) throw new Error("summary is required");
   const category = slugify(options.category ?? "workflow-issues") || "workflow-issues";
-  const moduleName = options.module?.trim() || "PGS fallback capture";
-  const dir = join16(root, "docs/solutions", category);
-  mkdirSync6(dir, { recursive: true });
-  const slug = slugify(title) || "fallback-learning";
-  const path = uniquePath(dir, slug);
-  const content = renderFallbackLearning({
-    title,
-    summary,
-    category,
-    moduleName
-  });
-  writeFileSync5(path, content);
+  const moduleName = options.module?.trim() || "PGS learning capture";
+  const dir = join15(root, "docs/solutions", category);
+  mkdirSync5(dir, { recursive: true });
+  const path = uniquePath(dir, slugify(title) || "learning");
+  writeFileSync4(path, renderLearning({ title, summary, category, moduleName }));
   return {
     relativePath: normalizePath2(relative6(root, path)),
     title,
-    captureMode: "pgs-fallback"
+    captureMode: "pgs-native"
   };
 }
-function renderFallbackLearning(options) {
-  const date = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
-  const problemType = options.category === "workflow-issues" ? "workflow_issue" : "knowledge";
+function renderLearning(options) {
   return [
     "---",
     `title: ${yamlString(options.title)}`,
-    `date: ${date}`,
+    `date: ${(/* @__PURE__ */ new Date()).toISOString().slice(0, 10)}`,
     `category: ${options.category}`,
     `module: ${yamlString(options.moduleName)}`,
-    `problem_type: ${problemType}`,
-    "component: development_workflow",
-    "severity: medium",
-    "capture_mode: pgs-fallback",
-    "applies_when:",
-    '  - "The Compound Engineering plugin or ce-compound skill is unavailable in the current host"',
-    '  - "Completed work produced reusable learning that should be recallable later"',
-    "tags: [compound-gate, fallback-capture, learning-recall]",
+    "capture_mode: pgs-native",
+    "tags: [learning-recall]",
     "---",
     "",
     `# ${options.title}`,
     "",
-    "## Context",
-    "",
-    "This record was captured with the PGS fallback capture path because the full",
-    "Compound Engineering `ce-compound` workflow was unavailable in the current",
-    "host. Prefer `ce-compound` when the plugin is installed; use this fallback",
-    "only to avoid losing reusable learning.",
-    "",
     "## Guidance",
     "",
     options.summary,
     "",
-    "## Why This Matters",
-    "",
-    "A Compound Gate that cannot write a learning record turns reusable experience",
-    "into a final-report sentence that future agents cannot reliably find. The",
-    "fallback keeps the learning searchable by `pro-gov learn recall` without",
-    "copying or replacing the Compound Engineering workflow.",
-    "",
-    "## When to Apply",
+    "## Applies When",
     "",
     "- The work is complete and verified.",
-    "- The lesson is reusable across future sessions or projects.",
-    "- `compound-engineering:ce-compound` is not available in the current host.",
-    "- The learning is not already covered by an existing `docs/solutions/**` record.",
-    "",
-    "## Examples",
-    "",
-    "```text",
-    "Compound Gate: ran fallback capture -> docs/solutions/<category>/<file>.md",
-    "```",
+    "- The lesson is non-obvious, reusable, and not already documented.",
     ""
   ].join("\n");
 }
 function uniquePath(dir, slug) {
   let index = 1;
-  let candidate = join16(dir, `${slug}.md`);
-  while (existsSync16(candidate)) {
+  let candidate = join15(dir, `${slug}.md`);
+  while (existsSync15(candidate)) {
     index += 1;
-    candidate = join16(dir, `${slug}-${index}.md`);
+    candidate = join15(dir, `${slug}-${index}.md`);
   }
   return candidate;
 }
@@ -2508,7 +2053,7 @@ function runLearnCapture(args) {
   }
   let result;
   try {
-    result = captureFallbackLearning(options.value.targetDir, {
+    result = captureLearning(options.value.targetDir, {
       title: options.value.title,
       summary: options.value.summary,
       category: options.value.category,
@@ -2629,20 +2174,18 @@ function printUsage2() {
 }
 
 // src/commands/lens.ts
-import { mkdirSync as mkdirSync8, writeFileSync as writeFileSync7 } from "node:fs";
+import { mkdirSync as mkdirSync7, writeFileSync as writeFileSync6 } from "node:fs";
 import { dirname as dirname9 } from "node:path";
 
 // src/lens/audit.ts
-import { existsSync as existsSync17, mkdirSync as mkdirSync7, readFileSync as readFileSync13, writeFileSync as writeFileSync6 } from "node:fs";
-import { basename as basename6, dirname as dirname8, join as join17 } from "node:path";
+import { existsSync as existsSync16, mkdirSync as mkdirSync6, readFileSync as readFileSync10, writeFileSync as writeFileSync5 } from "node:fs";
+import { basename as basename5, dirname as dirname8, join as join16 } from "node:path";
 var REQUIRED_ARTIFACTS = [
   "manifest.md",
   "raw/project-lens/architecture-lens.md",
   "raw/project-lens/truth-surface-audit.md",
   "raw/project-lens/technology-strategy.md",
-  "raw/ponytail/ponytail-audit.md",
-  "raw/ponytail/ponytail-debt.md",
-  "raw/ponytail/ponytail-gain.md",
+  "raw/project-lens/simplicity-review.md",
   "raw/target/target-state.md",
   "raw/target/commands.md",
   "raw/target/sources.md",
@@ -2654,20 +2197,20 @@ function createProjectLensAuditPackage(targetDir, auditDir) {
     version: 1,
     target: {
       path: targetDir,
-      name: basename6(targetDir) || "target"
+      name: basename5(targetDir) || "target"
     },
     requiredArtifacts: [...REQUIRED_ARTIFACTS]
   };
-  mkdirSync7(auditDir, { recursive: true });
-  writeJson(join17(auditDir, "audit.contract.json"), contract);
+  mkdirSync6(auditDir, { recursive: true });
+  writeJson(join16(auditDir, "audit.contract.json"), contract);
   for (const artifactPath of REQUIRED_ARTIFACTS) {
-    writeTemplate(join17(auditDir, artifactPath), renderArtifactTemplate(artifactPath, contract));
+    writeTemplate(join16(auditDir, artifactPath), renderArtifactTemplate(artifactPath, contract));
   }
   return contract;
 }
 function checkProjectLensAuditPackage(auditDir, options = {}) {
-  const contractPath = join17(auditDir, "audit.contract.json");
-  if (!existsSync17(contractPath)) {
+  const contractPath = join16(auditDir, "audit.contract.json");
+  if (!existsSync16(contractPath)) {
     return {
       ok: false,
       auditDir,
@@ -2681,7 +2224,7 @@ function checkProjectLensAuditPackage(auditDir, options = {}) {
   }
   let contract;
   try {
-    contract = JSON.parse(readFileSync13(contractPath, "utf8"));
+    contract = JSON.parse(readFileSync10(contractPath, "utf8"));
   } catch (error) {
     return {
       ok: false,
@@ -2714,12 +2257,12 @@ function checkProjectLensAuditPackage(auditDir, options = {}) {
     }
   }
   for (const artifactPath of REQUIRED_ARTIFACTS) {
-    const absolutePath = join17(auditDir, artifactPath);
-    if (!existsSync17(absolutePath)) {
+    const absolutePath = join16(auditDir, artifactPath);
+    if (!existsSync16(absolutePath)) {
       issues.push({ type: "missing-required-artifact", path: artifactPath });
       continue;
     }
-    const content = readFileSync13(absolutePath, "utf8");
+    const content = readFileSync10(absolutePath, "utf8");
     if (isPendingArtifact(content)) {
       issues.push({ type: "artifact-not-complete", path: artifactPath });
     } else if (hasTemplateBody(content)) {
@@ -2735,13 +2278,13 @@ function checkProjectLensAuditPackage(auditDir, options = {}) {
   };
 }
 function writeJson(path, value) {
-  mkdirSync7(dirname8(path), { recursive: true });
-  writeFileSync6(path, `${JSON.stringify(value, null, 2)}
+  mkdirSync6(dirname8(path), { recursive: true });
+  writeFileSync5(path, `${JSON.stringify(value, null, 2)}
 `);
 }
 function writeTemplate(path, content) {
-  mkdirSync7(dirname8(path), { recursive: true });
-  writeFileSync6(path, content);
+  mkdirSync6(dirname8(path), { recursive: true });
+  writeFileSync5(path, content);
 }
 function renderArtifactTemplate(artifactPath, contract) {
   const title = artifactPath.replace(/\.md$/, "").split("/").map((part) => part.replaceAll("-", " ")).join(" / ");
@@ -2797,7 +2340,6 @@ function renderArtifactGuardrailHint(artifactPath) {
 }
 function artifactProducer(artifactPath) {
   if (artifactPath.startsWith("raw/project-lens/")) return "project-lens";
-  if (artifactPath.startsWith("raw/ponytail/")) return "ponytail";
   if (artifactPath.startsWith("raw/target/")) return "target-evidence";
   if (artifactPath.startsWith("synthesis/")) return "synthesis";
   return "audit";
@@ -2831,8 +2373,8 @@ var REQUIRED_METHOD_RECORDS = {
       match: /^Project Lens method source:/im
     },
     {
-      label: "Ponytail method source:",
-      match: /^Ponytail method source:/im
+      label: "Simplicity review method source:",
+      match: /^Simplicity review method source:/im
     }
   ],
   "synthesis/decision-index.md": [
@@ -2910,6 +2452,10 @@ function formatProjectLensAuditCheckText(result) {
 function formatProjectLensInspection(report) {
   return [
     `target: ${report.targetDir}`,
+    `scan-scope: ${report.scanScope.mode}`,
+    `candidate-files: ${report.scanScope.candidateFileCount}`,
+    `included-files: ${report.scanScope.includedFileCount}`,
+    `excluded-files: ${report.scanScope.excludedFileCount}`,
     `ai-entry-files: ${formatList(report.aiEntryFiles)}`,
     `ai-config-files: ${formatList(report.aiConfigFiles)}`,
     `package-scripts: ${formatList(report.packageJson?.scripts ?? [])}`,
@@ -2931,6 +2477,10 @@ function renderProjectLensMarkdownReport(report) {
     `- Target: \`${report.targetDir}\``,
     `- Generated: ${(/* @__PURE__ */ new Date()).toISOString()}`,
     "- Scope: local read-only evidence for AI-assisted project review",
+    `- Evidence mode: ${report.scanScope.mode}`,
+    `- Candidate files: ${report.scanScope.candidateFileCount}`,
+    `- Included files: ${report.scanScope.includedFileCount}`,
+    `- Excluded vendor/cache files: ${report.scanScope.excludedFileCount}`,
     "",
     "## AI Entry Files",
     "",
@@ -2978,9 +2528,9 @@ function bulletList(values) {
 }
 
 // src/lens/scan.ts
-import { spawnSync as spawnSync4 } from "node:child_process";
-import { existsSync as existsSync18, readdirSync as readdirSync7, readFileSync as readFileSync14, statSync as statSync4 } from "node:fs";
-import { join as join18, relative as relative7 } from "node:path";
+import { spawnSync as spawnSync3 } from "node:child_process";
+import { existsSync as existsSync17, readdirSync as readdirSync7, readFileSync as readFileSync11, statSync as statSync3 } from "node:fs";
+import { join as join17, relative as relative7 } from "node:path";
 var ignoredDirectories = /* @__PURE__ */ new Set([
   ".git",
   ".next",
@@ -2991,30 +2541,39 @@ var ignoredDirectories = /* @__PURE__ */ new Set([
 ]);
 function scanProjectLensTarget(targetDir, options = {}) {
   const largeFileBytes = options.largeFileBytes ?? 5e4;
-  const files = listProjectFiles(targetDir);
-  const markdownFiles = files.filter((file) => file.endsWith(".md"));
+  const candidateFiles = listProjectFiles(targetDir);
+  const files = candidateFiles.filter(isFirstPartyEvidenceFile);
+  const markdownFiles = files.filter(
+    (file) => file.startsWith("docs/") && file.endsWith(".md")
+  );
   const packageJson = readPackageJson(targetDir);
   return {
     targetDir,
+    scanScope: {
+      mode: "first-party",
+      candidateFileCount: candidateFiles.length,
+      includedFileCount: files.length,
+      excludedFileCount: candidateFiles.length - files.length
+    },
     aiEntryFiles: ["AGENTS.md", "CLAUDE.md"].filter(
-      (file) => existsSync18(join18(targetDir, file))
+      (file) => existsSync17(join17(targetDir, file))
     ),
     aiConfigFiles: [],
     packageJson,
     docs: {
-      hasDocsDirectory: existsSync18(join18(targetDir, "docs")),
+      hasDocsDirectory: existsSync17(join17(targetDir, "docs")),
       markdownFileCount: markdownFiles.length,
       governanceFiles: markdownFiles.filter((file) => file.startsWith("docs/governance/") || file.startsWith("docs/policy/")).sort()
     },
     git: readGitState(targetDir),
-    largeFiles: files.map((file) => ({ path: file, bytes: statSync4(join18(targetDir, file)).size })).filter((file) => file.bytes >= largeFileBytes).sort((a, b) => b.bytes - a.bytes || a.path.localeCompare(b.path)).slice(0, 25)
+    largeFiles: files.map((file) => ({ path: file, bytes: statSync3(join17(targetDir, file)).size })).filter((file) => file.bytes >= largeFileBytes).sort((a, b) => b.bytes - a.bytes || a.path.localeCompare(b.path)).slice(0, 25)
   };
 }
 function readPackageJson(targetDir) {
-  const packageJsonPath = join18(targetDir, "package.json");
-  if (!existsSync18(packageJsonPath)) return void 0;
+  const packageJsonPath = join17(targetDir, "package.json");
+  if (!existsSync17(packageJsonPath)) return void 0;
   try {
-    const packageJson = JSON.parse(readFileSync14(packageJsonPath, "utf8"));
+    const packageJson = JSON.parse(readFileSync11(packageJsonPath, "utf8"));
     return {
       scripts: Object.keys(packageJson.scripts ?? {}).sort(),
       dependencies: Object.keys(packageJson.dependencies ?? {}).sort(),
@@ -3037,25 +2596,46 @@ function readGitState(targetDir) {
   };
 }
 function runGit(targetDir, args) {
-  const result = spawnSync4("git", ["-C", targetDir, ...args], {
+  const result = spawnSync3("git", ["-C", targetDir, ...args], {
     encoding: "utf8"
   });
   if (result.status !== 0) return { ok: false };
   return { ok: true, stdout: result.stdout.trim() };
 }
 function listProjectFiles(targetDir) {
+  const gitFiles = runGit(targetDir, [
+    "ls-files",
+    "--cached",
+    "--others",
+    "--exclude-standard",
+    "-z"
+  ]);
+  if (gitFiles.ok) {
+    return gitFiles.stdout.split("\0").filter(Boolean).map(toUnixPath4).filter((file) => existsSync17(join17(targetDir, file))).sort();
+  }
   const files = [];
   collectFiles2(targetDir, targetDir, files);
   return files.sort();
 }
+var excludedEvidencePrefixes = [
+  ".agents/manual-skills/",
+  ".agents/skills/",
+  "agent-assets/skills/npx-skills/",
+  "third-party/",
+  "third_party/",
+  "vendor/"
+];
+function isFirstPartyEvidenceFile(file) {
+  return !excludedEvidencePrefixes.some((prefix) => file.startsWith(prefix));
+}
 function collectFiles2(rootDir, currentDir, files) {
-  if (!existsSync18(currentDir)) return;
+  if (!existsSync17(currentDir)) return;
   for (const entry of readdirSync7(currentDir, { withFileTypes: true })) {
     if (entry.isDirectory()) {
       if (ignoredDirectories.has(entry.name)) continue;
-      collectFiles2(rootDir, join18(currentDir, entry.name), files);
+      collectFiles2(rootDir, join17(currentDir, entry.name), files);
     } else if (entry.isFile()) {
-      files.push(toUnixPath4(relative7(rootDir, join18(currentDir, entry.name))));
+      files.push(toUnixPath4(relative7(rootDir, join17(currentDir, entry.name))));
     }
   }
 }
@@ -3107,8 +2687,8 @@ function runLensReport(args) {
   }
   const report = scanProjectLensTarget(options.value.targetDir);
   const markdown = renderProjectLensMarkdownReport(report);
-  mkdirSync8(dirname9(options.value.outPath), { recursive: true });
-  writeFileSync7(options.value.outPath, markdown);
+  mkdirSync7(dirname9(options.value.outPath), { recursive: true });
+  writeFileSync6(options.value.outPath, markdown);
   console.log(`report: ${options.value.outPath}`);
   return 0;
 }
@@ -3211,16 +2791,16 @@ function printUsage3() {
 }
 
 // src/commands/portfolio.ts
-import { existsSync as existsSync22 } from "node:fs";
-import { join as join21 } from "node:path";
+import { existsSync as existsSync21 } from "node:fs";
+import { join as join20 } from "node:path";
 
 // src/portfolio/manifest.ts
-import { existsSync as existsSync19, readFileSync as readFileSync15 } from "node:fs";
-import { dirname as dirname10, isAbsolute as isAbsolute3, resolve as resolve4 } from "node:path";
+import { existsSync as existsSync18, readFileSync as readFileSync12 } from "node:fs";
+import { dirname as dirname10, isAbsolute as isAbsolute3, resolve as resolve3 } from "node:path";
 function loadPortfolioManifest(configPath) {
   let parsed;
   try {
-    parsed = JSON.parse(readFileSync15(configPath, "utf8"));
+    parsed = JSON.parse(readFileSync12(configPath, "utf8"));
   } catch (error) {
     return {
       configPath,
@@ -3232,7 +2812,7 @@ function loadPortfolioManifest(configPath) {
       ]
     };
   }
-  const normalized = resolveManifestPaths(parsed, dirname10(resolve4(configPath)));
+  const normalized = resolveManifestPaths(parsed, dirname10(resolve3(configPath)));
   const issues = validatePortfolioManifest(normalized);
   return {
     configPath,
@@ -3241,12 +2821,12 @@ function loadPortfolioManifest(configPath) {
   };
 }
 function resolveManifestPaths(value, configDir) {
-  if (!isRecord2(value)) return value;
+  if (!isRecord(value)) return value;
   const resolveEndpoint = (endpoint) => {
-    if (!isRecord2(endpoint) || typeof endpoint.path !== "string" || isAbsolute3(endpoint.path)) {
+    if (!isRecord(endpoint) || typeof endpoint.path !== "string" || isAbsolute3(endpoint.path)) {
       return endpoint;
     }
-    return { ...endpoint, path: resolve4(configDir, endpoint.path) };
+    return { ...endpoint, path: resolve3(configDir, endpoint.path) };
   };
   return {
     ...value,
@@ -3257,7 +2837,7 @@ function resolveManifestPaths(value, configDir) {
 }
 function validatePortfolioManifest(value) {
   const issues = [];
-  if (!isRecord2(value)) {
+  if (!isRecord(value)) {
     return [
       {
         type: "invalid-field",
@@ -3299,7 +2879,7 @@ function validatePortfolioManifest(value) {
   }
   const seenTargetIds = /* @__PURE__ */ new Set();
   for (const target of value.targets) {
-    if (!isRecord2(target)) {
+    if (!isRecord(target)) {
       issues.push({
         type: "invalid-field",
         field: "targets",
@@ -3356,7 +2936,7 @@ function validateAllowedFields(value, location, allowedFields, issues) {
 }
 function validateEndpoint(value, field, issues) {
   if (value === void 0) return;
-  if (!isRecord2(value)) {
+  if (!isRecord(value)) {
     issues.push({
       type: "invalid-field",
       field,
@@ -3380,7 +2960,7 @@ function validateEndpoint(value, field, issues) {
     });
     return;
   }
-  if (!existsSync19(value.path)) {
+  if (!existsSync18(value.path)) {
     issues.push({
       type: "missing-path",
       id: typeof value.id === "string" ? value.id : void 0,
@@ -3412,7 +2992,7 @@ function validateHostTooling(value, issues) {
   }
   const seenHosts = /* @__PURE__ */ new Set();
   for (const entry of value) {
-    if (!isRecord2(entry)) {
+    if (!isRecord(entry)) {
       issues.push({
         type: "invalid-field",
         field: "hostTooling",
@@ -3445,19 +3025,19 @@ function validateHostTooling(value, issues) {
     }
   }
 }
-function isRecord2(value) {
+function isRecord(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 
 // src/portfolio/doctor.ts
-import { spawnSync as spawnSync6 } from "node:child_process";
-import { existsSync as existsSync21, readFileSync as readFileSync17 } from "node:fs";
+import { spawnSync as spawnSync5 } from "node:child_process";
+import { existsSync as existsSync20, readFileSync as readFileSync14 } from "node:fs";
 import { createRequire as createRequire2 } from "node:module";
-import { dirname as dirname11, join as join20 } from "node:path";
+import { dirname as dirname11, join as join19 } from "node:path";
 import { fileURLToPath as fileURLToPath3 } from "node:url";
 
 // src/host-tooling/inventory.ts
-import { spawnSync as spawnSync5 } from "node:child_process";
+import { spawnSync as spawnSync4 } from "node:child_process";
 function inspectHostTooling(requirements, runner = defaultRunner2) {
   const hosts = [];
   const issues = [];
@@ -3515,10 +3095,10 @@ function inspectHostTooling(requirements, runner = defaultRunner2) {
   return { hosts, issues };
 }
 function parseHostPlugins(host, value) {
-  const entries = host === "codex" ? isRecord3(value) && Array.isArray(value.installed) ? value.installed : void 0 : Array.isArray(value) ? value : void 0;
+  const entries = host === "codex" ? isRecord2(value) && Array.isArray(value.installed) ? value.installed : void 0 : Array.isArray(value) ? value : void 0;
   if (!entries) throw new Error("expected a plugin array");
   return entries.flatMap((entry) => {
-    if (!isRecord3(entry)) return [];
+    if (!isRecord2(entry)) return [];
     const id = host === "codex" ? entry.pluginId : entry.id;
     if (typeof id !== "string") return [];
     return [{
@@ -3529,7 +3109,7 @@ function parseHostPlugins(host, value) {
   });
 }
 function defaultRunner2({ command: command2 }) {
-  const result = spawnSync5(command2[0] ?? "", command2.slice(1), {
+  const result = spawnSync4(command2[0] ?? "", command2.slice(1), {
     encoding: "utf8",
     timeout: 1e4
   });
@@ -3539,18 +3119,18 @@ function defaultRunner2({ command: command2 }) {
     stderr: result.stderr || result.error?.message || ""
   };
 }
-function isRecord3(value) {
+function isRecord2(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 
 // src/portfolio/asset-state.ts
-import { existsSync as existsSync20, lstatSync as lstatSync5, readFileSync as readFileSync16 } from "node:fs";
-import { join as join19 } from "node:path";
+import { existsSync as existsSync19, lstatSync as lstatSync5, readFileSync as readFileSync13 } from "node:fs";
+import { join as join18 } from "node:path";
 function comparePortfolioAssetState(options) {
   const expectedManifest = readPlanDocument(options.expectedPlan, ".pro-gov/assets.json");
   const expectedLock = readPlanDocument(options.expectedPlan, ".pro-gov/assets.lock.json");
-  const currentManifest = readJsonFile(join19(options.targetDir, ".pro-gov/assets.json"));
-  const currentLock = readJsonFile(join19(options.targetDir, ".pro-gov/assets.lock.json"));
+  const currentManifest = readJsonFile(join18(options.targetDir, ".pro-gov/assets.json"));
+  const currentLock = readJsonFile(join18(options.targetDir, ".pro-gov/assets.lock.json"));
   const issues = [];
   if (!sameStrings(currentManifest?.bundleIds, expectedManifest?.bundleIds)) {
     issues.push({
@@ -3573,7 +3153,7 @@ function comparePortfolioAssetState(options) {
   const expectedTargets = new Set((expectedLock?.assets ?? []).map((entry) => entry.targetPath));
   for (const entry of currentLock?.assets ?? []) {
     if (expectedTargets.has(entry.targetPath)) continue;
-    const targetAbsolutePath = join19(options.targetDir, entry.targetPath);
+    const targetAbsolutePath = join18(options.targetDir, entry.targetPath);
     if (!pathIsSymlink(targetAbsolutePath)) continue;
     issues.push({
       type: "orphaned-managed-symlink",
@@ -3595,9 +3175,9 @@ function readPlanDocument(plan, targetPath) {
   }
 }
 function readJsonFile(path) {
-  if (!existsSync20(path)) return void 0;
+  if (!existsSync19(path)) return void 0;
   try {
-    return JSON.parse(readFileSync16(path, "utf8"));
+    return JSON.parse(readFileSync13(path, "utf8"));
   } catch {
     return void 0;
   }
@@ -3646,11 +3226,11 @@ function inspectPortfolio(options) {
 function inspectTarget(options) {
   const { target } = options;
   const issues = [];
-  const packageJson = readJson2(join20(target.path, "package.json"));
+  const packageJson = readJson2(join19(target.path, "package.json"));
   const packages = {};
   for (const packageName of ["@pieai/pro-gov", "@pieai/doc-gov"]) {
     const declared = packageJson?.devDependencies?.[packageName] ?? packageJson?.dependencies?.[packageName];
-    const installedPackage = readJson2(join20(target.path, "node_modules", packageName, "package.json"));
+    const installedPackage = readJson2(join19(target.path, "node_modules", packageName, "package.json"));
     const installed = installedPackage?.version;
     const expected = options.expectedPackageVersions[packageName];
     packages[packageName] = { declared, installed, expected };
@@ -3704,7 +3284,7 @@ function inspectTarget(options) {
       type: "asset-lock-drift",
       message: error instanceof Error ? error.message : String(error)
     });
-    if (!existsSync21(join20(target.path, ".pro-gov/assets.json"))) {
+    if (!existsSync20(join19(target.path, ".pro-gov/assets.json"))) {
       issues.push({ type: "bundle-drift", message: "Target asset manifest is missing." });
     }
   }
@@ -3719,27 +3299,27 @@ function inspectTarget(options) {
   };
 }
 function readTargetAssetHost(targetDir) {
-  const lockfile = readJson2(join20(targetDir, ".pro-gov/assets.lock.json"));
+  const lockfile = readJson2(join19(targetDir, ".pro-gov/assets.lock.json"));
   return isAssetRegistryHost(lockfile?.host) ? lockfile.host : void 0;
 }
 function isAssetRegistryHost(value) {
   return value === "codex" || value === "claude-code" || value === "gemini-cli" || value === "antigravity";
 }
 function runTargetChecks(target) {
-  const proGovCli = join20(target.path, "node_modules/@pieai/pro-gov/dist/cli.js");
-  const docGovCli = join20(target.path, "node_modules/@pieai/doc-gov/dist/cli.js");
+  const proGovCli = join19(target.path, "node_modules/@pieai/pro-gov/dist/cli.js");
+  const docGovCli = join19(target.path, "node_modules/@pieai/doc-gov/dist/cli.js");
   const commands = [
     {
       name: "pro-gov doctor",
       cli: proGovCli,
-      args: target.profile === "engineering-runtime" ? ["doctor", "--strict-hooks"] : ["doctor"]
+      args: ["doctor"]
     },
     { name: "doc-gov router-check", cli: docGovCli, args: ["router-check"] },
     { name: "doc-gov scan --check", cli: docGovCli, args: ["scan", "--check"] }
   ];
   return commands.map((command2) => {
-    if (!existsSync21(command2.cli)) return { name: command2.name, status: null };
-    const result = spawnSync6(process.execPath, [command2.cli, ...command2.args], {
+    if (!existsSync20(command2.cli)) return { name: command2.name, status: null };
+    const result = spawnSync5(process.execPath, [command2.cli, ...command2.args], {
       cwd: target.path,
       encoding: "utf8",
       timeout: 3e4
@@ -3748,13 +3328,13 @@ function runTargetChecks(target) {
   });
 }
 function inspectGit(path) {
-  const inside = spawnSync6("git", ["rev-parse", "--is-inside-work-tree"], {
+  const inside = spawnSync5("git", ["rev-parse", "--is-inside-work-tree"], {
     cwd: path,
     encoding: "utf8"
   });
   if (inside.status !== 0) return { isRepository: false, dirty: false };
-  const status = spawnSync6("git", ["status", "--porcelain"], { cwd: path, encoding: "utf8" });
-  const branch = spawnSync6("git", ["branch", "--show-current"], { cwd: path, encoding: "utf8" });
+  const status = spawnSync5("git", ["status", "--porcelain"], { cwd: path, encoding: "utf8" });
+  const branch = spawnSync5("git", ["branch", "--show-current"], { cwd: path, encoding: "utf8" });
   return {
     isRepository: true,
     dirty: status.stdout.trim().length > 0,
@@ -3779,16 +3359,16 @@ function getExpectedPackageVersions() {
 function findOwnPackageJson() {
   let current = dirname11(fileURLToPath3(import.meta.url));
   for (let depth = 0; depth < 5; depth += 1) {
-    const candidate = join20(current, "package.json");
-    if (existsSync21(candidate)) return candidate;
+    const candidate = join19(current, "package.json");
+    if (existsSync20(candidate)) return candidate;
     current = dirname11(current);
   }
   return "";
 }
 function readJson2(path) {
-  if (!path || !existsSync21(path)) return void 0;
+  if (!path || !existsSync20(path)) return void 0;
   try {
-    return JSON.parse(readFileSync17(path, "utf8"));
+    return JSON.parse(readFileSync14(path, "utf8"));
   } catch {
     return void 0;
   }
@@ -4105,8 +3685,8 @@ function isHost2(value) {
   return value === "codex" || value === "claude-code" || value === "gemini-cli" || value === "antigravity";
 }
 function findPortfolioAgentAssetsDir(manifest) {
-  const agentAssetsDir = manifest?.executionEngine?.path ? join21(manifest.executionEngine.path, "agent-assets") : void 0;
-  return agentAssetsDir && existsSync22(join21(agentAssetsDir, "registry.json")) ? agentAssetsDir : void 0;
+  const agentAssetsDir = manifest?.executionEngine?.path ? join20(manifest.executionEngine.path, "agent-assets") : void 0;
+  return agentAssetsDir && existsSync21(join20(agentAssetsDir, "registry.json")) ? agentAssetsDir : void 0;
 }
 function printUsage4() {
   console.error("Usage:");
@@ -4117,69 +3697,12 @@ function printUsage4() {
 }
 
 // src/commands/sync.ts
-import { existsSync as existsSync23, mkdirSync as mkdirSync9, readFileSync as readFileSync18, writeFileSync as writeFileSync8 } from "node:fs";
-import { dirname as dirname12, join as join22 } from "node:path";
-import { isDeepStrictEqual } from "node:util";
-
-// src/host-hooks/config-merge.ts
-var MANAGED_EVENTS = ["Stop", "SubagentStop"];
-function mergeHostHookConfig(targetPath, current, template) {
-  const currentRecord = asRecord(current);
-  const templateRecord = asRecord(template);
-  if (targetPath === ".agents/hooks.json") {
-    return {
-      ...currentRecord,
-      "pgs-compound-gate": templateRecord["pgs-compound-gate"]
-    };
-  }
-  const host = targetPath === ".codex/hooks.json" ? "codex" : "claude-code";
-  const currentHooks = asRecord(currentRecord.hooks);
-  const templateHooks = asRecord(templateRecord.hooks);
-  const mergedHooks = { ...currentHooks };
-  for (const event of MANAGED_EVENTS) {
-    const currentEntries = asArray(currentHooks[event]);
-    const templateEntries = asArray(templateHooks[event]);
-    mergedHooks[event] = replaceManagedEntries(currentEntries, templateEntries, host, event);
-  }
-  return {
-    ...currentRecord,
-    hooks: mergedHooks
-  };
-}
-function replaceManagedEntries(currentEntries, templateEntries, host, event) {
-  const result = [];
-  let insertedTemplate = false;
-  for (const entry of currentEntries) {
-    if (isManagedEntry(entry, host, event)) {
-      if (!insertedTemplate) {
-        result.push(...templateEntries);
-        insertedTemplate = true;
-      }
-      continue;
-    }
-    result.push(entry);
-  }
-  if (!insertedTemplate) result.push(...templateEntries);
-  return result;
-}
-function isManagedEntry(entry, host, event) {
-  const serialized = JSON.stringify(entry);
-  return serialized.includes("pro-gov host-hook") && serialized.includes(`--host ${host}`) && serialized.includes(`--event ${event}`);
-}
-function asRecord(value) {
-  if (!value || typeof value !== "object" || Array.isArray(value)) return {};
-  return value;
-}
-function asArray(value) {
-  return Array.isArray(value) ? value : [];
-}
-
-// src/commands/sync.ts
+import { existsSync as existsSync22, readFileSync as readFileSync15 } from "node:fs";
+import { join as join21 } from "node:path";
 function runSync(args) {
   const check = args.includes("--check");
-  const applyHostHooks = args.includes("--apply-host-hooks");
-  if (check === applyHostHooks) {
-    console.error("pro-gov sync requires exactly one of --check or --apply-host-hooks.");
+  if (!check) {
+    console.error("pro-gov sync requires --check.");
     return 1;
   }
   const requestedProfile = readFlag2(args, "--profile");
@@ -4199,13 +3722,12 @@ function runSync(args) {
     );
     return 1;
   }
-  if (applyHostHooks) return applyHostHookConfigs(profile);
   let differences = 0;
   console.log("pro-gov sync check");
   console.log(`profile: ${profile}`);
   for (const file of planStarterFiles(profile)) {
-    const targetPath = join22(process.cwd(), file.targetPath);
-    if (!existsSync23(targetPath)) {
+    const targetPath = join21(process.cwd(), file.targetPath);
+    if (!existsSync22(targetPath)) {
       if (file.ownership === "optional-guardrail") continue;
       console.log(`missing: ${file.targetPath}`);
       differences += 1;
@@ -4213,8 +3735,8 @@ function runSync(args) {
     }
     if (file.ownership === "optional-guardrail") continue;
     if (file.ownership === "project-local-seed") continue;
-    const source = readFileSync18(file.absoluteSourcePath, "utf8");
-    const target = readFileSync18(targetPath, "utf8");
+    const source = readFileSync15(file.absoluteSourcePath, "utf8");
+    const target = readFileSync15(targetPath, "utf8");
     if (!matchesExpectedContent(file.targetPath, source, target)) {
       console.log(`different: ${file.targetPath}`);
       differences += 1;
@@ -4227,52 +3749,11 @@ function runSync(args) {
   console.log("sync check passed: starter files match packaged assets.");
   return 0;
 }
-function applyHostHookConfigs(profile) {
-  if (profile !== "engineering-runtime") {
-    console.error("Host hooks are installed only for the engineering-runtime profile.");
-    return 1;
-  }
-  const root = process.cwd();
-  const updates = [];
-  try {
-    for (const file of planStarterFiles(profile)) {
-      if (!isHostHookTargetPath(file.targetPath)) continue;
-      const path = join22(root, file.targetPath);
-      const template = JSON.parse(readFileSync18(file.absoluteSourcePath, "utf8"));
-      const targetExists = existsSync23(path);
-      const current = targetExists ? JSON.parse(readFileSync18(path, "utf8")) : {};
-      const merged = mergeHostHookConfig(file.targetPath, current, template);
-      if (targetExists && isDeepStrictEqual(current, merged)) continue;
-      updates.push({ path, content: `${JSON.stringify(merged, null, 2)}
-` });
-    }
-  } catch (error) {
-    console.error(`Cannot merge host hook configuration: ${errorMessage(error)}`);
-    console.error("No host hook files were written.");
-    return 1;
-  }
-  for (const update of updates) {
-    mkdirSync9(dirname12(update.path), { recursive: true });
-    writeFileSync8(update.path, update.content);
-  }
-  console.log(`host hooks applied: ${updates.length}`);
-  console.log("Project-owned host config keys and non-PGS hook entries were preserved.");
-  return 0;
-}
 function matchesExpectedContent(targetPath, source, target) {
-  if (!isHostHookTargetPath(targetPath)) {
-    if (targetPath.endsWith(".md")) {
-      return normalizeMarkdownTablePadding(source) === normalizeMarkdownTablePadding(target);
-    }
-    return source === target;
-  }
-  try {
-    const current = JSON.parse(target);
-    const template = JSON.parse(source);
-    return isDeepStrictEqual(current, mergeHostHookConfig(targetPath, current, template));
-  } catch {
-    return false;
+  if (targetPath.endsWith(".md")) {
+    return normalizeMarkdownTablePadding(source) === normalizeMarkdownTablePadding(target);
   }
+  return source === target;
 }
 function normalizeMarkdownTablePadding(content) {
   return content.split("\n").map((line) => {
@@ -4289,7 +3770,7 @@ function normalizeMarkdownTableCell(cell) {
 }
 function inferInstalledProfile(root) {
   const installed = ["engineering-runtime", "doc-only"].filter(
-    (profile) => existsSync23(join22(root, `docs/governance/agents-routing/${profile}-v0.9.md`))
+    (profile) => existsSync22(join21(root, `docs/governance/agents-routing/${profile}-v0.9.md`))
   );
   return installed.length === 1 ? installed[0] : void 0;
 }
@@ -4298,9 +3779,6 @@ function readFlag2(args, flag) {
   const value = index >= 0 ? args[index + 1] : void 0;
   return value && !value.startsWith("--") ? value : void 0;
 }
-function errorMessage(error) {
-  return error instanceof Error ? error.message : String(error);
-}
 
 // src/cli.ts
 var COMMANDS = [
@@ -4323,9 +3801,8 @@ var COMMANDS = [
   "lens report --target <path> --out <path>",
   "lens audit init --target <path> --out <path>",
   "lens audit check --dir <path> [--json]",
-  "host-hook --host <codex|claude-code|antigravity> --event <Stop|SubagentStop|...> [--compound-gate-mode off|lite|strict]",
   "init --profile <engineering-runtime|doc-only> <--dry-run|--apply>",
-  "sync <--check|--apply-host-hooks> [--profile <engineering-runtime|doc-only>]",
+  "sync --check [--profile <engineering-runtime|doc-only>]",
   "doctor"
 ];
 var [command, subcommand] = process.argv.slice(2);
@@ -4339,7 +3816,6 @@ async function main() {
   if (command === "learn") return runLearn(process.argv.slice(3));
   if (command === "lens") return runLens(process.argv.slice(3));
   if (command === "portfolio") return runPortfolio(process.argv.slice(3));
-  if (command === "host-hook") return runHostHook(process.argv.slice(3));
   if (command === "init") return runInit(process.argv.slice(3));
   if (command === "sync") return runSync(process.argv.slice(3));
   if (command === "doctor") return runDoctor(process.argv.slice(3));