@garygentry/feature-forge 0.2.14 → 0.3.1

package/adapters/pi/skills/forge-verify/references/verification-checklists/prd.md

@@ -0,0 +1,31 @@
+# PRD Verification Checklist
+
+Detailed checklist for the **prd** verification mode, loaded by the `forge-verifier` leaf subagent dispatched for that mode. Execute EVERY check — do not skip.
+
+> **Stack-specific details:** When a stack profile exists at `references/stacks/{stack}.md`, load it alongside this checklist for language-specific check criteria (e.g., what "valid syntax" means, what the type check command is, how module exports work).
+
+## PRD Mode Checklist
+
+### Completeness
+- [ ] **CHECK-P01**: All template sections from `references/prd-template.md` are populated
+- [ ] **CHECK-P02**: No TBD or TODO placeholders remain in the document
+- [ ] **CHECK-P03**: Out-of-scope section exists and is specific (not just "everything else")
+- [ ] **CHECK-P04**: Open questions section contains only actionable items (not vague concerns)
+- [ ] **CHECK-P05**: Success criteria are measurable and verifiable
+
+### Requirement Quality
+- [ ] **CHECK-P06**: Every requirement has a unique ID (REQ-XXX-NN format)
+- [ ] **CHECK-P07**: Every requirement has a priority assigned (P0/P1/P2)
+- [ ] **CHECK-P08**: Every requirement is testable/verifiable — could you write an acceptance test for it?
+- [ ] **CHECK-P09**: No requirements contain technology decisions (specific libraries, frameworks, or implementation choices) unless clearly labeled as constraints with justification
+- [ ] **CHECK-P10**: User stories cover all identified actors/personas
+
+### Non-Functional Requirements
+- [ ] **CHECK-P11**: Non-functional requirements are quantified where applicable (latency targets, uptime SLAs, throughput minimums)
+- [ ] **CHECK-P12**: Security requirements are explicit, not assumed
+- [ ] **CHECK-P13**: Constraints section distinguishes mandates (must) from preferences (should/nice-to-have)
+
+### Open-Ended Analysis
+- [ ] **CHECK-P14**: Are there implicit requirements that should be made explicit? (e.g., assumptions about authentication, authorization, data retention)
+- [ ] **CHECK-P15**: Are there requirement conflicts or tensions? (e.g., performance vs. completeness, simplicity vs. flexibility)
+

package/adapters/pi/skills/forge-verify/references/verification-checklists/specs.md

