@pieai/pro-gov 0.3.14 → 0.3.15

package/README.md

@@ -159,9 +159,15 @@ the final report to include either:
 
 ```text
 Compound Gate: ran ce-compound -> <path>
+Compound Gate: ran fallback capture -> <path>
 Compound Gate: skipped -> <reason>
 ```
 
+Use `ran fallback capture` only when the Compound Engineering plugin or
+`ce-compound` skill is unavailable in the current host. It writes a minimal
+`docs/solutions/**` learning record through `pro-gov learn capture`; it does
+not replace or copy the full CE workflow.
+
 Use `pro-gov doctor --strict-hooks` after syncing an engineering project to
 verify that the host configs are wired. This is a wiring check: it proves the
 project calls `pro-gov host-hook` for Codex, Claude Code, and Antigravity. The

package/assets/docs/reference/adoption/adoption-playbook.md

@@ -209,7 +209,10 @@ If a project needs local external-workflow guidance, keep it thin in `AGENTS.md`
 For engineering projects, keep Superpowers as the default engineering workflow.
 Use Compound Engineering by default only as the post-work Compound Gate:
 `ce-compound` captures reusable lessons when they exist; otherwise the agent
-reports a skip reason. Full CE workflows require an explicit user request.
+reports a skip reason. If the current host cannot load the CE plugin, use
+`pro-gov learn capture` as the fallback capture path and report
+`Compound Gate: ran fallback capture -> <path>`. Full CE workflows require an
+explicit user request.
 
 Use PGS Learning Recall before non-trivial work:
 
@@ -228,6 +231,7 @@ skipped:
 
 ```text
 Compound Gate: ran ce-compound -> <path>
+Compound Gate: ran fallback capture -> <path>
 Compound Gate: skipped -> <reason>
 ```
 

package/assets/docs/reference/adoption/recommended-agent-tooling.md

@@ -76,6 +76,7 @@ Compound Gate:
 Superpowers completes verified work
 -> decide with CE criteria whether reusable learning exists
 -> run ce-compound or report a skip reason
