thoth-agents 0.3.12 → 0.4.0

package/dist/{chunk-VPVBYBPU.js → chunk-WJ2YMM2E.js}

@@ -1,20 +1,26 @@
+import {
+  CONTEXT7_MCP_URL,
+  GREP_APP_MCP_URL,
+  exa
+} from "./chunk-62L3ORXN.js";
+import {
+  PI_MANAGED_OWNER,
+  PI_ROOT_END,
+  PI_ROOT_START,
+  piAdapter,
+  renderConfiguredRolePrompt,
+  syncPiSpecialists
+} from "./chunk-SECDI3TL.js";
 import {
   ALL_AGENT_NAMES,
   CLAUDE_CODE_PROMPT_DIALECT,
   CLAUDE_CODE_SUBAGENT_NAMESPACE,
   CODEX_PROMPT_DIALECT,
   CONFIRMED_OPENAI_SUBAGENT_PRESET,
-  CONTEXT7_MCP_URL,
   DEFAULT_MODELS,
-  GREP_APP_MCP_URL,
-  appendPromptSections,
+  PI_SPECIALIST_ROLES,
   claudeCodeSubagentType,
-  composeAgentPrompt,
-  createModelFamilySection,
-  createRolePromptSections,
-  createStepBudgetSection,
   ensureConfigDir,
-  exa,
   findPackageRoot,
   generateLiteConfig,
   getAgentOverride,
@@ -25,17 +31,16 @@ import {
   getExistingLiteConfigPath,
   getOpenCodeManagedModelStatePath,
   getPrimaryModelId,
+  isPiSpecialistRole,
   isValidPackageVersion,
-  loadAgentPrompt,
   parseConfig,
+  piSpecialistName,
   renderAgentRoutingDescription,
-  renderPromptSection,
-  renderRolePrompt,
   resolveExecutingPackageVersion,
   updateOpenCodeMainConfig,
   writeConfig,
   writeLiteConfig
-} from "./chunk-DX4U3AD3.js";
+} from "./chunk-Q6SDM4KP.js";
 
 // src/cli/codex-paths.ts
 import { homedir } from "os";
@@ -94,32 +99,6 @@ import { fileURLToPath as fileURLToPath2 } from "url";
 // src/harness/adapters/codex.ts
 import { fileURLToPath } from "url";
 
