pomaster 0.1.0 → 0.1.1

package/dist/bin.js

@@ -18732,8 +18732,8 @@ var init_digest = __esm({
 });
 
 // packages/kernel/dist/io.js
-import { appendFileSync, mkdirSync, readFileSync, renameSync, rmSync, statSync, writeFileSync } from "node:fs";
-import { dirname as dirname2 } from "node:path";
+import { appendFileSync, mkdirSync, readFileSync as readFileSync2, renameSync, rmSync, statSync, writeFileSync } from "node:fs";
+import { dirname as dirname3 } from "node:path";
 function captureOriginal(path) {
   try {
     statSync(path);
@@ -18743,7 +18743,7 @@ function captureOriginal(path) {
     throw error;
   }
   try {
-    return readFileSync(path, "utf8");
+    return readFileSync2(path, "utf8");
   } catch (error) {
     throw new GovernanceError("ENVIRONMENT_ERROR", `cannot read existing file for staged write: ${path}`, "\u68C0\u67E5\u6587\u4EF6\u5360\u7528/\u6743\u9650\u540E\u91CD\u8BD5\uFF1B\u5355\u673A\u672C\u5730\u76D8\u5047\u8BBE\u7834\u88C2\u65F6 doctor \u4F1A\u62A5 environment_error\uFF08\u7981\u9759\u9ED8\uFF09", { path, cause: String(error) });
   }
@@ -18757,7 +18757,7 @@ function ensureDir(dir) {
 }
 function readText(path) {
   try {
-    return readFileSync(path, "utf8");
+    return readFileSync2(path, "utf8");
   } catch (error) {
     if (isNotFoundError(error))
       return null;
@@ -18806,7 +18806,7 @@ function executeWrites(writes) {
   const renamed = [];
   try {
     writes.forEach((write, index) => {
-      ensureDir(dirname2(write.path));
+      ensureDir(dirname3(write.path));
       const tmp = `${write.path}.tmp-${process.pid}-${index}`;
       writeFileSync(tmp, write.next, "utf8");
       tmpPaths.push(tmp);
@@ -18953,8 +18953,8 @@ var init_paths = __esm({
 });
 
 // packages/kernel/dist/evidence-artifacts.js
-import { existsSync, mkdirSync as mkdirSync2, readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "node:fs";
-import { dirname as dirname3 } from "node:path";
+import { existsSync, mkdirSync as mkdirSync2, readFileSync as readFileSync3, writeFileSync as writeFileSync2 } from "node:fs";
+import { dirname as dirname4 } from "node:path";
 function blobAbsolutePath(evidenceDir, storagePath) {
   return `${evidenceDir}/${storagePath}`;
 }
@@ -18973,19 +18973,19 @@ function persistEvidenceArtifact(evidenceDir, input) {
   const storagePath = storagePathOfSha256(sha256);
   const absolutePath = blobAbsolutePath(evidenceDir, storagePath);
   if (existsSync(absolutePath)) {
-    const existing = readFileSync2(absolutePath);
+    const existing = readFileSync3(absolutePath);
     if (!existing.equals(Buffer.from(input.bytes.buffer, input.bytes.byteOffset, input.bytes.byteLength))) {
       throw new GovernanceError("REF_INTEGRITY_VIOLATION", `blob \u8DEF\u5F84\u5DF2\u5B58\u5728\u4E14\u5B57\u8282\u4E0D\u540C\uFF08sha256 \u78B0\u649E\u6216\u5185\u5BB9\u5BFB\u5740\u5B58\u50A8\u635F\u574F\uFF09\uFF1A${storagePath}`, "\u5185\u5BB9\u5BFB\u5740\u4E0D\u53D8\u91CF\uFF1A\u540C\u4E00\u8DEF\u5F84 \u21D4 \u540C\u4E00\u5B57\u8282\u3002\u8BF7\u6838\u67E5\u8BE5 blob \u7684\u5199\u5165\u6765\u6E90\uFF1B\u7981\u6B62\u8986\u76D6\u65E2\u6709 artifact", { storagePath, sha256 });
     }
     return { sha256, media: input.media, byteSize: input.bytes.length, storagePath };
   }
   try {
-    mkdirSync2(dirname3(absolutePath), { recursive: true });
+    mkdirSync2(dirname4(absolutePath), { recursive: true });
     writeFileSync2(absolutePath, input.bytes);
   } catch (error) {
     throw new GovernanceError("ENVIRONMENT_ERROR", `blob \u5199\u5165\u5931\u8D25\uFF1A${storagePath}`, "\u68C0\u67E5\u78C1\u76D8\u53EF\u5199\u6027\u540E\u91CD\u8BD5\uFF1BpersistEvidenceArtifact \u662F evidence blob \u5E73\u9762\u7684\u552F\u4E00\u5199\u5165\u53E3", { storagePath, cause: String(error) });
   }
-  const readBack = readFileSync2(absolutePath);
+  const readBack = readFileSync3(absolutePath);
   const readBackSha = sha256OfBytes(readBack);
   if (readBackSha !== sha256) {
     throw new GovernanceError("ENVIRONMENT_ERROR", `blob \u8BFB\u56DE\u81EA\u8BC1\u5931\u8D25\uFF08\u5199\u540E\u91CD\u7B97 ${readBackSha} \u2260 \u8EAB\u4EFD ${sha256}\uFF09\uFF1A${storagePath}`, "\u5B58\u50A8\u5C42\u4E0D\u53EF\u4FE1\uFF08\u5B57\u8282\u635F\u574F/\u5E76\u53D1\u8986\u5199\uFF09\uFF1B\u7981\u6B62\u643A\u5E26\u672A\u81EA\u8BC1\u7684 blob \u5F15\u7528\u5165\u8D26", { storagePath });
@@ -19044,7 +19044,7 @@ function assertArtifactBlobsExist(refs, evidenceDir) {
 function parseBindingRecord(runRecordPath) {
   let text;
   try {
-    text = readFileSync2(runRecordPath, "utf8");
+    text = readFileSync3(runRecordPath, "utf8");
   } catch (error) {
     if (isNotFoundError(error)) {
       throw new GovernanceError("SCHEMA_INVALID", `run \u8BB0\u5F55\u6587\u4EF6\u7F3A\u5931\uFF1A${runRecordPath}`, "verifyEvidenceBinding \u6821\u9A8C\u5BF9\u8C61\u662F\u5DF2\u843D\u76D8\u7684 evidence/runs/GRN-*.json\uFF1B\u5148\u5165\u8D26\u518D\u6821\u9A8C", { runRecordPath });
@@ -19124,7 +19124,7 @@ function verifyEvidenceBinding(input) {
     const absolutePath = blobAbsolutePath(input.evidenceDir, storagePath);
     let bytes;
     try {
-      bytes = readFileSync2(absolutePath);
+      bytes = readFileSync3(absolutePath);
     } catch (error) {
       if (isNotFoundError(error)) {
         return {
@@ -24283,13 +24283,13 @@ var init_ref_integrity = __esm({
 
 // packages/kernel/dist/catalog.js
 import { createHash as createHash3 } from "node:crypto";
-import { existsSync as existsSync2, readdirSync as readdirSync3, readFileSync as readFileSync3 } from "node:fs";
-import { fileURLToPath } from "node:url";
-import { join as join2 } from "node:path";
+import { existsSync as existsSync2, readdirSync as readdirSync3, readFileSync as readFileSync4 } from "node:fs";
+import { fileURLToPath as fileURLToPath2 } from "node:url";
+import { join as join3 } from "node:path";
 function catalogRootCandidates(moduleUrl) {
   return [
-    fileURLToPath(new URL("../../../catalog", moduleUrl)),
-    fileURLToPath(new URL("../catalog", moduleUrl))
+    fileURLToPath2(new URL("../../../catalog", moduleUrl)),
+    fileURLToPath2(new URL("../catalog", moduleUrl))
   ];
 }
 function resolveCatalogRoot(explicitRoot) {
@@ -24307,7 +24307,7 @@ function resolveCatalogRoot(explicitRoot) {
   throw new GovernanceError("NOT_CONFIGURED", `catalog/ \u76EE\u5F55\u672A\u627E\u5230\uFF08\u5019\u9009\u5747\u7F3A\u5E2D: ${candidates.join(" \u3001 ")}\uFF09`, "catalog/ \u662F POMaster_VNext \u4ED3\u5E93\u8D44\u4EA7\uFF08\u4ED3\u5E93\u5E03\u5C40 packages/kernel/{src,dist} \u2192 \u4ED3\u5E93\u6839 catalog/\uFF09\u6216 npm \u5B89\u88C5\u5F62\u6001\u7684\u5305\u5185\u8D44\u4EA7\uFF08<pkg>/dist/ \u2192 <pkg>/catalog/\uFF09\uFF1B\u5D4C\u5165\u65B9\u65E0\u6CD5\u547D\u4E2D\u65F6\u663E\u5F0F\u6CE8\u5165 catalog \u6839\u76EE\u5F55\u3002", { catalogRootCandidates: candidates });
 }
 function readCatalogLock(catalogRoot) {
-  const lockPath = join2(catalogRoot, LOCK_FILE_NAME);
+  const lockPath = join3(catalogRoot, LOCK_FILE_NAME);
   const raw = readText(lockPath);
   if (raw === null) {
     throw new GovernanceError("NOT_CONFIGURED", `catalog-lock \u7F3A\u5931: ${LOCK_FILE_NAME}`, "catalog-lock \u662F catalog \u7269\u6599\u7684 read-side \u6307\u7EB9\uFF08D24\uFF09\uFF1B\u5148\u8DD1 catalog/tools/materialize_*.py \u7269\u5316\u5E76\u91CD\u9501\u3002", { lockPath });
@@ -24361,11 +24361,11 @@ function verifyCatalogLock(catalogRoot, lock) {
   }
   const onDiskBySection = /* @__PURE__ */ new Map();
   for (const section of CATALOG_SECTIONS) {
-    const dir = join2(catalogRoot, section);
+    const dir = join3(catalogRoot, section);
     onDiskBySection.set(section, existsSync2(dir) ? new Set(readdirSync3(dir).filter((name) => name.endsWith(".json"))) : /* @__PURE__ */ new Set());
   }
   for (const entry of document.entries) {
-    const target = join2(catalogRoot, entry.path);
+    const target = join3(catalogRoot, entry.path);
     const raw = readText(target);
     if (raw === null) {
       drifts.push({
@@ -24423,7 +24423,7 @@ function asRecord2(value) {
   return typeof value === "object" && value !== null ? value : {};
 }
 function loadCatalogPolicies(catalogRoot) {
-  const dir = join2(catalogRoot, "policies");
+  const dir = join3(catalogRoot, "policies");
   if (!existsSync2(dir)) {
     throw new GovernanceError("SCHEMA_INVALID", `catalog/policies/ \u76EE\u5F55\u7F3A\u5931: ${dir}`, "policies/ \u662F catalog-lock required \u7BA1\u8F96\u9762\uFF1B\u76EE\u5F55\u7F3A\u5931\u8BF4\u660E\u7269\u6599\u4E0D\u5B8C\u6574\uFF0C\u91CD\u8DD1 materialize \u5DE5\u5177\u3002", { dir });
   }
@@ -24443,7 +24443,7 @@ function loadCatalogPolicies(catalogRoot) {
   const materials = [];
   for (const fileName of readdirSync3(dir).filter((name) => name.endsWith(".json")).sort()) {
     const file = `policies/${fileName}`;
-    const raw = readFileSync3(join2(dir, fileName), "utf8");
+    const raw = readFileSync4(join3(dir, fileName), "utf8");
     let body;
     try {
       body = asRecord2(JSON.parse(raw));
@@ -24546,19 +24546,19 @@ function loadCatalogPolicies(catalogRoot) {
   return materials;
 }
 function loadCatalogTools(catalogRoot) {
-  const dir = join2(catalogRoot, "tools");
+  const dir = join3(catalogRoot, "tools");
   if (!existsSync2(dir))
     return [];
   return readdirSync3(dir).filter((name) => name !== "." && name !== "..").filter((name) => !name.startsWith(".")).sort().map((name) => ({ file: `tools/${name}`, name }));
 }
 function loadCatalogProjectionPresets(catalogRoot) {
-  const dir = join2(catalogRoot, "projection-presets");
+  const dir = join3(catalogRoot, "projection-presets");
   if (!existsSync2(dir))
     return [];
   const materials = [];
   for (const fileName of readdirSync3(dir).filter((name) => name.endsWith(".yaml")).sort()) {
     const file = `projection-presets/${fileName}`;
-    const lines = readFileSync3(join2(dir, fileName), "utf8").split("\n");
+    const lines = readFileSync4(join3(dir, fileName), "utf8").split("\n");
     const pick3 = (key) => {
       const pattern = new RegExp(`^ {2}${key}:(?:\\s+(\\S+))?\\s*(?:#.*)?$`);
       let inPreset = false;
@@ -24591,14 +24591,14 @@ function isNonEmptyStringArray(value) {
   return Array.isArray(value) && value.length > 0 && value.every((item) => typeof item === "string" && item.length > 0);
 }
 function loadCatalogSensors(catalogRoot) {
-  const dir = join2(catalogRoot, "sensors");
+  const dir = join3(catalogRoot, "sensors");
   if (!existsSync2(dir)) {
     throw new GovernanceError("SCHEMA_INVALID", `catalog/sensors/ \u76EE\u5F55\u7F3A\u5931: ${dir}`, "sensors/ \u662F catalog-lock required \u7BA1\u8F96\u9762\uFF08P1-5 \u767B\u8BB0\u540E\uFF09\uFF1B\u76EE\u5F55\u7F3A\u5931\u8BF4\u660E\u7269\u6599\u4E0D\u5B8C\u6574\uFF0C\u5BF9\u7167 catalog-lock.draft.json required \u6BB5\u6062\u590D\u3002", { dir });
   }
   const materials = /* @__PURE__ */ new Map();
   for (const fileName of readdirSync3(dir).filter((name) => name.endsWith(".json")).sort()) {
     const file = `sensors/${fileName}`;
-    const raw = readFileSync3(join2(dir, fileName), "utf8");
+    const raw = readFileSync4(join3(dir, fileName), "utf8");
     let body;
     try {
       body = asRecord2(JSON.parse(raw));
@@ -26542,7 +26542,7 @@ var init_supervisor_trigger = __esm({
 
 // packages/kernel/dist/spec-analyzer.js
 import { existsSync as existsSync4, readdirSync as readdirSync7 } from "node:fs";
-import { join as join3, relative, sep } from "node:path";
+import { join as join4, relative, sep } from "node:path";
 function normalizeClassificationValue(value) {
   return CATALOG_CLASSIFICATION_VALUES.includes(value) ? value : null;
 }
@@ -27187,7 +27187,7 @@ function walkMarkdownFiles(rootDir) {
   let skipped = 0;
   const walk = (dir) => {
     for (const entry of readdirSync7(dir, { withFileTypes: true })) {
-      const full = join3(dir, entry.name);
+      const full = join4(dir, entry.name);
       if (entry.isDirectory()) {
         walk(full);
         continue;
@@ -27301,7 +27301,7 @@ function analyzeSpecDir(specDir) {
     throw new GovernanceError("NOT_CONFIGURED", `spec \u76EE\u5F55\u65E0 Markdown \u6587\u4EF6: ${specDir}`, "\u786E\u8BA4\u76EE\u5F55\u662F\u5426\u4E3A spec \u76EE\u5F55\uFF1B\u7A7A\u76EE\u5F55\u662F\u663E\u5F0F\u9519\u8BEF\u800C\u975E\u7A7A\u6E05\u5355\uFF08\u5206\u6BCD fail-closed\uFF0C\u7981\u9759\u9ED8\u8FD4\u56DE\u7A7A\u62A5\u544A\uFF09", { specDir, skippedNonMarkdown: skipped });
   }
   const files = markdown.map((relativePath) => {
-    const text = readText(join3(specDir, relativePath));
+    const text = readText(join4(specDir, relativePath));
     if (text === null) {
       throw new GovernanceError("SCHEMA_INVALID", `spec \u6587\u4EF6\u626B\u63CF\u6E05\u5355\u5728\u5EA7\u800C\u8BFB\u53D6\u5931\u8D25\uFF08\u626B\u63CF\u540E\u6D88\u5931/\u5E76\u53D1\u5220\u6539\u7A97\u53E3\uFF09\uFF1A${relativePath}`, "\u91CD\u8DD1 analyzeSpecDir\uFF08\u7F3A\u5E2D\u6587\u4EF6\u82E5\u4E3A\u5E76\u53D1\u5220\u9664\u6240\u81F4\uFF0C\u4EE5\u91CD\u8DD1\u65F6\u7684\u771F\u5B9E\u76EE\u5F55\u4E3A\u51C6\uFF09\uFF1B\u7981\u9759\u9ED8\u6309\u7A7A\u6587\u4EF6\u8BA1\u5165\u5206\u6BCD", { specDir, relativePath });
     }
@@ -28193,7 +28193,7 @@ var init_doctor = __esm({
 });
 
 // packages/kernel/dist/portability.js
-import { existsSync as existsSync5, mkdirSync as mkdirSync3, readdirSync as readdirSync10, readFileSync as readFileSync4, rmSync as rmSync3, statSync as statSync2 } from "node:fs";
+import { existsSync as existsSync5, mkdirSync as mkdirSync3, readdirSync as readdirSync10, readFileSync as readFileSync5, rmSync as rmSync3, statSync as statSync2 } from "node:fs";
 import { homedir } from "node:os";
 import { resolve } from "node:path";
 function canonicalPortabilityManifest() {
@@ -28724,7 +28724,7 @@ function stateHashes(rootDir) {
     for (const entry of entries) {
       const relName = rel.length > 0 ? `${rel}/${entry.name}` : entry.name;
       if (entry.isFile()) {
-        out.set(relName, sha256OfUtf8(readFileSync4(`${dir}/${entry.name}`, "utf8")));
+        out.set(relName, sha256OfUtf8(readFileSync5(`${dir}/${entry.name}`, "utf8")));
       } else if (entry.isDirectory()) {
         walk(`${dir}/${entry.name}`, relName);
       }
@@ -31443,7 +31443,7 @@ var init_adapter_types = __esm({
 });
 
 // packages/gauntlet-lite/dist/detectors.js
-import { statSync as statSync4, readFileSync as readFileSync6 } from "node:fs";
+import { statSync as statSync4, readFileSync as readFileSync7 } from "node:fs";
 import { join as pathJoin } from "node:path";
 function platformDetectorFacts(projectRoot) {
   const isWindows = process.platform === "win32";
@@ -31462,7 +31462,7 @@ function platformDetectorFacts(projectRoot) {
     },
     readTextFile: (absolutePath) => {
       try {
-        return readFileSync6(absolutePath, "utf8");
+        return readFileSync7(absolutePath, "utf8");
       } catch {
         return null;
       }
@@ -32112,10 +32112,10 @@ var init_normalize_common = __esm({
 });
 
 // packages/gauntlet-lite/dist/pytest-leg.js
-import { spawnSync } from "node:child_process";
-import { mkdtempSync, readFileSync as readFileSync7, rmSync as rmSync4 } from "node:fs";
+import { spawnSync as spawnSync2 } from "node:child_process";
+import { mkdtempSync, readFileSync as readFileSync8, rmSync as rmSync4 } from "node:fs";
 import { tmpdir } from "node:os";
-import { join as join5 } from "node:path";
+import { join as join6 } from "node:path";
 import { performance as performance2 } from "node:perf_hooks";
 function runPytestLeg(plan, spawnFn = pytestSpawn) {
   const probeTimeoutMs = Math.min(plan.timeoutMs, 6e4);
@@ -32139,8 +32139,8 @@ function runPytestLeg(plan, spawnFn = pytestSpawn) {
   let runCommand = plan.command;
   let reportDir = null;
   try {
-    reportDir = mkdtempSync(join5(tmpdir(), "pomaster-gauntlet-pytest-"));
-    runCommand = `${plan.command} --junitxml="${join5(reportDir, "junit.xml")}"`;
+    reportDir = mkdtempSync(join6(tmpdir(), "pomaster-gauntlet-pytest-"));
+    runCommand = `${plan.command} --junitxml="${join6(reportDir, "junit.xml")}"`;
   } catch {
     reportDir = null;
   }
@@ -32151,7 +32151,7 @@ function runPytestLeg(plan, spawnFn = pytestSpawn) {
   let stdout = run.stdout;
   if (reportDir !== null) {
     try {
-      stdout = readFileSync7(join5(reportDir, "junit.xml"), "utf8");
+      stdout = readFileSync8(join6(reportDir, "junit.xml"), "utf8");
     } catch {
     }
     try {
@@ -32343,7 +32343,7 @@ var init_pytest_leg = __esm({
     pytestSpawn = (command, options) => {
       const startedAt = performance2.now();
       const sanitizedEnv = stripQuotesFromPathEnv({ ...process.env });
-      const res = spawnSync(command, {
+      const res = spawnSync2(command, {
         shell: true,
         cwd: options.cwd,
         timeout: options.timeoutMs,
@@ -32366,7 +32366,7 @@ var init_pytest_leg = __esm({
 });
 
 // packages/gauntlet-lite/dist/build-adapter.js
-import { spawnSync as spawnSync2 } from "node:child_process";
+import { spawnSync as spawnSync3 } from "node:child_process";
 import { performance as performance3 } from "node:perf_hooks";
 function detectVitest(facts) {
   const tool = VITEST_TOOL_ID;
@@ -32754,7 +32754,7 @@ var init_build_adapter = __esm({
     defaultSpawn = (command, options) => {
       const startedAt = performance3.now();
       const sanitizedEnv = stripQuotesFromPathEnv({ ...process.env });
-      const res = spawnSync2(command, {
+      const res = spawnSync3(command, {
         shell: true,
         cwd: options.cwd,
         timeout: options.timeoutMs,
@@ -32776,7 +32776,7 @@ var init_build_adapter = __esm({
 });
 
 // packages/gauntlet-lite/dist/browser-adapter.js
-import { spawnSync as spawnSync3 } from "node:child_process";
+import { spawnSync as spawnSync4 } from "node:child_process";
 import { performance as performance4 } from "node:perf_hooks";
 function pngSignatureMatches(base64Data) {
   const decoded = Buffer.from(base64Data, "base64");
@@ -33180,7 +33180,7 @@ var init_browser_adapter = __esm({
     })}
 `;
     defaultMcpSmokeFn = (plan) => {
-      const res = spawnSync3(plan.smokeCommand, {
+      const res = spawnSync4(plan.smokeCommand, {
         shell: true,
         cwd: plan.projectRoot,
         input: MCP_INITIALIZE_MESSAGE,
@@ -33220,8 +33220,8 @@ var init_browser_adapter = __esm({
 });
 
 // packages/gauntlet-lite/dist/playwright-leg.js
-import { spawnSync as spawnSync4 } from "node:child_process";
-import { existsSync as existsSync9, readFileSync as readFileSync8, rmSync as rmSync5 } from "node:fs";
+import { spawnSync as spawnSync5 } from "node:child_process";
+import { existsSync as existsSync9, readFileSync as readFileSync9, rmSync as rmSync5 } from "node:fs";
 import { isAbsolute as pathIsAbsolute, join as pathJoin2, relative as pathRelative, resolve as pathResolve } from "node:path";
 import { performance as performance5 } from "node:perf_hooks";
 function isPlainObject2(value) {
@@ -33384,7 +33384,7 @@ function runPlaywrightLeg(plan, spawnFn = playwrightSpawn, executableProbe = pla
   });
   let reportText = null;
   try {
-    reportText = readFileSync8(reportAbs, "utf8");
+    reportText = readFileSync9(reportAbs, "utf8");
   } catch {
     reportText = null;
   }
@@ -33853,7 +33853,7 @@ var init_playwright_leg = __esm({
     playwrightSpawn = (command, options) => {
       const startedAt = performance5.now();
       const sanitizedEnv = stripQuotesFromPathEnv({ ...process.env });
-      const res = spawnSync4(command, {
+      const res = spawnSync5(command, {
         shell: true,
         cwd: options.cwd,
         timeout: options.timeoutMs,
@@ -34121,7 +34121,7 @@ var init_browser_legs = __esm({
 });
 
 // packages/gauntlet-lite/dist/oasdiff-leg.js
-import { spawnSync as spawnSync5 } from "node:child_process";
+import { spawnSync as spawnSync6 } from "node:child_process";
 import { performance as performance7 } from "node:perf_hooks";
 function oasdiffLegExecutable(versionProbeCommand) {
   return firstCommandToken(versionProbeCommand);
@@ -34350,7 +34350,7 @@ var init_oasdiff_leg = __esm({
     oasdiffSpawn = (command, options) => {
       const startedAt = performance7.now();
       const sanitizedEnv = stripQuotesFromPathEnv({ ...process.env });
-      const res = spawnSync5(command, {
+      const res = spawnSync6(command, {
         shell: true,
         cwd: options.cwd,
         timeout: options.timeoutMs,
@@ -34375,8 +34375,8 @@ var init_oasdiff_leg = __esm({
 });
 
 // packages/gauntlet-lite/dist/schemathesis-leg.js
-import { spawnSync as spawnSync6 } from "node:child_process";
-import { existsSync as existsSync10, readFileSync as readFileSync9, rmSync as rmSync6 } from "node:fs";
+import { spawnSync as spawnSync7 } from "node:child_process";
+import { existsSync as existsSync10, readFileSync as readFileSync10, rmSync as rmSync6 } from "node:fs";
 import { isAbsolute as pathIsAbsolute2, join as pathJoin3, relative as pathRelative2, resolve as pathResolve2 } from "node:path";
 import { performance as performance8 } from "node:perf_hooks";
 function pathEscapesProjectRoot2(projectRoot, absolutePath) {
@@ -34463,7 +34463,7 @@ function runSchemathesisLeg(plan, spawnFn = schemathesisSpawn, executableProbe =
   });
   let reportText = null;
   try {
-    reportText = readFileSync9(reportAbs, "utf8");
+    reportText = readFileSync10(reportAbs, "utf8");
   } catch {
     reportText = null;
   }
@@ -34746,7 +34746,7 @@ var init_schemathesis_leg = __esm({
     schemathesisSpawn = (command, options) => {
       const startedAt = performance8.now();
       const sanitizedEnv = stripQuotesFromPathEnv({ ...process.env });
-      const res = spawnSync6(command, {
+      const res = spawnSync7(command, {
         shell: true,
         cwd: options.cwd,
         timeout: options.timeoutMs,
@@ -34770,7 +34770,7 @@ var init_schemathesis_leg = __esm({
 });
 
 // packages/gauntlet-lite/dist/contract-adapter.js
-import { readFileSync as readFileSync10 } from "node:fs";
+import { readFileSync as readFileSync11 } from "node:fs";
 import { join as pathJoin4 } from "node:path";
 import { performance as performance9 } from "node:perf_hooks";
 function readContractConfig(facts) {
@@ -35144,7 +35144,7 @@ function createContractAdapter(options = {}) {
       }
       let text;
       try {
-        text = readFileSync10(pathJoin4(plan.projectRoot, plan.openapiPath ?? ""), "utf8");
+        text = readFileSync11(pathJoin4(plan.projectRoot, plan.openapiPath ?? ""), "utf8");
       } catch {
         return {
           plan,
@@ -35275,7 +35275,7 @@ var init_contract_adapter = __esm({
 });
 
 // packages/gauntlet-lite/dist/dependency-cruiser-leg.js
-import { spawnSync as spawnSync7 } from "node:child_process";
+import { spawnSync as spawnSync8 } from "node:child_process";
 import { performance as performance10 } from "node:perf_hooks";
 function runDepcruiseLeg(plan, spawnFn = depcruiseSpawn, executableProbe = platformExecutableProbe) {
   const executable = firstCommandToken(plan.command);
@@ -35459,7 +35459,7 @@ var init_dependency_cruiser_leg = __esm({
     depcruiseSpawn = (command, options) => {
       const startedAt = performance10.now();
       const sanitizedEnv = stripQuotesFromPathEnv({ ...process.env });
-      const res = spawnSync7(command, {
+      const res = spawnSync8(command, {
         shell: true,
         cwd: options.cwd,
         timeout: options.timeoutMs,
@@ -35482,7 +35482,7 @@ var init_dependency_cruiser_leg = __esm({
 });
 
 // packages/gauntlet-lite/dist/import-linter-leg.js
-import { spawnSync as spawnSync8 } from "node:child_process";
+import { spawnSync as spawnSync9 } from "node:child_process";
 import { performance as performance11 } from "node:perf_hooks";
 function runImportLinterLeg(plan, spawnFn = importLinterSpawn, executableProbe = platformExecutableProbe) {
   const executable = firstCommandToken(plan.command);
@@ -35653,7 +35653,7 @@ var init_import_linter_leg = __esm({
     importLinterSpawn = (command, options) => {
       const startedAt = performance11.now();
       const sanitizedEnv = stripQuotesFromPathEnv({ ...process.env });
-      const res = spawnSync8(command, {
+      const res = spawnSync9(command, {
         shell: true,
         cwd: options.cwd,
         timeout: options.timeoutMs,
@@ -35677,7 +35677,7 @@ var init_import_linter_leg = __esm({
 });
 
 // packages/gauntlet-lite/dist/architecture-adapter.js
-import { readdirSync as readdirSync15, readFileSync as readFileSync11 } from "node:fs";
+import { readdirSync as readdirSync15, readFileSync as readFileSync12 } from "node:fs";
 import { join as pathJoin5, sep as pathSep } from "node:path";
 import { performance as performance12 } from "node:perf_hooks";
 function readArchitectureConfig(facts) {
@@ -36069,7 +36069,7 @@ function createArchitectureAdapter(options = {}) {
         filesCovered++;
         let text;
         try {
-          text = readFileSync11(pathJoin5(plan.projectRoot, relative3), "utf8");
+          text = readFileSync12(pathJoin5(plan.projectRoot, relative3), "utf8");
         } catch {
           continue;
         }
@@ -36211,8 +36211,8 @@ var init_architecture_adapter = __esm({
 });
 
 // packages/gauntlet-lite/dist/coverage-leg.js
-import { spawnSync as spawnSync9 } from "node:child_process";
-import { existsSync as existsSync11, readFileSync as readFileSync12, rmSync as rmSync7 } from "node:fs";
+import { spawnSync as spawnSync10 } from "node:child_process";
+import { existsSync as existsSync11, readFileSync as readFileSync13, rmSync as rmSync7 } from "node:fs";
 import { join as pathJoin6, dirname as pathDirname, isAbsolute as pathIsAbsolute3, relative as pathRelative3, resolve as pathResolve3 } from "node:path";
 import { performance as performance13 } from "node:perf_hooks";
 function resolveCoverageProvisionalThresholdsForTier(tier) {
@@ -36296,7 +36296,7 @@ function runCoverageLeg(plan, spawnFn = coverageSpawn, executableProbe = platfor
   });
   let reportText = null;
   try {
-    reportText = readFileSync12(reportAbs, "utf8");
+    reportText = readFileSync13(reportAbs, "utf8");
   } catch {
     reportText = null;
   }
@@ -36624,7 +36624,7 @@ var init_coverage_leg = __esm({
     coverageSpawn = (command, options) => {
       const startedAt = performance13.now();
       const sanitizedEnv = stripQuotesFromPathEnv({ ...process.env });
-      const res = spawnSync9(command, {
+      const res = spawnSync10(command, {
         shell: true,
         cwd: options.cwd,
         timeout: options.timeoutMs,
@@ -36861,7 +36861,7 @@ var init_crap = __esm({
 });
 
 // packages/gauntlet-lite/dist/coverage-adapter.js
-import { readFileSync as readFileSync13 } from "node:fs";
+import { readFileSync as readFileSync14 } from "node:fs";
 import { join as pathJoin7 } from "node:path";
 import { performance as performance14 } from "node:perf_hooks";
 function isPlainObject3(value) {
@@ -37334,7 +37334,7 @@ function createCrapGateAdapter() {
       }
       const readOrNull = (relative3) => {
         try {
-          return readFileSync13(pathJoin7(plan.projectRoot, relative3), "utf8");
+          return readFileSync14(pathJoin7(plan.projectRoot, relative3), "utf8");
         } catch {
           return null;
         }
@@ -37378,8 +37378,8 @@ var init_coverage_adapter = __esm({
 });
 
 // packages/gauntlet-lite/dist/mutation-leg.js
-import { spawnSync as spawnSync10 } from "node:child_process";
-import { existsSync as existsSync12, readFileSync as readFileSync14, rmSync as rmSync8 } from "node:fs";
+import { spawnSync as spawnSync11 } from "node:child_process";
+import { existsSync as existsSync12, readFileSync as readFileSync15, rmSync as rmSync8 } from "node:fs";
 import { join as pathJoin8, isAbsolute as pathIsAbsolute4, relative as pathRelative4, resolve as pathResolve4 } from "node:path";
 import { performance as performance15 } from "node:perf_hooks";
 function runMutationLeg(plan, spawnFn = mutationSpawn, executableProbe = platformExecutableProbe) {
@@ -37453,7 +37453,7 @@ function runMutationLeg(plan, spawnFn = mutationSpawn, executableProbe = platfor
   });
   let reportText = null;
   try {
-    reportText = readFileSync14(reportAbs, "utf8");
+    reportText = readFileSync15(reportAbs, "utf8");
   } catch {
     reportText = null;
   }
@@ -37852,7 +37852,7 @@ var init_mutation_leg = __esm({
     mutationSpawn = (command, options) => {
       const startedAt = performance15.now();
       const sanitizedEnv = stripQuotesFromPathEnv({ ...process.env });
-      const res = spawnSync10(command, {
+      const res = spawnSync11(command, {
         shell: true,
         cwd: options.cwd,
         timeout: options.timeoutMs,
@@ -38207,8 +38207,8 @@ var init_mutation_adapter = __esm({
 });
 
 // packages/gauntlet-lite/dist/performance-leg.js
-import { spawnSync as spawnSync11 } from "node:child_process";
-import { existsSync as existsSync13, readFileSync as readFileSync15, rmSync as rmSync9 } from "node:fs";
+import { spawnSync as spawnSync12 } from "node:child_process";
+import { existsSync as existsSync13, readFileSync as readFileSync16, rmSync as rmSync9 } from "node:fs";
 import { isAbsolute as pathIsAbsolute5, join as pathJoin9, relative as pathRelative5, resolve as pathResolve5 } from "node:path";
 import { performance as performance17 } from "node:perf_hooks";
 function performanceCapabilityNote(runner) {
@@ -38463,7 +38463,7 @@ function runPerformanceLeg(plan, spawnFn = performanceSpawn, executableProbe = p
   });
   let reportText = null;
   try {
-    reportText = readFileSync15(reportAbs, "utf8");
+    reportText = readFileSync16(reportAbs, "utf8");
   } catch {
     reportText = null;
   }
@@ -38973,7 +38973,7 @@ var init_performance_leg = __esm({
     performanceSpawn = (command, options) => {
       const startedAt = performance17.now();
       const sanitizedEnv = stripQuotesFromPathEnv({ ...process.env });
-      const res = spawnSync11(command, {
+      const res = spawnSync12(command, {
         shell: true,
         cwd: options.cwd,
         timeout: options.timeoutMs,
@@ -39271,8 +39271,8 @@ var init_performance_adapter = __esm({
 });
 
 // packages/gauntlet-lite/dist/security-leg.js
-import { spawnSync as spawnSync12 } from "node:child_process";
-import { existsSync as existsSync14, readFileSync as readFileSync16, rmSync as rmSync10 } from "node:fs";
+import { spawnSync as spawnSync13 } from "node:child_process";
+import { existsSync as existsSync14, readFileSync as readFileSync17, rmSync as rmSync10 } from "node:fs";
 import { isAbsolute as pathIsAbsolute6, join as pathJoin10, relative as pathRelative6, resolve as pathResolve6 } from "node:path";
 import { performance as performance19 } from "node:perf_hooks";
 function securityCapabilityNote(runner) {
@@ -39349,7 +39349,7 @@ function runSecurityLeg(plan, spawnFn = securitySpawn, executableProbe = platfor
   });
   let reportText = null;
   try {
-    reportText = readFileSync16(reportAbs, "utf8");
+    reportText = readFileSync17(reportAbs, "utf8");
   } catch {
     reportText = null;
   }
@@ -39686,7 +39686,7 @@ var init_security_leg = __esm({
     securitySpawn = (command, options) => {
       const startedAt = performance19.now();
       const sanitizedEnv = stripQuotesFromPathEnv({ ...process.env });
-      const res = spawnSync12(command, {
+      const res = spawnSync13(command, {
         shell: true,
         cwd: options.cwd,
         timeout: options.timeoutMs,
@@ -41092,6 +41092,9 @@ var {
   Help
 } = import_index.default;
 
+// packages/cli/dist/index.js
+import { createInterface } from "node:readline";
+
 // packages/cli/dist/cli-info.js
 var CLI_NAME = "pomaster";
 var CLI_VERSION = "0.0.0";
@@ -41132,6 +41135,8 @@ var DISCOVERY_ID_PATTERN = /^[A-Za-z0-9][A-Za-z0-9_-]{0,63}$/;
 var CONFIG_RELATIVE = ".pomaster/config.yaml";
 var AGENTS_MD_RELATIVE = "AGENTS.md";
 var CLAUDE_MD_RELATIVE = "CLAUDE.md";
+var CURSOR_RULES_RELATIVE = ".cursor/rules/pomaster.mdc";
+var QODER_RULES_RELATIVE = ".qoder/rules/pomaster.md";
 var GENERATED_MARKER = "<!-- pomaster:generated -->";
 function truthIndexPath(rootDir) {
   return join(rootDir, ...TRUTH_INDEX_RELATIVE.split("/"));
@@ -41337,6 +41342,143 @@ function triageRequest(request) {
 }
 
 // packages/cli/dist/init.js
+var INIT_PLATFORMS = ["claude", "codex", "cursor", "qoder"];
+var THIN_POINTER_BODY = [
+  "# POMaster vNext \u2014 Agent \u5165\u53E3\u6307\u9488",
+  "\u552F\u4E00\u4E8B\u5B9E\u6E90\u662F\u4ED3\u5E93\u6839\u7684 `AGENTS.md`\uFF08\u7531 `pomaster init` \u751F\u6210\uFF0C\u5E42\u7B49\uFF09\uFF1B\u5148\u8BFB\u6839\u76EE\u5F55 `AGENTS.md`\uFF0C\u9075\u5FAA\u5176\u300C\u5F53\u524D\u6CBB\u7406\u6863\u4F4D\u300D\u4E0E\u300C\u5E38\u7528\u547D\u4EE4\u300D\u3002"
+].join("\n");
+var PLATFORM_ADAPTERS = [
+  {
+    name: "claude",
+    file: CLAUDE_MD_RELATIVE,
+    coveredByAgentsMd: false,
+    render: () => CLAUDE_ENTRY_CONTENT
+  },
+  {
+    name: "codex",
+    file: AGENTS_MD_RELATIVE,
+    coveredByAgentsMd: true,
+    render: () => ""
+  },
+  {
+    name: "cursor",
+    file: CURSOR_RULES_RELATIVE,
+    coveredByAgentsMd: false,
+    render: () => [
+      "---",
+      "description: POMaster vNext \u6CBB\u7406\u5165\u53E3\uFF08\u552F\u4E00\u4E8B\u5B9E\u6E90\uFF1A\u4ED3\u5E93\u6839 AGENTS.md\uFF09",
+      "globs:",
+      "alwaysApply: true",
+      "---",
+      "",
+      THIN_POINTER_BODY
+    ].join("\n")
+  },
+  {
+    name: "qoder",
+    file: QODER_RULES_RELATIVE,
+    coveredByAgentsMd: false,
+    render: () => [
+      "---",
+      "trigger: always_on",
+      "---",
+      "",
+      THIN_POINTER_BODY
+    ].join("\n")
+  }
+];
+var PLATFORM_WORDS_HINT = `\u5408\u6CD5\u8BCD\u5F62\uFF1A${INIT_PLATFORMS.join(" | ")} | none`;
+function parsePlatformSelection(raw) {
+  const tokens = raw.split(",").map((token) => token.trim()).filter((token) => token.length > 0);
+  if (tokens.length === 0) {
+    return {
+      ok: false,
+      error: {
+        code: "SCHEMA_INVALID",
+        message: `\u5E73\u53F0\u9009\u62E9\u4E3A\u7A7A\uFF1B${PLATFORM_WORDS_HINT}`,
+        hint: "\u793A\u4F8B\uFF1A--platforms claude,cursor \u6216 --platforms none\u3002"
+      }
+    };
+  }
+  if (tokens.includes("none")) {
+    if (tokens.length > 1) {
+      return {
+        ok: false,
+        error: {
+          code: "SCHEMA_INVALID",
+          message: `none \u4E0D\u53EF\u4E0E\u5176\u4ED6\u5E73\u53F0\u5E76\u5217\uFF1A${raw.trim()}`,
+          hint: `${PLATFORM_WORDS_HINT}\uFF1B\u53EA\u5EFA AGENTS.md/\u72B6\u6001\u9AA8\u67B6\u65F6\u5355\u72EC\u4F7F\u7528 none\u3002`
+        }
+      };
+    }
+    return { ok: true, platforms: [] };
+  }
+  const platforms = [];
+  const push = (platform) => {
+    if (!platforms.includes(platform))
+      platforms.push(platform);
+  };
+  for (const token of tokens) {
+    if (INIT_PLATFORMS.includes(token)) {
+      push(token);
+      continue;
+    }
+    if (token === "a" || token === "all") {
+      for (const platform of INIT_PLATFORMS)
+        push(platform);
+      continue;
+    }
+    if (/^[1-9][0-9]*$/.test(token)) {
+      const platform = INIT_PLATFORMS[Number.parseInt(token, 10) - 1];
+      if (platform === void 0) {
+        return {
+          ok: false,
+          error: {
+            code: "SCHEMA_INVALID",
+            message: `\u5E73\u53F0\u7F16\u53F7\u8D8A\u754C\uFF1A${token}\uFF1B${PLATFORM_WORDS_HINT}`,
+            hint: `\u7F16\u53F7\u5BF9\u5E94 renderPlatformMenu \u6E05\u5355\uFF081-${INIT_PLATFORMS.length}\uFF09\u3002`
+          }
+        };
+      }
+      push(platform);
+      continue;
+    }
+    return {
+      ok: false,
+      error: {
+        code: "SCHEMA_INVALID",
+        message: `\u975E\u6CD5\u5E73\u53F0\u8BCD\u5F62\uFF1A${token}\uFF1B${PLATFORM_WORDS_HINT}`,
+        hint: "\u793A\u4F8B\uFF1A--platforms claude,cursor \u6216 --platforms none\u3002"
+      }
+    };
+  }
+  return { ok: true, platforms };
+}
+function renderPlatformMenu() {
+  const lines = ["\u53EF\u542F\u7528\u7684\u5E73\u53F0\u9002\u914D\u5668\uFF08AGENTS.md \u6052\u751F\u6210\uFF0C\u4E3A\u552F\u4E00\u4E8B\u5B9E\u6E90\uFF09\uFF1A"];
+  PLATFORM_ADAPTERS.forEach((spec, index) => {
+    const note = spec.coveredByAgentsMd ? "\uFF08codex \u539F\u751F\u5165\u53E3\uFF0C\u96F6\u989D\u5916\u6587\u4EF6\uFF09" : "";
+    lines.push(`  ${index + 1}. ${spec.name.padEnd(7)} ${spec.file}${note}`);
+  });
+  lines.push("\u8F93\u5165\u8981\u542F\u7528\u7684\u5E73\u53F0\u7F16\u53F7\uFF08\u9017\u53F7\u5206\u9694\uFF0C\u56DE\u8F66\u9ED8\u8BA4 claude\uFF1Ba=\u5168\u9009\uFF09\uFF1A");
+  return lines;
+}
+async function runInitInteractive(rootDir, interactive) {
+  for (const line of renderPlatformMenu())
+    interactive.write(line);
+  const raw = (await interactive.readLine()).trim();
+  const parse = parsePlatformSelection(raw === "" ? "claude" : raw);
+  if (!parse.ok) {
+    return failOutcome("init", {
+      change: "NO_CHANGE",
+      tool: INIT_TOOL_ID,
+      profile: "LIGHT",
+      files: [],
+      platforms: []
+    }, [parse.error], ["init: FAILED \u2014 SCHEMA_INVALID", `  ${parse.error.message}`, `  hint: ${parse.error.hint}`]);
+  }
+  return runInit(rootDir, { platforms: parse.platforms.join(",") });
+}
 function parseConfigProfile(configText) {
   const match = /^\s*profile:\s*([A-Za-z_-]+)/m.exec(configText);
   const value = match?.[1]?.toUpperCase();
@@ -41438,10 +41580,45 @@ Claude harness \u5165\u53E3\u4E0E AGENTS.md \u5171\u4EAB\u540C\u4E00\u8F7B\u5165
 
 @AGENTS.md
 `;
-async function runInit(rootDir) {
+var INIT_LOGO_LINES = [
+  "\u2588\u2588\u2588\u2588\u2588\u2588\u2557   \u2588\u2588\u2588\u2588\u2588\u2588\u2557  \u2588\u2588\u2588\u2557   \u2588\u2588\u2588\u2557  \u2588\u2588\u2588\u2588\u2588\u2557  \u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557 \u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557 \u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557 \u2588\u2588\u2588\u2588\u2588\u2588\u2557 ",
+  "\u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2557 \u2588\u2588\u2554\u2550\u2550\u2550\u2588\u2588\u2557 \u2588\u2588\u2588\u2588\u2557 \u2588\u2588\u2588\u2588\u2551 \u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2557 \u2588\u2588\u2554\u2550\u2550\u2550\u2550\u255D \u255A\u2550\u2550\u2588\u2588\u2554\u2550\u2550\u255D \u2588\u2588\u2554\u2550\u2550\u2550\u2550\u255D \u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2557",
+  "\u2588\u2588\u2588\u2588\u2588\u2588\u2554\u255D \u2588\u2588\u2551   \u2588\u2588\u2551 \u2588\u2588\u2554\u2588\u2588\u2588\u2588\u2554\u2588\u2588\u2551 \u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2551 \u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557    \u2588\u2588\u2551    \u2588\u2588\u2588\u2588\u2588\u2557   \u2588\u2588\u2588\u2588\u2588\u2588\u2554\u255D",
+  "\u2588\u2588\u2554\u2550\u2550\u2550\u255D  \u2588\u2588\u2551   \u2588\u2588\u2551 \u2588\u2588\u2551\u255A\u2588\u2588\u2554\u255D\u2588\u2588\u2551 \u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2551 \u255A\u2550\u2550\u2550\u2550\u2588\u2588\u2551    \u2588\u2588\u2551    \u2588\u2588\u2554\u2550\u2550\u255D   \u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2557",
+  "\u2588\u2588\u2551      \u255A\u2588\u2588\u2588\u2588\u2588\u2588\u2554\u255D \u2588\u2588\u2551 \u255A\u2550\u255D \u2588\u2588\u2551 \u2588\u2588\u2551  \u2588\u2588\u2551 \u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2551    \u2588\u2588\u2551    \u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557 \u2588\u2588\u2551  \u2588\u2588\u2551",
+  "\u255A\u2550\u255D       \u255A\u2550\u2550\u2550\u2550\u2550\u255D  \u255A\u2550\u255D     \u255A\u2550\u255D \u255A\u2550\u255D  \u255A\u2550\u255D \u255A\u2550\u2550\u2550\u2550\u2550\u2550\u255D    \u255A\u2550\u255D    \u255A\u2550\u2550\u2550\u2550\u2550\u2550\u255D \u255A\u2550\u255D  \u255A\u2550\u255D",
+  "                                                                       VNext"
+];
+var INIT_BANNER_LINES = [
+  "",
+  "POMaster \xB7 Governed Software State Control Plane",
+  "",
+  "  State is the only truth. Evidence is the only proof.",
+  "  A tool that reports green without evidence is more dangerous",
+  "  than no tool at all. Every change is permitted, every claim",
+  "  is accounted for, and every fact carries its authority.",
+  "",
+  "Contact / commercial licensing: allenxujianyang@outlook.com"
+];
+async function runInit(rootDir, options = {}) {
   const warnings = [];
   const errors = [];
   const files = [];
+  const selection = parsePlatformSelection(options.platforms ?? "claude");
+  if (!selection.ok) {
+    return failOutcome("init", {
+      change: "NO_CHANGE",
+      tool: INIT_TOOL_ID,
+      profile: "LIGHT",
+      files: [],
+      platforms: []
+    }, [selection.error], [
+      "init: FAILED \u2014 SCHEMA_INVALID",
+      `  ${selection.error.message}`,
+      `  hint: ${selection.error.hint}`
+    ]);
+  }
+  const selectedPlatforms = selection.platforms;
   const { mkdir: mkdir3 } = await import("node:fs/promises");
   await mkdir3(objectsDirPath(rootDir), { recursive: true });
   const ledgerPath = truthIndexPath(rootDir);
@@ -41535,14 +41712,16 @@ async function runInit(rootDir) {
       absolute: `${rootDir}/${AGENTS_MD_RELATIVE}`,
       content: withMarker(entryMarkdown),
       mayUpdate: true
-    },
-    {
+    }
+  ];
+  if (selectedPlatforms.includes("claude")) {
+    plans.push({
       relative: CLAUDE_MD_RELATIVE,
       absolute: `${rootDir}/${CLAUDE_MD_RELATIVE}`,
       content: withMarker(CLAUDE_ENTRY_CONTENT),
       mayUpdate: true
-    }
-  ];
+    });
+  }
   for (const plan of plans) {
     const existing = await readIfExists(plan.absolute);
     if (existing === null) {
@@ -41567,10 +41746,36 @@ async function runInit(rootDir) {
       files.push({ file: plan.relative, action: "updated" });
     }
   }
-  const created = files.some((f) => f.action === "created");
+  const platforms = [];
+  for (const spec of PLATFORM_ADAPTERS) {
+    if (!selectedPlatforms.includes(spec.name))
+      continue;
+    if (spec.coveredByAgentsMd) {
+      platforms.push({ name: spec.name, file: spec.file, action: "covered" });
+      continue;
+    }
+    if (spec.name === "claude") {
+      const entry = files.find((f) => f.file === CLAUDE_MD_RELATIVE);
+      platforms.push({
+        name: "claude",
+        file: CLAUDE_MD_RELATIVE,
+        action: entry?.action === "created" ? "created" : "skipped-existing"
+      });
+      continue;
+    }
+    const absolute = `${rootDir}/${spec.file}`;
+    if (await pathExists(absolute)) {
+      platforms.push({ name: spec.name, file: spec.file, action: "skipped-existing" });
+      continue;
+    }
+    await ensureParentDir(absolute);
+    await writeFile(absolute, spec.render(), "utf8");
+    platforms.push({ name: spec.name, file: spec.file, action: "created" });
+  }
+  const created = files.some((f) => f.action === "created") || platforms.some((p) => p.action === "created");
   const updated = files.some((f) => f.action === "updated");
   const change = created ? "CREATED" : updated ? "UPDATED" : "NO_CHANGE";
-  const result2 = { change, tool: INIT_TOOL_ID, profile, files };
+  const result2 = { change, tool: INIT_TOOL_ID, profile, files, platforms };
   if (errors.length > 0) {
     return failOutcome("init", result2, errors, [
       "init: FAILED",
@@ -41578,14 +41783,158 @@ async function runInit(rootDir) {
     hint: ${e.hint}`)
     ], warnings);
   }
+  const platformLines = ["  platforms:"];
+  if (platforms.length === 0) {
+    platformLines.push("    none\uFF08--platforms none\uFF1A\u672A\u542F\u7528\u4EFB\u4F55\u5E73\u53F0\u9002\u914D\u5668\uFF09");
+  } else {
+    for (const platform of platforms) {
+      const note = platform.action === "covered" ? "\uFF08codex \u539F\u751F\u5165\u53E3\uFF0C\u96F6\u989D\u5916\u6587\u4EF6\uFF09" : "";
+      platformLines.push(`    [${platform.name}] ${platform.action.padEnd(16)} ${platform.file}${note}`);
+    }
+  }
   const human = [
+    ...INIT_LOGO_LINES,
+    "",
     `init: ${change}`,
     ...files.map((f) => `  ${f.action.padEnd(15)} ${f.file}`),
-    `  profile: ${profile}`
+    ...platformLines,
+    `  profile: ${profile}`,
+    ...INIT_BANNER_LINES
   ];
   return okOutcome("init", result2, human, warnings);
 }
 
+// packages/cli/dist/update.js
+import { spawnSync } from "node:child_process";
+
+// packages/cli/dist/version.js
+import { readFileSync } from "node:fs";
+import { dirname as dirname2, join as join2 } from "node:path";
+import { fileURLToPath } from "node:url";
+var CLI_PACKAGE_NAME = "@pomaster/cli";
+function readCliPackageVersion() {
+  let dir = dirname2(fileURLToPath(import.meta.url));
+  for (let depth = 0; depth < 8; depth += 1) {
+    try {
+      const manifest = JSON.parse(readFileSync(join2(dir, "package.json"), "utf8"));
+      if (manifest.name === CLI_PACKAGE_NAME && typeof manifest.version === "string") {
+        return manifest.version;
+      }
+    } catch {
+    }
+    const parent = dirname2(dir);
+    if (parent === dir)
+      break;
+    dir = parent;
+  }
+  return CLI_VERSION;
+}
+function resolveCliVersion() {
+  if (true) {
+    return "0.1.1";
+  }
+  return readCliPackageVersion();
+}
+
+// packages/cli/dist/update.js
+var UPDATE_PACKAGE_NAME = "pomaster";
+var NPM_VIEW_TIMEOUT_MS = 15e3;
+var NPM_INSTALL_TIMEOUT_MS = 3e5;
+function defaultNpmRunner(args, options) {
+  const res = spawnSync("npm", [...args], {
+    encoding: "utf8",
+    timeout: options.timeoutMs,
+    shell: process.platform === "win32",
+    ...options.inheritStdio ? { stdio: "inherit" } : {}
+  });
+  return {
+    status: res.status,
+    stdout: typeof res.stdout === "string" ? res.stdout : "",
+    stderr: typeof res.stderr === "string" ? res.stderr : ""
+  };
+}
+function compareSemver(a, b) {
+  const pa = a.trim().replace(/^v/i, "").split(".");
+  const pb = b.trim().replace(/^v/i, "").split(".");
+  for (let i = 0; i < 3; i += 1) {
+    const na = Number.parseInt(pa[i] ?? "0", 10) || 0;
+    const nb = Number.parseInt(pb[i] ?? "0", 10) || 0;
+    if (na !== nb)
+      return na - nb;
+  }
+  return 0;
+}
+function parseLatestVersion(stdout) {
+  const value = stdout.trim();
+  return /^v?\d+\.\d+\.\d+/.test(value) ? value.replace(/^v/, "") : null;
+}
+function runUpdate(options = {}, deps = {}) {
+  const yes = options.yes === true;
+  const current = deps.currentVersion ?? resolveCliVersion();
+  const runNpm = deps.runNpm ?? defaultNpmRunner;
+  const npmView = runNpm(["view", UPDATE_PACKAGE_NAME, "version"], {
+    timeoutMs: NPM_VIEW_TIMEOUT_MS,
+    inheritStdio: false
+  });
+  const latest = npmView.status === 0 ? parseLatestVersion(npmView.stdout) : null;
+  if (latest === null) {
+    const stderrExcerpt = npmView.stderr.trim().slice(0, 200);
+    const result2 = {
+      current,
+      latest: null,
+      updateAvailable: null,
+      check: "registry_unreachable"
+    };
+    return failOutcome("update", result2, [
+      {
+        code: "REGISTRY_UNREACHABLE",
+        message: `npm view ${UPDATE_PACKAGE_NAME} version \u672A\u8FD4\u56DE\u53EF\u89E3\u6790\u7248\u672C\uFF08exit ${npmView.status}${stderrExcerpt ? `\uFF1Bstderr: ${stderrExcerpt}` : ""}\uFF09`,
+        hint: "\u68C0\u67E5\u7F51\u7EDC\u6216 npm registry \u914D\u7F6E\uFF1B\u4E5F\u53EF\u76F4\u63A5\u8FD0\u884C npm i -g pomaster\u3002"
+      }
+    ], [
+      `update: current ${current}`,
+      "registry \u4E0D\u53EF\u8FBE\uFF0C\u65E0\u6CD5\u68C0\u67E5\u66F4\u65B0",
+      ...yes ? ["--yes \u5DF2\u62D2\u7EDD\u6267\u884C\uFF1A\u68C0\u67E5\u672A\u5B8C\u6210\uFF0C\u4E0D\u505A\u76F2\u88C5\uFF08fail-closed\uFF09\u3002"] : []
+    ]);
+  }
+  const updateAvailable = compareSemver(latest, current) > 0;
+  if (yes && !updateAvailable) {
+    return okOutcome("update", { current, latest, updateAvailable, check: "ok" }, [`update: current ${current} / latest ${latest}`, "\u5DF2\u662F\u6700\u65B0"]);
+  }
+  if (yes) {
+    const installArgs = ["install", "-g", `${UPDATE_PACKAGE_NAME}@latest`];
+    const npmInstall = runNpm(installArgs, {
+      timeoutMs: NPM_INSTALL_TIMEOUT_MS,
+      inheritStdio: true
+    });
+    const install = {
+      command: `npm ${installArgs.join(" ")}`,
+      exit_code: npmInstall.status,
+      ok: npmInstall.status === 0
+    };
+    const human2 = [
+      `update: current ${current} / latest ${latest} \u2192 ${install.command}`,
+      install.ok ? "npm install \u5B8C\u6210" : "npm install \u5931\u8D25\uFF08\u8BE6\u89C1\u4E0A\u65B9 npm \u900F\u4F20\u8F93\u51FA\uFF09",
+      ...install.ok ? ["\u91CD\u65B0\u8FD0\u884C pomaster init\uFF08\u5E42\u7B49\uFF09\u5237\u65B0\u8F7B\u5165\u53E3\u3002"] : []
+    ];
+    const result2 = { current, latest, updateAvailable, check: "ok", install };
+    if (install.ok) {
+      return okOutcome("update", result2, human2);
+    }
+    const installError = {
+      code: "NPM_INSTALL_FAILED",
+      message: `${install.command} \u5931\u8D25\uFF08exit ${npmInstall.status}\uFF09`,
+      hint: "npm \u7684\u9519\u8BEF\u8F93\u51FA\u5DF2\u900F\u4F20\u5230\u7EC8\u7AEF\uFF1B\u53EF\u624B\u52A8\u8FD0\u884C npm i -g pomaster \u540E\u91CD\u8BD5\u3002"
+    };
+    return failOutcome("update", result2, [installError], human2);
+  }
+  const human = [
+    `update: current ${current} / latest ${latest}`,
+    updateAvailable ? `\u66F4\u65B0\u53EF\u7528\uFF1A\u8FD0\u884C pomaster update --yes \u6216 npm i -g ${UPDATE_PACKAGE_NAME}` : "\u5DF2\u662F\u6700\u65B0"
+  ];
+  return okOutcome("update", { current, latest, updateAvailable, check: "ok" }, human);
+}
+
 // packages/cli/dist/status.js
 init_src();
 import { readFile as readFile2 } from "node:fs/promises";
@@ -41783,12 +42132,12 @@ function countMigratingWithPermit(objectRows) {
 // packages/cli/dist/inspect.js
 init_dist();
 import { readFile as readFile4 } from "node:fs/promises";
-import { join as join4 } from "node:path";
+import { join as join5 } from "node:path";
 
 // packages/cli/dist/evidence.js
 init_dist();
 init_src();
-import { existsSync as existsSync8, readdirSync as readdirSync14, readFileSync as readFileSync5 } from "node:fs";
+import { existsSync as existsSync8, readdirSync as readdirSync14, readFileSync as readFileSync6 } from "node:fs";
 var GRN_FILE_PATTERN = /^GRN-[0-9]+\.json$/;
 var CLM_FILE_PATTERN = /^CLM-[0-9]+\.json$/;
 var GRN_REF_PATTERN = /^GRN-[0-9]+$/;
@@ -42061,7 +42410,7 @@ function planRunFile(input) {
   const grn = input.fileName.slice(0, -".json".length);
   let bytes;
   try {
-    bytes = readFileSync5(`${input.runsDir}/${input.fileName}`, "utf8");
+    bytes = readFileSync6(`${input.runsDir}/${input.fileName}`, "utf8");
   } catch (err) {
     return { malformed: malformedOf(relPath, `\u6587\u4EF6\u4E0D\u53EF\u8BFB\uFF1A${err instanceof Error ? err.message : String(err)}`) };
   }
@@ -42139,7 +42488,7 @@ function findCanonicalRunMatch(input) {
     const grn = fileName.slice(0, -".json".length);
     let bytes;
     try {
-      bytes = readFileSync5(`${input.runsDir}/${fileName}`, "utf8");
+      bytes = readFileSync6(`${input.runsDir}/${fileName}`, "utf8");
     } catch {
       continue;
     }
@@ -42351,7 +42700,7 @@ function planClaimFile(input) {
   const clm = input.fileName.slice(0, -".json".length);
   let bytes;
   try {
-    bytes = readFileSync5(`${input.claimsDir}/${input.fileName}`, "utf8");
+    bytes = readFileSync6(`${input.claimsDir}/${input.fileName}`, "utf8");
   } catch (err) {
     return { malformed: malformedOf(relPath, `\u6587\u4EF6\u4E0D\u53EF\u8BFB\uFF1A${err instanceof Error ? err.message : String(err)}`) };
   }
@@ -42404,7 +42753,7 @@ function findCanonicalClaimMatch(input) {
     const clm = fileName.slice(0, -".json".length);
     let bytes;
     try {
-      bytes = readFileSync5(`${input.claimsDir}/${fileName}`, "utf8");
+      bytes = readFileSync6(`${input.claimsDir}/${fileName}`, "utf8");
     } catch {
       continue;
     }
@@ -43116,7 +43465,7 @@ async function runInspect(rootDir, input) {
       hint: "truth-index \u884C\u7531 kernel \u4E8B\u52A1\u7EF4\u62A4\uFF1B\u4ECE git \u6062\u590D\u540E\u91CD\u8BD5\u3002"
     }, input.id);
   }
-  const bodyPath = join4(rootDir, POMASTER_DIR, ...bodyRef.split("/"));
+  const bodyPath = join5(rootDir, POMASTER_DIR, ...bodyRef.split("/"));
   let bodyRaw;
   try {
     bodyRaw = await readFile4(bodyPath, "utf8");
@@ -43148,7 +43497,7 @@ async function runInspect(rootDir, input) {
   };
   const warnings = [];
   const runs = [];
-  const runsDir = join4(rootDir, POMASTER_DIR, "evidence", "runs");
+  const runsDir = join5(rootDir, POMASTER_DIR, "evidence", "runs");
   for (const fileName of listPlaneFiles(runsDir)) {
     if (!GRN_FILE_PATTERN.test(fileName)) {
       warnings.push({
@@ -43160,7 +43509,7 @@ async function runInspect(rootDir, input) {
     }
     let record;
     try {
-      const parsed = JSON.parse(await readFile4(join4(runsDir, fileName), "utf8"));
+      const parsed = JSON.parse(await readFile4(join5(runsDir, fileName), "utf8"));
       if (!isRecord4(parsed))
         throw new TypeError("run record is not an object");
       record = parsed;
@@ -43183,7 +43532,7 @@ async function runInspect(rootDir, input) {
     });
   }
   const claims = [];
-  const claimsDir = join4(rootDir, POMASTER_DIR, "evidence", "claims");
+  const claimsDir = join5(rootDir, POMASTER_DIR, "evidence", "claims");
   for (const fileName of listPlaneFiles(claimsDir)) {
     if (!CLM_FILE_PATTERN.test(fileName)) {
       warnings.push({
@@ -43195,7 +43544,7 @@ async function runInspect(rootDir, input) {
     }
     let record;
     try {
-      const parsed = JSON.parse(await readFile4(join4(claimsDir, fileName), "utf8"));
+      const parsed = JSON.parse(await readFile4(join5(claimsDir, fileName), "utf8"));
       if (!isRecord4(parsed))
         throw new TypeError("claim record is not an object");
       record = parsed;
@@ -44750,7 +45099,7 @@ ${" ".repeat(18)}note: ${row2.note}`}`)
 
 // packages/cli/dist/exec-guard.js
 init_dist();
-import { readFileSync as readFileSync17 } from "node:fs";
+import { readFileSync as readFileSync18 } from "node:fs";
 import { readFile as readFile7 } from "node:fs/promises";
 function isFATALCode(err) {
   return typeof err === "object" && err !== null && (err.reason === "unknown_prefix" || err.reason === "grammar");
@@ -44827,7 +45176,7 @@ async function runExecGuard(rootDir, input) {
   let text;
   if (input.attempt === "-") {
     try {
-      text = readFileSync17(0, "utf8");
+      text = readFileSync18(0, "utf8");
     } catch (err) {
       return malformed("ATTEMPT_MALFORMED", `stdin \u8BFB\u53D6\u5931\u8D25\uFF1A${err instanceof Error ? err.message : String(err)}`, "stdin \u5F62\u6001\u8981\u6C42\u7BA1\u9053\u4F20\u5165 attempt JSON\uFF08echo \u2026 | pomaster exec-guard --attempt -\uFF09\u3002");
     }
@@ -45001,7 +45350,7 @@ async function runReconcile(rootDir, input) {
 
 // packages/cli/dist/record.js
 init_dist();
-import { existsSync as existsSync15, readFileSync as readFileSync18 } from "node:fs";
+import { existsSync as existsSync15, readFileSync as readFileSync19 } from "node:fs";
 function emptyGateRunResult() {
   return {
     grn: null,
@@ -45020,7 +45369,7 @@ function gateRunFail(error) {
 }
 function readFromBytes(path) {
   try {
-    return { bytes: readFileSync18(path, "utf8") };
+    return { bytes: readFileSync19(path, "utf8") };
   } catch (err) {
     return {
       code: EVIDENCE_MALFORMED_CODE,
@@ -45158,7 +45507,7 @@ async function runRecordGateRun(rootDir, input) {
     grn = input.grn;
     let targetBytes = null;
     try {
-      targetBytes = readFileSync18(`${runsDir}/${grn}.json`, "utf8");
+      targetBytes = readFileSync19(`${runsDir}/${grn}.json`, "utf8");
     } catch {
       targetBytes = null;
     }
@@ -45380,7 +45729,7 @@ async function runRecordClaim(rootDir, input) {
     clm = input.clm;
     let targetBytes = null;
     try {
-      targetBytes = readFileSync18(`${claimsDir}/${clm}.json`, "utf8");
+      targetBytes = readFileSync19(`${claimsDir}/${clm}.json`, "utf8");
     } catch {
       targetBytes = null;
     }
@@ -45459,7 +45808,7 @@ init_dist();
 init_src();
 import { readdirSync as readdirSync16 } from "node:fs";
 import { readFile as readFile8 } from "node:fs/promises";
-import { join as join6 } from "node:path";
+import { join as join7 } from "node:path";
 function emptyResult4(task) {
   return {
     task,
@@ -45532,7 +45881,7 @@ function listGrnSidecarFiles(runsDir) {
 async function readRunRecord(runsDir, fileName) {
   let parsed;
   try {
-    parsed = JSON.parse(await readFile8(join6(runsDir, fileName), "utf8"));
+    parsed = JSON.parse(await readFile8(join7(runsDir, fileName), "utf8"));
   } catch (err) {
     return { damage: `evidence/runs/${fileName}: JSON \u65E0\u6CD5\u89E3\u6790 \u2014 ${err instanceof Error ? err.message : String(err)}` };
   }
@@ -45553,7 +45902,7 @@ async function readRunRecord(runsDir, fileName) {
 async function readClaimRecord(claimsDir, fileName) {
   let bytes;
   try {
-    bytes = await readFile8(join6(claimsDir, fileName), "utf8");
+    bytes = await readFile8(join7(claimsDir, fileName), "utf8");
   } catch {
     return { missing: true };
   }
@@ -45616,7 +45965,7 @@ async function runCloseout(rootDir, input) {
       hint: "change \u7684\u5B8C\u6210\u5224\u5377\u7ECF\u7531\u5176 affected TASKs \u9010\u4EFB\u52A1 closeout\uFF1Bkind \u8BCD\u5F62\u89C1 02b kind-payloads\u3002"
     }, withKind);
   }
-  const bodyPath = join6(rootDir, POMASTER_DIR, ...row2.bodyRef.split("/"));
+  const bodyPath = join7(rootDir, POMASTER_DIR, ...row2.bodyRef.split("/"));
   let bodyRaw;
   try {
     bodyRaw = await readFile8(bodyPath, "utf8");
@@ -46092,8 +46441,8 @@ async function runCatalogExplain(id, deps) {
 }
 
 // packages/cli/dist/eval.js
-import { existsSync as existsSync16, readFileSync as readFileSync19 } from "node:fs";
-import { fileURLToPath as fileURLToPath2 } from "node:url";
+import { existsSync as existsSync16, readFileSync as readFileSync20 } from "node:fs";
+import { fileURLToPath as fileURLToPath3 } from "node:url";
 
 // packages/cli/dist/triage-rule-v0.js
 var PROFILE_LADDER = ["MINIMAL", "LIGHT", "STANDARD"];
@@ -46222,7 +46571,7 @@ function triageRuleV0(req) {
 
 // packages/cli/dist/eval.js
 var EVAL_SUITES = ["behavioral"];
-var BEHAVIORAL_SEEDS_PATH = fileURLToPath2(new URL("../../../tests/behavioral/seeds.json", import.meta.url));
+var BEHAVIORAL_SEEDS_PATH = fileURLToPath3(new URL("../../../tests/behavioral/seeds.json", import.meta.url));
 var L5_FAMILIES = ["A", "B", "C", "D", "E", "F", "G", "X"];
 var L5_EVALUATORS = ["cli_keyword", "rule_v0"];
 function loadSeeds(seedsPath = BEHAVIORAL_SEEDS_PATH) {
@@ -46230,7 +46579,7 @@ function loadSeeds(seedsPath = BEHAVIORAL_SEEDS_PATH) {
   if (lower.endsWith(".yaml") || lower.endsWith(".yml")) {
     throw new Error(`eval \u547D\u4EE4\u6D88\u8D39\u9762\u4E3A seeds.json\uFF0C\u4E0D\u63A5\u53D7 yaml \u8F7D\u7269\uFF08${seedsPath}\uFF09\u3002PRD \xA794.2 yaml \u8F7D\u7269\uFF08tests/behavioral/eval-cases.yaml\uFF09\u662F\u767B\u8BB0\u5F62\u6001\uFF1Aschema \u6821\u9A8C\u4E0E json \u540C\u6784\u951A\u5B9A\u5728 tests/behavioral/eval-carrier.spec.ts\uFF08js-yaml devDependency + ajv\uFF0Ctests \u9762\uFF09\uFF1B\u5224\u5377\u8BF7\u6CE8\u5165 seeds.json \u6216\u7701\u7565 seedsPath \u7528\u4ED3\u5E93\u7F3A\u7701\u8D26\u672C\u3002`);
   }
-  const raw = JSON.parse(readFileSync19(seedsPath, "utf8"));
+  const raw = JSON.parse(readFileSync20(seedsPath, "utf8"));
   const file = raw;
   if (!Array.isArray(file.seeds)) {
     throw new Error(`seeds.json \u5F62\u6001\u975E\u6CD5\uFF1A\u7F3A seeds \u6570\u7EC4\uFF08${seedsPath}\uFF09`);
@@ -46570,7 +46919,7 @@ async function runEval(input) {
 // packages/cli/dist/projection-common.js
 init_dist();
 import { readFile as readFile9 } from "node:fs/promises";
-import { join as join7 } from "node:path";
+import { join as join8 } from "node:path";
 function isRecord6(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
@@ -46606,7 +46955,7 @@ async function readRawIndexOrFail(rootDir) {
   }
 }
 async function readLedgerEntries(rootDir) {
-  const path = join7(rootDir, POMASTER_DIR, "state", "exception-ledger.json");
+  const path = join8(rootDir, POMASTER_DIR, "state", "exception-ledger.json");
   let raw;
   try {
     raw = await readFile9(path, "utf8");
@@ -46670,7 +47019,7 @@ async function readBodyEnvelope(rootDir, row2) {
       }
     };
   }
-  const bodyPath = join7(rootDir, POMASTER_DIR, ...bodyRef.split("/"));
+  const bodyPath = join8(rootDir, POMASTER_DIR, ...bodyRef.split("/"));
   let raw;
   try {
     raw = await readFile9(bodyPath, "utf8");
@@ -46699,7 +47048,7 @@ async function readBodyEnvelope(rootDir, row2) {
   }
 }
 async function readPermitFile(rootDir) {
-  const path = join7(rootDir, POMASTER_DIR, "state", "permits.json");
+  const path = join8(rootDir, POMASTER_DIR, "state", "permits.json");
   let raw;
   try {
     raw = await readFile9(path, "utf8");
@@ -46736,7 +47085,7 @@ async function readEvidencePlane(rootDir, warnings) {
     return record[field];
   };
   const runs = [];
-  const runsDir = join7(rootDir, POMASTER_DIR, "evidence", "runs");
+  const runsDir = join8(rootDir, POMASTER_DIR, "evidence", "runs");
   for (const fileName of listPlaneFiles(runsDir)) {
     if (!GRN_FILE_PATTERN.test(fileName)) {
       warnings.push({
@@ -46748,7 +47097,7 @@ async function readEvidencePlane(rootDir, warnings) {
     }
     let record;
     try {
-      const parsed = JSON.parse(await read(join7(runsDir, fileName), "utf8"));
+      const parsed = JSON.parse(await read(join8(runsDir, fileName), "utf8"));
       if (!isRecord6(parsed))
         throw new TypeError("run record is not an object");
       record = parsed;
@@ -46769,7 +47118,7 @@ async function readEvidencePlane(rootDir, warnings) {
     });
   }
   const claims = [];
-  const claimsDir = join7(rootDir, POMASTER_DIR, "evidence", "claims");
+  const claimsDir = join8(rootDir, POMASTER_DIR, "evidence", "claims");
   for (const fileName of listPlaneFiles(claimsDir)) {
     if (!CLM_FILE_PATTERN.test(fileName)) {
       warnings.push({
@@ -46781,7 +47130,7 @@ async function readEvidencePlane(rootDir, warnings) {
     }
     let record;
     try {
-      const parsed = JSON.parse(await read(join7(claimsDir, fileName), "utf8"));
+      const parsed = JSON.parse(await read(join8(claimsDir, fileName), "utf8"));
       if (!isRecord6(parsed))
         throw new TypeError("claim record is not an object");
       record = parsed;
@@ -46805,7 +47154,7 @@ async function readEvidencePlane(rootDir, warnings) {
   return { runs, claims };
 }
 async function readTransitionHistory(rootDir) {
-  const path = join7(rootDir, POMASTER_DIR, "state", "journal.jsonl");
+  const path = join8(rootDir, POMASTER_DIR, "state", "journal.jsonl");
   let raw;
   try {
     raw = await readFile9(path, "utf8");
@@ -47472,7 +47821,7 @@ async function runAuditTask(rootDir, input) {
 init_dist();
 init_src();
 import { readFile as readFile10 } from "node:fs/promises";
-import { join as join8 } from "node:path";
+import { join as join9 } from "node:path";
 async function runLedgerRecord(rootDir, input, deps) {
   const emptyResult5 = {
     ledger_ref: "",
@@ -47561,7 +47910,7 @@ async function runLedgerRecord(rootDir, input, deps) {
 }
 async function runLedgerList(rootDir, input) {
   const classificationFilter = input.classification?.trim() ? input.classification.trim() : null;
-  const path = join8(rootDir, POMASTER_DIR, "state", "exception-ledger.json");
+  const path = join9(rootDir, POMASTER_DIR, "state", "exception-ledger.json");
   let raw;
   try {
     raw = await readFile10(path, "utf8");
@@ -47651,13 +48000,13 @@ async function runLedgerList(rootDir, input) {
 // packages/cli/dist/knowledge.js
 init_dist();
 import { existsSync as existsSync18 } from "node:fs";
-import { join as join10 } from "node:path";
+import { join as join11 } from "node:path";
 
 // packages/cli/dist/research.js
 init_dist();
 import { existsSync as existsSync17 } from "node:fs";
 import { mkdir, readFile as readFile11, readdir, writeFile as writeFile2 } from "node:fs/promises";
-import { join as join9 } from "node:path";
+import { join as join10 } from "node:path";
 var RESEARCH_MODE_ARGV_ALIASES = {
   internal: "INTERNAL",
   external: "EXTERNAL",
@@ -47716,7 +48065,7 @@ async function resolveResearchHost(rootDir, hostOption) {
         }
       };
     }
-    if (!existsSync17(join9(rootDir, ...host.split("/")))) {
+    if (!existsSync17(join10(rootDir, ...host.split("/")))) {
       return {
         error: {
           code: "RESEARCH_HOST_NOT_FOUND",
@@ -47741,7 +48090,7 @@ async function resolveResearchHost(rootDir, hostOption) {
   const active = [];
   for (const id of entries) {
     try {
-      const raw = JSON.parse(await readFile11(join9(padsDir, id, "state.json"), "utf8"));
+      const raw = JSON.parse(await readFile11(join10(padsDir, id, "state.json"), "utf8"));
       if (typeof raw.state === "string" && (raw.state === "DISCOVERY" || raw.state === "READY_TO_PROMOTE")) {
         active.push(id);
       }
@@ -47856,10 +48205,10 @@ async function runResearchStart(rootDir, input) {
   const created = [];
   const skipped = [];
   try {
-    const researchDir = join9(rootDir, ...artifactRoot.split("/"));
+    const researchDir = join10(rootDir, ...artifactRoot.split("/"));
     await mkdir(researchDir, { recursive: true });
     for (const fileName of RESEARCH_ARTIFACT_FILES) {
-      const filePath = join9(researchDir, fileName);
+      const filePath = join10(researchDir, fileName);
       if (existsSync17(filePath)) {
         skipped.push(`${artifactRoot}${fileName}`);
         continue;
@@ -47931,7 +48280,7 @@ async function runResearchList(rootDir, hostArg) {
     ], [`research list: FAILED \u2014 SCHEMA_INVALID`]);
   }
   const hostRef = normalizeDir(hostArg);
-  const hostDir = join9(rootDir, ...hostRef.split("/"));
+  const hostDir = join10(rootDir, ...hostRef.split("/"));
   if (!existsSync17(hostDir)) {
     return failOutcome("research list", { host_ref: hostRef, artifacts: [] }, [
       {
@@ -47941,7 +48290,7 @@ async function runResearchList(rootDir, hostArg) {
       }
     ], [`research list: FAILED \u2014 RESEARCH_HOST_NOT_FOUND (${hostRef})`]);
   }
-  const indexPath = join9(hostDir, "research", "index.yaml");
+  const indexPath = join10(hostDir, "research", "index.yaml");
   const index = await readIndexYaml(indexPath);
   const artifacts = [];
   if (index !== null) {
@@ -47998,7 +48347,7 @@ async function runResearchInspect(rootDir, researchId) {
       }
     ], [`research inspect: FAILED \u2014 SCHEMA_INVALID`]);
   }
-  const hostDir = join9(rootDir, ...hostRef.split("/"));
+  const hostDir = join10(rootDir, ...hostRef.split("/"));
   if (!existsSync17(hostDir)) {
     return failOutcome("research inspect", {
       research_id: researchId,
@@ -48016,8 +48365,8 @@ async function runResearchInspect(rootDir, researchId) {
       }
     ], [`research inspect: FAILED \u2014 RESEARCH_HOST_NOT_FOUND (${hostRef})`]);
   }
-  const researchDir = join9(hostDir, "research");
-  const indexPath = join9(researchDir, "index.yaml");
+  const researchDir = join10(hostDir, "research");
+  const indexPath = join10(researchDir, "index.yaml");
   if (!existsSync17(indexPath)) {
     return failOutcome("research inspect", {
       research_id: researchId,
@@ -48072,7 +48421,7 @@ async function runResearchInspect(rootDir, researchId) {
   }
   const files = RESEARCH_ARTIFACT_FILES.map((f) => ({
     file: f,
-    present: existsSync17(join9(researchDir, f))
+    present: existsSync17(join10(researchDir, f))
   }));
   const missing = files.filter((f) => !f.present).map((f) => f.file);
   const rawFindings = Array.isArray(index.findings) ? index.findings : [];
@@ -48416,7 +48765,7 @@ async function loadResearchFinding(rootDir, researchId, findingNumber) {
       }
     };
   }
-  const indexPath = join10(rootDir, ...artifactRoot.split("/"), "index.yaml");
+  const indexPath = join11(rootDir, ...artifactRoot.split("/"), "index.yaml");
   if (!existsSync18(indexPath)) {
     return {
       error: {
@@ -48634,16 +48983,16 @@ init_src();
 init_dist();
 import { existsSync as existsSync19 } from "node:fs";
 import { mkdir as mkdir2, readdir as readdir2, readFile as readFile12, writeFile as writeFile3 } from "node:fs/promises";
-import { isAbsolute, join as join11, relative as relative2, resolve as resolve2 } from "node:path";
+import { isAbsolute, join as join12, relative as relative2, resolve as resolve2 } from "node:path";
 var PROMOTE_TARGETS = ["CHANGE", "TASK"];
 function scratchpadRefOf(id) {
   return `.pomaster/discovery/scratchpads/${id}/`;
 }
 function stateFilePath(rootDir, id) {
-  return join11(discoveryScratchpadDirPath(rootDir, id), "state.json");
+  return join12(discoveryScratchpadDirPath(rootDir, id), "state.json");
 }
 function metaFilePath(rootDir, id) {
-  return join11(discoveryScratchpadDirPath(rootDir, id), "meta.json");
+  return join12(discoveryScratchpadDirPath(rootDir, id), "meta.json");
 }
 function cliError(err) {
   if (err instanceof GovernedIdParseError) {
@@ -49042,7 +49391,7 @@ async function runBrainstormPromote(rootDir, input) {
     return fail6(txOutError, [`brainstorm promote: FAILED \u2014 SCHEMA_INVALID (--tx-out)`]);
   }
   if (txPath === null) {
-    txPath = join11(discoveryScratchpadDirPath(rootDir, input.discoveryId), "promote-tx.json");
+    txPath = join12(discoveryScratchpadDirPath(rootDir, input.discoveryId), "promote-tx.json");
   }
   try {
     await mkdir2(discoveryScratchpadDirPath(rootDir, input.discoveryId), { recursive: true });
@@ -49150,7 +49499,7 @@ async function runBrainstormPromote(rootDir, input) {
 
 // packages/cli/dist/memory.js
 init_dist();
-import { readFileSync as readFileSync20 } from "node:fs";
+import { readFileSync as readFileSync21 } from "node:fs";
 import { homedir as homedir3 } from "node:os";
 var [MEMORY_ENTRY_NOT_FOUND, MEMORY_ALREADY_REVIEWED, MEMORY_REVIEW_REQUIRED, MEMORY_ALREADY_PROMOTED, MEMORY_PROMOTE_OWNER_REQUIRED, MEMORY_CAPTURE_DUPLICATE, MEMORY_HARVEST_NOT_RUN] = MEMORY_CLI_ERROR_VALUES;
 function toCliError2(err, docSection) {
@@ -49219,7 +49568,7 @@ function readStdinText() {
     };
   }
   try {
-    return { text: readFileSync20(0, "utf8") };
+    return { text: readFileSync21(0, "utf8") };
   } catch (err) {
     return {
       error: {
@@ -49797,7 +50146,7 @@ async function runMemoryAudit(rootDir, input) {
 
 // packages/cli/dist/production.js
 init_dist();
-import { readFileSync as readFileSync21 } from "node:fs";
+import { readFileSync as readFileSync22 } from "node:fs";
 var [BAND_SCHEMA_INVALID, BAND_NOT_FOUND, OBSERVATION_NOT_EVALUABLE, CHALLENGE_REJECTED, EVIDENCE_NOT_FOUND] = PRODUCTION_CLI_ERROR_VALUES;
 var NO_AUTO_APPLY_NOTE = "\u5448\u62A5\u6001\u2014\u2014\u4E0D\u5F97\u81EA\u52A8\u5E94\u7528\uFF08PRD \xA790.4 L5695 \u9010\u5B57\uFF09\uFF1APOMASTER_SELF_IMPROVEMENT_CANDIDATE \u65E0\u4EFB\u4F55\u81EA\u52A8\u5E94\u7528\u901A\u8DEF\uFF0C\u300C\u5E94\u7528\u300D\u6C38\u8FDC\u662F\u4EBA/Owner \u7ECF\u6CBB\u7406\u9762\u7684\u663E\u5F0F\u52A8\u4F5C";
 function fail5(result2, command, error) {
@@ -50059,7 +50408,7 @@ async function runProductionEvaluate(rootDir, input) {
     const filePath = input.observationsFile.trim();
     let text;
     try {
-      text = readFileSync21(filePath, "utf8");
+      text = readFileSync22(filePath, "utf8");
     } catch (err) {
       return fail5(empty, command, {
         code: OBSERVATION_NOT_EVALUABLE,
@@ -51443,10 +51792,24 @@ function createProgram(runs, io = defaultIo) {
     writeOut: (chunk) => io.stdout(chunk.replace(/\n$/, "")),
     writeErr: (chunk) => io.stderr(chunk.replace(/\n$/, ""))
   });
-  program2.name(CLI_NAME).description("POMaster vNext \u2014 Governed Software State Control Plane\uFF08\u516B\u62CD Change Loop \u547D\u4EE4\u9762\uFF09").version("0.0.0").option("--dir <path>", "project root directory", process.cwd());
-  program2.command("init").description("\u521B\u5EFA .pomaster/ \u6700\u5C0F\u9AA8\u67B6 + AGENTS.md/CLAUDE.md \u8F7B\u5165\u53E3\uFF08\u5E42\u7B49\uFF1B\u91CD\u590D\u6267\u884C NO_CHANGE\uFF09").option("--json", "machine-readable JSON output (\xA745)").action(async (_opts, command) => {
-    const outcome = await runInit(resolveDir(command));
-    record({ command: "init", outcome, asJson: command.opts().json === true });
+  program2.name(CLI_NAME).description("POMaster vNext \u2014 Governed Software State Control Plane\uFF08\u516B\u62CD Change Loop \u547D\u4EE4\u9762\uFF09").version(resolveCliVersion()).option("--dir <path>", "project root directory", process.cwd());
+  program2.addHelpText("after", "\nContact / commercial licensing: allenxujianyang@outlook.com");
+  program2.command("init").description("\u521B\u5EFA .pomaster/ \u6700\u5C0F\u9AA8\u67B6 + AGENTS.md \u552F\u4E00\u4E8B\u5B9E\u6E90 + \u5E73\u53F0\u9002\u914D\u5668\uFF08F1\uFF1A--platforms \u9017\u53F7\u5217\u8868 claude,codex,cursor,qoder / none\uFF1B\u5E42\u7B49\uFF1B\u91CD\u590D\u6267\u884C NO_CHANGE\uFF09").option("--platforms <platforms>", "\u5E73\u53F0\u9002\u914D\u5668\u9017\u53F7\u5217\u8868\uFF08claude|codex|cursor|qoder|none\uFF1B\u7F3A\u7701 claude\uFF1BTTY \u4EBA\u8BFB\u6A21\u5F0F\u65E0\u65D7\u6807\u65F6\u51FA\u6E05\u5355\u4EA4\u4E92\uFF09").option("--json", "machine-readable JSON output (\xA745)").action(async (_opts, command) => {
+    const platformsArg = command.opts().platforms;
+    const asJson = command.opts().json === true;
+    const outcome = platformsArg === void 0 && !asJson && process.stdin.isTTY === true ? await runInitInteractive(resolveDir(command), {
+      write: (line) => io.stdout(line),
+      readLine: readLineFromStdin
+    }) : await runInit(resolveDir(command), { platforms: platformsArg });
+    record({ command: "init", outcome, asJson });
+  });
+  program2.command("update").description("\u68C0\u67E5/\u6267\u884C CLI \u81EA\u66F4\u65B0\uFF1A\u7F3A\u7701 --check\uFF08npm view \u6BD4\u5BF9 semver\uFF0Cregistry \u4E0D\u53EF\u8FBE\u663E\u5F0F\u5448\u73B0\u7981\u5047\u7EFF\uFF09\uFF1B--yes = \u66F4\u65B0\u53EF\u7528\u65F6 npm install -g pomaster@latest\uFF08npm \u5931\u8D25\u900F\u4F20 exit 1\uFF1B\u5B8C\u6210\u540E\u91CD\u65B0 pomaster init \u5237\u65B0\u8F7B\u5165\u53E3\uFF09").option("--check", "\u68C0\u67E5\u66F4\u65B0\uFF08\u7F3A\u7701\u884C\u4E3A\uFF0C\u663E\u5F0F\u8BCD\u5F62\u517C\u5BB9\uFF09").option("--yes", "\u68C0\u67E5\u5230\u66F4\u65B0\u65F6\u6267\u884C npm install -g pomaster@latest").option("--json", "machine-readable JSON output (\xA745)").action(async (opts, command) => {
+    const outcome = runUpdate({ yes: opts.yes === true });
+    record({
+      command: "update",
+      outcome,
+      asJson: command.optsWithGlobals().json === true
+    });
   });
   program2.command("triage").description("\u516B\u62CD\u2460\uFF1A\u89C4\u5219\u6876\u5224\u6863\uFF08\u8DE8\u57DF contract\u2192STANDARD\uFF1B\u7EAF\u6587\u6848/\u6837\u5F0F\u2192MINIMAL\uFF1B\u9ED8\u8BA4 LIGHT\uFF09").argument("<request>", "change request text").option("--json", "machine-readable JSON output (\xA745)").action(async (request, _opts, command) => {
     const result2 = triageRequest(request);
@@ -52321,6 +52684,16 @@ function createProgram(runs, io = defaultIo) {
 function collectValues(value, previous) {
   return [...previous ?? [], value];
 }
+function readLineFromStdin() {
+  const rl = createInterface({ input: process.stdin });
+  return new Promise((resolve3) => {
+    rl.once("line", (line) => {
+      resolve3(line);
+      rl.close();
+    });
+    rl.once("close", () => resolve3(""));
+  });
+}
 function isInformationalCommanderExit(err) {
   return err instanceof CommanderError && (err.code === "commander.helpDisplayed" || err.code === "commander.help" || err.code === "commander.version");
 }