+-> if CE is unavailable in this host, run pro-gov learn capture as fallback
 ```
 
 PGS Learning Recall is the matching pre-work step:
@@ -87,6 +88,16 @@ pro-gov learn recall --query "<task summary>"
 It searches `docs/solutions/**` and `CONCEPTS.md` so agents can reuse prior
 lessons without making Compound Engineering the default execution workflow.
 
+The fallback path is deliberately smaller than CE:
+
+```bash
+pro-gov learn capture --title "<learning title>" --summary "<reusable lesson>"
+```
+
+Use it only when the CE plugin or skill is unavailable in the current host. It
+keeps the lesson searchable by Learning Recall without copying CE's full
+workflow into PGS.
+
 Do not make routine tasks choose between Superpowers and Compound Engineering as
 competing default engineering processes. Use CE's full `ce-plan`, `ce-work`, or
 `lfg` flow only when the user explicitly asks for it.

package/assets/integrations/compound-engineering.md

@@ -57,11 +57,14 @@ Every completed non-trivial engineering task must pass the Compound Gate:
 ```text
 Was there reusable learning?
 -> yes: run compound-engineering:ce-compound
+-> yes, but CE is unavailable: run pro-gov learn capture
 -> no: report "Compound Gate: skipped" and give the reason
 ```
 
-Use Compound Engineering's own capture criteria. Do not invent a separate PGS
-scoring system.
+Use Compound Engineering's own capture criteria when CE is available. PGS
+fallback capture exists only so hosts without the CE plugin can still preserve a
+searchable lesson. It is a minimal backup path, not a copied CE workflow and not
+a separate default process.
 
 Run `ce-compound` when the completed work produced a reusable lesson, such as:
 
@@ -81,6 +84,23 @@ Skip compounding when the work was:
 The skip must be explicit in the final report. This prevents agents from
 forgetting the gate while avoiding a low-value knowledge dump.
 
+If `compound-engineering:ce-compound` is unavailable in the current host, write
+a minimal fallback record:
+
+```bash
+pro-gov learn capture \
+  --title "<learning title>" \
+  --summary "<the reusable lesson future agents should recall>"
+```
+
+The fallback record should capture only verified, reusable learning. It should
+not document unfinished work, trivial changes, or lessons already covered by an
+existing `docs/solutions/**` record. Report it as:
+
+```text
+Compound Gate: ran fallback capture -> docs/solutions/<category>/<file>.md
+```
+
 ## When CE May Own The Main Flow
 
 Use the full Compound Engineering flow only when the user explicitly names it,
@@ -137,6 +157,7 @@ When a task finishes, report one of:
 
 ```text
 Compound Gate: ran ce-compound -> docs/solutions/<category>/<file>.md
+Compound Gate: ran fallback capture -> docs/solutions/<category>/<file>.md
 Compound Gate: skipped -> <reason>
 ```
 

package/assets/integrations/superpowers.md

@@ -47,6 +47,7 @@ Ponytail, when explicitly enabled for a task, may advise on:
 Compound Engineering, by default, owns:
 
 - post-work knowledge capture through `ce-compound`;
+- fallback capture through `pro-gov learn capture` only when CE is unavailable;
 - `docs/solutions/**` learning records and their CE frontmatter;
 - CE-owned external artifacts when the user explicitly invokes CE workflows.
 

package/assets/starter/AGENTS.template.md

@@ -43,7 +43,8 @@
 - Engineering projects may use Superpowers, Directed Development, GStack, or other external workflows only inside the selected lane; do not copy upstream integration guides into the target project by default.
 - For engineering projects, Superpowers is the default engineering workflow. Compound Engineering is used by default only as the post-work Compound Gate through `ce-compound`; full CE workflows require an explicit user request.
 - For engineering projects, PGS Learning Recall is the pre-work companion to that post-work gate: recall existing lessons first, then do the work, then decide whether a new lesson should be compounded.
-- Engineering projects should have PGS Stop hooks wired for Codex, Claude Code, and Antigravity. Before final reporting after completed engineering work, report `Compound Gate: ran ce-compound -> <path>` or `Compound Gate: skipped -> <reason>`.
+- Engineering projects should have PGS Stop hooks wired for Codex, Claude Code, and Antigravity. Before final reporting after completed engineering work, report `Compound Gate: ran ce-compound -> <path>`, `Compound Gate: ran fallback capture -> <path>`, or `Compound Gate: skipped -> <reason>`.
+- Use fallback capture only when the current host cannot load Compound Engineering; run `pro-gov learn capture --title "<learning title>" --summary "<reusable lesson>"` so Learning Recall can find the lesson later.
 - Doc-only projects should say that Superpowers TDD and Directed Development are not enabled by default.
 - External workflow systems such as Superpowers or GStack run inside the lane selected by this router. They must not replace this project router.
 

package/assets/starter/docs/governance/templates/donor-map.md

@@ -0,0 +1,82 @@
+---
+id: REPLACE-ME
+title: Replace Me Donor Map
+type: reference
+status: draft
+canonical: false
+owner: ai-assisted
+created: YYYY-MM-DD
+last_reviewed: YYYY-MM-DD
+domain: architecture
+tags:
+  - donor-map
+  - provenance
+pinned: false
+related: []
+---
+
+# REPLACE-ME: Replace Me Donor Map
+
+This reference isolates what this product may reuse from the donor repository.
+The donor is a source of parts, not a product template: research broadly,
+isolate a donor map, and promote only current-phase needs.
+
+## Donor Ref
+
+- Source repository: `https://github.com/replace-me/replace-me`
+- Intake commit (immutable pin for copied files): `<full 40-char SHA>`
+- Research branch/ref: `main`
+- Research commit: `<full 40-char SHA>`
+- Latest stable tag observed during intake: `vX.Y.Z`
+
+Copied files stay pinned to their original intake commit and hashes. Updating
+the research pin never silently re-sources copied files.
+
+## License And Provenance Readout
+
+State the donor's code license, the license of every asset family taken, and
+where each claim comes from (`LICENSE`, `CREDITS`, `README`). Explicitly name
+anything that is not portable: paid packs, account-bound purchases, or
+trademarked content.
+
+## Direct Reuse
+
+Immutable files copied byte-for-byte from the pinned intake commit. One row
+per file.
+
+| Id | Donor source path | Target path | License | SHA-256 | Bytes | Provenance |
+| --- | --- | --- | --- | --- | ---: | --- |
+| `replace-me` | `path/in/donor` | `path/in/product` | CC0-1.0 | `<sha256>` | 0 | `<claim source>` |
+
+## Adapted And Pattern Reuse
+
+Donor code rewritten for this product, and donor disciplines adopted without
+copying code. One row per item.
+
+| Donor source | Reuse class | Local adaptation |
+| --- | --- | --- |
+| `path/in/donor` | adapted code / adapted pattern / pattern | What this product keeps, changes, and rejects. |
+
+## Not Available From The Donor
+
+Product responsibilities the donor does not solve. Listing them prevents false
+confidence that the donor already handles them.
+
+## Future Candidates, Not Promoted
+
+Observed in the donor, deliberately not taken in the current phase, plus the
+condition that would revisit each item.
+
+## Rejected Donor Items
+
+What must not cross into this product, and why: license risk, product-identity
+mismatch, scale mismatch, or wholesale-transplant risk.
+
+## Verification Contract
+
+The command that re-verifies pinned commit, source paths, licenses, per-file
+SHA-256, byte sizes, and manifest coverage after any donated-file change:
+
+```bash
+replace-me-verifier
+```

package/cli-guide.md

@@ -21,6 +21,7 @@ pro-gov portfolio plan --config /path/to/portfolio.json --target web-app --json
 pro-gov portfolio assets-check --config /path/to/portfolio.json --json
 pro-gov portfolio doctor --config /path/to/portfolio.json --json
 pro-gov learn recall --query "release downstream sync" --target .
+pro-gov learn capture --title "Fallback learning" --summary "Reusable lesson..." --target .
 pro-gov lens inspect --target .
 pro-gov lens report --target . --out .pro-gov/lens-report.md
 pro-gov lens audit init --target /path/to/project --out audits/project/2026-07-01
@@ -50,6 +51,24 @@ lessons for the current task. Use it before non-trivial implementation,
 debugging, release, architecture, or portfolio-sync work. It is read-only and
 does not require a full local PGS checkout.
 
+`learn capture` is the fallback capture path for hosts where the Compound
+Engineering plugin or `ce-compound` skill is unavailable. Prefer CE when it is
+installed. Use fallback capture only after verified completed work produced a
+reusable lesson that is not already covered by an existing `docs/solutions/**`
+record:
+
+```bash
+pro-gov learn capture \
+  --title "Use fallback capture when CE is unavailable" \
+  --summary "Capture the reusable lesson through PGS fallback capture so Learning Recall can find it later."
+```
+
+Then report:
+
+```text
+Compound Gate: ran fallback capture -> docs/solutions/<category>/<file>.md
+```
+
 Full upstream-checkout commands:
 
 ```bash

package/dist/cli.js

@@ -1742,7 +1742,7 @@ import { basename as basename3, join as join13, resolve as resolve3 } from "node
 
 // 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|skipped)\s*->/i;
+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,
@@ -1757,6 +1757,9 @@ 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");
@@ -2335,10 +2338,111 @@ function cleanMarkdownLine(input) {
   return input.replace(/^#+\s*/, "").trim();
 }
 