-// src/agents/configured-role-prompt.ts
-function renderConfiguredRolePrompt({
-  role,
-  dialect,
-  config,
-  model
-}) {
-  const promptOverrides = loadAgentPrompt(role, config?.preset);
-  const override = getAgentOverride(config, role);
-  const modelSection = createModelFamilySection(role, model);
-  const stepSection = createStepBudgetSection(override?.steps);
-  const basePrompt = renderRolePrompt(createRolePromptSections(role), dialect);
-  const prompt = composeAgentPrompt({
-    basePrompt,
-    customPrompt: promptOverrides.prompt,
-    customAppendPrompt: appendPromptSections(
-      modelSection ? renderPromptSection(modelSection, dialect) : void 0,
-      promptOverrides.appendPrompt
-    )
-  });
-  return appendPromptSections(
-    prompt,
-    stepSection ? renderPromptSection(stepSection, dialect) : void 0
-  );
-}
-
 // src/harness/core/memory-governance.ts
 function memoryGovernanceDiagnostics(input) {
   const diagnostics = [];
@@ -953,9 +932,9 @@ function stripProviderMcpValues(surfaceId, values) {
   const { thoth_mem: _provider, ...mcpServers } = servers;
   return { ...values, mcp_servers: mcpServers };
 }
-function fieldOrder(fields, keys) {
+function fieldOrder(fields, keys2) {
   const orderedRoots = fields.map((field) => field.split(".")[0]);
-  return [...keys].sort((left, right) => {
+  return [...keys2].sort((left, right) => {
     const leftIndex = orderedRoots.indexOf(left);
     const rightIndex = orderedRoots.indexOf(right);
     if (leftIndex !== -1 || rightIndex !== -1) {
@@ -2482,11 +2461,12 @@ var INSTALL_LEDGER_SCHEMA_VERSION = 1;
 var INSTALL_HARNESSES = /* @__PURE__ */ new Set([
   "opencode",
   "codex",
-  "claude"
+  "claude",
+  "pi"
 ]);
-function hasOnlyKeys(value, keys) {
+function hasOnlyKeys(value, keys2) {
   const actual = Object.keys(value);
-  return actual.length === keys.length && actual.every((key) => keys.includes(key));
+  return actual.length === keys2.length && actual.every((key) => keys2.includes(key));
 }
 function parseInstallLedger(serialized) {
   let parsed;
@@ -2678,8 +2658,6 @@ function getThothMemSetupCommand(harness, dryRun, options = {}) {
       "thoth-mem@latest",
       "setup",
       harness,
-      "--scope",
-      "global",
       ...dryRun ? ["--plan"] : [],
       "--json"
     ],
@@ -2757,26 +2735,11 @@ function runThothMemSetup(options) {
 function isConsistentProviderSuccess(result, harness) {
   return result.success && result.evidenceValid && result.status === "complete" && result.exitCode === 0 && result.harness === harness;
 }
-function finalizeHarnessInstall(options) {
+function recordHarnessInstallCompletion(options) {
   const ledgerPath = getInstallLedgerPath(options.ledgerOptions);
-  const setup = options.runThothMemSetup ?? runThothMemSetup;
-  const provider = setup({
-    harness: options.harness,
-    dryRun: options.dryRun,
-    cwd: options.cwd
-  });
-  if (!isConsistentProviderSuccess(provider, options.harness)) {
-    return {
-      success: false,
-      provider,
-      ledger: { status: "not-attempted", path: ledgerPath },
-      error: provider.error ?? "thoth-mem setup did not return consistent complete evidence."
-    };
-  }
   if (options.dryRun) {
     return {
       success: true,
-      provider,
       ledger: { status: "planned", path: ledgerPath }
     };
   }
@@ -2789,7 +2752,6 @@ function finalizeHarnessInstall(options) {
   if (!ledger.success) {
     return {
       success: false,
-      provider,
       ledger: {
         status: "failed",
         path: ledger.path,
@@ -2800,7 +2762,6 @@ function finalizeHarnessInstall(options) {
   }
   return {
     success: true,
-    provider,
     ledger: {
       status: "recorded",
       path: ledger.path,
@@ -2809,6 +2770,34 @@ function finalizeHarnessInstall(options) {
     }
   };
 }
+function finalizeHarnessInstall(options) {
+  const ledgerPath = getInstallLedgerPath(options.ledgerOptions);
+  const setup = options.runThothMemSetup ?? runThothMemSetup;
+  const provider = setup({
+    harness: options.harness,
+    dryRun: options.dryRun,
+    cwd: options.cwd
+  });
+  if (!isConsistentProviderSuccess(provider, options.harness)) {
+    return {
+      success: false,
+      provider,
+      ledger: { status: "not-attempted", path: ledgerPath },
+      error: provider.error ?? "thoth-mem setup did not return consistent complete evidence."
+    };
+  }
+  const completion = recordHarnessInstallCompletion({
+    harness: options.harness,
+    version: options.version,
+    dryRun: options.dryRun,
+    recordCompletedInstall: options.recordCompletedInstall,
+    ledgerOptions: options.ledgerOptions
+  });
+  return {
+    provider,
+    ...completion
+  };
+}
 
 // src/cli/skills.ts
 import { spawnSync as spawnSync3 } from "child_process";
@@ -2818,7 +2807,8 @@ import { join as join3 } from "path";
 var SKILLS_CLI_AGENT = {
   opencode: "opencode",
   codex: "codex",
-  claude: "claude-code"
+  claude: "claude-code",
+  pi: "pi"
 };
 var GLOBAL_SKILL_ROOTS = {
   opencode: [
@@ -2826,7 +2816,8 @@ var GLOBAL_SKILL_ROOTS = {
     [".agents", "skills"]
   ],
   codex: [[".agents", "skills"]],
-  claude: [[".claude", "skills"]]
+  claude: [[".claude", "skills"]],
+  pi: [[".pi", "agent", "skills"]]
 };
 var REQUIRED_SKILLS = [
   {
@@ -2883,7 +2874,8 @@ function getRequiredSkillInstallCommand(skill, harness, options = {}) {
       "--global",
       "--agent",
       SKILLS_CLI_AGENT[harness],
-      "--yes"
+      "--yes",
+      ...harness === "pi" ? ["--copy"] : []
     ],
     options
   );
@@ -5124,8 +5116,10 @@ function resolveOpenCodeEffort(input) {
 import {
   cpSync,
   existsSync as existsSync9,
+  lstatSync as lstatSync2,
   mkdirSync as mkdirSync4,
   mkdtempSync,
+  readFileSync as readFileSync8,
   renameSync as renameSync3,
   rmSync as rmSync3,
   statSync
@@ -5144,6 +5138,68 @@ var THOTH_OWNED_SKILL_NAMES = [
 ];
 
 // src/cli/owned-skills.ts
+function parseSkillFrontmatter(content) {
+  const lines = content.split(/\r?\n/);
+  if (lines[0] !== "---") return void 0;
+  const closingDelimiter = lines.findIndex(
+    (line, index) => index > 0 && line === "---"
+  );
+  if (closingDelimiter < 0) return void 0;
+  const values = /* @__PURE__ */ new Map();
+  for (const line of lines.slice(1, closingDelimiter)) {
+    const field = /^(name|description):\s*(.*)$/.exec(line);
+    if (!field) continue;
+    const [, key, rawValue] = field;
+    if (!key || rawValue === void 0 || values.has(key)) return void 0;
+    const value = rawValue.trim();
+    values.set(
+      key,
+      value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'") ? value.slice(1, -1) : value
+    );
+  }
+  const name = values.get("name");
+  const description = values.get("description");
+  if (!name || !description || description.startsWith("#")) return void 0;
+  return { name, description };
+}
+function inspectPiPackageSkill(entry) {
+  if (!existsSync9(entry.sourcePath))
+    return {
+      name: entry.name,
+      state: "missing",
+      message: `Package-declared Pi skill directory is missing: ${entry.name}`
+    };
+  const root = lstatSync2(entry.sourcePath);
+  if (!root.isDirectory() || root.isSymbolicLink())
+    return {
+      name: entry.name,
+      state: "drift",
+      message: `Package-declared Pi skill directory is not a regular directory: ${entry.name}`
+    };
+  const contractPath = join5(entry.sourcePath, "SKILL.md");
+  if (!existsSync9(contractPath))
+    return {
+      name: entry.name,
+      state: "missing",
+      message: `Package-declared Pi skill contract is missing: ${entry.name}`
+    };
+  const contract = lstatSync2(contractPath);
+  if (!contract.isFile() || contract.isSymbolicLink())
+    return {
+      name: entry.name,
+      state: "drift",
+      message: `Package-declared Pi skill contract is not a regular file: ${entry.name}`
+    };
+  const content = readFileSync8(contractPath, "utf8");
+  const frontmatter = parseSkillFrontmatter(content);
+  if (!frontmatter || frontmatter.name !== entry.name)
+    return {
+      name: entry.name,
+      state: "drift",
+      message: `Package-declared Pi skill contract is malformed: ${entry.name}`
+    };
+  return void 0;
+}
 function resolveOwnedSkillPackageRoot(moduleUrl) {
   const packageRoot = findPackageRoot(dirname5(fileURLToPath4(moduleUrl)));
   if (!packageRoot) {
@@ -5165,6 +5221,14 @@ function getOpenCodeOwnedSkillEntries(options = {}) {
     destinationPath: join5(homeDir, ".config", "opencode", "skills", name)
   }));
 }
+function getPiOwnedSkillEntries(options) {
+  const packageRoot = options.packageRoot;
+  return THOTH_OWNED_SKILL_NAMES.map((name) => ({
+    name,
+    sourcePath: join5(packageRoot, "skills", name),
+    destinationPath: join5(packageRoot, "skills", name)
+  }));
+}
 function validateCanonicalSkill(entry) {
   if (!existsSync9(entry.sourcePath) || !statSync(entry.sourcePath).isDirectory()) {
     throw new Error(
@@ -5235,6 +5299,37 @@ function syncOpenCodeOwnedSkills(options = {}) {
     };
   }
 }
+function inspectPiPackageSkills(options) {
+  const skills = getPiOwnedSkillEntries(options);
+  try {
+    const issues = skills.flatMap((skill) => {
+      const issue = inspectPiPackageSkill(skill);
+      return issue ? [issue] : [];
+    });
+    if (issues.length > 0)
+      return {
+        success: false,
+        state: "unavailable",
+        skills,
+        issues,
+        error: issues.map(({ message }) => message).join("; ")
+      };
+    return {
+      success: true,
+      state: "available",
+      skills,
+      issues: []
+    };
+  } catch (error) {
+    return {
+      success: false,
+      state: "unavailable",
+      skills,
+      issues: [],
+      error: error instanceof Error ? error.message : String(error)
+    };
+  }
+}
 
 // src/cli/operations/opencode.ts
 var PACKAGE_NAME = "thoth-agents";
@@ -5286,7 +5381,7 @@ function canonicalData(value, active) {
   if (ownKeys.some((key) => typeof key === "symbol")) {
     throw new NonCanonicalDataError("Symbol keys are not canonical.");
   }
-  const keys = ownKeys;
+  const keys2 = ownKeys;
   active.add(value);
   try {
     if (array) {
@@ -5298,7 +5393,7 @@ function canonicalData(value, active) {
       if (!Number.isSafeInteger(length) || length < 0) {
         throw new NonCanonicalDataError("Array length is invalid.");
       }
-      const indexKeys = keys.filter((key) => key !== "length");
+      const indexKeys = keys2.filter((key) => key !== "length");
       if (indexKeys.length !== length || indexKeys.some(
         (key) => !/^(0|[1-9]\d*)$/.test(key) || Number(key) >= length || String(Number(key)) !== key
       )) {
@@ -5320,7 +5415,7 @@ function canonicalData(value, active) {
       return `[${parts2.join(",")}]`;
     }
     const parts = [];
-    for (const key of keys.sort()) {
+    for (const key of keys2.sort()) {
       const descriptor = Object.getOwnPropertyDescriptor(value, key);
       if (!descriptor || !("value" in descriptor)) {
         throw new NonCanonicalDataError("Accessors are not canonical.");
@@ -6859,143 +6954,2121 @@ function applyOpenCodePlan(plan) {
   };
 }
 
-// src/cli/operations/index.ts
-var OPERATION_HARNESSES = {
-  opencode: opencodeOperationAdapter,
-  codex: codexOperationAdapter,
-  claude: claudeCodeOperationAdapter
-};
-var SUPPORTED_OPERATION_HARNESSES = Object.keys(
-  OPERATION_HARNESSES
-);
-function listOperationHarnesses() {
-  return SUPPORTED_OPERATION_HARNESSES.map(
-    (harness) => OPERATION_HARNESSES[harness]
-  );
-}
-function getOperationHarness(harness) {
-  return OPERATION_HARNESSES[harness];
+// src/cli/operations/pi.ts
+import { spawnSync as spawnSync7 } from "child_process";
+import { createHash as createHash5 } from "crypto";
+import { existsSync as existsSync15, readFileSync as readFileSync12 } from "fs";
+import { basename as basename3, isAbsolute as isAbsolute4, join as join12 } from "path";
+
+// src/cli/pi-effort.ts
+var PI_EFFORT_VALUES = [
+  "off",
+  "minimal",
+  "low",
+  "medium",
+  "high",
+  "xhigh"
+];
+var PI_EFFORTS = new Set(PI_EFFORT_VALUES);
+function resolvePiEffort(input) {
+  if (!input.effort || input.effort.kind === "inherit") {
+    return { ok: true, effort: void 0 };
+  }
+  const effort = input.effort.value;
+  if (!PI_EFFORTS.has(effort)) {
+    return {
+      ok: false,
+      message: `Pi does not support effort ${effort}; expected ${PI_EFFORT_VALUES.join(", ")}, or inherit.`
+    };
+  }
+  if (input.availableEfforts !== void 0 && !input.availableEfforts.includes(effort)) {
+    return {
+      ok: false,
+      message: `Effort ${effort} is not available for ${input.model} in the selected model catalog entry.`
+    };
+  }
+  return { ok: true, effort };
 }
 
-// src/cli/tui/model-catalog.ts
-import { execFileSync } from "child_process";
+// src/cli/pi-install.ts
+import { spawnSync as spawnSync6 } from "child_process";
+import { createHash as createHash4 } from "crypto";
+import {
+  copyFileSync as copyFileSync5,
+  existsSync as existsSync14,
+  lstatSync as lstatSync3,
+  mkdirSync as mkdirSync7,
+  readdirSync as readdirSync3,
+  readFileSync as readFileSync11,
+  renameSync as renameSync6,
+  rmSync as rmSync6,
+  writeFileSync as writeFileSync7
+} from "fs";
+import { dirname as dirname9, isAbsolute as isAbsolute3, join as join11 } from "path";
+import { fileURLToPath as fileURLToPath5, pathToFileURL } from "url";
 
-// src/cli/model-catalog/cache.ts
+// src/cli/pi-migration.ts
 import {
+  copyFileSync as copyFileSync4,
   existsSync as existsSync11,
   mkdirSync as mkdirSync5,
-  readFileSync as readFileSync8,
+  readdirSync as readdirSync2,
+  readFileSync as readFileSync9,
   renameSync as renameSync4,
-  unlinkSync,
+  statSync as statSync2,
   writeFileSync as writeFileSync4
 } from "fs";
-import { homedir as homedir5 } from "os";
-import { dirname as dirname6, posix, win32 } from "path";
-import { z as z2 } from "zod";
-var modelCatalogSourceSchema = z2.enum(["remote", "lkg", "manual"]);
-var cachedModelOptionSchema = z2.object({
-  id: z2.string().min(1),
-  catalogId: z2.string().min(1).optional(),
-  label: z2.string().min(1),
-  provider: z2.string().min(1),
-  efforts: z2.array(z2.string().min(1)),
-  source: modelCatalogSourceSchema
-}).passthrough();
-var modelsDevCacheSchema = z2.object({
-  version: z2.literal(1),
-  etag: z2.string().optional(),
-  fetchedAt: z2.string().datetime(),
-  catalog: z2.object({ models: z2.array(cachedModelOptionSchema) }).passthrough()
-}).passthrough();
-function resolveModelsDevCachePath(options = {}) {
-  const platform = options.platform ?? process.platform;
-  const env = options.env ?? process.env;
-  const home = options.homeDir ?? homedir5();
-  if (platform === "win32") {
-    const path = win32;
-    const base2 = env.LOCALAPPDATA ?? env.APPDATA ?? path.join(home, "AppData", "Local");
-    return path.join(base2, "thoth-agents", "models-dev-v1.json");
-  }
-  const base = env.XDG_CACHE_HOME ?? posix.join(home, ".cache");
-  return posix.join(base, "thoth-agents", "models-dev-v1.json");
+import { dirname as dirname6, join as join7 } from "path";
+function files(root, current = root) {
+  if (!existsSync11(root)) return [];
+  return readdirSync2(current, { withFileTypes: true }).flatMap((entry) => {
+    const path = join7(current, entry.name);
+    return entry.isDirectory() ? files(root, path) : [path.slice(root.length + 1).replaceAll("\\", "/")];
+  }).sort();
+}
+function identicalTrees(left, right) {
+  const leftFiles = files(left);
+  const rightFiles = files(right);
+  return leftFiles.length === rightFiles.length && leftFiles.every(
+    (name, index) => name === rightFiles[index] && readFileSync9(join7(left, name)).equals(readFileSync9(join7(right, name)))
+  );
 }
-function readModelsDevCache(cachePath) {
-  if (!existsSync11(cachePath)) return void 0;
-  try {
-    const input = JSON.parse(readFileSync8(cachePath, "utf8"));
-    const parsed = modelsDevCacheSchema.safeParse(input);
-    return parsed.success ? parsed.data : void 0;
-  } catch {
-    return void 0;
-  }
+function removeRootBlock(content) {
+  const start = content.indexOf(PI_ROOT_START);
+  const end = content.indexOf(PI_ROOT_END, start + PI_ROOT_START.length);
+  if (start < 0 && end < 0) return void 0;
+  if (start < 0 || end < 0 || content.indexOf(PI_ROOT_START, start + 1) >= 0 || content.indexOf(PI_ROOT_END, end + 1) >= 0)
+    throw new Error("Legacy Pi root block ownership is ambiguous.");
+  const after = end + PI_ROOT_END.length;
+  return `${content.slice(0, start)}${content.slice(after).replace(/^\r?\n/, "")}`;
 }
-function writeModelsDevCacheAtomic(cachePath, cache) {
-  const validated = modelsDevCacheSchema.safeParse(cache);
-  if (!validated.success) {
-    throw new Error(`Invalid models.dev cache: ${validated.error.message}`);
+function migrateLegacyPiResources(options) {
+  const changed = [];
+  const manualActions = [];
+  const appendPath = join7(options.piRoot, "APPEND_SYSTEM.md");
+  let nextRoot;
+  try {
+    if (existsSync11(appendPath))
+      nextRoot = removeRootBlock(readFileSync9(appendPath, "utf8"));
+  } catch (error) {
+    manualActions.push(error instanceof Error ? error.message : String(error));
+  }
+  const retire = [];
+  for (const name of THOTH_OWNED_SKILL_NAMES) {
+    const source = join7(options.piRoot, "skills", name);
+    if (!existsSync11(source)) continue;
+    const canonical = join7(options.packageRoot, "skills", name);
+    const backup = `${source}.thoth-agents-legacy.bak`;
+    if (!statSync2(source).isDirectory() || !identicalTrees(source, canonical) || existsSync11(backup)) {
+      manualActions.push(
+        `Legacy Pi skill ${name} is modified or has ambiguous backup ownership; remove it manually after review.`
+      );
+      continue;
+    }
+    retire.push({ source, backup });
   }
-  mkdirSync5(dirname6(cachePath), { recursive: true });
-  const temporaryPath = `${cachePath}.${process.pid}.${Date.now()}.tmp`;
+  if (options.dryRun)
+    return {
+      success: true,
+      changed: [
+        ...nextRoot === void 0 ? [] : [appendPath],
+        ...retire.map(({ source }) => source)
+      ],
+      manualActions
+    };
   try {
-    writeFileSync4(
-      temporaryPath,
-      `${JSON.stringify(validated.data, null, 2)}
-`
-    );
-    renameSync4(temporaryPath, cachePath);
+    if (nextRoot !== void 0) {
+      mkdirSync5(dirname6(appendPath), { recursive: true });
+      copyFileSync4(appendPath, `${appendPath}.thoth-agents-legacy.bak`);
+      const temporary = `${appendPath}.tmp-${process.pid}`;
+      writeFileSync4(temporary, nextRoot);
+      renameSync4(temporary, appendPath);
+      changed.push(appendPath);
+    }
+    for (const item of retire) {
+      renameSync4(item.source, item.backup);
+      changed.push(item.source);
+    }
+    return { success: true, changed, manualActions };
   } catch (error) {
-    if (existsSync11(temporaryPath)) unlinkSync(temporaryPath);
-    throw error;
+    try {
+      for (const item of retire)
+        if (existsSync11(item.backup) && !existsSync11(item.source))
+          renameSync4(item.backup, item.source);
+      if (existsSync11(`${appendPath}.thoth-agents-legacy.bak`))
+        copyFileSync4(`${appendPath}.thoth-agents-legacy.bak`, appendPath);
+    } catch {
+    }
+    return {
+      success: false,
+      changed,
+      manualActions,
+      error: error instanceof Error ? error.message : String(error)
+    };
   }
 }
 
-// src/cli/model-catalog/models-dev.ts
-import { z as z3 } from "zod";
-var modelsDevModelSchema = z3.object({
-  id: z3.string().min(1).optional(),
-  name: z3.string().min(1).optional(),
-  reasoning: z3.boolean().optional(),
-  reasoning_options: z3.array(z3.unknown()).optional()
-}).passthrough();
-var modelsDevProviderSchema = z3.object({
-  models: z3.record(z3.string(), modelsDevModelSchema)
-}).passthrough();
-var modelsDevCatalogSchema = z3.record(
-  z3.string(),
-  modelsDevProviderSchema
-);
-var effortOptionSchema = z3.object({
-  type: z3.literal("effort"),
-  values: z3.array(z3.string().min(1))
-}).passthrough();
-function normalizedCatalogId(provider, modelKey, declaredId) {
-  const candidate = (declaredId ?? modelKey).trim().toLowerCase();
-  return candidate.includes("/") ? candidate : `${provider}/${candidate}`;
-}
-function runtimeModelId(provider, catalogId) {
-  const prefix = `${provider}/`;
-  return catalogId.startsWith(prefix) ? catalogId.slice(prefix.length) : catalogId;
-}
-function effortValues(options) {
-  const values = /* @__PURE__ */ new Set();
-  for (const option of options ?? []) {
-    const parsed = effortOptionSchema.safeParse(option);
-    if (!parsed.success) continue;
-    for (const value of parsed.data.values) {
-      const normalized = value.trim();
-      if (normalized) values.add(normalized);
+// src/cli/pi-native-probe.ts
+import { spawnSync as spawnSync5 } from "child_process";
+import { existsSync as existsSync12, mkdtempSync as mkdtempSync2, rmSync as rmSync4, writeFileSync as writeFileSync5 } from "fs";
+import { tmpdir } from "os";
+import { dirname as dirname7, join as join8, resolve as resolve3 } from "path";
+function defaultExecutor(command, args, env) {
+  let executable = command;
+  let executableArgs = [...args];
+  if (process.platform === "win32" && command === "pi") {
+    const located = spawnSync5("where.exe", ["pi.cmd"], { encoding: "utf8" }).stdout?.split(/\r?\n/).find(Boolean);
+    const cli = located ? join8(
+      dirname7(located),
+      "node_modules",
+      "@earendil-works",
+      "pi-coding-agent",
+      "dist",
+      "bundle",
+      "cli.js"
+    ) : void 0;
+    if (cli && existsSync12(cli)) {
+      executable = process.execPath;
+      executableArgs = [cli, ...args];
     }
   }
-  return [...values];
+  const result = spawnSync5(executable, executableArgs, {
+    encoding: "utf8",
+    timeout: 3e4,
+    env: { ...process.env, ...env }
+  });
+  return {
+    exitCode: result.status,
+    stdout: result.stdout ?? "",
+    stderr: result.stderr ?? "",
+    error: result.error
+  };
 }
-function normalizeModelsDevCatalog(input) {
-  const parsed = modelsDevCatalogSchema.safeParse(input);
-  if (!parsed.success) {
-    return {
-      ok: false,
-      issues: parsed.error.issues.map(
-        (issue) => `${issue.path.join(".") || "<root>"}: ${issue.message}`
-      )
+function occurrences(text, marker) {
+  return text.split(marker).length - 1;
+}
+function observePiNativeRoot(options) {
+  const ownsIsolatedRoot = options.piHome === void 0;
+  const isolatedRoot = options.piHome ?? mkdtempSync2(join8(tmpdir(), "thoth-pi-observer-"));
+  const observerPath = join8(
+    isolatedRoot,
+    `observer-${process.pid}-${Date.now()}.mjs`
+  );
+  try {
+    writeFileSync5(
+      observerPath,
+      `import { existsSync, readdirSync, readFileSync } from 'node:fs';
+import { isAbsolute, join, relative, resolve } from 'node:path';
+import { createAssistantMessageEventStream } from '@earendil-works/pi-ai';
+const manifestSha256=${JSON.stringify(options.manifestSha256)};
+const extensionSha256=${JSON.stringify(options.extensionSha256)};
+const packageRoot=${JSON.stringify(options.packageRoot)};
+function discoveredSkills(systemPrompt) {
+  const block=systemPrompt.match(/<available_skills>([\\s\\S]*?)<\\/available_skills>/)?.[1] ?? '';
+  const entries=[...block.matchAll(/<skill>[\\s\\S]*?<name>([^<]+)<\\/name>[\\s\\S]*?<location>([^<]+)<\\/location>[\\s\\S]*?<\\/skill>/g)]
+    .map((match)=>({name:match[1],location:match[2]}));
+  if (!packageRoot) return entries;
+  const skillRoot=resolve(packageRoot,'skills');
+  return entries.filter(({location}) => {
+    const child=relative(skillRoot,resolve(location));
+    return child !== '' && !child.startsWith('..') && !isAbsolute(child);
+  });
+}
+function specialistEvidence() {
+  const root=join(process.env.PI_CODING_AGENT_DIR ?? '', 'agents');
+  if (!existsSync(root)) return {materializedSpecialists:[],orchestratorChild:false};
+  const managed=readdirSync(root)
+    .filter((name)=>name.endsWith('.md'))
+    .filter((name)=>/^managed-by:\\s*thoth-agents\\s*$/m.test(readFileSync(join(root,name),'utf8')))
+    .map((name)=>name.slice(0,-3))
+    .sort();
+  return {materializedSpecialists:managed.filter((name)=>name!=='orchestrator'),orchestratorChild:managed.includes('orchestrator')};
+}
+export default function observer(pi) {
+  let hookCount=0;
+  let sessionStartCount=0;
+  let sessionEvidence={materializedSpecialists:[],orchestratorChild:false};
+  let skills=[];
+  pi.on('session_start', () => {
+    sessionStartCount += 1;
+    sessionEvidence=specialistEvidence();
+  });
+  pi.on('before_provider_request', (event) => {
+    hookCount += 1;
+    process.stdout.write(JSON.stringify({systemPrompt:JSON.stringify(event.payload),manifestSha256,extensionSha256,hookCount,sessionStartCount,discoveredSkills:skills,...sessionEvidence})+'\\n');
+  });
+  pi.registerProvider('thoth-observer', {
+    name:'Thoth Observer', baseUrl:'local://thoth-observer', apiKey:'credential-free', api:'thoth-observer',
+    models:[{id:'probe',name:'Probe',api:'thoth-observer',reasoning:false,input:['text'],cost:{input:0,output:0,cacheRead:0,cacheWrite:0},contextWindow:8192,maxTokens:16}],
+    streamSimple(model, context, streamOptions) {
+      const stream=createAssistantMessageEventStream();
+      queueMicrotask(async () => {
+        try {
+          skills=discoveredSkills(context.systemPrompt);
+          const raw={systemPrompt:context.systemPrompt,messages:context.messages};
+          if (streamOptions?.onPayload) await streamOptions.onPayload(raw);
+          const message={role:'assistant',content:[{type:'text',text:'probe'}],api:model.api,provider:model.provider,model:model.id,usage:{input:0,output:1,cacheRead:0,cacheWrite:0,totalTokens:1,cost:{input:0,output:0,cacheRead:0,cacheWrite:0,total:0}},stopReason:'stop',timestamp:Date.now()};
+          stream.push({type:'done',message});
+        } catch (error) { stream.push({type:'error',error}); }
+      });
+      return stream;
+    }
+  });
+}
+`
+    );
+    const args = [
+      "--mode",
+      "json",
+      "--no-session",
+      "--no-approve",
+      "--offline",
+      "--no-extensions",
+      "--extension",
+      resolve3(options.extensionPath),
+      "--extension",
+      observerPath,
+      "--provider",
+      "thoth-observer",
+      "--model",
+      "thoth-observer/probe",
+      "--print",
+      options.probePrompt ?? "Return the single word probe."
+    ];
+    const command = { command: options.piCommand ?? "pi", args };
+    const result = (options.commandExecutor ?? defaultExecutor)(
+      command.command,
+      args,
+      { PI_CODING_AGENT_DIR: isolatedRoot }
+    );
+    if (result.exitCode === null || result.error)
+      return {
+        state: "unavailable",
+        basis: [
+          result.stderr || String(result.error ?? "Pi executable unavailable")
+        ],
+        command
+      };
+    if (result.exitCode !== 0)
+      return {
+        state: "unobserved",
+        basis: [`Pi probe exited ${result.exitCode}: ${result.stderr.trim()}`],
+        command
+      };
+    const records = `${result.stdout}
+${result.stderr}`.split(/\r?\n/).flatMap((line) => {
+      try {
+        const value = JSON.parse(line);
+        return typeof value.systemPrompt === "string" ? [value] : [];
+      } catch {
+        return [];
+      }
+    });
+    const record = records.at(-1);
+    const prompt = typeof record?.systemPrompt === "string" ? record.systemPrompt : "";
+    const discoveredSkills = Array.isArray(record?.discoveredSkills) ? record.discoveredSkills.flatMap((entry) => {
+      if (!entry || typeof entry !== "object" || typeof entry.name !== "string" || typeof entry.location !== "string")
+        return [];
+      return [{ name: entry.name, location: entry.location }];
+    }) : void 0;
+    const materializedSpecialists = Array.isArray(
+      record?.materializedSpecialists
+    ) ? record.materializedSpecialists.filter(
+      (name) => typeof name === "string"
+    ) : void 0;
+    const orchestratorChild = typeof record?.orchestratorChild === "boolean" ? record.orchestratorChild : void 0;
+    const sessionStartCount = typeof record?.sessionStartCount === "number" ? record.sessionStartCount : void 0;
+    const valid = record?.manifestSha256 === options.manifestSha256 && record?.extensionSha256 === options.extensionSha256 && record?.hookCount === 1 && occurrences(prompt, PI_ROOT_START) === 1 && occurrences(prompt, PI_ROOT_END) === 1 && prompt.indexOf(PI_ROOT_START) < prompt.indexOf(PI_ROOT_END);
+    return valid ? {
+      state: "observed-at-install",
+      basis: [
+        "Real Pi final provider request contained exactly one receipt-bound root marker."
+      ],
+      command,
+      ...discoveredSkills ? { discoveredSkills } : {},
+      ...materializedSpecialists ? { materializedSpecialists } : {},
+      ...orchestratorChild !== void 0 ? { orchestratorChild } : {},
+      ...sessionStartCount !== void 0 ? { sessionStartCount } : {}
+    } : {
+      state: "unobserved",
+      basis: [
+        "Pi probe did not return one complete digest-bound native root marker."
+      ],
+      command
+    };
+  } finally {
+    if (ownsIsolatedRoot)
+      rmSync4(isolatedRoot, { recursive: true, force: true });
+    else rmSync4(observerPath, { force: true });
+  }
+}
+
+// src/cli/pi-package-receipt.ts
+import {
+  existsSync as existsSync13,
+  mkdirSync as mkdirSync6,
+  readFileSync as readFileSync10,
+  renameSync as renameSync5,
+  rmSync as rmSync5,
+  writeFileSync as writeFileSync6
+} from "fs";
+import { homedir as homedir5 } from "os";
+import { dirname as dirname8, isAbsolute as isAbsolute2, join as join9, normalize, resolve as resolve4 } from "path";
+var keys = [
+  "schemaVersion",
+  "owner",
+  "scope",
+  "packageName",
+  "source",
+  "installSource",
+  "version",
+  "manifestSha256",
+  "extensionSha256"
+];
+var semver = /^\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?$/;
+var digest = /^[0-9a-f]{64}$/;
+function piPackagePathsEqual(left, right) {
+  const normalizedLeft = normalize(resolve4(left));
+  const normalizedRight = normalize(resolve4(right));
+  return process.platform === "win32" ? normalizedLeft.toLowerCase() === normalizedRight.toLowerCase() : normalizedLeft === normalizedRight;
+}
+function getPiPackageReceiptPath(options = {}) {
+  const env = options.env ?? process.env;
+  const root = options.configRoot ?? env.XDG_CONFIG_HOME?.trim() ?? join9(options.homeDir ?? homedir5(), ".config");
+  return join9(root, "thoth-agents", "pi-package.json");
+}
+function parse(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value))
+    throw new Error("Receipt must be a JSON object.");
+  const record = value;
+  if (Object.keys(record).sort().join("|") !== [...keys].sort().join("|"))
+    throw new Error("Receipt contains missing or additional keys.");
+  if (record.schemaVersion !== 1 || record.owner !== "thoth-agents" || record.scope !== "user" || record.packageName !== "thoth-agents")
+    throw new Error("Receipt identity is invalid.");
+  if (typeof record.version !== "string" || !semver.test(record.version))
+    throw new Error("Receipt version is invalid.");
+  const npmSource = `npm:thoth-agents@${record.version}`;
+  const npmIdentity = record.source === npmSource && record.installSource === npmSource;
+  const localIdentity = typeof record.source === "string" && record.source.length > 0 && !isAbsolute2(record.source) && !/^[a-z][a-z+.-]*:/i.test(record.source) && typeof record.installSource === "string" && isAbsolute2(record.installSource);
+  if (!npmIdentity && !localIdentity)
+    throw new Error("Receipt source is not canonical.");
+  if (typeof record.manifestSha256 !== "string" || !digest.test(record.manifestSha256) || typeof record.extensionSha256 !== "string" || !digest.test(record.extensionSha256))
+    throw new Error("Receipt digests are invalid.");
+  return record;
+}
+function readPiPackageReceipt(options = {}) {
+  const path = getPiPackageReceiptPath(options);
+  if (!existsSync13(path)) return { status: "missing", path };
+  try {
+    return {
+      status: "valid",
+      path,
+      receipt: parse(JSON.parse(readFileSync10(path, "utf8")))
+    };
+  } catch (error) {
+    return {
+      status: "invalid",
+      path,
+      error: error instanceof Error ? error.message : String(error)
+    };
+  }
+}
+function writePiPackageReceipt(receipt, options = {}) {
+  const path = getPiPackageReceiptPath(options);
+  try {
+    const validated = parse(receipt);
+    mkdirSync6(dirname8(path), { recursive: true });
+    const temporary = `${path}.tmp-${process.pid}`;
+    writeFileSync6(temporary, `${JSON.stringify(validated, null, 2)}
+`, {
+      flag: "wx"
+    });
+    try {
+      renameSync5(temporary, path);
+    } catch (error) {
+      rmSync5(temporary, { force: true });
+      throw error;
+    }
+    return { success: true, path };
+  } catch (error) {
+    return {
+      success: false,
+      path,
+      error: error instanceof Error ? error.message : String(error)
+    };
+  }
+}
+function classifyPiPackageOwnership(input) {
+  if (input.receipt.status === "invalid" || input.projectPackages.length > 0 || input.globalPackages.length > 1)
+    return {
+      state: "conflicting",
+      reason: input.receipt.status === "invalid" ? input.receipt.error : "Ambiguous or project-local first-party source."
+    };
+  const configured = input.globalPackages[0];
+  if (input.receipt.status === "missing")
+    return { state: configured ? "configured-unowned" : "missing" };
+  if (!configured) return { state: "owned-missing" };
+  const configuredPath = configured.installedPath;
+  const receipt = input.receipt.receipt;
+  const identityMatches = (configured.packageName === void 0 || configured.packageName === receipt.packageName) && (configured.packageVersion === void 0 || configured.packageVersion === receipt.version);
+  const isNpm = receipt.source === receipt.installSource;
+  const pathMatches = isNpm || configuredPath !== void 0 && piPackagePathsEqual(configuredPath, receipt.installSource);
+  return configured.source === receipt.source && pathMatches && identityMatches ? { state: "owned-current" } : {
+    state: "conflicting",
+    reason: "Configured source, resolved package identity, or path differs from the ownership receipt."
+  };
+}
+
+// src/cli/pi-paths.ts
+import { homedir as homedir6 } from "os";
+import { join as join10, resolve as resolve5 } from "path";
+function resolvePiPaths(options = {}) {
+  const env = options.env ?? process.env;
+  const homeDir = resolve5(
+    options.homeDir ?? env.HOME ?? env.USERPROFILE ?? homedir6()
+  );
+  const defaultPiRoot = join10(homeDir, ".pi", "agent");
+  const configured = env.PI_CODING_AGENT_DIR?.trim();
+  const piRoot = configured ? resolve5(configured) : defaultPiRoot;
+  const cwd = resolve5(options.cwd ?? process.cwd());
+  const configRoot = env.XDG_CONFIG_HOME?.trim() ? resolve5(env.XDG_CONFIG_HOME) : join10(homeDir, ".config");
+  return {
+    homeDir,
+    piRoot,
+    defaultPiRoot,
+    customPiRoot: piRoot !== defaultPiRoot,
+    skillsDestinationCompatible: piRoot === defaultPiRoot,
+    appendSystemPath: join10(piRoot, "APPEND_SYSTEM.md"),
+    agentsRoot: join10(piRoot, "agents"),
+    alternateAgentsRoot: join10(piRoot, "subagents"),
+    ownedSkillsRoot: join10(piRoot, "skills"),
+    mcpConfigPath: join10(configRoot, "mcp", "mcp.json"),
+    projectAgentRoots: [
+      join10(cwd, ".pi", "agents"),
+      join10(cwd, ".pi", "subagents")
+    ],
+    projectMcpPaths: [join10(cwd, ".mcp.json"), join10(cwd, ".pi", "mcp.json")]
+  };
+}
+
+// src/cli/pi-install.ts
+var PI_MINIMUM_VERSION = "0.84.4";
+var PI_NODE_MINIMUM = "22.19.0";
+var PI_COMMAND_TIMEOUT_MS = 12e4;
+var PI_PACKAGE_SPECS = [
+  {
+    id: "delegation",
+    source: "npm:pi-subagents-j0k3r@1.5.9",
+    packageName: "pi-subagents-j0k3r",
+    version: "1.5.9"
+  },
+  {
+    id: "context7",
+    source: "npm:@upstash/context7-pi@0.1.2",
+    packageName: "@upstash/context7-pi",
+    version: "0.1.2"
+  },
+  {
+    id: "web-access",
+    source: "npm:pi-web-access@0.27.0",
+    packageName: "pi-web-access",
+    version: "0.27.0"
+  },
+  {
+    id: "grep-adapter",
+    source: "npm:pi-mcp-adapter@2.32.1",
+    packageName: "pi-mcp-adapter",
+    version: "2.32.1"
+  },
+  {
+    id: "ask-user-question",
+    source: "npm:@juicesharp/rpiv-ask-user-question@2.9.0",
+    packageName: "@juicesharp/rpiv-ask-user-question",
+    version: "2.9.0"
+  },
+  {
+    id: "todo",
+    source: "npm:@juicesharp/rpiv-todo@2.9.0",
+    packageName: "@juicesharp/rpiv-todo",
+    version: "2.9.0"
+  }
+];
+var PI_GREP_MCP_ENTRY = {
+  url: "https://mcp.grep.app",
+  protocolVersion: "legacy",
+  lifecycle: "lazy"
+};
+function getPiFirstPartySource(version) {
+  return `npm:thoth-agents@${version}`;
+}
+function packageRootFor(options) {
+  const root = options.packageRoot ?? findPackageRoot(dirname9(fileURLToPath5(import.meta.url)));
+  if (!root)
+    throw new Error(
+      "Unable to locate the executing thoth-agents package root."
+    );
+  return root;
+}
+function packageVersionFor(root) {
+  const value = JSON.parse(
+    readFileSync11(join11(root, "package.json"), "utf8")
+  );
+  if (typeof value.version !== "string")
+    throw new Error("Executing thoth-agents package version is invalid.");
+  return value.version;
+}
+function sha2562(path) {
+  return createHash4("sha256").update(readFileSync11(path)).digest("hex");
+}
+function verifyPiFirstPartyPackage(input) {
+  try {
+    const manifestPath = join11(input.packageRoot, "package.json");
+    const extensionPath = join11(input.packageRoot, "dist", "pi.js");
+    const assetsPath = join11(
+      input.packageRoot,
+      "pi",
+      ".thoth-agents-assets.json"
+    );
+    for (const path of [manifestPath, extensionPath, assetsPath])
+      if (!existsSync14(path) || !lstatSync3(path).isFile() || lstatSync3(path).isSymbolicLink())
+        throw new Error(
+          `Required regular package asset is missing or symlinked: ${path}`
+        );
+    const manifest = JSON.parse(readFileSync11(manifestPath, "utf8"));
+    if (manifest.name !== "thoth-agents" || manifest.version !== input.version || JSON.stringify(manifest.pi) !== JSON.stringify({ extensions: ["./dist/pi.js"], skills: ["./skills"] }))
+      throw new Error(
+        "Installed package identity or Pi manifest is inconsistent."
+      );
+    const assets = JSON.parse(readFileSync11(assetsPath, "utf8"));
+    const expectedAgentPaths = PI_SPECIALIST_ROLES.map(
+      (role) => `agents/${piSpecialistName(role)}.md`
+    );
+    if (assets.schemaVersion !== 1 || assets.owner !== "thoth-agents" || !isRecord6(assets.files) || Object.keys(assets.files).sort().join("|") !== [...expectedAgentPaths].sort().join("|"))
+      throw new Error("Installed Pi specialist provenance is invalid.");
+    for (const relativePath of expectedAgentPaths) {
+      const path = join11(input.packageRoot, "pi", relativePath);
+      if (!existsSync14(path) || !lstatSync3(path).isFile() || lstatSync3(path).isSymbolicLink() || sha2562(path) !== assets.files[relativePath])
+        throw new Error(
+          `Installed Pi specialist asset is missing, symlinked, or stale: ${relativePath}`
+        );
+    }
+    for (const skill of THOTH_OWNED_SKILL_NAMES) {
+      const path = join11(input.packageRoot, "skills", skill, "SKILL.md");
+      if (!existsSync14(path) || !lstatSync3(path).isFile() || lstatSync3(path).isSymbolicLink())
+        throw new Error(
+          `Installed Pi manifest skill is missing or symlinked: ${skill}`
+        );
+    }
+    const manifestSha256 = sha2562(manifestPath);
+    const extensionSha256 = sha2562(extensionPath);
+    const load = defaultCommandExecutor4("node", [
+      "--input-type=module",
+      "--eval",
+      `import(${JSON.stringify(pathToFileURL(extensionPath).href)}).then(m=>{if(typeof m.default!=="function")process.exit(2)})`
+    ]);
+    if (load.exitCode !== 0)
+      throw new Error(`Compiled Pi extension is not loadable: ${load.stderr}`);
+    const observation = observePiNativeRoot({
+      extensionPath,
+      manifestSha256,
+      extensionSha256
+    });
+    if (observation.state !== "observed-at-install")
+      throw new Error(observation.basis.join("; "));
+    return {
+      success: true,
+      receipt: {
+        schemaVersion: 1,
+        owner: "thoth-agents",
+        scope: "user",
+        packageName: "thoth-agents",
+        source: input.source,
+        installSource: input.installSource,
+        version: input.version,
+        manifestSha256,
+        extensionSha256
+      }
+    };
+  } catch (error) {
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : String(error)
+    };
+  }
+}
+function isRecord6(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function readJsonObject(path) {
+  if (!existsSync14(path)) return {};
+  const parsed = JSON.parse(readFileSync11(path, "utf8"));
+  if (!isRecord6(parsed)) throw new Error(`${path} must contain a JSON object.`);
+  return parsed;
+}
+function mergePiGrepMcpConfig(current) {
+  const rawServers = current.mcpServers;
+  if (rawServers !== void 0 && !isRecord6(rawServers)) {
+    throw new Error("Global MCP mcpServers must be a JSON object.");
+  }
+  const servers = isRecord6(rawServers) ? rawServers : {};
+  const existing = servers.grep;
+  if (existing !== void 0 && JSON.stringify(existing) !== JSON.stringify(PI_GREP_MCP_ENTRY)) {
+    throw new Error(
+      'Global MCP server "grep" is not owned by thoth-agents and conflicts with the required grep.app entry.'
+    );
+  }
+  return {
+    ...current,
+    mcpServers: { ...servers, grep: { ...PI_GREP_MCP_ENTRY } }
+  };
+}
+function frontmatterValue(content, field) {
+  const lines = content.split(/\r?\n/);
+  if (lines[0]?.trim() !== "---") return void 0;
+  const end = lines.findIndex(
+    (line2, index) => index > 0 && line2.trim() === "---"
+  );
+  if (end === -1) return void 0;
+  const prefix = `${field}:`;
+  const line = lines.slice(1, end).find((candidate) => candidate.startsWith(prefix));
+  if (!line) return void 0;
+  const value = line.slice(prefix.length).trim();
+  if (value.length >= 2 && (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'"))) {
+    return value.slice(1, -1).trim();
+  }
+  return value || void 0;
+}
+function findAgentConflicts(paths) {
+  const canonical = new Set(PI_SPECIALIST_ROLES.map(piSpecialistName));
+  const conflicts = [];
+  for (const root of [paths.agentsRoot, paths.alternateAgentsRoot]) {
+    if (!existsSync14(root)) continue;
+    for (const name of readdirSync3(root)) {
+      if (!name.endsWith(".md")) continue;
+      const path = join11(root, name);
+      const content = readFileSync11(path, "utf8");
+      const role = frontmatterValue(content, "name");
+      const filenameRole = name.slice(0, -".md".length).toLowerCase();
+      const canonicalRole = role && canonical.has(role) ? role : canonical.has(filenameRole) ? filenameRole : void 0;
+      if (canonicalRole && frontmatterValue(content, "managed-by") !== PI_MANAGED_OWNER) {
+        conflicts.push(
+          `${path} defines canonical specialist ${canonicalRole} without thoth-agents ownership.`
+        );
+      }
+    }
+  }
+  return conflicts;
+}
+function buildPiSetupPlan(options = {}) {
+  const paths = resolvePiPaths(options);
+  let packageRoot;
+  let expectedVersion;
+  try {
+    packageRoot = packageRootFor(options);
+    expectedVersion = options.expectedVersion ?? packageVersionFor(packageRoot);
+  } catch {
+    packageRoot = options.packageRoot ?? "";
+    expectedVersion = options.expectedVersion ?? "";
+  }
+  const blockers = [];
+  const diagnostics = [];
+  if (!paths.skillsDestinationCompatible) {
+    blockers.push(
+      `PI_CODING_AGENT_DIR resolves to ${paths.piRoot}, but the required skills CLI targets ${paths.defaultPiRoot}. Remove the override or install the four external skills manually into ${paths.ownedSkillsRoot}.`
+    );
+  }
+  blockers.push(...findAgentConflicts(paths));
+  let mcpContent;
+  try {
+    mcpContent = `${JSON.stringify(
+      mergePiGrepMcpConfig(readJsonObject(paths.mcpConfigPath)),
+      null,
+      2
+    )}
+`;
+  } catch (error) {
+    blockers.push(error instanceof Error ? error.message : String(error));
+  }
+  for (const path of [...paths.projectAgentRoots, ...paths.projectMcpPaths]) {
+    if (existsSync14(path))
+      diagnostics.push(
+        `Project-local Pi resource may shadow global managed state: ${path}`
+      );
+  }
+  const rendered = piAdapter.render({
+    projectRoot: options.cwd ?? process.cwd()
+  });
+  if (!expectedVersion || !packageRoot)
+    blockers.push(
+      "The executing thoth-agents package identity is unavailable."
+    );
+  const firstPartySource = options.firstPartySource ?? getPiFirstPartySource(expectedVersion);
+  const items = [
+    {
+      kind: "preflight",
+      description: "Verify Node.js >=22.19 and Pi >=0.84.4 before mutation",
+      target: "node/pi runtime"
+    },
+    {
+      kind: "package",
+      description: `Install and verify first-party native Pi package ${firstPartySource}`,
+      target: firstPartySource,
+      command: {
+        command: "pi",
+        args: ["install", firstPartySource, "--no-approve"]
+      }
+    },
+    ...PI_PACKAGE_SPECS.map((pkg) => ({
+      kind: "package",
+      description: `Install and verify Pi package ${pkg.source}`,
+      target: pkg.source,
+      command: { command: "pi", args: ["install", pkg.source, "--no-approve"] }
+    })),
+    ...mcpContent === void 0 ? [] : [
+      {
+        kind: "mcp",
+        description: "Merge attributable global grep.app MCP entry",
+        target: paths.mcpConfigPath,
+        content: mcpContent
+      }
+    ],
+    ...rendered.artifacts.filter((artifact) => artifact.kind === "agent-config").map((artifact) => ({
+      kind: "agent",
+      description: artifact.description ?? `Install ${artifact.path}`,
+      target: join11(paths.piRoot, artifact.path),
+      content: String(artifact.content)
+    }))
+  ];
+  return {
+    dryRun: options.dryRun ?? false,
+    ready: blockers.length === 0,
+    paths,
+    items,
+    blockers,
+    diagnostics,
+    disclaimers: [
+      "Pi extensions execute with the invoking user's system permissions; package pins and tool allowlists are not a security sandbox.",
+      "Context7 and web access are native Pi extensions; only grep.app uses pi-mcp-adapter and directTools is intentionally omitted.",
+      "Project-local resources require Pi trust and may shadow global resources."
+    ],
+    options: { ...options, expectedVersion, packageRoot, firstPartySource }
+  };
+}
+function formatPiSetupPlan(plan) {
+  return [
+    "Pi setup plan:",
+    ...plan.items.map(
+      (item) => item.command ? `- ${item.kind}: ${item.command.command} ${item.command.args.join(" ")}` : `- ${item.kind}: ${item.target}`
+    ),
+    ...plan.blockers.map((blocker) => `- BLOCKED: ${blocker}`)
+  ].join("\n");
+}
+function isVersionAtLeast(actual, expected) {
+  const parts = (value) => value.replace(/^v/, "").split(".").slice(0, 3).map((part) => Number.parseInt(part, 10));
+  const left = parts(actual);
+  const right = parts(expected);
+  if (left.some(Number.isNaN) || right.some(Number.isNaN)) return false;
+  for (let index = 0; index < 3; index += 1) {
+    const difference = (left[index] ?? 0) - (right[index] ?? 0);
+    if (difference !== 0) return difference > 0;
+  }
+  return true;
+}
+function hasExactInstalledPiPackage(output, source) {
+  return output.split(/\r?\n/).some((line) => line.trim() === source);
+}
+function parsePiPackageList(output) {
+  const packages = [];
+  let scope = "user";
+  for (const line of output.split(/\r?\n/)) {
+    const value = line.trim();
+    if (!value || value === "No packages installed.") continue;
+    if (value === "User packages:") {
+      scope = "user";
+      continue;
+    }
+    if (value === "Project packages:") {
+      scope = "project";
+      continue;
+    }
+    const previous = packages.at(-1);
+    if (/^\s{4,}\S/.test(line) && previous && !previous.installedPath) {
+      previous.installedPath = value;
+      continue;
+    }
+    packages.push({ scope, source: value.replace(/ \(filtered\)$/, "") });
+  }
+  return packages;
+}
+function isThothPackageLocation(candidate, knownSource) {
+  if (candidate.source === knownSource || /^npm:thoth-agents@/.test(candidate.source))
+    return true;
+  if (!candidate.installedPath) return false;
+  try {
+    const manifest = JSON.parse(
+      readFileSync11(join11(candidate.installedPath, "package.json"), "utf8")
+    );
+    return manifest.name === "thoth-agents";
+  } catch {
+    return false;
+  }
+}
+function configuredPackageIdentity(candidate) {
+  if (!candidate.installedPath) return { packageName: "", packageVersion: "" };
+  try {
+    const manifest = JSON.parse(
+      readFileSync11(join11(candidate.installedPath, "package.json"), "utf8")
+    );
+    return {
+      packageName: typeof manifest.name === "string" ? manifest.name : "",
+      packageVersion: typeof manifest.version === "string" ? manifest.version : ""
+    };
+  } catch {
+    return { packageName: "", packageVersion: "" };
+  }
+}
+function getPiFirstPartyPackages(packages, knownSource) {
+  return packages.filter((candidate) => isThothPackageLocation(candidate, knownSource)).map((candidate) => ({
+    ...candidate,
+    ...configuredPackageIdentity(candidate)
+  }));
+}
+function matchesInstallSource(candidate, installSource) {
+  return isAbsolute3(installSource) ? candidate.installedPath !== void 0 && piPackagePathsEqual(candidate.installedPath, installSource) : candidate.source === installSource;
+}
+function defaultCommandExecutor4(command, args) {
+  let executable = command;
+  let executableArgs = [...args];
+  if (process.platform === "win32" && command === "pi") {
+    const located = spawnSync6("where.exe", ["pi.cmd"], { encoding: "utf8" }).stdout?.split(/\r?\n/).find(Boolean);
+    const cli = located ? join11(
+      dirname9(located),
+      "node_modules",
+      "@earendil-works",
+      "pi-coding-agent",
+      "dist",
+      "bundle",
+      "cli.js"
+    ) : void 0;
+    if (cli && existsSync14(cli)) {
+      executable = process.execPath;
+      executableArgs = [cli, ...args];
+    }
+  }
+  const result = spawnSync6(executable, executableArgs, {
+    encoding: "utf8",
+    timeout: PI_COMMAND_TIMEOUT_MS
+  });
+  return {
+    exitCode: result.status,
+    stdout: result.stdout ?? "",
+    stderr: result.stderr ?? "",
+    error: result.error
+  };
+}
+function writePiManagedText(path, content) {
+  if (existsSync14(path) && readFileSync11(path, "utf8") === content) return false;
+  mkdirSync7(dirname9(path), { recursive: true });
+  const temporaryPath = `${path}.tmp`;
+  const backupPath = `${path}.bak`;
+  writeFileSync7(temporaryPath, content);
+  try {
+    if (existsSync14(path)) copyFileSync5(path, backupPath);
+    renameSync6(temporaryPath, path);
+  } catch (error) {
+    rmSync6(temporaryPath, { force: true });
+    throw error;
+  }
+  return true;
+}
+function applyPiSetup(plan) {
+  const diagnostics = [...plan.diagnostics];
+  if (!plan.ready)
+    return {
+      success: false,
+      changed: [],
+      diagnostics,
+      error: plan.blockers.join("\n"),
+      failedStep: "preflight",
+      installedPackages: []
+    };
+  if (plan.dryRun)
+    return { success: true, changed: [], diagnostics, installedPackages: [] };
+  const execute = plan.options.commandExecutor ?? defaultCommandExecutor4;
+  const changed = [];
+  const installedPackages = [];
+  let receiptCommitted = false;
+  let configuredPackageRoot;
+  try {
+    const node = execute("node", ["--version"]);
+    if (node.exitCode !== 0 || !isVersionAtLeast(node.stdout.trim(), PI_NODE_MINIMUM))
+      throw new Error(
+        `Node.js >=${PI_NODE_MINIMUM} is required; observed ${node.stdout.trim() || node.stderr.trim() || "unavailable"}.`
+      );
+    const pi = execute("pi", ["--version"]);
+    if (pi.exitCode !== 0 || !isVersionAtLeast(pi.stdout.trim(), PI_MINIMUM_VERSION))
+      throw new Error(
+        `Pi >=${PI_MINIMUM_VERSION} is required; observed ${pi.stdout.trim() || pi.stderr.trim() || "unavailable"}.`
+      );
+    const desiredSource = plan.options.firstPartySource ?? getPiFirstPartySource(plan.options.expectedVersion ?? "");
+    const before = execute("pi", ["list", "--no-approve"]);
+    if (before.exitCode !== 0)
+      throw new Error(
+        `Unable to inspect Pi package ownership before mutation: ${before.stderr}`
+      );
+    const receiptOptions = {
+      homeDir: plan.paths.homeDir,
+      env: plan.options.env,
+      ...plan.options.receiptOptions
+    };
+    const receipt = readPiPackageReceipt(receiptOptions);
+    const configuredBefore = parsePiPackageList(before.stdout);
+    const knownReceiptSource = receipt.status === "valid" ? receipt.receipt.source : void 0;
+    const firstPartyBefore = getPiFirstPartyPackages(
+      configuredBefore,
+      knownReceiptSource
+    );
+    const globalPackages = firstPartyBefore.filter(
+      ({ scope }) => scope === "user"
+    );
+    const projectPackages = firstPartyBefore.filter(
+      ({ scope }) => scope === "project"
+    );
+    const ownership = classifyPiPackageOwnership({
+      receipt,
+      globalPackages,
+      projectPackages
+    });
+    if (ownership.state === "configured-unowned" || ownership.state === "conflicting")
+      throw new Error(
+        `First-party Pi package ownership conflict: ${ownership.reason ?? ownership.state}`
+      );
+    const installed = execute("pi", ["install", desiredSource, "--no-approve"]);
+    if (installed.exitCode !== 0)
+      throw new Error(
+        `Failed to install ${desiredSource}: ${installed.stderr.trim() || "unknown Pi error"}`
+      );
+    installedPackages.push(desiredSource);
+    try {
+      const listed = execute("pi", ["list", "--no-approve"]);
+      const configuredAfter = parsePiPackageList(listed.stdout);
+      const firstPartyAfter = getPiFirstPartyPackages(
+        configuredAfter.filter(
+          (candidate) => isThothPackageLocation(candidate, knownReceiptSource) || matchesInstallSource(candidate, desiredSource)
+        ),
+        knownReceiptSource
+      );
+      const projectCandidates = firstPartyAfter.filter(
+        ({ scope }) => scope === "project"
+      );
+      const globalCandidates = firstPartyAfter.filter(
+        ({ scope }) => scope === "user"
+      );
+      const candidates = globalCandidates.filter(
+        (candidate) => matchesInstallSource(candidate, desiredSource)
+      );
+      if (listed.exitCode !== 0 || candidates.length !== 1 || globalCandidates.length !== 1 || projectCandidates.length !== 0)
+        throw new Error(
+          `Pi did not verify the exact installed package source ${desiredSource}.`
+        );
+      const resolvedPackageRoot = candidates[0]?.installedPath;
+      if (!resolvedPackageRoot || !isAbsolute3(resolvedPackageRoot) || !existsSync14(resolvedPackageRoot) || !lstatSync3(resolvedPackageRoot).isDirectory() || lstatSync3(resolvedPackageRoot).isSymbolicLink())
+        throw new Error(
+          `Pi did not report one absolute regular installed directory for ${desiredSource}.`
+        );
+      const packageRoot = resolvedPackageRoot;
+      configuredPackageRoot = packageRoot;
+      const verified = (plan.options.verifyFirstParty ?? verifyPiFirstPartyPackage)({
+        source: candidates[0]?.source ?? desiredSource,
+        installSource: desiredSource,
+        version: plan.options.expectedVersion ?? packageVersionFor(packageRoot),
+        packageRoot
+      });
+      if (!verified.success) throw new Error(verified.error);
+      const committed = writePiPackageReceipt(verified.receipt, receiptOptions);
+      if (!committed.success)
+        throw new Error(
+          `Could not commit Pi package receipt: ${committed.error}`
+        );
+      receiptCommitted = true;
+      changed.push(committed.path);
+    } catch (originalError) {
+      const restoreSource = ownership.state === "owned-current" && receipt.status === "valid" ? receipt.receipt.installSource : void 0;
+      const rollback = restoreSource ? execute("pi", ["install", restoreSource, "--no-approve"]) : execute("pi", ["remove", desiredSource, "--no-approve"]);
+      const afterRollback = execute("pi", ["list", "--no-approve"]);
+      const rollbackPackages = parsePiPackageList(afterRollback.stdout);
+      const restored = (() => {
+        if (rollback.exitCode !== 0 || afterRollback.exitCode !== 0)
+          return false;
+        if (restoreSource && receipt.status === "valid") {
+          const priorPackages = getPiFirstPartyPackages(
+            rollbackPackages,
+            receipt.receipt.source
+          );
+          return classifyPiPackageOwnership({
+            receipt,
+            globalPackages: priorPackages.filter(
+              ({ scope }) => scope === "user"
+            ),
+            projectPackages: priorPackages.filter(
+              ({ scope }) => scope === "project"
+            )
+          }).state === "owned-current";
+        }
+        return !rollbackPackages.some(
+          (candidate) => matchesInstallSource(candidate, desiredSource)
+        );
+      })();
+      if (!restored)
+        return {
+          success: false,
+          changed,
+          diagnostics,
+          error: `${originalError instanceof Error ? originalError.message : String(originalError)}; rollback failed: ${rollback.stderr || afterRollback.stderr}`,
+          failedStep: "package",
+          installedPackages,
+          rollbackFailed: true,
+          manualRecovery: restoreSource ? `pi install ${restoreSource} --no-approve` : `pi remove ${desiredSource} --no-approve`
+        };
+      return {
+        success: false,
+        changed,
+        diagnostics,
+        error: originalError instanceof Error ? originalError.message : String(originalError),
+        failedStep: "package",
+        installedPackages,
+        receiptCommitted: false
+      };
+    }
+    if (!configuredPackageRoot)
+      throw new Error("Verified Pi package root is unavailable.");
+    const migration = migrateLegacyPiResources({
+      packageRoot: configuredPackageRoot,
+      piRoot: plan.paths.piRoot
+    });
+    diagnostics.push(...migration.manualActions);
+    if (!migration.success)
+      throw new Error(migration.error ?? "Pi legacy migration failed.");
+    changed.push(...migration.changed);
+    for (const pkg of PI_PACKAGE_SPECS) {
+      const result = execute("pi", ["install", pkg.source, "--no-approve"]);
+      if (result.exitCode !== 0)
+        throw new Error(
+          `Failed to install ${pkg.source}: ${result.stderr.trim() || "unknown Pi error"}`
+        );
+      const listed = execute("pi", ["list", "--no-approve"]);
+      if (listed.exitCode !== 0 || !hasExactInstalledPiPackage(listed.stdout, pkg.source)) {
+        throw new Error(
+          `Pi did not verify the exact installed package source ${pkg.source}.`
+        );
+      }
+      installedPackages.push(pkg.source);
+    }
+    for (const item of plan.items.filter(
+      (candidate) => candidate.content !== void 0 && candidate.kind === "mcp"
+    )) {
+      if (writePiManagedText(item.target, item.content ?? ""))
+        changed.push(item.target);
+    }
+    const resources = syncPiSpecialists({
+      packageRoot: configuredPackageRoot,
+      piRoot: plan.paths.piRoot,
+      projectRoots: plan.paths.projectAgentRoots
+    });
+    diagnostics.push(...resources.diagnostics);
+    if (!resources.success)
+      throw new Error(
+        resources.error ?? "Pi specialist synchronization failed."
+      );
+    changed.push(...resources.changed);
+    return {
+      success: true,
+      changed,
+      diagnostics,
+      installedPackages,
+      receiptCommitted,
+      configuredPackageRoot
+    };
+  } catch (error) {
+    return {
+      success: false,
+      changed,
+      diagnostics,
+      error: error instanceof Error ? error.message : String(error),
+      failedStep: installedPackages.length < plan.items.filter((item) => item.kind === "package").length ? "package" : "managed-surface",
+      installedPackages,
+      receiptCommitted
+    };
+  }
+}
+
+// src/cli/operations/pi.ts
+var PI_DISPLAY_NAME = "Pi";
+var MODEL_ROOT_LIMITATION = "Pi owns the ambient root session model; only thoth-agents-owned specialist definitions may be changed.";
+var piActions = [
+  {
+    id: "pi-status",
+    kind: "status",
+    label: "Status",
+    description: "Inspect Pi packages, resources, research providers, and CLI ledger",
+    dryRun: false,
+    requiresConfirmation: false,
+    supported: true
+  },
+  {
+    id: "pi-list",
+    kind: "list",
+    label: "List",
+    description: "List Pi-managed targets and truthful capability limits",
+    dryRun: false,
+    requiresConfirmation: false,
+    supported: true
+  },
+  {
+    id: "pi-install",
+    kind: "install",
+    label: "Install",
+    description: "Preview complete ordered Pi setup",
+    dryRun: true,
+    requiresConfirmation: true,
+    supported: true
+  },
+  {
+    id: "pi-update",
+    kind: "update",
+    label: "Update",
+    description: "Preview an installation-equivalent Pi refresh",
+    dryRun: true,
+    requiresConfirmation: true,
+    supported: true
+  },
+  {
+    id: "pi-sync",
+    kind: "sync",
+    label: "Sync",
+    description: "Preview attributable root, specialist, skill, and grep configuration sync",
+    dryRun: true,
+    requiresConfirmation: true,
+    supported: true
+  },
+  {
+    id: "pi-model-config",
+    kind: "model-config",
+    label: "Model",
+    description: "Configure attributable Pi specialist model and effort fields",
+    dryRun: true,
+    requiresConfirmation: true,
+    supported: true,
+    disabledReason: MODEL_ROOT_LIMITATION
+  }
+];
+var piOperationAdapter = {
+  id: "pi",
+  displayName: PI_DISPLAY_NAME,
+  available: true,
+  description: "Pi-native packages, ambient root, six specialists, skills, and hybrid research stack.",
+  actions: piActions
+};
+function disclaimers() {
+  return [
+    {
+      code: "pi-no-os-sandbox",
+      message: "Pi extensions execute with the invoking user's system permissions; tool allowlists are not an OS or credential sandbox."
+    },
+    {
+      code: "pi-runtime-owned",
+      message: "Pi and pi-subagents own execution, concurrency, task/history storage, trust, and lifecycle."
+    },
+    {
+      code: "pi-research-independent",
+      message: "Context7, web access, and grep.app availability is reported independently; provider configuration and credentials remain operator-owned."
+    },
+    { code: "pi-root-model-owned", message: MODEL_ROOT_LIMITATION }
+  ];
+}
+function warning3(message, code, severity = "important") {
+  return { severity, message, code };
+}
+var RESEARCH_PROVIDER_LABEL = {
+  context7: "Context7",
+  "web-access": "Web access",
+  grep: "grep.app"
+};
+function researchRuntimeState(provider, targets, evidence) {
+  const observed = evidence.research?.[provider];
+  if (observed) return observed;
+  const packageId = provider === "grep" ? "grep-adapter" : provider;
+  const packageSource = PI_PACKAGE_SPECS.find(
+    ({ id }) => id === packageId
+  )?.source;
+  const packageReady = targets.some(
+    ({ path, state }) => path === packageSource && state === "installed"
+  );
+  const configReady = provider !== "grep" || targets.some(
+    ({ kind, label, state }) => kind === "config" && label?.includes("grep.app") && state === "installed"
+  );
+  if (!packageReady || !configReady)
+    return {
+      state: "drifted",
+      basis: [
+        "managed package or configuration preconditions are not satisfied"
+      ]
+    };
+  return provider === "web-access" ? {
+    state: "unverified",
+    basis: [
+      "exact package is installed; no live provider request was observed"
+    ]
+  } : {
+    state: "ready",
+    basis: [
+      "managed package and configuration preconditions are satisfied; no live probe was requested"
+    ]
+  };
+}
+function runtimeTarget(provider, evidence) {
+  const managedState = evidence.state === "ready" ? "installed" : evidence.state === "credential-required" ? "missing" : evidence.state === "drifted" ? "drift" : "unknown";
+  return {
+    kind: "surface",
+    label: `${RESEARCH_PROVIDER_LABEL[provider]} runtime availability`,
+    state: managedState,
+    expected: "ready",
+    observed: evidence.state,
+    description: evidence.basis.join("; ")
+  };
+}
+function runtimeDiagnostic(provider, evidence) {
+  if (evidence.state === "ready") return void 0;
+  const code = `pi-${provider}-runtime-${evidence.state}`;
+  const severity = evidence.state === "failed" ? "critical" : evidence.state === "credential-required" || evidence.state === "unverified" ? "minor" : "important";
+  return warning3(
+    `${RESEARCH_PROVIDER_LABEL[provider]} runtime is ${evidence.state}: ${evidence.basis.join("; ")}.`,
+    code,
+    severity
+  );
+}
+function statusFromPlan(plan, context2, evidence = {}) {
+  const targets = plan.items.filter((item) => item.kind !== "preflight").map((item) => ({
+    kind: item.kind === "package" ? "package" : item.kind === "agent" ? "file" : item.kind === "mcp" ? "config" : "file",
+    path: item.target,
+    label: item.description,
+    state: item.kind === "package" ? "unknown" : existsSync15(item.target) ? item.content === void 0 || readFileSync12(item.target, "utf8") === item.content ? "installed" : "drift" : "missing",
+    expected: item.kind === "package" ? item.target : "attributable managed content",
+    description: item.kind === "package" ? "Exact installed-package evidence; this does not prove live tool availability." : void 0
+  }));
+  const execute = context2.piCommandExecutor ?? ((command, args) => {
+    const result = spawnSync7(command, [...args], {
+      encoding: "utf8",
+      timeout: 5e3,
+      env: {
+        ...process.env,
+        ...context2.env,
+        ...context2.homeDir ? { HOME: context2.homeDir, USERPROFILE: context2.homeDir } : {},
+        PI_CODING_AGENT_DIR: plan.paths.piRoot
+      }
+    });
+    return {
+      exitCode: result.status,
+      stdout: result.stdout ?? "",
+      stderr: result.stderr ?? "",
+      error: result.error
+    };
+  });
+  const node = execute("node", ["--version"]);
+  const pi = execute("pi", ["--version"]);
+  const packages = execute("pi", ["list", "--no-approve"]);
+  targets.unshift(
+    {
+      kind: "surface",
+      label: "Node.js runtime",
+      state: node.exitCode !== 0 ? "missing" : isVersionAtLeast(node.stdout.trim(), PI_NODE_MINIMUM) ? "installed" : "drift",
+      expected: `>=${PI_NODE_MINIMUM}`,
+      observed: node.stdout.trim() || node.stderr.trim() || "unavailable"
+    },
+    {
+      kind: "package",
+      label: "Pi runtime",
+      state: pi.exitCode !== 0 ? "missing" : isVersionAtLeast(pi.stdout.trim(), PI_MINIMUM_VERSION) ? "installed" : "drift",
+      expected: `>=${PI_MINIMUM_VERSION}`,
+      observed: pi.stdout.trim() || pi.stderr.trim() || "unavailable"
+    }
+  );
+  for (const target of targets.filter(
+    (candidate) => candidate.kind === "package" && candidate.path?.startsWith("npm:")
+  )) {
+    const packageName = target.path?.replace(/^npm:/, "").replace(/@[^@]+$/, "");
+    target.state = packages.exitCode !== 0 ? "unknown" : hasExactInstalledPiPackage(packages.stdout, target.path ?? "") ? "installed" : packageName && packages.stdout.includes(packageName) ? "drift" : "missing";
+    target.observed = packages.exitCode === 0 ? target.state : packages.stderr.trim() || "pi list unavailable";
+  }
+  const receiptOptions = context2.installLedgerOptions ?? {
+    env: context2.env,
+    homeDir: context2.homeDir
+  };
+  const receipt = readPiPackageReceipt(receiptOptions);
+  const configuredPackages = packages.exitCode === 0 ? parsePiPackageList(packages.stdout) : [];
+  const firstPartyPackages = getPiFirstPartyPackages(
+    configuredPackages,
+    receipt.status === "valid" ? receipt.receipt.source : void 0
+  );
+  const ownership = classifyPiPackageOwnership({
+    receipt,
+    globalPackages: firstPartyPackages.filter(({ scope }) => scope === "user"),
+    projectPackages: firstPartyPackages.filter(
+      ({ scope }) => scope === "project"
+    )
+  });
+  targets.push({
+    kind: "file",
+    path: getPiPackageReceiptPath(receiptOptions),
+    label: "First-party Pi ownership receipt",
+    state: receipt.status === "valid" ? "installed" : receipt.status === "missing" ? "missing" : "drift",
+    observed: receipt.status
+  });
+  targets.push({
+    kind: "surface",
+    label: "First-party Pi package ownership",
+    state: ownership.state === "owned-current" ? "installed" : ownership.state === "missing" || ownership.state === "owned-missing" ? "missing" : "drift",
+    expected: "owned-current",
+    observed: ownership.state,
+    description: ownership.reason
+  });
+  let validatedPackageRoot;
+  if (receipt.status === "valid") {
+    const configuredCandidates = firstPartyPackages.filter(
+      ({ scope, source }) => scope === "user" && source === receipt.receipt.source
+    );
+    const configuredPackage = configuredCandidates[0];
+    const configuredPath = configuredPackage?.installedPath;
+    const localPathMatches = receipt.receipt.source === receipt.receipt.installSource || configuredPath !== void 0 && piPackagePathsEqual(configuredPath, receipt.receipt.installSource);
+    const configured = ownership.state === "owned-current" && configuredCandidates.length === 1 && configuredPath !== void 0 && isAbsolute4(configuredPath) && localPathMatches;
+    if (configured) validatedPackageRoot = configuredPath;
+    targets.push({
+      kind: "surface",
+      path: configuredPath,
+      label: "First-party Pi configured source",
+      state: configured ? "installed" : configuredCandidates.length === 0 ? "missing" : "drift",
+      expected: `${receipt.receipt.source} -> ${receipt.receipt.installSource}`,
+      observed: configuredPackage ? `${configuredPackage.source} -> ${configuredPath ?? "unavailable"}` : "unavailable"
+    });
+    const extensionPath = configuredPath ? join12(configuredPath, "dist", "pi.js") : void 0;
+    const manifestPath = configuredPath ? join12(configuredPath, "package.json") : void 0;
+    let receiptMatches = false;
+    if (extensionPath && manifestPath && existsSync15(extensionPath) && existsSync15(manifestPath))
+      receiptMatches = createHash5("sha256").update(readFileSync12(extensionPath)).digest("hex") === receipt.receipt.extensionSha256 && createHash5("sha256").update(readFileSync12(manifestPath)).digest("hex") === receipt.receipt.manifestSha256;
+    targets.push({
+      kind: "surface",
+      path: extensionPath,
+      label: "Native Pi extension loadability",
+      state: receiptMatches ? "installed" : extensionPath ? "drift" : "unknown",
+      observed: receiptMatches ? "loadable" : "unavailable"
+    });
+    targets.push({
+      kind: "surface",
+      label: "Native root observation",
+      state: configured && receiptMatches ? "installed" : "drift",
+      expected: "observed-at-install",
+      observed: configured && receiptMatches ? "observed-at-install (receipt-bound)" : "unobserved"
+    });
+  }
+  const ownedSkills = validatedPackageRoot ? (() => {
+    const inspection = inspectPiPackageSkills({
+      packageRoot: validatedPackageRoot
+    });
+    return inspection.skills.map((skill) => {
+      const issue = inspection.issues.find(({ name }) => name === skill.name) ?? (!inspection.success ? {
+        state: "drift",
+        message: inspection.error ?? "Package-declared Pi skill inspection is unavailable."
+      } : void 0);
+      return {
+        kind: "skill",
+        path: join12(skill.destinationPath, "SKILL.md"),
+        label: `Pi package-declared skill: ${skill.name}`,
+        state: issue?.state ?? "installed",
+        ...issue ? { observed: issue.message } : {}
+      };
+    });
+  })() : THOTH_OWNED_SKILL_NAMES.map((name) => ({
+    kind: "skill",
+    label: `Pi package-declared skill: ${name}`,
+    state: "unknown",
+    observed: "package ownership unavailable"
+  }));
+  targets.push(...ownedSkills);
+  targets.push(
+    getCliManagedInstallVersionTarget("pi", {
+      env: context2.env,
+      homeDir: context2.homeDir
+    })
+  );
+  const fileStates = targets.map((target) => target.state);
+  const state = !plan.ready ? "unknown" : fileStates.includes("missing") ? "missing" : fileStates.includes("drift") ? "drift" : fileStates.includes("unknown") ? "unknown" : "installed";
+  const runtimeEvidence = ["context7", "web-access", "grep"].map(
+    (provider) => ({
+      provider,
+      evidence: researchRuntimeState(provider, targets, evidence)
+    })
+  );
+  targets.push(
+    ...runtimeEvidence.map(
+      ({ provider, evidence: runtime }) => runtimeTarget(provider, runtime)
+    )
+  );
+  const diagnostics = [
+    ...plan.blockers.map(
+      (message) => warning3(message, "pi-preflight-blocked", "critical")
+    ),
+    ...plan.diagnostics.map(
+      (message) => warning3(message, "pi-resource-shadowing")
+    ),
+    ...ownership.state === "configured-unowned" || ownership.state === "conflicting" ? [
+      warning3(
+        ownership.reason ?? `First-party Pi package ownership is ${ownership.state}; remove it manually or restore a matching receipt before Update.`,
+        `pi-first-party-${ownership.state}`,
+        "critical"
+      )
+    ] : ownership.state === "owned-missing" ? [
+      warning3(
+        "The receipt-owned first-party Pi package is not configured; Install or Update may repair it.",
+        "pi-first-party-owned-missing"
+      )
+    ] : [],
+    ...runtimeEvidence.map(
+      ({ provider, evidence: runtime }) => runtimeDiagnostic(provider, runtime)
+    ).filter((item) => item !== void 0)
+  ];
+  return {
+    harness: "pi",
+    displayName: PI_DISPLAY_NAME,
+    state,
+    summary: state === "installed" ? "Pi managed resources are present; native package and remote-provider health remain separately owned." : "Pi setup is missing, drifted, shadowed, or blocked; rerun the complete install after resolving diagnostics.",
+    targets,
+    diagnostics,
+    actions: piActions,
+    disclaimers: disclaimers()
+  };
+}
+function contextPlan(context2, dryRun = true) {
+  const build = context2.buildPiSetupPlan ?? buildPiSetupPlan;
+  const version = resolveExecutingPackageVersion();
+  return build({
+    dryRun,
+    cwd: context2.cwd,
+    env: context2.env,
+    homeDir: context2.homeDir,
+    commandExecutor: context2.piCommandExecutor,
+    packageRoot: context2.packageRoot ?? (version.ok ? version.packageRoot : void 0),
+    expectedVersion: version.ok ? version.version : void 0,
+    receiptOptions: context2.installLedgerOptions
+  });
+}
+function getPiStatus(context2 = { cwd: process.cwd() }, evidence = {}) {
+  const status = statusFromPlan(contextPlan(context2), context2, evidence);
+  return {
+    ...status,
+    providerCapability: classifyProviderCapabilityEvidence(evidence)
+  };
+}
+var planSources = /* @__PURE__ */ new WeakMap();
+function configuredPackageRootFromStatus(status) {
+  const ownership = status.targets.find(
+    ({ label }) => label === "First-party Pi package ownership"
+  );
+  const configured = status.targets.find(
+    ({ label }) => label === "First-party Pi configured source"
+  );
+  return ownership?.observed === "owned-current" && configured?.state === "installed" && configured.path && isAbsolute4(configured.path) ? configured.path : void 0;
+}
+function piPlan(action, context2) {
+  const setup = contextPlan(context2);
+  const status = statusFromPlan(setup, context2);
+  const configuredPackageRoot = configuredPackageRootFromStatus(status);
+  const version = resolveExecutingPackageVersion();
+  const complete = action !== "sync";
+  const items = setup.items.filter(
+    (item) => complete || item.kind === "root" || item.kind === "agent" || item.kind === "mcp"
+  ).map((item) => ({
+    title: item.description,
+    target: {
+      kind: item.kind === "package" ? "package" : item.kind === "mcp" ? "config" : "file",
+      path: item.target,
+      label: item.description
+    },
+    preview: item.command ? `${item.command.command} ${item.command.args.join(" ")}` : `write attributable ${item.kind} surface`,
+    backup: {
+      required: ["root", "agent", "mcp"].includes(item.kind),
+      strategy: "managed-backup-file"
+    }
+  }));
+  items.push({
+    title: "Inspect five package-declared Pi skills",
+    target: { kind: "skill", label: "Pi package-declared skills" },
+    preview: configuredPackageRoot ? getPiOwnedSkillEntries({ packageRoot: configuredPackageRoot }).map((entry) => join12(entry.destinationPath, "SKILL.md")).join(", ") : "unavailable until the first-party Pi package is receipt-validated"
+  });
+  if (complete) {
+    items.push(
+      {
+        title: "Install four required external skills for Pi",
+        target: { kind: "skill", label: "Pi required external skills" },
+        preview: JSON.stringify(
+          REQUIRED_SKILLS.map(
+            (skill) => getRequiredSkillInstallCommand(skill, "pi")
+          ),
+          null,
+          2
+        )
+      },
+      {
+        title: "Run provider-owned thoth-mem setup pi",
+        target: { kind: "surface", label: "Provider setup" },
+        preview: (() => {
+          const cmd = getThothMemSetupCommand("pi", true);
+          return `${cmd.command} ${cmd.args.join(" ")}`;
+        })()
+      },
+      {
+        title: "Record completed Pi CLI install",
+        target: {
+          kind: "file",
+          path: getInstallLedgerPath(
+            context2.installLedgerOptions ?? {
+              env: context2.env,
+              homeDir: context2.homeDir
+            }
+          ),
+          label: "CLI-managed install version"
+        },
+        preview: version.ok ? JSON.stringify({ harness: "pi", version: version.version }) : "unavailable"
+      }
+    );
+  }
+  const ownershipState = status.targets.find(
+    ({ label }) => label === "First-party Pi package ownership"
+  )?.observed;
+  const ownershipBlocked = ownershipState === "configured-unowned" || ownershipState === "conflicting";
+  const ownershipBlockers = ownershipBlocked ? [
+    {
+      kind: "surface",
+      label: "First-party Pi package ownership blocker",
+      state: "drift",
+      observed: `${ownershipState}; remove the configured first-party package manually or restore its matching receipt before applying ${action}.`
+    }
+  ] : [];
+  const syncSkillsUnavailable = action === "sync" && (!configuredPackageRoot || status.targets.some(
+    ({ label, state }) => label?.startsWith("Pi package-declared skill:") && state !== "installed"
+  ));
+  const syncSkillBlockers = syncSkillsUnavailable ? [
+    {
+      kind: "skill",
+      label: "Pi package-declared skill evidence blocker",
+      state: "unknown",
+      observed: "A receipt-validated configured Pi package root with all five manifest-owned skills is required before Sync."
+    }
+  ] : [];
+  const plan = {
+    id: `pi-${action}-preview`,
+    harness: "pi",
+    action,
+    title: `${action === "install" ? "Install" : action === "update" ? "Update" : "Sync"} Pi`,
+    summary: complete ? "Preview complete pinned Pi packages, owned resources, skills, provider setup, and final ledger commit." : "Preview only attributable Pi root, specialist, package-skill evidence, and grep.app surfaces.",
+    dryRun: true,
+    canApply: setup.ready && (!complete || version.ok) && ownershipBlockers.length === 0 && syncSkillBlockers.length === 0,
+    targets: status.targets,
+    blockerTargets: [
+      ...setup.blockers.map((message) => ({
+        kind: "surface",
+        label: "Pi preflight blocker",
+        state: "unknown",
+        observed: message
+      })),
+      ...ownershipBlockers,
+      ...syncSkillBlockers
+    ],
+    surfaces: setup.items.filter((item) => item.kind !== "preflight").map((item) => ({
+      id: `${item.kind}:${item.target}`,
+      label: item.description,
+      path: item.target
+    })),
+    backup: {
+      required: true,
+      strategy: "managed-backup-file",
+      description: "Attributable shared files retain sibling .bak files when replaced; Pi package state remains manager-owned."
+    },
+    items,
+    warnings: status.diagnostics,
+    disclaimers: disclaimers()
+  };
+  if (!version.ok && complete)
+    plan.warnings.push(
+      warning3(
+        version.error.message,
+        "pi-package-version-unresolved",
+        "critical"
+      )
+    );
+  planSources.set(plan, {
+    setup,
+    context: context2,
+    ...version.ok ? { version: version.version } : {},
+    ...configuredPackageRoot ? { configuredPackageRoot } : {}
+  });
+  return plan;
+}
+function buildPiInstallPlan(context2 = { cwd: process.cwd() }) {
+  return piPlan("install", context2);
+}
+function buildPiUpdatePlan(context2 = { cwd: process.cwd() }) {
+  return piPlan("update", context2);
+}
+function buildPiSyncPlan(context2 = { cwd: process.cwd() }) {
+  return piPlan("sync", context2);
+}
+function defaultPiModelRoles(context2 = { cwd: process.cwd() }) {
+  const plan = contextPlan(context2);
+  return getAgentPackContract().roles.filter(
+    (role) => isPiSpecialistRole(role.name)
+  ).map((role) => {
+    const path = plan.items.find(
+      (item) => item.kind === "agent" && basename3(item.target) === `${piSpecialistName(role.name)}.md`
+    )?.target;
+    const content = path && existsSync15(path) ? readFileSync12(path, "utf8") : "";
+    const model = /^model:\s*["']?([^"'\r\n]+)/m.exec(content)?.[1]?.trim();
+    return {
+      role: role.name,
+      model: model && model !== "default" ? model : "inherit",
+      effort: (() => {
+        const value = /^effort:\s*["']?([^"'\r\n]+)/m.exec(content)?.[1]?.trim();
+        return value && value !== "default" && value !== "inherit" ? { kind: "effort", value } : { kind: "inherit" };
+      })()
+    };
+  });
+}
+function buildPiModelPlan(input, context2 = { cwd: process.cwd() }) {
+  const setup = contextPlan(context2);
+  const specialistNames = new Set(
+    getAgentPackContract().roles.filter((role) => role.name !== "orchestrator").map((role) => role.name)
+  );
+  const invalid = input.harness !== "pi" || input.roles.some((role) => !specialistNames.has(role.role));
+  const effortErrors = input.roles.map((role) => ({ role: role.role, resolution: resolvePiEffort(role) })).filter(({ resolution }) => !resolution.ok);
+  const items = input.roles.map((role) => {
+    const specialist = isPiSpecialistRole(role.role) ? piSpecialistName(role.role) : void 0;
+    return {
+      title: `Configure Pi specialist ${role.role}`,
+      target: {
+        kind: "file",
+        path: specialist ? setup.items.find(
+          (item) => item.kind === "agent" && basename3(item.target) === `${specialist}.md`
+        )?.target : void 0,
+        label: `Pi ${role.role} specialist`
+      },
+      preview: JSON.stringify({
+        model: role.model,
+        effort: role.effort ?? null
+      })
+    };
+  });
+  const plan = {
+    id: "pi-model-config-preview",
+    harness: "pi",
+    action: "model-config",
+    title: "Configure Pi specialist models",
+    summary: MODEL_ROOT_LIMITATION,
+    dryRun: true,
+    canApply: setup.ready && !invalid && effortErrors.length === 0 && items.every((item) => Boolean(item.target.path)),
+    targets: items.map((item) => item.target),
+    surfaces: [],
+    backup: { required: true, strategy: "managed-backup-file" },
+    items,
+    warnings: [
+      ...invalid ? [
+        warning3(
+          "Pi model configuration accepts only the six owned specialists and never the ambient orchestrator.",
+          "pi-model-role-unsupported",
+          "critical"
+        )
+      ] : [],
+      ...effortErrors.map(
+        ({ role, resolution }) => warning3(
+          `Pi specialist ${role}: ${resolution.ok ? "" : resolution.message}`,
+          "pi-model-effort-unsupported",
+          "critical"
+        )
+      )
+    ],
+    disclaimers: disclaimers()
+  };
+  planSources.set(plan, { setup, context: context2, model: input });
+  return plan;
+}
+function replaceFrontmatterField(content, field, value) {
+  const newline = content.includes("\r\n") ? "\r\n" : "\n";
+  const lines = content.split(/\r?\n/);
+  if (lines[0]?.trim() !== "---") return content;
+  const end = lines.findIndex(
+    (line, index2) => index2 > 0 && line.trim() === "---"
+  );
+  if (end === -1) return content;
+  const prefix = `${field}:`;
+  const index = lines.slice(1, end).findIndex((line) => line.startsWith(prefix));
+  const absoluteIndex = index === -1 ? -1 : index + 1;
+  const nativeValue = value === void 0 || value === "inherit" ? "default" : value;
+  const replacement = `${field}: ${JSON.stringify(nativeValue)}`;
+  if (absoluteIndex === -1) lines.splice(1, 0, replacement);
+  else lines[absoluteIndex] = replacement;
+  return lines.join(newline);
+}
+function applyPiPlan(plan) {
+  const source = planSources.get(plan);
+  const fileTargets = (paths) => paths.map((path) => ({ kind: "file", path, state: "installed" }));
+  const reject = (message, changedTargets = []) => ({
+    harness: "pi",
+    action: plan.action,
+    applied: false,
+    summary: message,
+    changedTargets,
+    backups: [],
+    warnings: [
+      ...plan.warnings,
+      warning3(message, "pi-apply-rejected", "critical")
+    ],
+    disclaimers: disclaimers()
+  });
+  if (plan.harness !== "pi" || !plan.canApply || !source)
+    return reject(
+      "Pi operation plan is not applicable or was not built in this process."
+    );
+  if (plan.action === "model-config" && source.model) {
+    const changedTargets = [];
+    for (const role of source.model.roles) {
+      const target = plan.items.find((item) => item.title.endsWith(role.role))?.target.path;
+      if (!target || !existsSync15(target))
+        return reject(
+          `Owned Pi specialist definition is missing: ${role.role}.`
+        );
+      let content = readFileSync12(target, "utf8");
+      content = replaceFrontmatterField(content, "model", role.model);
+      content = replaceFrontmatterField(
+        content,
+        "effort",
+        role.effort?.kind === "effort" ? role.effort.value : void 0
+      );
+      writePiManagedText(target, content);
+      changedTargets.push({
+        kind: "file",
+        path: target,
+        label: `Pi ${role.role} specialist`,
+        state: "installed"
+      });
+    }
+    return {
+      harness: "pi",
+      action: plan.action,
+      applied: true,
+      summary: "Applied Pi specialist model configuration; ambient root model remains Pi-owned.",
+      changedTargets,
+      backups: [],
+      warnings: [],
+      disclaimers: disclaimers()
+    };
+  }
+  if (plan.action === "sync") {
+    const fresh = (source.context.buildPiSetupPlan ?? buildPiSetupPlan)({
+      ...source.setup.options,
+      dryRun: false
+    });
+    if (!fresh.ready) return reject(fresh.blockers.join("\n"));
+    const liveStatus = statusFromPlan(
+      contextPlan(source.context),
+      source.context
+    );
+    const packageRoot = configuredPackageRootFromStatus(liveStatus);
+    if (!packageRoot)
+      return reject(
+        "Receipt-validated configured Pi package root is unavailable."
+      );
+    const packageSkills = (source.context.inspectPiPackageSkills ?? inspectPiPackageSkills)({ packageRoot });
+    if (!packageSkills.success)
+      return reject(
+        packageSkills.error ?? "Pi package-declared skills are unavailable."
+      );
+    const changed = [];
+    try {
+      for (const item of fresh.items.filter(
+        (item2) => item2.kind === "mcp" && item2.content !== void 0
+      ))
+        if (writePiManagedText(item.target, item.content ?? ""))
+          changed.push(item.target);
+    } catch (error) {
+      return reject(
+        error instanceof Error ? error.message : String(error),
+        fileTargets(changed)
+      );
+    }
+    const resources = syncPiSpecialists({
+      packageRoot,
+      piRoot: fresh.paths.piRoot,
+      projectRoots: fresh.paths.projectAgentRoots
+    });
+    changed.push(...resources.changed);
+    if (!resources.success)
+      return reject(
+        resources.error ?? "Pi specialist sync failed.",
+        fileTargets(changed)
+      );
+    const migration = migrateLegacyPiResources({
+      packageRoot,
+      piRoot: fresh.paths.piRoot
+    });
+    changed.push(...migration.changed);
+    if (!migration.success)
+      return reject(
+        migration.error ?? "Pi legacy migration failed.",
+        fileTargets(changed)
+      );
+    return {
+      harness: "pi",
+      action: plan.action,
+      applied: true,
+      summary: "Applied attributable Pi managed-surface sync without changing packages, external skills, provider state, or ledger.",
+      changedTargets: fileTargets(changed),
+      diagnosticTargets: packageSkills.skills.map((skill) => ({
+        kind: "skill",
+        path: join12(skill.destinationPath, "SKILL.md"),
+        label: `Pi package-declared skill: ${skill.name}`,
+        state: "installed"
+      })),
+      backups: [],
+      warnings: [],
+      disclaimers: disclaimers()
+    };
+  }
+  if (plan.action === "install" || plan.action === "update") {
+    const fresh = (source.context.buildPiSetupPlan ?? buildPiSetupPlan)({
+      ...source.setup.options,
+      dryRun: false,
+      commandExecutor: source.context.piCommandExecutor
+    });
+    const applied = (source.context.applyPiSetup ?? applyPiSetup)(fresh);
+    const setupTargets = fileTargets(applied.changed);
+    if (!applied.success)
+      return reject(
+        applied.error ?? "Pi package or managed-surface setup failed.",
+        setupTargets
+      );
+    if (!applied.configuredPackageRoot)
+      return reject(
+        "Verified configured Pi package root is unavailable.",
+        setupTargets
+      );
+    const packageSkills = (source.context.inspectPiPackageSkills ?? inspectPiPackageSkills)({ packageRoot: applied.configuredPackageRoot });
+    if (!packageSkills.success)
+      return reject(
+        packageSkills.error ?? "Pi package-declared skills are unavailable.",
+        setupTargets
+      );
+    const installSkill = source.context.installRequiredSkill ?? installRequiredSkill;
+    const skillTargets = [];
+    for (const skill of REQUIRED_SKILLS) {
+      const installed = installSkill(skill, "pi", {
+        homeDir: source.context.homeDir
+      });
+      if (installed.status === "failed")
+        return reject(`Failed to install required Pi skill: ${skill.name}.`, [
+          ...setupTargets,
+          ...skillTargets
+        ]);
+      skillTargets.push({
+        kind: "skill",
+        path: installed.skillPath,
+        label: `Pi required skill: ${skill.name}`,
+        state: "installed"
+      });
+    }
+    if (!source.version)
+      return reject("Executing thoth-agents package version is unavailable.");
+    const finalize = source.context.finalizeHarnessInstall ?? finalizeHarnessInstall;
+    const completion = finalize({
+      harness: "pi",
+      version: source.version,
+      dryRun: false,
+      cwd: source.context.cwd,
+      runThothMemSetup: source.context.runThothMemSetup,
+      ledgerOptions: source.context.installLedgerOptions ?? {
+        env: source.context.env,
+        homeDir: source.context.homeDir
+      }
+    });
+    if (!completion.success)
+      return reject(
+        completion.error ?? "Pi provider setup or ledger commit failed.",
+        [...setupTargets, ...skillTargets]
+      );
+    return {
+      harness: "pi",
+      action: plan.action,
+      applied: true,
+      summary: `Applied complete ordered Pi ${plan.action} including provider evidence and final ledger commit.`,
+      changedTargets: [
+        ...setupTargets,
+        ...skillTargets,
+        {
+          kind: "file",
+          path: completion.ledger.path,
+          label: "CLI-managed install version",
+          state: "installed"
+        }
+      ],
+      diagnosticTargets: packageSkills.skills.map((skill) => ({
+        kind: "skill",
+        path: join12(skill.destinationPath, "SKILL.md"),
+        label: `Pi package-declared skill: ${skill.name}`,
+        state: "installed"
+      })),
+      backups: [],
+      warnings: [],
+      disclaimers: disclaimers()
+    };
+  }
+  return reject(`Unsupported Pi apply action: ${plan.action}.`);
+}
+
+// src/cli/operations/index.ts
+var OPERATION_HARNESSES = {
+  opencode: opencodeOperationAdapter,
+  codex: codexOperationAdapter,
+  claude: claudeCodeOperationAdapter,
+  pi: piOperationAdapter
+};
+var SUPPORTED_OPERATION_HARNESSES = Object.keys(
+  OPERATION_HARNESSES
+);
+function listOperationHarnesses() {
+  return SUPPORTED_OPERATION_HARNESSES.map(
+    (harness) => OPERATION_HARNESSES[harness]
+  );
+}
+function getOperationHarness(harness) {
+  return OPERATION_HARNESSES[harness];
+}
+
+// src/cli/tui/model-catalog.ts
+import { execFileSync } from "child_process";
+
+// src/cli/model-catalog/cache.ts
+import {
+  existsSync as existsSync16,
+  mkdirSync as mkdirSync8,
+  readFileSync as readFileSync13,
+  renameSync as renameSync7,
+  unlinkSync,
+  writeFileSync as writeFileSync8
+} from "fs";
+import { homedir as homedir7 } from "os";
+import { dirname as dirname10, posix, win32 } from "path";
+import { z as z2 } from "zod";
+var modelCatalogSourceSchema = z2.enum(["remote", "lkg", "manual"]);
+var cachedModelOptionSchema = z2.object({
+  id: z2.string().min(1),
+  catalogId: z2.string().min(1).optional(),
+  label: z2.string().min(1),
+  provider: z2.string().min(1),
+  efforts: z2.array(z2.string().min(1)),
+  source: modelCatalogSourceSchema
+}).passthrough();
+var modelsDevCacheSchema = z2.object({
+  version: z2.literal(1),
+  etag: z2.string().optional(),
+  fetchedAt: z2.string().datetime(),
+  catalog: z2.object({ models: z2.array(cachedModelOptionSchema) }).passthrough()
+}).passthrough();
+function resolveModelsDevCachePath(options = {}) {
+  const platform = options.platform ?? process.platform;
+  const env = options.env ?? process.env;
+  const home = options.homeDir ?? homedir7();
+  if (platform === "win32") {
+    const path = win32;
+    const base2 = env.LOCALAPPDATA ?? env.APPDATA ?? path.join(home, "AppData", "Local");
+    return path.join(base2, "thoth-agents", "models-dev-v1.json");
+  }
+  const base = env.XDG_CACHE_HOME ?? posix.join(home, ".cache");
+  return posix.join(base, "thoth-agents", "models-dev-v1.json");
+}
+function readModelsDevCache(cachePath) {
+  if (!existsSync16(cachePath)) return void 0;
+  try {
+    const input = JSON.parse(readFileSync13(cachePath, "utf8"));
+    const parsed = modelsDevCacheSchema.safeParse(input);
+    return parsed.success ? parsed.data : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function writeModelsDevCacheAtomic(cachePath, cache) {
+  const validated = modelsDevCacheSchema.safeParse(cache);
+  if (!validated.success) {
+    throw new Error(`Invalid models.dev cache: ${validated.error.message}`);
+  }
+  mkdirSync8(dirname10(cachePath), { recursive: true });
+  const temporaryPath = `${cachePath}.${process.pid}.${Date.now()}.tmp`;
+  try {
+    writeFileSync8(
+      temporaryPath,
+      `${JSON.stringify(validated.data, null, 2)}
+`
+    );
+    renameSync7(temporaryPath, cachePath);
+  } catch (error) {
+    if (existsSync16(temporaryPath)) unlinkSync(temporaryPath);
+    throw error;
+  }
+}
+
+// src/cli/model-catalog/models-dev.ts
+import { z as z3 } from "zod";
+var modelsDevModelSchema = z3.object({
+  id: z3.string().min(1).optional(),
+  name: z3.string().min(1).optional(),
+  reasoning: z3.boolean().optional(),
+  reasoning_options: z3.array(z3.unknown()).optional()
+}).passthrough();
+var modelsDevProviderSchema = z3.object({
+  models: z3.record(z3.string(), modelsDevModelSchema)
+}).passthrough();
+var modelsDevCatalogSchema = z3.record(
+  z3.string(),
+  modelsDevProviderSchema
+);
+var effortOptionSchema = z3.object({
+  type: z3.literal("effort"),
+  values: z3.array(z3.string().min(1))
+}).passthrough();
+function normalizedCatalogId(provider, modelKey, declaredId) {
+  const candidate = (declaredId ?? modelKey).trim().toLowerCase();
+  return candidate.includes("/") ? candidate : `${provider}/${candidate}`;
+}
+function runtimeModelId(provider, catalogId) {
+  const prefix = `${provider}/`;
+  return catalogId.startsWith(prefix) ? catalogId.slice(prefix.length) : catalogId;
+}
+function effortValues(options) {
+  const values = /* @__PURE__ */ new Set();
+  for (const option of options ?? []) {
+    const parsed = effortOptionSchema.safeParse(option);
+    if (!parsed.success) continue;
+    for (const value of parsed.data.values) {
+      const normalized = value.trim();
+      if (normalized) values.add(normalized);
+    }
+  }
+  return [...values];
+}
+function normalizeModelsDevCatalog(input) {
+  const parsed = modelsDevCatalogSchema.safeParse(input);
+  if (!parsed.success) {
+    return {
+      ok: false,
+      issues: parsed.error.issues.map(
+        (issue) => `${issue.path.join(".") || "<root>"}: ${issue.message}`
+      )
     };
   }
   const models = [];
@@ -7137,6 +9210,7 @@ var CODEX_DOCUMENTED_EFFORTS2 = /* @__PURE__ */ new Set([
   "ultra"
 ]);
 var CLAUDE_CODE_EFFORTS2 = ["low", "medium", "high", "xhigh", "max"];
+var PI_EFFORTS2 = new Set(PI_EFFORT_VALUES);
 function parseOpenCodeModels(output) {
   const seen = /* @__PURE__ */ new Set();
   const options = [];
@@ -7172,6 +9246,9 @@ function writableEfforts(harness, option) {
       (effort) => CLAUDE_CODE_EFFORTS2.includes(effort)
     );
   }
+  if (harness === "pi") {
+    return option.efforts.filter((effort) => PI_EFFORTS2.has(effort));
+  }
   return option.efforts.filter(
     (effort) => resolveOpenCodeEffort({
       model: option.id,
@@ -7246,6 +9323,12 @@ async function getModelOptions(harness) {
       efforts: writableEfforts(harness, option)
     }));
   }
+  if (harness === "pi") {
+    return loaded.models.map((option) => ({
+      ...option,
+      efforts: writableEfforts(harness, option)
+    }));
+  }
   const catalogById = new Map(
     loaded.models.map((option) => [option.catalogId ?? option.id, option])
   );
@@ -7257,7 +9340,7 @@ async function getModelOptions(harness) {
 }
 
 // src/cli/tui/operations.ts
-import { existsSync as existsSync12, readFileSync as readFileSync9 } from "fs";
+import { existsSync as existsSync17, readFileSync as readFileSync14 } from "fs";
 var context = { cwd: process.cwd() };
 var codexContext = { cwd: process.cwd() };
 var claudeCodeContext = {
@@ -7299,7 +9382,7 @@ function getCodexModelRoles(source = codexContext) {
       const item = plan.items.find(
         (candidate) => candidate.action === "write-role-toml" && candidate.role === role
       );
-      const content = item && existsSync12(item.targetPath) ? readFileSync9(item.targetPath, "utf8") : item?.content;
+      const content = item && existsSync17(item.targetPath) ? readFileSync14(item.targetPath, "utf8") : item?.content;
       const effort = content ? parseRoleTomlEffort(content) : void 0;
       return {
         role,
@@ -7314,6 +9397,9 @@ function getCodexModelRoles(source = codexContext) {
 function getClaudeCodeModelRoles(_source = claudeCodeContext) {
   return defaultClaudeCodeModelRoles();
 }
+function getPiModelRoles() {
+  return defaultPiModelRoles(context);
+}
 function readRoleField(config, role, field) {
   if (!config || typeof config !== "object" || Array.isArray(config)) {
     return void 0;
@@ -7356,6 +9442,9 @@ function buildTuiModelPlan(harness, roles) {
       claudeCodeContext
     );
   }
+  if (harness === "pi") {
+    return buildPiModelPlan({ harness, dryRun: true, roles }, context);
+  }
   return buildCodexModelPlan({ harness, dryRun: true, roles }, codexContext);
 }
 var defaultTuiOperations = {
@@ -7364,6 +9453,7 @@ var defaultTuiOperations = {
     if (harness === "claude") {
       return getClaudeCodeStatus(claudeCodeContext, evidence);
     }
+    if (harness === "pi") return getPiStatus(context, evidence);
     return getCodexStatus(codexContext, evidence);
   },
   modelRoles(harness) {
@@ -7371,6 +9461,7 @@ var defaultTuiOperations = {
     if (harness === "claude") {
       return getClaudeCodeModelRoles(claudeCodeContext);
     }
+    if (harness === "pi") return getPiModelRoles();
     return getCodexModelRoles(codexContext);
   },
   modelOptions(harness) {
@@ -7396,6 +9487,12 @@ var defaultTuiOperations = {
         getClaudeCodeModelRoles(claudeCodeContext)
       );
     }
+    if (harness === "pi") {
+      if (action === "install") return buildPiInstallPlan(context);
+      if (action === "update") return buildPiUpdatePlan(context);
+      if (action === "sync") return buildPiSyncPlan(context);
+      return buildTuiModelPlan(harness, getPiModelRoles());
+    }
     if (action === "install") return buildCodexInstallPlan(codexContext);
     if (action === "update") return buildCodexUpdatePlan(codexContext);
     if (action === "sync") return buildCodexSyncPlan(codexContext);
@@ -7407,6 +9504,7 @@ var defaultTuiOperations = {
   apply(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);
   }
 };
@@ -7425,8 +9523,13 @@ export {
   buildCodexPluginSetupPlan,
   applyCodexPluginSetup,
   formatCodexPluginSetupPlan,
+  recordHarnessInstallCompletion,
   finalizeHarnessInstall,
   syncOpenCodeOwnedSkills,
+  inspectPiPackageSkills,
+  buildPiSetupPlan,
+  formatPiSetupPlan,
+  applyPiSetup,
   REQUIRED_SKILLS,
   getRequiredSkillInstallCommand,
   installRequiredSkill,
@@ -7446,6 +9549,12 @@ export {
   buildOpenCodeSyncPlan,
   buildOpenCodeModelPlan,
   applyOpenCodePlan,
+  getPiStatus,
+  buildPiUpdatePlan,
+  buildPiSyncPlan,
+  defaultPiModelRoles,
+  buildPiModelPlan,
+  applyPiPlan,
   SUPPORTED_OPERATION_HARNESSES,
   listOperationHarnesses,
   getOperationHarness,
@@ -7453,6 +9562,7 @@ export {
   getModelOptions,
   getCodexModelRoles,
   getClaudeCodeModelRoles,
+  getPiModelRoles,
   getOpenCodeModelRoles,
   defaultTuiOperations
 };