@@ -0,0 +1,64 @@
+# Specs Verification Checklist
+
+Detailed checklist for the **specs** verification mode, loaded by the `forge-verifier` leaf subagent dispatched for that mode. Execute EVERY check — do not skip.
+
+> **Stack-specific details:** When a stack profile exists at `references/stacks/{stack}.md`, load it alongside this checklist for language-specific check criteria (e.g., what "valid syntax" means, what the type check command is, how module exports work).
+
+## Specs Mode Checklist
+
+### Requirement Coverage
+- [ ] **CHECK-S01**: Every PRD requirement (REQ-XXX-NN) is referenced by at least one implementation spec
+- [ ] **CHECK-S02**: Every P0 (must-have) requirement has detailed implementation guidance, not just a mention
+- [ ] **CHECK-S03**: Every P1 requirement is at least acknowledged with an implementation approach
+- [ ] **CHECK-S04**: No implementation spec sections exist that don't trace to a PRD requirement or tech-spec decision (orphaned specs indicate scope creep)
+
+### Tech Spec ↔ Implementation Spec Consistency
+- [ ] **CHECK-S05**: Every technology decision in the tech spec is reflected in the implementation specs
+- [ ] **CHECK-S06**: Package structure in 01-architecture-layout.md matches what the tech spec describes
+- [ ] **CHECK-S07**: Dependencies listed in the tech spec match those in the architecture spec
+- [ ] **CHECK-S08**: No implementation spec contradicts a tech-spec decision
+
+### Type System Integrity
+- [ ] **CHECK-S09**: All type definitions in 00-core-definitions.md are valid syntax in the project's language (not pseudocode)
+- [ ] **CHECK-S10**: All types referenced in other spec docs are defined in 00-core-definitions.md or an explicit external package
+- [ ] **CHECK-S11**: Error classes form a consistent hierarchy with no gaps
+- [ ] **CHECK-S12**: No duplicate or conflicting type definitions across documents
+- [ ] **CHECK-S13**: Every type/interface/struct has documentation comments on every field (JSDoc, docstrings, godoc, etc.)
+
+### Cross-Reference Consistency
+- [ ] **CHECK-S14**: All file references between spec documents point to actual files
+- [ ] **CHECK-S15**: Section references (e.g., "see section 3.2 of 02-provider-registry.md") point to actual sections
+- [ ] **CHECK-S16**: Dependency ordering between spec docs is consistent (no circular dependencies)
+- [ ] **CHECK-S17**: Import paths referenced in specs are consistent with the exports map in 01-architecture-layout.md
+
+### Error Handling Coverage
+- [ ] **CHECK-S18**: Every operation that can fail has an error type defined
+- [ ] **CHECK-S19**: Error propagation is described: where errors are thrown, caught, transformed, and surfaced
+- [ ] **CHECK-S20**: User-facing error messages are specified (not just error codes)
+- [ ] **CHECK-S21**: Recovery behavior is described for recoverable errors
+
+### Integration Point Completeness
+- [ ] **CHECK-S22**: Every package listed in the tech spec's integration section has corresponding detail in the implementation specs
+- [ ] **CHECK-S23**: For each integration: the shared types/contracts are explicitly named
+- [ ] **CHECK-S24**: For each integration: data flow direction is clear
+- [ ] **CHECK-S25**: If integration requires changes to existing packages, those changes are specified
+- [ ] **CHECK-S26**: Import paths match actual package export maps
+
+### Edge Cases and Non-Functional
+- [ ] **CHECK-S27**: Concurrent access scenarios are addressed if relevant
+- [ ] **CHECK-S28**: Empty/null/undefined inputs are handled
+- [ ] **CHECK-S29**: Performance-sensitive paths are identified
+- [ ] **CHECK-S30**: Security considerations from PRD are reflected in implementation
+- [ ] **CHECK-S31**: Observability (logging, metrics, tracing) approach is specified if PRD requires it
+- [ ] **CHECK-S32**: Each implementation spec has a clear "public API" section that defines what is exported vs internal
+
+### Testing Strategy
+- [ ] **CHECK-S33**: Testing strategy document exists
+- [ ] **CHECK-S34**: Test approach covers unit, integration, and e2e as appropriate
+- [ ] **CHECK-S35**: Mock/fixture strategy is defined for external dependencies
+- [ ] **CHECK-S36**: Coverage targets are stated
+- [ ] **CHECK-S37**: Test fixtures and mocks defined in specs align with real interface shapes from 00-core-definitions.md
+
+### Traceability
+- [ ] **CHECK-S38**: Build a complete traceability matrix from every REQ-XXX-NN to the spec document and section that implements it. Any REQ ID not found in at least one spec is a gap finding.
+

package/adapters/pi/skills/forge-verify/references/verification-checklists/tech.md