+// 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) {
+  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);
+  return {
+    relativePath: normalizePath2(relative6(root, path)),
+    title,
+    captureMode: "pgs-fallback"
+  };
+}
+function renderFallbackLearning(options) {
+  const date = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+  const problemType = options.category === "workflow-issues" ? "workflow_issue" : "knowledge";
+  return [
+    "---",
+    `title: ${yamlString(options.title)}`,
+    `date: ${date}`,
+    `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]",
+    "---",
+    "",
+    `# ${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",
+    "",
+    "- 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",
+    "```",
+    ""
+  ].join("\n");
+}
+function uniquePath(dir, slug) {
+  let index = 1;
+  let candidate = join16(dir, `${slug}.md`);
+  while (existsSync16(candidate)) {
+    index += 1;
+    candidate = join16(dir, `${slug}-${index}.md`);
+  }
+  return candidate;
+}
+function slugify(input) {
+  return input.toLowerCase().replace(/['"]/g, "").replace(/[^a-z0-9\u4e00-\u9fff]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 80);
+}
+function yamlString(input) {
+  return JSON.stringify(input);
+}
+function normalizePath2(path) {
+  return path.split("\\").join("/");
+}
+
 // src/commands/learn.ts
 function runLearn(args) {
   const [subcommand2, ...rest] = args;
   if (subcommand2 === "recall") return runLearnRecall(rest);
+  if (subcommand2 === "capture") return runLearnCapture(rest);
   printUsage2();
   return 1;
 }
@@ -2367,6 +2471,32 @@ function runLearnRecall(args) {
   }
   return 0;
 }
+function runLearnCapture(args) {
+  const options = parseCaptureOptions(args);
+  if (!options.ok) {
+    console.error(options.error);
+    printUsage2();
+    return 1;
+  }
+  let result;
+  try {
+    result = captureFallbackLearning(options.value.targetDir, {
+      title: options.value.title,
+      summary: options.value.summary,
+      category: options.value.category,
+      module: options.value.module
+    });
+  } catch (error) {
+    console.error(error instanceof Error ? error.message : String(error));
+    return 1;
+  }
+  if (options.value.json) {
+    console.log(JSON.stringify(result, null, 2));
+    return 0;
+  }
+  console.log(`Learning Capture: ${result.relativePath}`);
+  return 0;
+}
 function parseRecallOptions(args) {
   let targetDir = process.cwd();
   let query = "";
@@ -2410,6 +2540,54 @@ function parseRecallOptions(args) {
   }
   return { ok: true, value: { targetDir, query, limit, json } };
 }
+function parseCaptureOptions(args) {
+  let targetDir = process.cwd();
+  let title = "";
+  let summary = "";
+  let category = "workflow-issues";
+  let module;
+  let json = false;
+  for (let index = 0; index < args.length; index += 1) {
+    const arg = args[index];
+    if (arg === "--target") {
+      const value = readFlagValue(args, index, "--target");
+      if (!value.ok) return value;
+      targetDir = value.value;
+      index += 1;
+    } else if (arg === "--title") {
+      const value = readFlagValue(args, index, "--title");
+      if (!value.ok) return value;
+      title = value.value;
+      index += 1;
+    } else if (arg === "--summary") {
+      const value = readFlagValue(args, index, "--summary");
+      if (!value.ok) return value;
+      summary = value.value;
+      index += 1;
+    } else if (arg === "--category") {
+      const value = readFlagValue(args, index, "--category");
+      if (!value.ok) return value;
+      category = value.value;
+      index += 1;
+    } else if (arg === "--module") {
+      const value = readFlagValue(args, index, "--module");
+      if (!value.ok) return value;
+      module = value.value;
+      index += 1;
+    } else if (arg === "--json") {
+      json = true;
+    } else if (arg === "--help" || arg === "-h") {
+      return { ok: false, error: "Usage requested" };
+    } else if (arg.startsWith("--")) {
+      return { ok: false, error: `Unknown option: ${arg}` };
+    } else {
+      return { ok: false, error: `Unexpected argument: ${arg}` };
+    }
+  }
+  if (!title.trim()) return { ok: false, error: "Missing required --title <text>" };
+  if (!summary.trim()) return { ok: false, error: "Missing required --summary <text>" };
+  return { ok: true, value: { targetDir, title, summary, category, module, json } };
+}
 function readFlagValue(args, index, flag) {
   const value = args[index + 1];
   if (!value || value.startsWith("--")) {
@@ -2419,15 +2597,16 @@ function readFlagValue(args, index, flag) {
 }
 function printUsage2() {
   console.error("Usage: pro-gov learn recall --query <text> [--target <path>] [--limit <n>] [--json]");
+  console.error("Usage: pro-gov learn capture --title <text> --summary <text> [--category <slug>] [--target <path>] [--json]");
 }
 
 // src/commands/lens.ts
-import { mkdirSync as mkdirSync7, writeFileSync as writeFileSync6 } from "node:fs";
+import { mkdirSync as mkdirSync8, writeFileSync as writeFileSync7 } from "node:fs";
 import { dirname as dirname9 } from "node:path";
 
 // src/lens/audit.ts
-import { existsSync as existsSync16, mkdirSync as mkdirSync6, readFileSync as readFileSync13, writeFileSync as writeFileSync5 } from "node:fs";
-import { basename as basename6, dirname as dirname8, join as join16 } from "node:path";
+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";
 var REQUIRED_ARTIFACTS = [
   "manifest.md",
   "raw/project-lens/architecture-lens.md",
@@ -2451,16 +2630,16 @@ function createProjectLensAuditPackage(targetDir, auditDir) {
     },
     requiredArtifacts: [...REQUIRED_ARTIFACTS]
   };
-  mkdirSync6(auditDir, { recursive: true });
-  writeJson(join16(auditDir, "audit.contract.json"), contract);
+  mkdirSync7(auditDir, { recursive: true });
+  writeJson(join17(auditDir, "audit.contract.json"), contract);
   for (const artifactPath of REQUIRED_ARTIFACTS) {
-    writeTemplate(join16(auditDir, artifactPath), renderArtifactTemplate(artifactPath, contract));
+    writeTemplate(join17(auditDir, artifactPath), renderArtifactTemplate(artifactPath, contract));
   }
   return contract;
 }
 function checkProjectLensAuditPackage(auditDir, options = {}) {
-  const contractPath = join16(auditDir, "audit.contract.json");
-  if (!existsSync16(contractPath)) {
+  const contractPath = join17(auditDir, "audit.contract.json");
+  if (!existsSync17(contractPath)) {
     return {
       ok: false,
       auditDir,
@@ -2507,8 +2686,8 @@ function checkProjectLensAuditPackage(auditDir, options = {}) {
     }
   }
   for (const artifactPath of REQUIRED_ARTIFACTS) {
-    const absolutePath = join16(auditDir, artifactPath);
-    if (!existsSync16(absolutePath)) {
+    const absolutePath = join17(auditDir, artifactPath);
+    if (!existsSync17(absolutePath)) {
       issues.push({ type: "missing-required-artifact", path: artifactPath });
       continue;
     }
@@ -2528,13 +2707,13 @@ function checkProjectLensAuditPackage(auditDir, options = {}) {
   };
 }
 function writeJson(path, value) {
-  mkdirSync6(dirname8(path), { recursive: true });
-  writeFileSync5(path, `${JSON.stringify(value, null, 2)}
+  mkdirSync7(dirname8(path), { recursive: true });
+  writeFileSync6(path, `${JSON.stringify(value, null, 2)}
 `);
 }
 function writeTemplate(path, content) {
-  mkdirSync6(dirname8(path), { recursive: true });
-  writeFileSync5(path, content);
+  mkdirSync7(dirname8(path), { recursive: true });
+  writeFileSync6(path, content);
 }
 function renderArtifactTemplate(artifactPath, contract) {
   const title = artifactPath.replace(/\.md$/, "").split("/").map((part) => part.replaceAll("-", " ")).join(" / ");
@@ -2772,8 +2951,8 @@ function bulletList(values) {
 
 // src/lens/scan.ts
 import { spawnSync as spawnSync4 } from "node:child_process";
-import { existsSync as existsSync17, readdirSync as readdirSync7, readFileSync as readFileSync14, statSync as statSync4 } from "node:fs";
-import { join as join17, relative as relative6 } from "node:path";
+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";
 var ignoredDirectories = /* @__PURE__ */ new Set([
   ".git",
   ".next",
@@ -2790,22 +2969,22 @@ function scanProjectLensTarget(targetDir, options = {}) {
   return {
     targetDir,
     aiEntryFiles: ["AGENTS.md", "CLAUDE.md"].filter(
-      (file) => existsSync17(join17(targetDir, file))
+      (file) => existsSync18(join18(targetDir, file))
     ),
     aiConfigFiles: [],
     packageJson,
     docs: {
-      hasDocsDirectory: existsSync17(join17(targetDir, "docs")),
+      hasDocsDirectory: existsSync18(join18(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(join17(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: 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)
   };
 }
 function readPackageJson(targetDir) {
-  const packageJsonPath = join17(targetDir, "package.json");
-  if (!existsSync17(packageJsonPath)) return void 0;
+  const packageJsonPath = join18(targetDir, "package.json");
+  if (!existsSync18(packageJsonPath)) return void 0;
   try {
     const packageJson = JSON.parse(readFileSync14(packageJsonPath, "utf8"));
     return {
@@ -2842,13 +3021,13 @@ function listProjectFiles(targetDir) {
   return files.sort();
 }
 function collectFiles2(rootDir, currentDir, files) {
-  if (!existsSync17(currentDir)) return;
+  if (!existsSync18(currentDir)) return;
   for (const entry of readdirSync7(currentDir, { withFileTypes: true })) {
     if (entry.isDirectory()) {
       if (ignoredDirectories.has(entry.name)) continue;
-      collectFiles2(rootDir, join17(currentDir, entry.name), files);
+      collectFiles2(rootDir, join18(currentDir, entry.name), files);
     } else if (entry.isFile()) {
-      files.push(toUnixPath4(relative6(rootDir, join17(currentDir, entry.name))));
+      files.push(toUnixPath4(relative7(rootDir, join18(currentDir, entry.name))));
     }
   }
 }
@@ -2900,8 +3079,8 @@ function runLensReport(args) {
   }
   const report = scanProjectLensTarget(options.value.targetDir);
   const markdown = renderProjectLensMarkdownReport(report);
-  mkdirSync7(dirname9(options.value.outPath), { recursive: true });
-  writeFileSync6(options.value.outPath, markdown);
+  mkdirSync8(dirname9(options.value.outPath), { recursive: true });
+  writeFileSync7(options.value.outPath, markdown);
   console.log(`report: ${options.value.outPath}`);
   return 0;
 }
@@ -3004,11 +3183,11 @@ function printUsage3() {
 }
 
 // src/commands/portfolio.ts
-import { existsSync as existsSync21 } from "node:fs";
-import { join as join20 } from "node:path";
+import { existsSync as existsSync22 } from "node:fs";
+import { join as join21 } from "node:path";
 
 // src/portfolio/manifest.ts
-import { existsSync as existsSync18, readFileSync as readFileSync15 } from "node:fs";
+import { existsSync as existsSync19, readFileSync as readFileSync15 } from "node:fs";
 import { dirname as dirname10, isAbsolute as isAbsolute3, resolve as resolve4 } from "node:path";
 function loadPortfolioManifest(configPath) {
   let parsed;
@@ -3173,7 +3352,7 @@ function validateEndpoint(value, field, issues) {
     });
     return;
   }
-  if (!existsSync18(value.path)) {
+  if (!existsSync19(value.path)) {
     issues.push({
       type: "missing-path",
       id: typeof value.id === "string" ? value.id : void 0,
@@ -3244,9 +3423,9 @@ function isRecord2(value) {
 
 // src/portfolio/doctor.ts
 import { spawnSync as spawnSync6 } from "node:child_process";
-import { existsSync as existsSync20, readFileSync as readFileSync17 } from "node:fs";
+import { existsSync as existsSync21, readFileSync as readFileSync17 } from "node:fs";
 import { createRequire as createRequire2 } from "node:module";
-import { dirname as dirname11, join as join19 } from "node:path";
+import { dirname as dirname11, join as join20 } from "node:path";
 import { fileURLToPath as fileURLToPath3 } from "node:url";
 
 // src/host-tooling/inventory.ts
@@ -3337,13 +3516,13 @@ function isRecord3(value) {
 }
 
 // src/portfolio/asset-state.ts
-import { existsSync as existsSync19, lstatSync as lstatSync5, readFileSync as readFileSync16 } from "node:fs";
-import { join as join18 } from "node:path";
+import { existsSync as existsSync20, lstatSync as lstatSync5, readFileSync as readFileSync16 } from "node:fs";
+import { join as join19 } 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(join18(options.targetDir, ".pro-gov/assets.json"));
-  const currentLock = readJsonFile(join18(options.targetDir, ".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 issues = [];
   if (!sameStrings(currentManifest?.bundleIds, expectedManifest?.bundleIds)) {
     issues.push({
@@ -3366,7 +3545,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 = join18(options.targetDir, entry.targetPath);
+    const targetAbsolutePath = join19(options.targetDir, entry.targetPath);
     if (!pathIsSymlink(targetAbsolutePath)) continue;
     issues.push({
       type: "orphaned-managed-symlink",
@@ -3388,7 +3567,7 @@ function readPlanDocument(plan, targetPath) {
   }
 }
 function readJsonFile(path) {
-  if (!existsSync19(path)) return void 0;
+  if (!existsSync20(path)) return void 0;
   try {
     return JSON.parse(readFileSync16(path, "utf8"));
   } catch {
@@ -3439,11 +3618,11 @@ function inspectPortfolio(options) {
 function inspectTarget(options) {
   const { target } = options;
   const issues = [];
-  const packageJson = readJson2(join19(target.path, "package.json"));
+  const packageJson = readJson2(join20(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(join19(target.path, "node_modules", packageName, "package.json"));
+    const installedPackage = readJson2(join20(target.path, "node_modules", packageName, "package.json"));
     const installed = installedPackage?.version;
     const expected = options.expectedPackageVersions[packageName];
     packages[packageName] = { declared, installed, expected };
@@ -3497,7 +3676,7 @@ function inspectTarget(options) {
       type: "asset-lock-drift",
       message: error instanceof Error ? error.message : String(error)
     });
-    if (!existsSync20(join19(target.path, ".pro-gov/assets.json"))) {
+    if (!existsSync21(join20(target.path, ".pro-gov/assets.json"))) {
       issues.push({ type: "bundle-drift", message: "Target asset manifest is missing." });
     }
   }
@@ -3512,15 +3691,15 @@ function inspectTarget(options) {
   };
 }
 function readTargetAssetHost(targetDir) {
-  const lockfile = readJson2(join19(targetDir, ".pro-gov/assets.lock.json"));
+  const lockfile = readJson2(join20(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 = 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 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 commands = [
     {
       name: "pro-gov doctor",
@@ -3531,7 +3710,7 @@ function runTargetChecks(target) {
     { name: "doc-gov scan --check", cli: docGovCli, args: ["scan", "--check"] }
   ];
   return commands.map((command2) => {
-    if (!existsSync20(command2.cli)) return { name: command2.name, status: null };
+    if (!existsSync21(command2.cli)) return { name: command2.name, status: null };
     const result = spawnSync6(process.execPath, [command2.cli, ...command2.args], {
       cwd: target.path,
       encoding: "utf8",
@@ -3572,14 +3751,14 @@ function getExpectedPackageVersions() {
 function findOwnPackageJson() {
   let current = dirname11(fileURLToPath3(import.meta.url));
   for (let depth = 0; depth < 5; depth += 1) {
-    const candidate = join19(current, "package.json");
-    if (existsSync20(candidate)) return candidate;
+    const candidate = join20(current, "package.json");
+    if (existsSync21(candidate)) return candidate;
     current = dirname11(current);
   }
   return "";
 }
 function readJson2(path) {
-  if (!path || !existsSync20(path)) return void 0;
+  if (!path || !existsSync21(path)) return void 0;
   try {
     return JSON.parse(readFileSync17(path, "utf8"));
   } catch {
@@ -3898,8 +4077,8 @@ function isHost2(value) {
   return value === "codex" || value === "claude-code" || value === "gemini-cli" || value === "antigravity";
 }
 function findPortfolioAgentAssetsDir(manifest) {
-  const agentAssetsDir = manifest?.executionEngine?.path ? join20(manifest.executionEngine.path, "agent-assets") : void 0;
-  return agentAssetsDir && existsSync21(join20(agentAssetsDir, "registry.json")) ? agentAssetsDir : void 0;
+  const agentAssetsDir = manifest?.executionEngine?.path ? join21(manifest.executionEngine.path, "agent-assets") : void 0;
+  return agentAssetsDir && existsSync22(join21(agentAssetsDir, "registry.json")) ? agentAssetsDir : void 0;
 }
 function printUsage4() {
   console.error("Usage:");
@@ -3910,8 +4089,8 @@ function printUsage4() {
 }
 
 // src/commands/sync.ts
-import { existsSync as existsSync22, readFileSync as readFileSync18 } from "node:fs";
-import { join as join21 } from "node:path";
+import { existsSync as existsSync23, readFileSync as readFileSync18 } from "node:fs";
+import { join as join22 } from "node:path";
 function runSync(args) {
   if (!args.includes("--check")) {
     console.error("pro-gov sync is read-only and requires --check.");
@@ -3938,8 +4117,8 @@ function runSync(args) {
   console.log("pro-gov sync check");
   console.log(`profile: ${profile}`);
   for (const file of planStarterFiles(profile)) {
-    const targetPath = join21(process.cwd(), file.targetPath);
-    if (!existsSync22(targetPath)) {
+    const targetPath = join22(process.cwd(), file.targetPath);
+    if (!existsSync23(targetPath)) {
       if (file.ownership === "optional-guardrail") continue;
       console.log(`missing: ${file.targetPath}`);
       differences += 1;
@@ -3962,7 +4141,7 @@ function runSync(args) {
 }
 function inferInstalledProfile(root) {
   const installed = ["engineering-runtime", "doc-only"].filter(
-    (profile) => existsSync22(join21(root, `docs/governance/agents-routing/${profile}-v0.9.md`))
+    (profile) => existsSync23(join22(root, `docs/governance/agents-routing/${profile}-v0.9.md`))
   );
   return installed.length === 1 ? installed[0] : void 0;
 }
@@ -3987,6 +4166,7 @@ var COMMANDS = [
   "portfolio assets-check --config <path> [--target <id|all>] [--json]",
   "portfolio doctor --config <path> [--target <id|all>] [--json]",
   "learn recall --query <text> [--target <path>] [--limit <n>] [--json]",
+  "learn capture --title <text> --summary <text> [--category <slug>] [--target <path>] [--json]",
   "lens scan [--target <path>] [--json]",
   "lens inspect [--target <path>] [--format text|json]",
   "lens report --target <path> --out <path>",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pieai/pro-gov",
-  "version": "0.3.14",
+  "version": "0.3.15",
   "description": "Project-level distribution kit for Project Governance System.",
   "keywords": [
     "ai-agents",
@@ -35,7 +35,7 @@
     "access": "public"
   },
   "dependencies": {
-    "@pieai/doc-gov": "^0.3.14"
+    "@pieai/doc-gov": "^0.3.15"
   },
   "devDependencies": {
     "@types/node": "24.13.2",