thoth-agents 0.3.12 → 0.4.1

package/dist/cli/index.js

@@ -4,7 +4,7 @@ import {
   getOpenCodeVersion,
   isOpenCodeInstalled,
   opencodeAdapter
-} from "../chunk-5UBJB5QO.js";
+} from "../chunk-STCURXAQ.js";
 import {
   CODEX_ROLE_NAMES,
   REQUIRED_SKILLS,
@@ -15,6 +15,8 @@ import {
   applyCodexPluginSetup,
   applyCodexSetup,
   applyOpenCodePlan,
+  applyPiPlan,
+  applyPiSetup,
   buildClaudeCodeModelPlan,
   buildClaudeCodeSetupPlan,
   buildClaudeCodeSyncPlan,
@@ -27,13 +29,19 @@ import {
   buildOpenCodeModelPlan,
   buildOpenCodeSyncPlan,
   buildOpenCodeUpdatePlan,
+  buildPiModelPlan,
+  buildPiSetupPlan,
+  buildPiSyncPlan,
+  buildPiUpdatePlan,
   claudeCodeAdapter,
   codexAdapter,
   defaultClaudeCodeModelRoles,
+  defaultPiModelRoles,
   finalizeHarnessInstall,
   formatClaudeCodeSetupPlan,
   formatCodexPluginSetupPlan,
   formatCodexSetupPlan,
+  formatPiSetupPlan,
   getClaudeCodeModelRoles,
   getClaudeCodeStatus,
   getCodexModelRoles,
@@ -42,12 +50,20 @@ import {
   getOpenCodeModelRoles,
   getOpenCodeStatus,
   getOperationHarness,
+  getPiModelRoles,
+  getPiStatus,
   getRequiredSkillInstallCommand,
+  inspectPiPackageSkills,
   installRequiredSkill,
   listOperationHarnesses,
   normalizeEffortSelection,
+  recordHarnessInstallCompletion,
   syncOpenCodeOwnedSkills
-} from "../chunk-VPVBYBPU.js";
+} from "../chunk-2D7E7GMP.js";
+import "../chunk-62L3ORXN.js";
+import {
+  piAdapter
+} from "../chunk-2U5MBLLV.js";
 import {
   ALL_AGENT_NAMES,
   detectCurrentConfig,
@@ -58,7 +74,7 @@ import {
   resolveExecutingPackageVersion,
   updateOpenCodeMainConfig,
   writeLiteConfig
-} from "../chunk-DX4U3AD3.js";
+} from "../chunk-EFGSGPYM.js";
 
 // src/cli/index.ts
 import { pathToFileURL } from "url";
@@ -67,7 +83,8 @@ import { pathToFileURL } from "url";
 var HARNESS_ADAPTERS = {
   opencode: opencodeAdapter,
   codex: codexAdapter,
-  claude: claudeCodeAdapter
+  claude: claudeCodeAdapter,
+  pi: piAdapter
 };
 var SUPPORTED_HARNESSES = Object.keys(HARNESS_ADAPTERS);
 function getHarnessAdapter(harness) {
@@ -77,6 +94,7 @@ function getHarnessAdapter(harness) {
 // src/cli/install.ts
 import { existsSync } from "fs";
 import { homedir } from "os";
+import { join } from "path";
 import { cwd } from "process";
 var GREEN = "\x1B[32m";
 var BLUE = "\x1B[34m";
@@ -250,6 +268,9 @@ function finalizeInstallForHarness(harness, dryRun, version, dependencies) {
   });
   const providerComplete = printThothMemSetupResult(result.provider, dryRun);
   if (!providerComplete) return false;
+  return printInstallLedgerResult(result);
+}
+function printInstallLedgerResult(result) {
   if (!result.success) {
     printError(result.error ?? "Failed to record the completed CLI install.");
     return false;
@@ -261,6 +282,25 @@ function finalizeInstallForHarness(harness, dryRun, version, dependencies) {
   }
   return true;
 }
+function finalizeLocalPiInstall(dryRun, version, dependencies) {
+  printWarning(
+    "Local thoth-agents install omits thoth-mem setup; install thoth-mem separately from its local checkout."
+  );
+  printInfo(
+    'Separate command: node <thoth-mem-root>/dist/index.js setup pi --local-package-root "<absolute-thoth-mem-root>"'
+  );
+  const record = dependencies.recordHarnessInstallCompletion ?? recordHarnessInstallCompletion;
+  return printInstallLedgerResult(
+    record({
+      harness: "pi",
+      version,
+      dryRun,
+      ledgerOptions: dependencies.installLedgerOptions ?? {
+        homeDir: dependencies.homeDir ?? homedir()
+      }
+    })
+  );
+}
 async function runInstall(config, dependencies, pluginVersion) {
   const detected = detectCurrentConfig();
   const isUpdate = detected.isInstalled;
@@ -356,10 +396,93 @@ ${JSON.stringify(liteConfig, null, 2)}
   );
   return 0;
 }
+async function runPiInstall(config, dependencies, packageVersion, executingPackageRoot) {
+  const buildPlan = dependencies.buildPiSetupPlan ?? buildPiSetupPlan;
+  const applyPlan = dependencies.applyPiSetup ?? applyPiSetup;
+  const plan = buildPlan({
+    dryRun: config.dryRun,
+    homeDir: dependencies.homeDir ?? homedir(),
+    cwd: cwd(),
+    commandExecutor: dependencies.piCommandExecutor,
+    expectedVersion: packageVersion,
+    packageRoot: executingPackageRoot,
+    ...config.localPackageRoot ? { firstPartySource: config.localPackageRoot } : {},
+    receiptOptions: dependencies.installLedgerOptions,
+    verifyFirstParty: dependencies.verifyPiFirstParty
+  });
+  console.log(formatPiSetupPlan(plan));
+  for (const diagnostic of [...plan.diagnostics, ...plan.disclaimers]) {
+    printInfo(diagnostic);
+  }
+  if (!plan.ready) {
+    for (const blocker of plan.blockers) printError(blocker);
+    return 1;
+  }
+  const applied = applyPlan(plan);
+  for (const diagnostic of applied.diagnostics) printInfo(diagnostic);
+  if (!applied.success) {
+    printError(
+      `Pi install failed after ${applied.installedPackages.length} package step(s): ${applied.error ?? "unknown error"}`
+    );
+    return 1;
+  }
+  if (config.dryRun) {
+    printInfo(
+      "Pi package-declared skills remain unavailable until the first-party package is receipt-validated."
+    );
+  } else {
+    if (!applied.configuredPackageRoot) {
+      printError("Verified configured Pi package root is unavailable.");
+      return 1;
+    }
+    const packageSkills = (dependencies.inspectPiPackageSkills ?? inspectPiPackageSkills)({ packageRoot: applied.configuredPackageRoot });
+    for (const skill of packageSkills.skills)
+      printInfo(
+        `  - ${skill.name}: ${join(skill.destinationPath, "SKILL.md")}`
+      );
+    if (!packageSkills.success) {
+      printError(
+        `Failed to inspect package-declared Pi skills: ${packageSkills.error ?? "unknown error"}`
+      );
+      return 1;
+    }
+  }
+  if (config.dryRun) {
+    if (!installRequiredSkillsForHarness("pi", true, dependencies.homeDir)) {
+      return 1;
+    }
+  } else {
+    const installSkill = dependencies.installRequiredSkill ?? installRequiredSkill;
+    for (const skill of REQUIRED_SKILLS) {
+      const result = installSkill(skill, "pi", {
+        homeDir: dependencies.homeDir ?? homedir()
+      });
+      if (result.status === "failed") {
+        printError(`Failed to install required Pi skill: ${skill.name}`);
+        return 1;
+      }
+      printInfo(`  - ${skill.name}: ${result.skillPath}`);
+    }
+  }
+  const finalized = config.localPackageRoot ? finalizeLocalPiInstall(config.dryRun, packageVersion, dependencies) : finalizeInstallForHarness(
+    "pi",
+    config.dryRun,
+    packageVersion,
+    dependencies
+  );
+  if (!finalized) {
+    return 1;
+  }
+  printSuccess(
+    config.dryRun ? `Pi dry-run complete; no packages, files, provider state, or ledger state changed${config.localPackageRoot ? "; thoth-mem remains a separate local install" : ""}` : `Complete Pi native package, agent, skill, research, and ledger setup applied${config.localPackageRoot ? "; thoth-mem remains a separate local install" : ", including provider setup"}`
+  );
+  return 0;
+}
 function createInstallConfig(args) {
   return {
     agent: args.agent ?? "opencode",
     hasTmux: args.tmux === "yes",
+    ...args.localPackageRoot ? { localPackageRoot: args.localPackageRoot } : {},
     dryRun: args.dryRun,
     reset: args.reset ?? false
   };
@@ -455,6 +578,14 @@ async function install(args, dependencies = {}) {
     );
     return 0;
   }
+  if (config.agent === "pi") {
+    return runPiInstall(
+      config,
+      dependencies,
+      packageVersion.version,
+      packageVersion.packageRoot
+    );
+  }
   return runInstall(config, dependencies, packageVersion.version);
 }
 
@@ -615,7 +746,7 @@ Usage: thoth-agents [COMMAND] [OPTIONS]
 
 Commands:
   (no command)          Open the interactive TUI in a TTY; fall back to OpenCode install in CI/non-TTY
-  install               Install OpenCode, Codex, or Claude Code agent assets
+  install               Install OpenCode, Codex, Claude Code, or Pi agent assets
   generate              Generate harness-specific artifacts
   status                Show official CLI-managed versions and managed install status
   list                  List managed surfaces and actions
@@ -629,9 +760,11 @@ Options:
   --dry-run              Simulate install without writing files
   --apply                Apply a reviewed update, sync, or model plan
   --reset                Repair managed installer-owned targets
-  --agent=opencode|codex|claude
-                         Select OpenCode plugin install (default), Codex agent-pack, or Claude Code plugin setup
-  --harness=...          Select harness for status/update/sync/model (opencode|codex|claude)
+  --agent=opencode|codex|claude|pi
+                         Select OpenCode plugin install (default), Codex/Claude setup, or complete Pi-native setup
+  --local-package-root=PATH
+                         Install local thoth-agents with --agent=pi; thoth-mem is installed separately
+  --harness=...          Select harness for status/update/sync/model (opencode|codex|claude|pi)
   --role-effort=role=effort
                          Set a repeatable role effort; use inherit or default for no override
   -h, --help             Show this help message
@@ -673,6 +806,8 @@ Examples:
   pnpm dlx thoth-agents@latest install --agent=codex --dry-run
   pnpm dlx thoth-agents@latest install --agent=claude
   pnpm dlx thoth-agents@latest install --agent=claude --dry-run
+  pnpm dlx thoth-agents@latest install --agent=pi --dry-run
+  node dist/cli/index.js install --agent=pi --local-package-root="<absolute-path>"
   pnpm dlx thoth-agents install --no-tui --tmux=no
   pnpm dlx thoth-agents install --dry-run
   pnpm dlx thoth-agents install --reset
@@ -691,6 +826,7 @@ function statusReports(args, context = operationContext()) {
   return harnesses.map((harness) => {
     if (harness === "opencode") return getOpenCodeStatus(context);
     if (harness === "claude") return getClaudeCodeStatus(context);
+    if (harness === "pi") return getPiStatus(context);
     return getCodexStatus(context);
   });
 }
@@ -702,6 +838,9 @@ function buildOperationPlan(command, args, context = operationContext()) {
   if (harness === "claude") {
     return command === "update" ? buildClaudeCodeUpdatePlan(context) : buildClaudeCodeSyncPlan(context);
   }
+  if (harness === "pi") {
+    return command === "update" ? buildPiUpdatePlan(context) : buildPiSyncPlan(context);
+  }
   return command === "update" ? buildCodexUpdatePlan(context) : buildCodexSyncPlan(context);
 }
 function defaultModelRoles(harness) {
@@ -714,6 +853,7 @@ function defaultModelRoles(harness) {
   if (harness === "claude") {
     return defaultClaudeCodeModelRoles();
   }
+  if (harness === "pi") return defaultPiModelRoles();
   return ALL_AGENT_NAMES.map((role) => ({
     role,
     model: getDefaultOpenCodeModel(role),
@@ -747,6 +887,7 @@ var defaultModelCommandServices = {
   modelRoles(harness) {
     if (harness === "opencode") return getOpenCodeModelRoles();
     if (harness === "claude") return getClaudeCodeModelRoles();
+    if (harness === "pi") return getPiModelRoles();
     return getCodexModelRoles();
   },
   modelOptions: getModelOptions
@@ -779,11 +920,13 @@ async function buildModelPlan(args, services) {
   };
   if (harness === "opencode") return buildOpenCodeModelPlan(input, context);
   if (harness === "claude") return buildClaudeCodeModelPlan(input, context);
+  if (harness === "pi") return buildPiModelPlan(input, context);
   return buildCodexModelPlan(input, context);
 }
 function applyOperationPlan(plan) {
   if (plan.harness === "opencode") return applyOpenCodePlan(plan);
   if (plan.harness === "claude") return applyClaudeCodePlan(plan);
+  if (plan.harness === "pi") return applyPiPlan(plan);
   return applyCodexPlan(plan);
 }
 function printPlanOrApply(plan, args, applyPlan) {
@@ -871,6 +1014,9 @@ async function runCliCommand(parsed, modelServices = defaultModelCommandServices
   );
 }
 
+// src/cli/parser.ts
+import { isAbsolute, resolve } from "path";
+
 // src/cli/runtime.ts
 var automationEnvironmentKeys = [
   "CI",
@@ -922,9 +1068,9 @@ function parseBooleanArg(name, value) {
   return value;
 }
 function parseOperationHarness(value) {
-  if (value !== "opencode" && value !== "codex" && value !== "claude") {
+  if (value !== "opencode" && value !== "codex" && value !== "claude" && value !== "pi") {
     throw new Error(
-      `Unsupported operation harness: ${value}. Supported harnesses: opencode, codex, claude.`
+      `Unsupported operation harness: ${value}. Supported harnesses: opencode, codex, claude, pi.`
     );
   }
   return value;
@@ -1027,7 +1173,9 @@ function parseInstallArgs(args) {
     tui: true,
     agent: "opencode"
   };
-  for (const arg of args) {
+  for (let index = 0; index < args.length; index += 1) {
+    const arg = args[index];
+    if (arg === void 0) break;
     if (arg === "--no-tui") {
       result.tui = false;
     } else if (arg.startsWith("--tmux=")) {
@@ -1038,18 +1186,41 @@ function parseInstallArgs(args) {
       result.reset = true;
     } else if (arg.startsWith("--agent=")) {
       const agent = arg.split("=")[1];
-      if (agent !== "opencode" && agent !== "codex" && agent !== "claude") {
+      if (agent !== "opencode" && agent !== "codex" && agent !== "claude" && agent !== "pi") {
         throw new Error(
-          `Unsupported install agent: ${agent}. Supported agents: opencode, codex, claude.`
+          `Unsupported install agent: ${agent}. Supported agents: opencode, codex, claude, pi.`
         );
       }
       result.agent = agent;
+    } else if (arg === "--local-package-root" || arg.startsWith("--local-package-root=")) {
+      if (result.localPackageRoot !== void 0) {
+        throw new Error("--local-package-root cannot be repeated.");
+      }
+      let localPackageRoot;
+      if (arg === "--local-package-root") {
+        index += 1;
+        localPackageRoot = args[index];
+      } else {
+        localPackageRoot = arg.slice("--local-package-root=".length);
+      }
+      if (!localPackageRoot || localPackageRoot.startsWith("--")) {
+        throw new Error("--local-package-root requires a value.");
+      }
+      if (!isAbsolute(localPackageRoot) || resolve(localPackageRoot) !== localPackageRoot) {
+        throw new Error(
+          "--local-package-root requires a normalized absolute path."
+        );
+      }
+      result.localPackageRoot = localPackageRoot;
     } else if (arg === "-h" || arg === "--help") {
       throw new Error("help");
     } else {
       throw new Error(`Unsupported install option: ${arg}`);
     }
   }
+  if (result.localPackageRoot !== void 0 && result.agent !== "pi") {
+    throw new Error("--local-package-root is supported only with --agent=pi.");
+  }
   return result;
 }
 function parseGenerateArgs(args) {

package/dist/cli/install-completion.d.ts

@@ -22,6 +22,18 @@ export interface HarnessInstallCompletionResult {
     ledger: InstallCompletionLedgerResult;
     error?: string;
 }
+export interface HarnessInstallLedgerCompletionResult {
+    success: boolean;
+    ledger: InstallCompletionLedgerResult;
+    error?: string;
+}
+export interface RecordHarnessInstallCompletionOptions {
+    harness: InstallHarnessId;
+    version: string;
+    dryRun?: boolean;
+    recordCompletedInstall?: (options: Parameters<typeof recordCompletedInstall>[0]) => RecordCompletedInstallResult;
+    ledgerOptions?: InstallLedgerOptions;
+}
 export interface FinalizeHarnessInstallOptions {
     harness: InstallHarnessId;
     version: string;
@@ -31,4 +43,5 @@ export interface FinalizeHarnessInstallOptions {
     recordCompletedInstall?: (options: Parameters<typeof recordCompletedInstall>[0]) => RecordCompletedInstallResult;
     ledgerOptions?: InstallLedgerOptions;
 }
+export declare function recordHarnessInstallCompletion(options: RecordHarnessInstallCompletionOptions): HarnessInstallLedgerCompletionResult;
 export declare function finalizeHarnessInstall(options: FinalizeHarnessInstallOptions): HarnessInstallCompletionResult;

package/dist/cli/install-ledger.d.ts

@@ -1,5 +1,5 @@
 export declare const INSTALL_LEDGER_SCHEMA_VERSION: 1;
-export type InstallHarnessId = 'opencode' | 'codex' | 'claude';
+export type InstallHarnessId = 'opencode' | 'codex' | 'claude' | 'pi';
 export interface InstallLedger {
     schemaVersion: typeof INSTALL_LEDGER_SCHEMA_VERSION;
     harnesses: Partial<Record<InstallHarnessId, {

package/dist/cli/install.d.ts

@@ -1,7 +1,10 @@
 import { updateOpenCodeMainConfig } from './config-manager';
-import { finalizeHarnessInstall } from './install-completion';
+import { finalizeHarnessInstall, recordHarnessInstallCompletion } from './install-completion';
 import type { InstallLedgerOptions } from './install-ledger';
+import { inspectPiPackageSkills } from './owned-skills';
 import { type ExecutingPackageVersionResult } from './package-version';
+import { applyPiSetup, buildPiSetupPlan, type PiCommandExecutor, type PiSetupOptions } from './pi-install';
+import { installRequiredSkill } from './skills';
 import type { ThothMemSetupOptions, ThothMemSetupResult } from './thoth-mem-install';
 import type { InstallArgs, InstallConfig } from './types';
 export interface InstallDependencies {
@@ -11,7 +14,14 @@ export interface InstallDependencies {
     resolveExecutingPackageVersion?: () => ExecutingPackageVersionResult;
     updateOpenCodeMainConfig?: typeof updateOpenCodeMainConfig;
     finalizeHarnessInstall?: typeof finalizeHarnessInstall;
+    recordHarnessInstallCompletion?: typeof recordHarnessInstallCompletion;
     installLedgerOptions?: InstallLedgerOptions;
+    piCommandExecutor?: PiCommandExecutor;
+    buildPiSetupPlan?: typeof buildPiSetupPlan;
+    applyPiSetup?: typeof applyPiSetup;
+    inspectPiPackageSkills?: typeof inspectPiPackageSkills;
+    verifyPiFirstParty?: PiSetupOptions['verifyFirstParty'];
+    installRequiredSkill?: typeof installRequiredSkill;
 }
 export declare function createInstallConfig(args: InstallArgs): InstallConfig;
 export declare function install(args: InstallArgs, dependencies?: InstallDependencies): Promise<number>;

package/dist/cli/operations/pi.d.ts

@@ -0,0 +1,43 @@
+import type { ProviderEvidenceInput } from '../../harness/types';
+import { type FinalizeHarnessInstallOptions, finalizeHarnessInstall } from '../install-completion';
+import { type InstallLedgerOptions } from '../install-ledger';
+import { inspectPiPackageSkills } from '../owned-skills';
+import { applyPiSetup, buildPiSetupPlan, type PiCommandExecutor } from '../pi-install';
+import { installRequiredSkill } from '../skills';
+import type { HarnessAction, HarnessStatusReport, ModelConfigInput, ModelRoleInput, OperationApplyResult, OperationContext, OperationPlan } from './types';
+export interface PiOperationContext extends OperationContext {
+    homeDir?: string;
+    packageRoot?: string;
+    env?: Readonly<Record<string, string | undefined>>;
+    installLedgerOptions?: InstallLedgerOptions;
+    buildPiSetupPlan?: typeof buildPiSetupPlan;
+    applyPiSetup?: typeof applyPiSetup;
+    inspectPiPackageSkills?: typeof inspectPiPackageSkills;
+    piCommandExecutor?: PiCommandExecutor;
+    installRequiredSkill?: typeof installRequiredSkill;
+    finalizeHarnessInstall?: (options: FinalizeHarnessInstallOptions) => ReturnType<typeof finalizeHarnessInstall>;
+    runThothMemSetup?: FinalizeHarnessInstallOptions['runThothMemSetup'];
+}
+export type PiResearchProviderId = 'context7' | 'web-access' | 'grep';
+export type PiResearchRuntimeState = 'ready' | 'unverified' | 'credential-required' | 'unreachable' | 'drifted' | 'failed';
+export interface PiResearchRuntimeEvidence {
+    state: PiResearchRuntimeState;
+    basis: readonly string[];
+}
+export interface PiStatusEvidence extends ProviderEvidenceInput {
+    research?: Partial<Record<PiResearchProviderId, PiResearchRuntimeEvidence>>;
+}
+export declare const piOperationAdapter: {
+    readonly id: "pi";
+    readonly displayName: "Pi";
+    readonly available: true;
+    readonly description: "Pi-native packages, ambient root, six specialists, skills, and hybrid research stack.";
+    readonly actions: HarnessAction[];
+};
+export declare function getPiStatus(context?: PiOperationContext, evidence?: PiStatusEvidence): HarnessStatusReport;
+export declare function buildPiInstallPlan(context?: PiOperationContext): OperationPlan;
+export declare function buildPiUpdatePlan(context?: PiOperationContext): OperationPlan;
+export declare function buildPiSyncPlan(context?: PiOperationContext): OperationPlan;
+export declare function defaultPiModelRoles(context?: PiOperationContext): ModelRoleInput[];
+export declare function buildPiModelPlan(input: ModelConfigInput, context?: PiOperationContext): OperationPlan;
+export declare function applyPiPlan(plan: OperationPlan): OperationApplyResult;

package/dist/cli/owned-skills.d.ts

@@ -15,6 +15,23 @@ export interface OpenCodeOwnedSkillSyncResult {
     skills: OpenCodeOwnedSkillSyncEntry[];
     error?: string;
 }
+export interface PiPackageSkillInspectionResult {
+    success: boolean;
+    state: 'available' | 'unavailable';
+    skills: OpenCodeOwnedSkillSyncEntry[];
+    issues: Array<{
+        name: ThothOwnedSkillName;
+        state: 'missing' | 'drift';
+        message: string;
+    }>;
+    error?: string;
+}
 export declare function resolveOwnedSkillPackageRoot(moduleUrl: string): string;
 export declare function getOpenCodeOwnedSkillEntries(options?: Pick<OpenCodeOwnedSkillSyncOptions, 'homeDir' | 'packageRoot'>): OpenCodeOwnedSkillSyncEntry[];
+export declare function getPiOwnedSkillEntries(options: {
+    packageRoot: string;
+}): OpenCodeOwnedSkillSyncEntry[];
 export declare function syncOpenCodeOwnedSkills(options?: OpenCodeOwnedSkillSyncOptions): OpenCodeOwnedSkillSyncResult;
+export declare function inspectPiPackageSkills(options: {
+    packageRoot: string;
+}): PiPackageSkillInspectionResult;

package/dist/cli/pi-effort.d.ts

@@ -0,0 +1,10 @@
+import type { ModelRoleInput } from './operations/types';
+export declare const PI_EFFORT_VALUES: readonly ["off", "minimal", "low", "medium", "high", "xhigh"];
+export type PiEffortResolution = {
+    ok: true;
+    effort: string | undefined;
+} | {
+    ok: false;
+    message: string;
+};
+export declare function resolvePiEffort(input: Pick<ModelRoleInput, 'availableEfforts' | 'effort' | 'model'>): PiEffortResolution;

package/dist/cli/pi-install.d.ts

@@ -0,0 +1,131 @@
+import { type PiPackageReceipt, type PiPackageReceiptOptions } from './pi-package-receipt';
+import { type PiPathOptions, type PiPaths } from './pi-paths';
+export declare const PI_MINIMUM_VERSION = "0.84.4";
+export declare const PI_NODE_MINIMUM = "22.19.0";
+export declare const PI_COMMAND_TIMEOUT_MS = 120000;
+export declare const PI_PACKAGE_SPECS: readonly [{
+    readonly id: "delegation";
+    readonly source: "npm:pi-subagents-j0k3r@1.5.9";
+    readonly packageName: "pi-subagents-j0k3r";
+    readonly version: "1.5.9";
+}, {
+    readonly id: "context7";
+    readonly source: "npm:@upstash/context7-pi@0.1.2";
+    readonly packageName: "@upstash/context7-pi";
+    readonly version: "0.1.2";
+}, {
+    readonly id: "web-access";
+    readonly source: "npm:pi-web-access@0.27.0";
+    readonly packageName: "pi-web-access";
+    readonly version: "0.27.0";
+}, {
+    readonly id: "grep-adapter";
+    readonly source: "npm:pi-mcp-adapter@2.32.1";
+    readonly packageName: "pi-mcp-adapter";
+    readonly version: "2.32.1";
+}, {
+    readonly id: "ask-user-question";
+    readonly source: "npm:@juicesharp/rpiv-ask-user-question@2.9.0";
+    readonly packageName: "@juicesharp/rpiv-ask-user-question";
+    readonly version: "2.9.0";
+}, {
+    readonly id: "todo";
+    readonly source: "npm:@juicesharp/rpiv-todo@2.9.0";
+    readonly packageName: "@juicesharp/rpiv-todo";
+    readonly version: "2.9.0";
+}];
+export declare const PI_GREP_MCP_ENTRY: {
+    readonly url: "https://mcp.grep.app";
+    readonly protocolVersion: "legacy";
+    readonly lifecycle: "lazy";
+};
+export interface PiCommandResult {
+    exitCode: number | null;
+    stdout: string;
+    stderr: string;
+    error?: unknown;
+}
+export type PiCommandExecutor = (command: string, args: readonly string[]) => PiCommandResult;
+export interface PiSetupOptions extends PiPathOptions {
+    dryRun?: boolean;
+    commandExecutor?: PiCommandExecutor;
+    expectedVersion?: string;
+    packageRoot?: string;
+    firstPartySource?: string;
+    receiptOptions?: PiPackageReceiptOptions;
+    verifyFirstParty?: (input: {
+        source: string;
+        installSource: string;
+        version: string;
+        packageRoot: string;
+    }) => {
+        success: true;
+        receipt: PiPackageReceipt;
+    } | {
+        success: false;
+        error: string;
+    };
+}
+export interface PiSetupPlanItem {
+    kind: 'preflight' | 'package' | 'root' | 'agent' | 'mcp';
+    description: string;
+    target: string;
+    command?: {
+        command: string;
+        args: string[];
+    };
+    content?: string;
+}
+export interface PiSetupPlan {
+    dryRun: boolean;
+    ready: boolean;
+    paths: PiPaths;
+    items: PiSetupPlanItem[];
+    blockers: string[];
+    diagnostics: string[];
+    disclaimers: string[];
+    options: PiSetupOptions;
+}
+export interface PiApplyResult {
+    success: boolean;
+    changed: string[];
+    diagnostics: string[];
+    error?: string;
+    failedStep?: string;
+    installedPackages: string[];
+    receiptCommitted?: boolean;
+    rollbackFailed?: boolean;
+    manualRecovery?: string;
+    configuredPackageRoot?: string;
+}
+export declare function getPiFirstPartySource(version: string): string;
+export declare function verifyPiFirstPartyPackage(input: {
+    source: string;
+    installSource: string;
+    version: string;
+    packageRoot: string;
+}): {
+    success: true;
+    receipt: PiPackageReceipt;
+} | {
+    success: false;
+    error: string;
+};
+export declare function mergePiGrepMcpConfig(current: Record<string, unknown>): Record<string, unknown>;
+export declare function mergePiRootBlock(current: string, managedBlock: string): string;
+export declare function buildPiSetupPlan(options?: PiSetupOptions): PiSetupPlan;
+export declare function formatPiSetupPlan(plan: PiSetupPlan): string;
+export declare function isVersionAtLeast(actual: string, expected: string): boolean;
+export declare function hasExactInstalledPiPackage(output: string, source: string): boolean;
+export interface PiConfiguredPackage {
+    scope: 'user' | 'project';
+    source: string;
+    installedPath?: string;
+    packageName?: string;
+    packageVersion?: string;
+}
+export declare function parsePiPackageList(output: string): PiConfiguredPackage[];
+export declare function isThothPackageLocation(candidate: PiConfiguredPackage, knownSource?: string): boolean;
+export declare function getPiFirstPartyPackages(packages: readonly PiConfiguredPackage[], knownSource?: string): PiConfiguredPackage[];
+export declare function writePiManagedText(path: string, content: string): boolean;
+export declare function applyPiSetup(plan: PiSetupPlan): PiApplyResult;

package/dist/cli/pi-migration.d.ts

@@ -0,0 +1,12 @@
+export interface PiLegacyMigrationOptions {
+    packageRoot: string;
+    piRoot: string;
+    dryRun?: boolean;
+}
+export interface PiLegacyMigrationResult {
+    success: boolean;
+    changed: string[];
+    manualActions: string[];
+    error?: string;
+}
+export declare function migrateLegacyPiResources(options: PiLegacyMigrationOptions): PiLegacyMigrationResult;