@@ -0,0 +1,35 @@
+# Tech-Spec Verification Checklist
+
+Detailed checklist for the **tech** verification mode, loaded by the `forge-verifier` leaf subagent dispatched for that mode. Execute EVERY check — do not skip.
+
+> **Stack-specific details:** When a stack profile exists at `references/stacks/{stack}.md`, load it alongside this checklist for language-specific check criteria (e.g., what "valid syntax" means, what the type check command is, how module exports work).
+
+## Tech-Spec Mode Checklist
+
+### Requirement Traceability
+- [ ] **CHECK-T01**: Every tech decision traces to at least one PRD requirement (REQ-XXX-NN)
+- [ ] **CHECK-T02**: No tech decisions contradict PRD constraints
+- [ ] **CHECK-T03**: Every P0 PRD requirement has a corresponding tech decision or is explicitly deferred with rationale
+
+### Integration Analysis
+- [ ] **CHECK-T04**: Integration analysis section is complete — all packages identified
+- [ ] **CHECK-T05**: Import paths and function signatures are verified against actual source code
+- [ ] **CHECK-T06**: For each integration point: shared types/contracts are explicitly named
+- [ ] **CHECK-T07**: For each integration point: data flow direction is clear
+- [ ] **CHECK-T08**: Changes required to existing packages are specified
+
+### Design Quality
+- [ ] **CHECK-T09**: Alternatives considered for major decisions (not just "we chose X")
+- [ ] **CHECK-T10**: Error handling strategy is defined (error types, propagation, recovery)
+- [ ] **CHECK-T11**: Testing approach is specified (unit, integration, e2e strategy)
+- [ ] **CHECK-T12**: Data model aligns with PRD data requirements
+
+### Completeness
+- [ ] **CHECK-T13**: Package/module structure is defined with exports map
+- [ ] **CHECK-T14**: Configuration approach is specified
+- [ ] **CHECK-T15**: Migration/deployment considerations are addressed if applicable
+
+### Open-Ended Analysis
+- [ ] **CHECK-T16**: Are there integration points that could cause implementation surprises? (e.g., undocumented behavior, version incompatibilities, missing APIs)
+- [ ] **CHECK-T17**: Are there scalability concerns unaddressed by the current design? (e.g., data growth, concurrent users, resource limits)
+

package/dist/agent-targets.d.ts

@@ -67,7 +67,7 @@ export declare function confidenceFor(target: AgentTarget, scope: Scope): Confid
 export declare function detectAgent(id: AgentId, opts?: ResolveOpts): DetectionResult;
 /** Options for {@link detectAgents}: {@link ResolveOpts} plus a single-agent scope (REQ-FLAG-01). */
 export interface DetectAgentsOpts extends ResolveOpts {
-    /** Restrict detection to this one agent (`--agent/-a`). Absent ⇒ all five (REQ-DET-03). */
+    /** Restrict detection to this one agent (`--agent/-a`). Absent ⇒ all agents (REQ-DET-03). */
     readonly only?: AgentId;
 }
 /**

package/dist/agent-targets.js

@@ -40,6 +40,24 @@ export function resolveRoots(opts) {
 function scopeRootFor(scope, roots) {
     return scope === "global" ? roots.home : roots.cwd;
 }
+/** Select a scope-specific config dir name, falling back to the legacy single field. */
+function configDirNameFor(target, scope) {
+    if (scope === "global")
+        return target.globalConfigDirName ?? target.configDirName;
+    return target.projectConfigDirName ?? target.configDirName;
+}
+/** Select a scope-specific install base dir, falling back to the legacy single field. */
+function installBaseDirFor(target, scope) {
+    if (scope === "global")
+        return target.globalInstallBaseDir ?? target.installBaseDir;
+    return target.projectInstallBaseDir ?? target.installBaseDir;
+}
+/** Select a scope-specific install subpath, falling back to the legacy single field. */
+function installSubpathFor(target, scope) {
+    if (scope === "global")
+        return target.globalInstallSubpath ?? target.installSubpath;
+    return target.projectInstallSubpath ?? target.installSubpath;
+}
 /**
  * Derive the absolute install destination for one agent under a given scope (REQ-DET-01,
  * REQ-FLAG-02):
@@ -58,7 +76,9 @@ function scopeRootFor(scope, roots) {
 export function destinationFor(target, scope, opts) {
     const roots = resolveRoots(opts);
     const root = scopeRootFor(scope, roots);
-    return path.resolve(root, target.installBaseDir, ...(target.installSubpath ? [target.installSubpath] : []), FEATURE_FORGE_NS);
+    const installBaseDir = installBaseDirFor(target, scope);
+    const installSubpath = installSubpathFor(target, scope);
+    return path.resolve(root, installBaseDir, ...(installSubpath ? [installSubpath] : []), FEATURE_FORGE_NS);
 }
 /**
  * The filesystem containment boundary every write for `target` is checked against (REQ-SEC-02):
@@ -68,7 +88,7 @@ export function destinationFor(target, scope, opts) {
  */
 export function agentRootFor(target, scope, opts) {
     const roots = resolveRoots(opts);
-    return path.resolve(scopeRootFor(scope, roots), target.installBaseDir);
+    return path.resolve(scopeRootFor(scope, roots), installBaseDirFor(target, scope));
 }
 /**
  * The effective confidence for `target` under `scope` (A4): the per-row `projectConfidence`
@@ -95,7 +115,7 @@ export function detectAgent(id, opts) {
     const roots = resolveRoots(opts);
     const root = scopeRootFor(scope, roots);
     // Primary signal (REQ-DET-02): presence of the config dir under the active scope root.
-    const configDir = path.resolve(root, target.configDirName);
+    const configDir = path.resolve(root, configDirNameFor(target, scope));
     const detected = probeConfigDir(configDir);
     return {
         agent: id,

package/dist/detect.d.ts

@@ -16,7 +16,7 @@ import type { AgentId } from "./types.js";
  * instant, REQ-PERF-01) and never creates the dir (REQ-DET-04). Any stat failure
  * (`ENOENT` not present, `EACCES` unreadable, or a non-directory at the path) ⇒ `false`.
  *
- * Synchronous by design: exactly one stat per agent (five total), so async adds no
+ * Synchronous by design: exactly one stat per agent, so async adds no
  * throughput and would complicate the pure-derivation surface.
  */
 export declare function probeConfigDir(configDir: string): boolean;

package/dist/detect.js

@@ -17,7 +17,7 @@ import { execFileSync } from "node:child_process";
  * instant, REQ-PERF-01) and never creates the dir (REQ-DET-04). Any stat failure
  * (`ENOENT` not present, `EACCES` unreadable, or a non-directory at the path) ⇒ `false`.
  *
- * Synchronous by design: exactly one stat per agent (five total), so async adds no
+ * Synchronous by design: exactly one stat per agent, so async adds no
  * throughput and would complicate the pure-derivation surface.
  */
 export function probeConfigDir(configDir) {
@@ -34,6 +34,7 @@ const CLI_NAMES = {
     codex: "codex",
     copilot: "copilot",
     gemini: "gemini",
+    pi: "pi",
     // cursor: intentionally omitted — IDE/GUI agent, no canonical CLI on PATH (REQ-DET-02).
 };
 /** The real resolver: `which <bin>` (POSIX) / `where <bin>` (Windows). Any failure ⇒ false. */

package/dist/manifest.d.ts

@@ -28,7 +28,7 @@ export interface BuildManifestArgs {
     readonly skills: readonly string[];
     /** SHA-256 over the source bundle's canonical (sorted-path) file set — drift anchor (spec 03). */
     readonly sourceHash: string;
-    /** Recorded pinned rauf coordinate (e.g. "@garygentry/rauf@0.12.0"); `null` when `--skip-rauf` (spec 06). */
+    /** Recorded pinned rauf coordinate (e.g. "@garygentry/rauf@0.13.0"); `null` when `--skip-rauf` (spec 06). */
     readonly raufPin: string | null;
     /** Symlink mode only: the source bundle the namespace dir links to (REQ-SAFE-02). */
     readonly link?: {

package/dist/manifest.js

@@ -10,7 +10,7 @@
  */
 import * as fs from "node:fs";
 import * as path from "node:path";
-import { AGENT_TARGETS, MANIFEST_PREFIX, SCHEMA_VERSION, ok, err, READABLE_SCHEMA_VERSIONS, } from "./types.js";
+import { AGENT_IDS, AGENT_TARGETS, MANIFEST_PREFIX, SCHEMA_VERSION, ok, err, READABLE_SCHEMA_VERSIONS, } from "./types.js";
 import { destinationFor } from "./agent-targets.js";
 /**
  * Assemble an {@link InstallManifest} from an apply result (REQ-SAFE-01/03). Pure — no I/O.
@@ -146,7 +146,7 @@ export function writeManifest(p, m) {
         });
     }
 }
-const AGENT_IDS_SET = new Set(["claude", "codex", "copilot", "cursor", "gemini"]);
+const AGENT_IDS_SET = new Set(AGENT_IDS);
 /** Structural validation of a parsed manifest (internal to manifest.ts). */
 function validateManifest(x) {
     if (typeof x !== "object" || x === null)

package/dist/placements.js

@@ -23,7 +23,11 @@ export function resolvePlacements(target, scope, opts) {
     const roots = resolveRoots(opts);
     const scopeRoot = scope === "global" ? roots.home : roots.cwd;
     return (target.placements ?? []).map((spec) => {
-        const root = path.resolve(scopeRoot, spec.baseDir);
+        // Scope-aware second root: pi mirrors into `~/.pi/agent/agents` (global) but `.pi/agents`
+        // (project), which one `baseDir` string cannot express. Fall back to `baseDir` for the common
+        // case (codex/copilot) where the second root is scope-invariant.
+        const baseDir = (scope === "global" ? spec.globalBaseDir : spec.projectBaseDir) ?? spec.baseDir;
+        const root = path.resolve(scopeRoot, baseDir);
         return { kind: spec.kind, root, destination: path.resolve(root, spec.subpath), spec };
     });
 }

package/dist/rauf.d.ts

@@ -19,13 +19,13 @@ import { type Result } from "./types.js";
  *
  * Shape: `<name>@<version>` — the SCOPED package `@garygentry/rauf` (the unscoped `rauf` name is
  * blocked by npm's similarity filter). Advanced on each feature-forge release to a new
- * known-compatible rauf (REQ-RAUF-03). The current rauf version is 0.12.0.
+ * known-compatible rauf (REQ-RAUF-03). The current rauf version is 0.13.0.
  *
- * rauf is now PUBLISHED (rauf#28): `@garygentry/rauf@0.12.0` resolves from the npm registry, so the
+ * rauf is now PUBLISHED (rauf#28): `@garygentry/rauf@0.13.0` resolves from the npm registry, so the
  * preflight below passes by default. (Historically this pin pointed at an unpublished package and
  * the preflight was a designed-to-fail check — see the `--skip-rauf` escape hatch.)
  */
-export declare const RAUF_PIN = "@garygentry/rauf@0.12.0";
+export declare const RAUF_PIN = "@garygentry/rauf@0.13.0";
 /**
  * An injectable, READ-ONLY registry query (D1). Given a coordinate `name@version`, returns the
  * resolved version string on success, or an `InstallerError` if it is not resolvable.
@@ -37,7 +37,7 @@ export declare const RAUF_PIN = "@garygentry/rauf@0.12.0";
  * Contract: the query MUST be read-only — it MUST NOT install, MUST NOT mutate global npm
  * state, and MUST NOT execute rauf. `npm view` satisfies this (it only reads registry metadata).
  *
- * @param coordinate - the `name@version` to resolve, e.g. "@garygentry/rauf@0.12.0"
+ * @param coordinate - the `name@version` to resolve, e.g. "@garygentry/rauf@0.13.0"
  * @returns Result<string> — the resolved version on success; RAUF_UNRESOLVABLE on failure.
  */
 export type RegistryQuery = (coordinate: string) => Result<string>;

package/dist/rauf.js

@@ -20,13 +20,13 @@ import { err, ok } from "./types.js";
  *
  * Shape: `<name>@<version>` — the SCOPED package `@garygentry/rauf` (the unscoped `rauf` name is
  * blocked by npm's similarity filter). Advanced on each feature-forge release to a new
- * known-compatible rauf (REQ-RAUF-03). The current rauf version is 0.12.0.
+ * known-compatible rauf (REQ-RAUF-03). The current rauf version is 0.13.0.
  *
- * rauf is now PUBLISHED (rauf#28): `@garygentry/rauf@0.12.0` resolves from the npm registry, so the
+ * rauf is now PUBLISHED (rauf#28): `@garygentry/rauf@0.13.0` resolves from the npm registry, so the
  * preflight below passes by default. (Historically this pin pointed at an unpublished package and
  * the preflight was a designed-to-fail check — see the `--skip-rauf` escape hatch.)
  */
-export const RAUF_PIN = "@garygentry/rauf@0.12.0";
+export const RAUF_PIN = "@garygentry/rauf@0.13.0";
 /**
  * Resolvability preflight for the pinned default loop runner (D1; REQ-RAUF-01/02/03, OQ-1).
  *

package/dist/types.d.ts

@@ -6,10 +6,10 @@
  * exports only; `node:` built-ins only where applicable; zero runtime dependencies.
  */
 /**
- * The five coding agents this installer targets (REQ-DET-01). Order is the canonical
+ * The coding agents this installer targets (REQ-DET-01). Order is the canonical
  * iteration order used by detection, planning, and reporting so output is deterministic.
  */
-export declare const AGENT_IDS: readonly ["claude", "codex", "copilot", "cursor", "gemini"];
+export declare const AGENT_IDS: readonly ["claude", "codex", "copilot", "cursor", "gemini", "pi"];
 /** A supported coding-agent identifier. */
 export type AgentId = (typeof AGENT_IDS)[number];
 /**
@@ -60,10 +60,13 @@ export type Confidence = "confirmed" | "verified-current" | "best-known" | "unsu
 export type InstallKind = "skills" | "extension" | "rules" | "instructions";
 /**
  * Kind of a SECONDARY install placement (A4b). The primary bundle (the `feature-forge/` namespace
- * dir) is always present and is never a placement; placements describe extra writes under a
- * DIFFERENT filesystem root than the primary bundle:
+ * dir) is always present and is never a placement; placements describe extra writes into a DIFFERENT
+ * subtree than the primary bundle (a different top-level root for codex/copilot, or a sibling dir
+ * under the same root for pi):
  * - "mirror"        — copy a subset of bundle files flat into a second dir (codex `.codex/agents/`,
- *                     where Codex loads custom agents — it does not read them from `.agents/skills`).
+ *                     where Codex loads custom agents — it does not read them from `.agents/skills`;
+ *                     pi `~/.pi/agent/agents/` global or `.pi/agents/` project, which pi-subagents
+ *                     scans but does not read from the `skills/feature-forge` bundle).
  * - "managed-block" — write/merge a sentinel-delimited block into a (possibly user-owned) instructions
  *                     file (copilot `.github/copilot-instructions.md`), preserving the rest of the file.
  */
@@ -80,6 +83,14 @@ export interface PlacementSpec {
     readonly kind: PlacementKind;
     /** Second-root dir under the scope root, e.g. ".codex" (mirror) or ".github" (managed-block). */
     readonly baseDir: string;
+    /**
+     * Optional global-scope override for `baseDir`, for placements whose second root differs by scope
+     * (pi: `.pi/agent` global vs `.pi` project). Mirrors {@link AgentTarget.globalInstallBaseDir}.
+     * Falls back to `baseDir` when absent.
+     */
+    readonly globalBaseDir?: string;
+    /** Optional project-scope override for `baseDir` (see {@link globalBaseDir}); falls back to `baseDir`. */
+    readonly projectBaseDir?: string;
     /**
      * Path under `baseDir`. For "mirror" this is the destination DIR (e.g. "agents"); for
      * "managed-block" this is the target FILE (e.g. "copilot-instructions.md").
@@ -111,17 +122,29 @@ export interface AgentTarget {
      * e.g. ".claude", ".codex", ".cursor". Detection is `stat` on this dir, never a subprocess.
      */
     readonly configDirName: string;
+    /** Optional scope-specific config dir probe. Pi uses ~/.pi/agent globally but .pi in projects. */
+    readonly globalConfigDirName?: string;
+    /** Optional scope-specific config dir probe. Pi uses ~/.pi/agent globally but .pi in projects. */
+    readonly projectConfigDirName?: string;
     /**
      * Top-level dir under the scope root that holds the install AND is the containment boundary
      * every write is checked against (REQ-SEC-02). Usually equals `configDirName`; decoupled for
      * codex (".agents") and copilot (".github").
      */
     readonly installBaseDir: string;
+    /** Optional global-scope override for agents with asymmetric global/project layouts. */
+    readonly globalInstallBaseDir?: string;
+    /** Optional project-scope override for agents with asymmetric global/project layouts. */
+    readonly projectInstallBaseDir?: string;
     /**
      * Path under `installBaseDir` to the namespace parent, e.g. "skills" (claude/codex),
      * "rules" (cursor), "extensions" (gemini), "" (copilot — directly under `.github`).
      */
     readonly installSubpath: string;
+    /** Optional global-scope override for the namespace parent path. */
+    readonly globalInstallSubpath?: string;
+    /** Optional project-scope override for the namespace parent path. */
+    readonly projectInstallSubpath?: string;
     /** How this agent consumes the bundle (REQ-SCALE-01; per-kind placement extended in A4b). */
     readonly installKind: InstallKind;
     /**
@@ -216,7 +239,7 @@ export interface InstallManifest {
     readonly featureForgeVersion: string | null;
     /** SHA-256 over the source bundle's canonical (sorted-path) file set — drift anchor (OQ-4, spec 03). */
     readonly sourceHash: string;
-    /** Pinned rauf coordinate recorded at install, e.g. "@garygentry/rauf@0.12.0"; `null` if `--skip-rauf` (spec 06). */
+    /** Pinned rauf coordinate recorded at install, e.g. "@garygentry/rauf@0.13.0"; `null` if `--skip-rauf` (spec 06). */
     readonly raufPin: string | null;
     /** ISO-8601 timestamps. */
     readonly installedAt: string;
@@ -348,6 +371,8 @@ export interface RunReport {
  *  - cursor  — `.cursor/rules/*.mdc` confirmed current (verified-current).
  *  - gemini  — `~/.gemini/extensions/feature-forge` global confirmed; project scope is
  *              best-known (project extension install is not clearly documented).
+ *  - pi      — globally detects ~/.pi/agent and installs ~/.pi/agent/skills/feature-forge;
+ *              project scope detects .pi and installs .pi/skills/feature-forge.
  */
 export declare const AGENT_TARGETS: Readonly<Record<AgentId, AgentTarget>>;
 /**

package/dist/types.js

@@ -9,10 +9,10 @@
 // 1. Primitive aliases and enumerations
 // ---------------------------------------------------------------------------
 /**
- * The five coding agents this installer targets (REQ-DET-01). Order is the canonical
+ * The coding agents this installer targets (REQ-DET-01). Order is the canonical
  * iteration order used by detection, planning, and reporting so output is deterministic.
  */
-export const AGENT_IDS = ["claude", "codex", "copilot", "cursor", "gemini"];
+export const AGENT_IDS = ["claude", "codex", "copilot", "cursor", "gemini", "pi"];
 /** Process exit codes (REQ-OBS-01/03, spec 07). */
 export const EXIT = { SUCCESS: 0, FAILURE: 1, USAGE: 2 };
 /**
@@ -53,6 +53,8 @@ export const MANAGED_BLOCK_END = "<!-- feature-forge:managed:end -->";
  *  - cursor  — `.cursor/rules/*.mdc` confirmed current (verified-current).
  *  - gemini  — `~/.gemini/extensions/feature-forge` global confirmed; project scope is
  *              best-known (project extension install is not clearly documented).
+ *  - pi      — globally detects ~/.pi/agent and installs ~/.pi/agent/skills/feature-forge;
+ *              project scope detects .pi and installs .pi/skills/feature-forge.
  */
 export const AGENT_TARGETS = {
     claude: { id: "claude", configDirName: ".claude", installBaseDir: ".claude", installSubpath: "skills", installKind: "skills", skillFileForm: "SKILL.md", confidence: "confirmed", docsUrl: "https://docs.claude.com/en/docs/claude-code/skills" },
@@ -60,6 +62,7 @@ export const AGENT_TARGETS = {
     copilot: { id: "copilot", configDirName: ".copilot", installBaseDir: ".github", installSubpath: "", installKind: "instructions", skillFileForm: "<name>.md", confidence: "best-known", docsUrl: "https://docs.github.com/en/copilot/how-tos/configure-custom-instructions/add-repository-instructions", placements: [{ kind: "managed-block", baseDir: ".github", subpath: "copilot-instructions.md" }] },
     cursor: { id: "cursor", configDirName: ".cursor", installBaseDir: ".cursor", installSubpath: "rules", installKind: "rules", skillFileForm: "<name>.mdc", confidence: "verified-current", docsUrl: "https://cursor.com/docs/context/rules" },
     gemini: { id: "gemini", configDirName: ".gemini", installBaseDir: ".gemini", installSubpath: "extensions", installKind: "extension", skillFileForm: "<name>.md", confidence: "verified-current", projectConfidence: "best-known", docsUrl: "https://github.com/google-gemini/gemini-cli/blob/main/docs/extensions/index.md" },
+    pi: { id: "pi", configDirName: ".pi", globalConfigDirName: ".pi/agent", projectConfigDirName: ".pi", installBaseDir: ".pi", globalInstallBaseDir: ".pi/agent", projectInstallBaseDir: ".pi", installSubpath: "skills", installKind: "skills", skillFileForm: "SKILL.md", confidence: "verified-current", docsUrl: "https://github.com/earendil-works/pi-coding-agent", placements: [{ kind: "mirror", baseDir: ".pi", globalBaseDir: ".pi/agent", projectBaseDir: ".pi", subpath: "agents", sourcePrefix: "agents/" }] },
 };
 /**
  * Minimal integrity check (REQ-OPS-06, spec 03): a located bundle is valid iff `skills/` is a
@@ -80,7 +83,7 @@ export const BUNDLE_REQUIRED_PATHS = {
         "scripts/forge-bootstrap.py",
     ],
     /** Additional per-agent requirements. */
-    perAgent: { gemini: ["gemini-extension.json"] },
+    perAgent: { gemini: ["gemini-extension.json"], pi: ["package.json", "extensions/ask-user-question/index.ts"] },
 };
 /** Success constructor. */
 export const ok = (value) => ({ ok: true, value });

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@garygentry/feature-forge",
-  "version": "0.2.14",
-  "description": "Cross-agent installer for the feature-forge skill suite — installs the canonical forge pipeline into Claude, Codex, Copilot, Cursor, or Gemini.",
+  "version": "0.3.1",
+  "description": "Cross-agent installer for the feature-forge skill suite — installs the canonical forge pipeline into Claude, Codex, Copilot, Cursor, Gemini, or Pi.",
   "license": "MIT",
   "type": "module",
   "bin": {
@@ -38,13 +38,24 @@
     "codex",
     "copilot",
     "cursor",
-    "gemini"
+    "gemini",
+    "pi",
+    "pi-package"
   ],
   "publishConfig": {
     "access": "public"
   },
+  "pi": {
+    "skills": [
+      "./adapters/pi/skills"
+    ],
+    "extensions": [
+      "./adapters/pi/extensions/ask-user-question/index.ts"
+    ]
+  },
   "scripts": {
     "build": "tsc -p tsconfig.json",
+    "pretest": "npm run build",
     "test": "node --test",
     "prepack": "npm run build && node scripts/bundle-adapters.mjs"
   },