thoth-agents 0.4.1 → 0.5.0

package/dist/{chunk-2D7E7GMP.js → chunk-VUNYH263.js}

@@ -4,13 +4,19 @@ import {
   exa
 } from "./chunk-62L3ORXN.js";
 import {
+  PI_EFFORT_VALUES,
   PI_MANAGED_OWNER,
   PI_ROOT_END,
   PI_ROOT_START,
+  assertSafePiManagedPath,
   piAdapter,
+  readPiModelConfig,
   renderConfiguredRolePrompt,
-  syncPiSpecialists
-} from "./chunk-2U5MBLLV.js";
+  resolvePiEffort,
+  savePiModelConfig,
+  syncPiSpecialists,
+  writePiManagedText
+} from "./chunk-V7HSGRMB.js";
 import {
   ALL_AGENT_NAMES,
   CLAUDE_CODE_PROMPT_DIALECT,
@@ -19,6 +25,7 @@ import {
   CONFIRMED_OPENAI_SUBAGENT_PRESET,
   DEFAULT_MODELS,
   PI_SPECIALIST_ROLES,
+  SUBAGENT_NAMES,
   claudeCodeSubagentType,
   ensureConfigDir,
   findPackageRoot,
@@ -40,7 +47,7 @@ import {
   updateOpenCodeMainConfig,
   writeConfig,
   writeLiteConfig
-} from "./chunk-EFGSGPYM.js";
+} from "./chunk-OW6I7ZUU.js";
 
 // src/cli/codex-paths.ts
 import { homedir } from "os";
@@ -50,8 +57,7 @@ var CODEX_ROLE_NAMES = [
   "librarian",
   "oracle",
   "designer",
-  "quick",
-  "deep"
+  "worker"
 ];
 function getCodexHome(options = {}) {
   const explicit = options.codexHome ?? process.env.CODEX_HOME?.trim();
@@ -92,8 +98,9 @@ function isExplicitEffort(selection) {
 }
 
 // src/cli/codex-install.ts
-import { existsSync as existsSync4, readFileSync as readFileSync4 } from "fs";
-import { basename } from "path";
+import { createHash as createHash2 } from "crypto";
+import { existsSync as existsSync4, lstatSync, readFileSync as readFileSync4, rmSync } from "fs";
+import { basename, dirname as dirname4, parse, resolve as resolve2 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 
 // src/harness/adapters/codex.ts
@@ -1019,7 +1026,7 @@ function createCodexPluginPackageManifest(context2) {
   return {
     name: "thoth-agents",
     version: readRootPackageVersion(context2),
-    description: "Bundled Spec Kit-compatible SDD skills and MCP configuration; the seven-role global Codex layer requires thoth-agents CLI setup."
+    description: "Bundled AI-first work skills and MCP configuration; the six-role global Codex layer requires thoth-agents CLI setup."
   };
 }
 function stableJson2(value) {
@@ -1064,7 +1071,7 @@ function codexRuntimeGuidance() {
   return [
     "<codex-runtime>",
     "- The ambient Codex session is the adaptive root; no orchestrator child TOML is generated.",
-    "- Delegate with `collaboration.spawn_agent` only when the root determines that specialization, context isolation, review, or independent parallel work creates a net gain.",
+    "- When delegation is selected under the shared ownership policy, use `collaboration.spawn_agent`; honor explicit direct-work instructions.",
     "- Collaboration tools are direct tools and must not be called from inside `functions.exec`.",
     "- When the active `collaboration.spawn_agent` schema exposes `agent_type`, set it to the selected canonical role. When it does not, use a role-prefixed `task_name` plus a self-contained bounded envelope; that fallback is instruction-only.",
     "- Keep maximum depth 1: children do not delegate. Use one writer per mutable surface and parallelize only independent work.",
@@ -1496,6 +1503,90 @@ function readManagedModelState(path, version) {
 var ROOT_START = "<!-- thoth-agents:codex-root:start -->";
 var ROOT_END = "<!-- thoth-agents:codex-root:end -->";
 var MANAGED_MODEL_STATE_VERSION = 1;
+var OBSOLETE_CODEX_ROLES = ["quick", "deep"];
+var RECOVERY_FILE = ".thoth-agents-install-recovery.json";
+function lstatIfPresent(path) {
+  try {
+    return lstatSync(path);
+  } catch (error) {
+    if (error.code === "ENOENT") return void 0;
+    throw error;
+  }
+}
+function fingerprint(content) {
+  return createHash2("sha256").update(content).digest("hex");
+}
+function assertSafeCodexRolePath(path, agentsDir) {
+  const absolute = resolve2(path);
+  const expectedParent = resolve2(agentsDir);
+  if (dirname4(absolute) !== expectedParent)
+    throw new Error(
+      `Unsafe Codex role path outside managed agents directory: ${path}`
+    );
+  const root = parse(absolute).root;
+  const ancestors = [];
+  let cursor = dirname4(absolute);
+  while (cursor !== root) {
+    ancestors.push(cursor);
+    cursor = dirname4(cursor);
+  }
+  ancestors.push(root);
+  for (const ancestor of ancestors.reverse()) {
+    const stat2 = lstatIfPresent(ancestor);
+    if (!stat2) continue;
+    if (stat2.isSymbolicLink())
+      throw new Error(
+        `Managed Codex role path has a symlinked parent: ${ancestor}`
+      );
+    if (!stat2.isDirectory())
+      throw new Error(
+        `Managed Codex role path parent is not a directory: ${ancestor}`
+      );
+  }
+  const stat = lstatIfPresent(absolute);
+  if (!stat) return;
+  if (stat.isSymbolicLink())
+    throw new Error(`Managed Codex role target is a symlink: ${absolute}`);
+  if (!stat.isFile())
+    throw new Error(
+      `Managed Codex role target is not a regular file: ${absolute}`
+    );
+}
+function addApplyGuard(item) {
+  if (!lstatIfPresent(item.targetPath))
+    return { ...item, expectedAbsent: true };
+  return { ...item, expectedContent: readFileSync4(item.targetPath, "utf8") };
+}
+function assertApplyGuard(item) {
+  if (item.expectedAbsent) {
+    if (lstatIfPresent(item.targetPath))
+      throw new Error(
+        `Managed Codex target appeared after planning: ${item.targetPath}`
+      );
+    return;
+  }
+  if (item.expectedContent !== void 0) {
+    if (!lstatIfPresent(item.targetPath) || readFileSync4(item.targetPath, "utf8") !== item.expectedContent)
+      throw new Error(
+        `Managed Codex target changed after planning: ${item.targetPath}`
+      );
+  }
+}
+function readInstallRecovery(path) {
+  if (!lstatIfPresent(path)) return void 0;
+  const raw = JSON.parse(readFileSync4(path, "utf8"));
+  if (!raw || typeof raw !== "object" || Array.isArray(raw))
+    throw new Error(`Corrupt Codex install recovery state: ${path}`);
+  const value = raw;
+  if (value.version !== 1 || !value.roles || typeof value.roles !== "object" || Array.isArray(value.roles))
+    throw new Error(`Corrupt Codex install recovery state: ${path}`);
+  const roles = Object.fromEntries(Object.entries(value.roles));
+  if (Object.values(roles).some(
+    (hash) => typeof hash !== "string" || !/^[a-f0-9]{64}$/.test(hash)
+  ))
+    throw new Error(`Corrupt Codex install recovery state: ${path}`);
+  return { version: 1, roles };
+}
 function mergeManagedBlock(existing, managedBlock) {
   const start = existing.indexOf(ROOT_START);
   const end = existing.indexOf(ROOT_END);
@@ -1713,8 +1804,82 @@ function buildCodexSetupPlan(config) {
     ...packageRoot ? { packageRoot } : {}
   });
   const rootBlock = renderCodexRootInstructions();
+  const agentsDir = dirname4(
+    targets.roleAgentPaths[0]?.path ?? targets.managedModelsPath
+  );
+  const recoveryPath = resolve2(agentsDir, RECOVERY_FILE);
+  assertSafeCodexRolePath(targets.managedModelsPath, agentsDir);
+  assertSafeCodexRolePath(recoveryPath, agentsDir);
+  for (const target of targets.roleAgentPaths)
+    assertSafeCodexRolePath(target.path, agentsDir);
   const managedModelState2 = readManagedModelState2(targets.managedModelsPath);
+  const recovery = readInstallRecovery(recoveryPath);
   const nextManagedModelState = emptyManagedModelState2();
+  const roleItems = targets.roleAgentPaths.map(
+    (target) => addApplyGuard({
+      kind: "role-subagent-toml",
+      action: "write-role-toml",
+      targetPath: target.path,
+      description: `Materialize Codex role subagent ${target.role}.`,
+      requiresBackup: Boolean(lstatIfPresent(target.path)),
+      role: target.role,
+      renderedModel: parseRoleTomlModel(
+        roleArtifactContent(target.role, render.artifacts)
+      ),
+      content: resolveRoleTomlContent({
+        renderedContent: roleArtifactContent(target.role, render.artifacts),
+        targetPath: target.path,
+        state: managedModelState2,
+        nextState: nextManagedModelState,
+        reset: config.reset
+      })
+    })
+  );
+  const recoveryRoles = Object.fromEntries(
+    roleItems.map((item) => [
+      roleManagedModelStateKey(item.targetPath),
+      fingerprint(item.content ?? "")
+    ])
+  );
+  for (const item of roleItems) {
+    if (item.role !== "worker" || !lstatIfPresent(item.targetPath)) continue;
+    const key = roleManagedModelStateKey(item.targetPath);
+    const ownedByLedger = key in managedModelState2.models;
+    const contentHash = fingerprint(readFileSync4(item.targetPath, "utf8"));
+    const recoverable = recovery?.roles[key] === contentHash && recoveryRoles[key] === contentHash;
+    if (!ownedByLedger && !recoverable)
+      throw new Error(
+        `Existing Worker Codex role lacks thoth-agents ownership state or a trustworthy recovery fingerprint: ${item.targetPath}. Move or remove it explicitly before retrying.`
+      );
+  }
+  if (recovery) {
+    const expectedKeys = Object.keys(recoveryRoles).sort();
+    if (JSON.stringify(Object.keys(recovery.roles).sort()) !== JSON.stringify(expectedKeys) || expectedKeys.some((key) => recovery.roles[key] !== recoveryRoles[key]))
+      throw new Error(
+        `Codex install recovery state does not match this package: ${recoveryPath}`
+      );
+  }
+  const obsoleteItems = OBSOLETE_CODEX_ROLES.flatMap(
+    (role) => {
+      const targetPath = resolve2(agentsDir, `thoth-agents-${role}.toml`);
+      assertSafeCodexRolePath(targetPath, agentsDir);
+      if (!lstatIfPresent(targetPath)) return [];
+      const key = roleManagedModelStateKey(targetPath);
+      if (!(key in managedModelState2.models))
+        throw new Error(
+          `Obsolete Codex role lacks thoth-agents ownership state and was preserved: ${targetPath}. Remove it explicitly before retrying.`
+        );
+      return [
+        addApplyGuard({
+          kind: "role-subagent-toml",
+          action: "retire-obsolete-role-toml",
+          targetPath,
+          description: `Retire attributable obsolete Codex role ${role}.`,
+          requiresBackup: false
+        })
+      ];
+    }
+  );
   const items = [
     {
       kind: "root-instructions",
@@ -1724,34 +1889,24 @@ function buildCodexSetupPlan(config) {
       requiresBackup: true,
       content: rootBlock
     },
-    ...targets.roleAgentPaths.map(
-      (target) => ({
-        kind: "role-subagent-toml",
-        action: "write-role-toml",
-        targetPath: target.path,
-        description: `Materialize Codex role subagent ${target.role}.`,
-        requiresBackup: existsSync4(target.path),
-        role: target.role,
-        renderedModel: parseRoleTomlModel(
-          roleArtifactContent(target.role, render.artifacts)
-        ),
-        content: resolveRoleTomlContent({
-          renderedContent: roleArtifactContent(target.role, render.artifacts),
-          targetPath: target.path,
-          state: managedModelState2,
-          nextState: nextManagedModelState,
-          reset: config.reset
-        })
-      })
-    ),
-    {
+    addApplyGuard({
+      kind: "install-recovery",
+      action: "write-install-recovery",
+      targetPath: recoveryPath,
+      description: "Persist exact role fingerprints for interrupted-install recovery.",
+      requiresBackup: Boolean(lstatIfPresent(recoveryPath)),
+      content: stableJson3({ version: 1, roles: recoveryRoles })
+    }),
+    ...roleItems,
+    ...obsoleteItems,
+    addApplyGuard({
       kind: "managed-model-state",
       action: "write-managed-model-state",
       targetPath: targets.managedModelsPath,
       description: "Record thoth-agents-managed Codex role model ownership state.",
       requiresBackup: existsSync4(targets.managedModelsPath),
       content: stableJson3(nextManagedModelState)
-    },
+    }),
     {
       kind: "user-config",
       action: "merge-toml",
@@ -1801,8 +1956,32 @@ function applyCodexSetup(plan) {
   ]);
   if (plan.dryRun) return { success: true, changed, diagnostics };
   try {
+    const stateItem = plan.items.find(
+      (item) => item.action === "write-managed-model-state"
+    );
+    if (!stateItem)
+      throw new Error("Codex managed model state item is missing from plan.");
+    const agentsDir = dirname4(stateItem.targetPath);
+    for (const item of plan.items) {
+      if (item.action === "write-role-toml" || item.action === "retire-obsolete-role-toml" || item.action === "write-install-recovery" || item.action === "write-managed-model-state") {
+        assertSafeCodexRolePath(item.targetPath, agentsDir);
+        assertApplyGuard(item);
+      }
+    }
     for (const item of plan.items) {
       if (item.action === "diagnose-only") continue;
+      if (item.action === "retire-obsolete-role-toml") {
+        const agentsDir2 = dirname4(item.targetPath);
+        assertSafeCodexRolePath(item.targetPath, agentsDir2);
+        assertApplyGuard(item);
+        assertSafeCodexRolePath(stateItem.targetPath, agentsDir2);
+        assertApplyGuard(stateItem);
+        if (existsSync4(item.targetPath)) {
+          rmSync(item.targetPath);
+          changed.push(item.targetPath);
+        }
+        continue;
+      }
       if (item.action === "merge-toml") {
         const result = writeCodexConfigMerge({
           configPath: item.targetPath,
@@ -1815,12 +1994,29 @@ function applyCodexSetup(plan) {
         continue;
       }
       if (item.content === void 0) continue;
+      if (item.action === "write-role-toml" || item.action === "write-install-recovery" || item.action === "write-managed-model-state") {
+        assertSafeCodexRolePath(item.targetPath, agentsDir);
+        assertApplyGuard(item);
+      }
       const content = item.action === "merge-managed-block" ? mergeManagedBlock(
         existsSync4(item.targetPath) ? readFileSync4(item.targetPath, "utf8") : "",
         item.content
       ) : item.content;
       if (writeTextWithBackup(item.targetPath, content))
         changed.push(item.targetPath);
+      if (item.action === "write-managed-model-state") {
+        const recoveryItem = plan.items.find(
+          (candidate) => candidate.action === "write-install-recovery"
+        );
+        if (!recoveryItem?.content)
+          throw new Error("Codex install recovery item is missing from plan.");
+        assertSafeCodexRolePath(recoveryItem.targetPath, agentsDir);
+        if (!lstatIfPresent(recoveryItem.targetPath) || readFileSync4(recoveryItem.targetPath, "utf8") !== recoveryItem.content)
+          throw new Error(
+            `Codex install recovery state changed before completion: ${recoveryItem.targetPath}`
+          );
+        rmSync(recoveryItem.targetPath);
+      }
     }
     return { success: true, changed, diagnostics: uniqueMessages(diagnostics) };
   } catch (error) {
@@ -1840,7 +2036,7 @@ import { existsSync as existsSync7 } from "fs";
 import { fileURLToPath as fileURLToPath3 } from "url";
 
 // src/harness/writers/claude-code-plugin-package.ts
-import { createHash as createHash2 } from "crypto";
+import { createHash as createHash3 } from "crypto";
 var CLAUDE_PLUGIN_MANIFEST_FIELDS = [
   "name",
   "version",
@@ -1857,7 +2053,7 @@ function stableJson4(value) {
 `;
 }
 function sha256Hash(content) {
-  return `sha256:${createHash2("sha256").update(content).digest("hex")}`;
+  return `sha256:${createHash3("sha256").update(content).digest("hex")}`;
 }
 function withoutProviderAsset(artifact) {
   if (!normalizePath2(artifact.path).endsWith(".mcp.json")) return artifact;
@@ -1951,14 +2147,12 @@ var CLAUDE_CODE_SUBAGENT_DEFAULT_MODELS = {
   librarian: "sonnet",
   oracle: "opus",
   designer: "sonnet",
-  quick: "haiku",
-  deep: "sonnet"
+  worker: "sonnet"
 };
 var CLAUDE_CODE_SUBAGENT_DEFAULT_EFFORTS = {
   explorer: "low",
-  quick: "low",
   designer: "medium",
-  deep: "medium",
+  worker: "medium",
   librarian: "high",
   oracle: "high"
 };
@@ -2012,7 +2206,7 @@ function renderClaudeCodeRootInstructions(config) {
     rootPrompt,
     "<claude-code-runtime>",
     "- You are the Claude Code adaptive root activated by plugin settings.json.",
-    `- Delegate only for net gain through Agent with \`subagent_type\` set to one of these plugin-namespaced specialists: ${specialists}. Always keep the ${CLAUDE_CODE_SUBAGENT_NAMESPACE}: prefix.`,
+    `- When delegation is selected, use Agent with \`subagent_type\`: ${specialists}. Honor shared ownership and explicit direct-work instructions. Keep the ${CLAUDE_CODE_SUBAGENT_NAMESPACE}: prefix.`,
     "- Subagents cannot delegate further. Parallelize only independent work and maintain one writer per mutable surface.",
     "- Read-only roles deny Write and Edit while retaining other inherited tools, including MCP tools. Coordination-agent path scope remains instruction-level.",
     "- Use AskUserQuestion only for blocking material choices and TodoWrite only for genuine multi-step progress.",
@@ -2055,7 +2249,7 @@ function createPluginManifest(context2) {
   return {
     name: "thoth-agents",
     version: readRootPackageVersion2(context2),
-    description: "Adaptive multi-harness agent pack with seven roles and a runtime-autonomous Spec Kit-compatible SDD bundle for Claude Code.",
+    description: "Adaptive multi-harness agent pack with six roles and proportional SDD governance for Claude Code.",
     author: { name: "thoth-agents" }
   };
 }
@@ -2088,7 +2282,7 @@ function renderOrchestratorArtifact(config) {
   );
   const content = renderClaudeCodeSubagent({
     name: "orchestrator",
-    description: orchestrator?.responsibility ?? "Adaptive root coordinator for direct work, SDD routing, and specialist dispatch.",
+    description: orchestrator?.responsibility ?? "Adaptive root coordinator for human agreement, SDD classification, and specialist dispatch.",
     model: "inherit",
     instructions: renderClaudeCodeRootInstructions(config)
   });
@@ -2145,8 +2339,7 @@ var CLAUDE_CODE_ROLE_NAMES = [
   "librarian",
   "oracle",
   "designer",
-  "quick",
-  "deep"
+  "worker"
 ];
 
 // src/cli/claude-code-install.ts
@@ -2452,11 +2645,11 @@ import {
   mkdirSync as mkdirSync3,
   readFileSync as readFileSync5,
   renameSync as renameSync2,
-  rmSync,
+  rmSync as rmSync2,
   writeFileSync as writeFileSync3
 } from "fs";
 import { homedir as homedir2 } from "os";
-import { dirname as dirname4, join as join2 } from "path";
+import { dirname as dirname5, join as join2 } from "path";
 var INSTALL_LEDGER_SCHEMA_VERSION = 1;
 var INSTALL_HARNESSES = /* @__PURE__ */ new Set([
   "opencode",
@@ -2536,7 +2729,7 @@ function recordCompletedInstall(options) {
   const repairedInvalidState = current.status === "invalid";
   const backupPath = repairedInvalidState ? `${path}.bak` : void 0;
   try {
-    mkdirSync3(dirname4(path), { recursive: true });
+    mkdirSync3(dirname5(path), { recursive: true });
     writeFileSync3(temporaryPath, `${JSON.stringify(ledger, null, 2)}
 `);
     if (backupPath) copyFileSync3(path, backupPath);
@@ -2550,7 +2743,7 @@ function recordCompletedInstall(options) {
     };
   } catch (error) {
     try {
-      rmSync(temporaryPath, { recursive: true, force: true });
+      rmSync2(temporaryPath, { recursive: true, force: true });
     } catch {
     }
     return {
@@ -2616,6 +2809,7 @@ function parseProviderSetupResult(stdout, expectedHarness) {
 }
 function defaultCommandExecutor2(command, args, options) {
   const result = spawnSync2(command, [...args], {
+    windowsHide: true,
     cwd: options.cwd,
     encoding: "utf8",
     stdio: ["ignore", "pipe", "pipe"],
@@ -2901,7 +3095,10 @@ function installRequiredSkill(skill, harness, options = {}) {
     options
   );
   try {
-    const result = spawnSync3(command, args, { stdio: "inherit" });
+    const result = spawnSync3(command, args, {
+      windowsHide: true,
+      stdio: "inherit"
+    });
     if (result.status === 0) {
       return {
         skill,
@@ -3613,13 +3810,13 @@ import { basename as basename2 } from "path";
 // src/cli/codex-plugin-install.ts
 import { spawnSync as spawnSync4 } from "child_process";
 import {
-  lstatSync,
+  lstatSync as lstatSync2,
   readdirSync,
   readFileSync as readFileSync6,
   realpathSync,
-  rmSync as rmSync2
+  rmSync as rmSync3
 } from "fs";
-import { isAbsolute, join as join4, relative, resolve as resolve2, sep } from "path";
+import { isAbsolute, join as join4, relative, resolve as resolve3, sep } from "path";
 var PLUGIN_NAME2 = "thoth-agents";
 var MARKETPLACE_NAME2 = "thoth-plugins";
 var MARKETPLACE_SOURCE2 = "https://github.com/EremesNG/thoth-plugins.git";
@@ -3693,9 +3890,9 @@ function parseManagerRecord(content) {
 function normalizeMarketplaceSource2(value) {
   return value.trim().replace(/#.*$/u, "").replace(/^git@github\.com:/i, "").replace(/^(?:https?|ssh):\/\/(?:git@)?github\.com\//i, "").replace(/^github\.com\//i, "").replace(/\/?\.git\/?$/i, "").replace(/\/$/, "").toLowerCase();
 }
-function lstatIfPresent(path) {
+function lstatIfPresent2(path) {
   try {
-    return lstatSync(path);
+    return lstatSync2(path);
   } catch (error) {
     if (error && typeof error === "object" && "code" in error && error.code === "ENOENT") {
       return null;
@@ -3708,7 +3905,7 @@ function strictDescendant(base, candidate) {
   return suffix !== "" && suffix !== ".." && !suffix.startsWith(`..${sep}`) && !isAbsolute(suffix);
 }
 function parseObjectFile(path, label) {
-  const file = lstatIfPresent(path);
+  const file = lstatIfPresent2(path);
   if (!file || file.isSymbolicLink() || !file.isFile()) {
     throw new Error(`${label} must be a regular non-link file`);
   }
@@ -3731,7 +3928,7 @@ function validateCacheManifest(root) {
     );
   }
   const productRoot = join4(root, PLUGIN_NAME2);
-  const product = lstatIfPresent(productRoot);
+  const product = lstatIfPresent2(productRoot);
   if (!product || product.isSymbolicLink() || !product.isDirectory()) {
     throw new Error(`Legacy cache product root ${productRoot} is unsafe`);
   }
@@ -3741,7 +3938,7 @@ function validateCacheManifest(root) {
   }
   for (const entry of versions) {
     const versionRoot = join4(productRoot, entry.name);
-    const version = lstatIfPresent(versionRoot);
+    const version = lstatIfPresent2(versionRoot);
     if (!entry.isDirectory() || !version || version.isSymbolicLink() || !version.isDirectory()) {
       throw new Error(`Legacy cache version root ${versionRoot} is unsafe`);
     }
@@ -3782,22 +3979,22 @@ function validateSnapshotManifest(root, marketplaceName) {
   }
 }
 function validateLegacyRoot(codexHome, definition, expectedRealPath) {
-  const path = resolve2(codexHome, ...definition.relativePath.split("/"));
+  const path = resolve3(codexHome, ...definition.relativePath.split("/"));
   if (!strictDescendant(codexHome, path)) {
     throw new Error(
       `Legacy cleanup target escapes CODEX_HOME: ${definition.relativePath}`
     );
   }
-  const target = lstatIfPresent(path);
+  const target = lstatIfPresent2(path);
   if (!target) return null;
-  const home = lstatIfPresent(codexHome);
+  const home = lstatIfPresent2(codexHome);
   if (!home || !home.isDirectory()) {
     throw new Error(`Resolved CODEX_HOME is not a directory: ${codexHome}`);
   }
   let boundary = codexHome;
   for (const segment of definition.relativePath.split("/")) {
     boundary = join4(boundary, segment);
-    const value = lstatIfPresent(boundary);
+    const value = lstatIfPresent2(boundary);
     if (!value || value.isSymbolicLink() || !value.isDirectory()) {
       throw new Error(
         `Legacy cleanup boundary is not a real directory: ${boundary}`
@@ -3830,7 +4027,7 @@ function preflightLegacyRoots(codexHomeInput) {
   if (typeof codexHomeInput !== "string" || codexHomeInput.trim() === "") {
     throw new Error("CODEX_HOME could not be resolved");
   }
-  const codexHome = resolve2(codexHomeInput);
+  const codexHome = resolve3(codexHomeInput);
   const roots = LEGACY_ROOTS.map(
     (definition) => validateLegacyRoot(codexHome, definition)
   ).filter((root) => root !== null);
@@ -3965,7 +4162,7 @@ function legacyManagerClean(inspection) {
 }
 function legacyRootsAbsent(codexHome) {
   return LEGACY_ROOTS.every(
-    ({ relativePath }) => !lstatIfPresent(resolve2(codexHome, ...relativePath.split("/")))
+    ({ relativePath }) => !lstatIfPresent2(resolve3(codexHome, ...relativePath.split("/")))
   );
 }
 function legacyPluginCommandItem(pluginId, projectRoot) {
@@ -4193,11 +4390,11 @@ function applyCodexPluginSetup(plan) {
         error: `Central ${PLUGIN_ID2} remains installed, but the fixed legacy cleanup plan is invalid; close Codex and retry.`
       };
     }
-    const exactPath = resolve2(
+    const exactPath = resolve3(
       plan.codexHome,
       ...definition.relativePath.split("/")
     );
-    if (resolve2(root.path) !== exactPath || resolve2(item.targetPath) !== exactPath || root.kind !== definition.kind || root.marketplaceName !== definition.marketplaceName) {
+    if (resolve3(root.path) !== exactPath || resolve3(item.targetPath) !== exactPath || root.kind !== definition.kind || root.marketplaceName !== definition.marketplaceName) {
       return {
         success: false,
         changed,
@@ -4205,7 +4402,7 @@ function applyCodexPluginSetup(plan) {
         error: `Central ${PLUGIN_ID2} remains installed, but the fixed legacy cleanup target changed; close Codex and retry.`
       };
     }
-    if (!lstatIfPresent(exactPath)) continue;
+    if (!lstatIfPresent2(exactPath)) continue;
     try {
       const validated = validateLegacyRoot(
         plan.codexHome,
@@ -4213,8 +4410,8 @@ function applyCodexPluginSetup(plan) {
         root.realPath
       );
       if (!validated) continue;
-      rmSync2(validated.path, { recursive: true, force: false });
-      if (lstatIfPresent(validated.path)) {
+      rmSync3(validated.path, { recursive: true, force: false });
+      if (lstatIfPresent2(validated.path)) {
         throw new Error(
           `Legacy cleanup target still exists: ${root.relativePath}`
         );
@@ -4439,6 +4636,14 @@ function classifyItem(item) {
   if (item.action === "write-managed-model-state") {
     return managedModelState(item);
   }
+  if (item.action === "write-install-recovery") {
+    if (!existsSync8(item.targetPath))
+      return { state: "installed", observed: "no interrupted install" };
+    return {
+      state: "drift",
+      observed: "recoverable interrupted install journal present"
+    };
+  }
   if (item.action === "merge-toml") return userConfigState(item);
   return contentState(item);
 }
@@ -4546,6 +4751,14 @@ function getCodexStatus(context2 = { cwd: process.cwd() }, evidence = {}) {
     code: "codex-diagnostic"
   }));
   diagnostics.push(...requiredSkills.diagnostics);
+  if (classified.some(
+    ({ item, state: state2 }) => item.action === "write-install-recovery" && state2 === "drift"
+  ))
+    diagnostics.push({
+      severity: "important",
+      code: "codex-interrupted-install-recoverable",
+      message: "An exact thoth-agents recovery journal indicates an interrupted Codex install; run sync or update to resume safely."
+    });
   return {
     harness: "codex",
     displayName: CODEX_DISPLAY_NAME,
@@ -5078,7 +5291,7 @@ function applyCodexPlan(plan) {
 }
 
 // src/cli/operations/opencode.ts
-import { createHash as createHash3 } from "crypto";
+import { createHash as createHash4 } from "crypto";
 import { existsSync as existsSync10 } from "fs";
 import { join as join6 } from "path";
 
@@ -5088,7 +5301,8 @@ var OPENAI_GPT_RUNTIME_VARIANTS = /* @__PURE__ */ new Set([
   "low",
   "medium",
   "high",
-  "xhigh"
+  "xhigh",
+  "max"
 ]);
 function resolveOpenCodeEffort(input) {
   if (!input.effort || input.effort.kind === "inherit") {
@@ -5116,16 +5330,16 @@ function resolveOpenCodeEffort(input) {
 import {
   cpSync,
   existsSync as existsSync9,
-  lstatSync as lstatSync2,
+  lstatSync as lstatSync3,
   mkdirSync as mkdirSync4,
   mkdtempSync,
   readFileSync as readFileSync8,
   renameSync as renameSync3,
-  rmSync as rmSync3,
+  rmSync as rmSync4,
   statSync
 } from "fs";
 import { homedir as homedir4 } from "os";
-import { dirname as dirname5, join as join5 } from "path";
+import { dirname as dirname6, join as join5 } from "path";
 import { fileURLToPath as fileURLToPath4 } from "url";
 
 // src/harness/core/owned-skills.ts
@@ -5169,7 +5383,7 @@ function inspectPiPackageSkill(entry) {
       state: "missing",
       message: `Package-declared Pi skill directory is missing: ${entry.name}`
     };
-  const root = lstatSync2(entry.sourcePath);
+  const root = lstatSync3(entry.sourcePath);
   if (!root.isDirectory() || root.isSymbolicLink())
     return {
       name: entry.name,
@@ -5183,7 +5397,7 @@ function inspectPiPackageSkill(entry) {
       state: "missing",
       message: `Package-declared Pi skill contract is missing: ${entry.name}`
     };
-  const contract = lstatSync2(contractPath);
+  const contract = lstatSync3(contractPath);
   if (!contract.isFile() || contract.isSymbolicLink())
     return {
       name: entry.name,
@@ -5201,7 +5415,7 @@ function inspectPiPackageSkill(entry) {
   return void 0;
 }
 function resolveOwnedSkillPackageRoot(moduleUrl) {
-  const packageRoot = findPackageRoot(dirname5(fileURLToPath4(moduleUrl)));
+  const packageRoot = findPackageRoot(dirname6(fileURLToPath4(moduleUrl)));
   if (!packageRoot) {
     throw new Error(
       "Unable to locate the thoth-agents package root for bundled owned skills."
@@ -5243,7 +5457,7 @@ function validateCanonicalSkill(entry) {
 function installOwnedSkills(skills) {
   const firstSkill = skills[0];
   if (!firstSkill) return;
-  const globalRoot = dirname5(firstSkill.destinationPath);
+  const globalRoot = dirname6(firstSkill.destinationPath);
   mkdirSync4(globalRoot, { recursive: true });
   const transactionRoot = mkdtempSync(join5(globalRoot, ".thoth-agents-owned-"));
   const stagedRoot = join5(transactionRoot, "staged");
@@ -5268,7 +5482,7 @@ function installOwnedSkills(skills) {
         renameSync3(stagedPath, skill.destinationPath);
       } catch (error) {
         if (existsSync9(skill.destinationPath)) {
-          rmSync3(skill.destinationPath, { recursive: true, force: true });
+          rmSync4(skill.destinationPath, { recursive: true, force: true });
         }
         if (hadExistingDestination && existsSync9(backupPath)) {
           renameSync3(backupPath, skill.destinationPath);
@@ -5276,11 +5490,11 @@ function installOwnedSkills(skills) {
         throw error;
       }
       if (existsSync9(backupPath)) {
-        rmSync3(backupPath, { recursive: true, force: true });
+        rmSync4(backupPath, { recursive: true, force: true });
       }
     }
   } finally {
-    rmSync3(transactionRoot, { recursive: true, force: true });
+    rmSync4(transactionRoot, { recursive: true, force: true });
   }
 }
 function syncOpenCodeOwnedSkills(options = {}) {
@@ -5434,7 +5648,7 @@ function canonicalDigest(value) {
     const serialized = canonicalData(value, /* @__PURE__ */ new Set());
     return {
       ok: true,
-      digest: createHash3("sha256").update(serialized).digest("hex")
+      digest: createHash4("sha256").update(serialized).digest("hex")
     };
   } catch {
     return { ok: false };
@@ -5558,7 +5772,7 @@ function targetForLiteConfig(state) {
     path: getExistingLiteConfigPath(),
     label: "thoth-agents config",
     ...state ? { state } : {},
-    expected: `seven-role ${OPENAI_PRESET} roster`
+    expected: `six-role ${OPENAI_PRESET} roster`
   };
 }
 function titleCaseSkillName(value) {
@@ -6036,7 +6250,7 @@ function getOpenCodeManagedStatus(context2 = { cwd: process.cwd() }) {
       harness: "opencode",
       displayName: "OpenCode",
       state: "drift",
-      summary: selectedNamedPreset ? "A valid named OpenCode preset is active outside the managed seven-role roster." : "thoth-agents config does not match the expected seven-role roster.",
+      summary: selectedNamedPreset ? "A valid named OpenCode preset is active outside the managed six-role roster." : "thoth-agents config does not match the expected six-role roster.",
       targets: [
         { ...mainTarget, state: "installed" },
         { ...liteTarget, state: "drift" },
@@ -6240,7 +6454,7 @@ function buildOpenCodeCompletePlan(action, context2) {
         backup: defaultBackup(getExistingConfigPath())
       },
       {
-        title: "Write thoth-agents seven-role config",
+        title: "Write thoth-agents six-role config",
         target: targetForLiteConfig(),
         preview: JSON.stringify(generatedConfig, null, 2),
         backup: defaultBackup(getExistingLiteConfigPath())
@@ -6341,7 +6555,7 @@ function buildOpenCodeSyncPlan(context2 = { cwd: process.cwd() }) {
         backup: defaultBackup(getExistingConfigPath())
       },
       {
-        title: "Write thoth-agents seven-role config",
+        title: "Write thoth-agents six-role config",
         target: targetForLiteConfig(),
         preview: JSON.stringify(generatedConfig, null, 2),
         backup: defaultBackup(litePath)
@@ -6864,7 +7078,7 @@ function applyOpenCodePlan(plan) {
   }
   changedTargets.push({
     ...targetForLiteConfig("installed"),
-    observed: "seven-role roster written"
+    observed: "six-role roster written"
   });
   if (existsSync10(`${liteResult.configPath}.bak`)) {
     backups.push({
@@ -6956,56 +7170,289 @@ function applyOpenCodePlan(plan) {
 
 // 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";
+import { createHash as createHash6 } from "crypto";
+import { existsSync as existsSync15, readFileSync as readFileSync14 } from "fs";
+import { basename as basename4, dirname as dirname11, isAbsolute as isAbsolute5, join as join13 } 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 };
+// src/cli/pi-external-package.ts
+import { readFileSync as readFileSync9, realpathSync as realpathSync2 } from "fs";
+import { isAbsolute as isAbsolute2, join as join7 } from "path";
+import { satisfies, valid } from "semver";
+function npmPackageName(source) {
+  if (!source.startsWith("npm:")) return void 0;
+  const spec = source.slice("npm:".length);
+  const separator = spec.lastIndexOf("@");
+  if (separator <= 0) return spec || void 0;
+  return spec.slice(0, separator);
+}
+function installedPackageName(path) {
+  if (!path) return void 0;
+  try {
+    const manifest = JSON.parse(
+      readFileSync9(join7(path, "package.json"), "utf8")
+    );
+    if (typeof manifest === "object" && manifest !== null && !Array.isArray(manifest)) {
+      const { name } = manifest;
+      if (typeof name === "string") return name;
+    }
+  } catch {
+    return void 0;
+  }
+  return void 0;
+}
+function piExternalSourceMatches(candidate, expectedSource) {
+  if (candidate.source === expectedSource) return true;
+  if (!isAbsolute2(expectedSource) || !candidate.installedPath) return false;
+  try {
+    return realpathSync2(candidate.installedPath) === realpathSync2(expectedSource);
+  } catch {
+    return false;
   }
-  const effort = input.effort.value;
-  if (!PI_EFFORTS.has(effort)) {
+}
+function inspectPiExternalPackage(packages, spec, requireManagedSource = true) {
+  const matching = packages.filter(
+    ({ source, installedPath }) => source === spec.source || npmPackageName(source) === spec.packageName || installedPackageName(installedPath) === spec.packageName
+  );
+  if (matching.some(({ scope }) => scope === "project"))
     return {
-      ok: false,
-      message: `Pi does not support effort ${effort}; expected ${PI_EFFORT_VALUES.join(", ")}, or inherit.`
+      state: "drift",
+      reason: "project package shadows the required global package"
     };
-  }
-  if (input.availableEfforts !== void 0 && !input.availableEfforts.includes(effort)) {
+  const candidates = matching.filter(({ scope }) => scope === "user");
+  if (candidates.length === 0)
+    return { state: "missing", reason: "package is not configured globally" };
+  if (candidates.length !== 1)
+    return { state: "drift", reason: "package configuration is ambiguous" };
+  const candidate = candidates[0];
+  if (!candidate?.installedPath)
     return {
-      ok: false,
-      message: `Effort ${effort} is not available for ${input.model} in the selected model catalog entry.`
+      state: "drift",
+      source: candidate?.source,
+      reason: "Pi did not report an installed package directory"
+    };
+  let manifest;
+  try {
+    manifest = JSON.parse(
+      readFileSync9(join7(candidate.installedPath, "package.json"), "utf8")
+    );
+  } catch {
+    return {
+      state: "drift",
+      source: candidate.source,
+      installedPath: candidate.installedPath,
+      reason: "installed package manifest is missing or malformed"
     };
   }
-  return { ok: true, effort };
+  if (!manifest || typeof manifest !== "object" || Array.isArray(manifest))
+    return {
+      state: "drift",
+      source: candidate.source,
+      installedPath: candidate.installedPath,
+      reason: "installed package manifest is not an object"
+    };
+  const { name, version } = manifest;
+  if (name !== spec.packageName)
+    return {
+      state: "drift",
+      source: candidate.source,
+      installedPath: candidate.installedPath,
+      reason: `installed package name does not match ${spec.packageName}`
+    };
+  if (typeof version !== "string" || valid(version) === null)
+    return {
+      state: "drift",
+      source: candidate.source,
+      installedPath: candidate.installedPath,
+      reason: "installed package version is not valid SemVer"
+    };
+  if (!satisfies(version, `>=${spec.version}`))
+    return {
+      state: "drift",
+      source: candidate.source,
+      installedPath: candidate.installedPath,
+      version,
+      reason: `installed package version does not satisfy >=${spec.version}`
+    };
+  if (requireManagedSource && !piExternalSourceMatches(candidate, spec.source))
+    return {
+      state: "drift",
+      source: candidate.source,
+      installedPath: candidate.installedPath,
+      version,
+      reason: `configured source must resolve to ${spec.source}`
+    };
+  return {
+    state: "installed",
+    source: candidate.source,
+    installedPath: candidate.installedPath,
+    version
+  };
 }
 
 // src/cli/pi-install.ts
 import { spawnSync as spawnSync6 } from "child_process";
-import { createHash as createHash4 } from "crypto";
+import { createHash as createHash5 } from "crypto";
 import {
-  copyFileSync as copyFileSync5,
   existsSync as existsSync14,
-  lstatSync as lstatSync3,
-  mkdirSync as mkdirSync7,
+  lstatSync as lstatSync4,
   readdirSync as readdirSync3,
-  readFileSync as readFileSync11,
-  renameSync as renameSync6,
-  rmSync as rmSync6,
-  writeFileSync as writeFileSync7
+  readFileSync as readFileSync13,
+  realpathSync as realpathSync3,
+  statSync as statSync3
 } from "fs";
-import { dirname as dirname9, isAbsolute as isAbsolute3, join as join11 } from "path";
-import { fileURLToPath as fileURLToPath5, pathToFileURL } from "url";
+import { basename as basename3, dirname as dirname10, isAbsolute as isAbsolute4, join as join12, resolve as resolve8, sep as sep3 } from "path";
+import { fileURLToPath as fileURLToPath5 } from "url";
+import { lt } from "semver";
+
+// src/cli/pi-git-source.ts
+import { resolve as resolve4, sep as sep2 } from "path";
+import hostedGitInfo from "hosted-git-info";
+function splitRef(url) {
+  const scpLikeMatch = url.match(/^git@([^:]+):(.+)$/);
+  if (scpLikeMatch) {
+    const pathWithMaybeRef2 = scpLikeMatch[2] ?? "";
+    const refSeparator2 = pathWithMaybeRef2.indexOf("@");
+    if (refSeparator2 < 0) return { repo: url };
+    const repoPath2 = pathWithMaybeRef2.slice(0, refSeparator2);
+    const ref2 = pathWithMaybeRef2.slice(refSeparator2 + 1);
+    if (!repoPath2 || !ref2) return { repo: url };
+    return { repo: `git@${scpLikeMatch[1] ?? ""}:${repoPath2}`, ref: ref2 };
+  }
+  if (url.includes("://")) {
+    try {
+      const parsed = new URL(url);
+      const pathWithMaybeRef2 = parsed.pathname.replace(/^\/+/, "");
+      const refSeparator2 = pathWithMaybeRef2.indexOf("@");
+      if (refSeparator2 < 0) return { repo: url };
+      const repoPath2 = pathWithMaybeRef2.slice(0, refSeparator2);
+      const ref2 = pathWithMaybeRef2.slice(refSeparator2 + 1);
+      if (!repoPath2 || !ref2) return { repo: url };
+      parsed.pathname = `/${repoPath2}`;
+      return { repo: parsed.toString().replace(/\/$/, ""), ref: ref2 };
+    } catch {
+      return { repo: url };
+    }
+  }
+  const slashIndex = url.indexOf("/");
+  if (slashIndex < 0) return { repo: url };
+  const host = url.slice(0, slashIndex);
+  const pathWithMaybeRef = url.slice(slashIndex + 1);
+  const refSeparator = pathWithMaybeRef.indexOf("@");
+  if (refSeparator < 0) return { repo: url };
+  const repoPath = pathWithMaybeRef.slice(0, refSeparator);
+  const ref = pathWithMaybeRef.slice(refSeparator + 1);
+  if (!repoPath || !ref) return { repo: url };
+  return { repo: `${host}/${repoPath}`, ref };
+}
+function hasUnsafeGitInstallPart(value, allowSlash) {
+  let decoded;
+  try {
+    decoded = decodeURIComponent(value);
+  } catch {
+    return true;
+  }
+  for (const candidate of [value, decoded]) {
+    if (candidate.includes("\0") || candidate.includes("\\") || candidate.startsWith("/") || !allowSlash && candidate.includes("/") || candidate.split("/").includes(".."))
+      return true;
+  }
+  return false;
+}
+function buildGitSource(args) {
+  if (args.path.startsWith("/")) return null;
+  const normalizedPath = args.path.replace(/\.git$/, "").replace(/^\/+/, "");
+  if (!args.host || !normalizedPath || normalizedPath.split("/").length < 2 || hasUnsafeGitInstallPart(args.host, false) || hasUnsafeGitInstallPart(normalizedPath, true))
+    return null;
+  return {
+    type: "git",
+    repo: args.repo,
+    host: args.host,
+    path: normalizedPath,
+    ref: args.ref,
+    pinned: Boolean(args.ref)
+  };
+}
+function parseGenericGitUrl(url) {
+  const { repo: repoWithoutRef, ref } = splitRef(url);
+  let repo = repoWithoutRef;
+  let host = "";
+  let path = "";
+  const scpLikeMatch = repoWithoutRef.match(/^git@([^:]+):(.+)$/);
+  if (scpLikeMatch) {
+    host = scpLikeMatch[1] ?? "";
+    path = scpLikeMatch[2] ?? "";
+  } else if (repoWithoutRef.startsWith("https://") || repoWithoutRef.startsWith("http://") || repoWithoutRef.startsWith("ssh://") || repoWithoutRef.startsWith("git://")) {
+    try {
+      const parsed = new URL(repoWithoutRef);
+      host = parsed.hostname;
+      path = parsed.pathname.replace(/^\/+/, "");
+    } catch {
+      return null;
+    }
+  } else {
+    const slashIndex = repoWithoutRef.indexOf("/");
+    if (slashIndex < 0) return null;
+    host = repoWithoutRef.slice(0, slashIndex);
+    path = repoWithoutRef.slice(slashIndex + 1);
+    if (!host.includes(".") && host !== "localhost") return null;
+    repo = `https://${repoWithoutRef}`;
+  }
+  return buildGitSource({ repo, host, path, ref });
+}
+function parseGitUrl(source) {
+  const trimmed = source.trim();
+  const hasGitPrefix = trimmed.startsWith("git:");
+  const url = hasGitPrefix ? trimmed.slice(4).trim() : trimmed;
+  if (!hasGitPrefix && !/^(https?|ssh|git):\/\//i.test(url)) return null;
+  const split = splitRef(url);
+  const hostedCandidates = [
+    split.ref ? `${split.repo}#${split.ref}` : void 0,
+    url
+  ].filter((value) => Boolean(value));
+  for (const candidate of hostedCandidates) {
+    const info = hostedGitInfo.fromUrl(candidate);
+    if (info) {
+      if (split.ref && info.project?.includes("@")) continue;
+      const useHttpsPrefix = !split.repo.startsWith("http://") && !split.repo.startsWith("https://") && !split.repo.startsWith("ssh://") && !split.repo.startsWith("git://") && !split.repo.startsWith("git@");
+      return buildGitSource({
+        repo: useHttpsPrefix ? `https://${split.repo}` : split.repo,
+        host: info.domain || "",
+        path: `${info.user}/${info.project}`,
+        ref: info.committish || split.ref || void 0
+      });
+    }
+  }
+  const httpsCandidates = [
+    split.ref ? `https://${split.repo}#${split.ref}` : void 0,
+    `https://${url}`
+  ].filter((value) => Boolean(value));
+  for (const candidate of httpsCandidates) {
+    const info = hostedGitInfo.fromUrl(candidate);
+    if (info) {
+      if (split.ref && info.project?.includes("@")) continue;
+      return buildGitSource({
+        repo: `https://${split.repo}`,
+        host: info.domain || "",
+        path: `${info.user}/${info.project}`,
+        ref: info.committish || split.ref || void 0
+      });
+    }
+  }
+  return parseGenericGitUrl(url);
+}
+function projectGitPackagePath(source, projectRoot) {
+  const trimmed = source.trim();
+  if (!["npm:", "git:", "github:", "http:", "https:", "ssh:", "builtin:"].some(
+    (prefix) => trimmed.startsWith(prefix)
+  ))
+    return void 0;
+  const parsed = parseGitUrl(source);
+  if (!parsed) return void 0;
+  const installRoot = resolve4(projectRoot, "git");
+  const installedPath = resolve4(installRoot, parsed.host, parsed.path);
+  if (installedPath !== installRoot && !installedPath.startsWith(`${installRoot}${sep2}`))
+    return void 0;
+  return installedPath;
+}
 
 // src/cli/pi-migration.ts
 import {
@@ -7013,16 +7460,16 @@ import {
   existsSync as existsSync11,
   mkdirSync as mkdirSync5,
   readdirSync as readdirSync2,
-  readFileSync as readFileSync9,
+  readFileSync as readFileSync10,
   renameSync as renameSync4,
   statSync as statSync2,
   writeFileSync as writeFileSync4
 } from "fs";
-import { dirname as dirname6, join as join7 } from "path";
+import { dirname as dirname7, join as join8 } from "path";
 function files(root, current = root) {
   if (!existsSync11(root)) return [];
   return readdirSync2(current, { withFileTypes: true }).flatMap((entry) => {
-    const path = join7(current, entry.name);
+    const path = join8(current, entry.name);
     return entry.isDirectory() ? files(root, path) : [path.slice(root.length + 1).replaceAll("\\", "/")];
   }).sort();
 }
@@ -7030,7 +7477,7 @@ 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)))
+    (name, index) => name === rightFiles[index] && readFileSync10(join8(left, name)).equals(readFileSync10(join8(right, name)))
   );
 }
 function removeRootBlock(content) {
@@ -7045,19 +7492,19 @@ function removeRootBlock(content) {
 function migrateLegacyPiResources(options) {
   const changed = [];
   const manualActions = [];
-  const appendPath = join7(options.piRoot, "APPEND_SYSTEM.md");
+  const appendPath = join8(options.piRoot, "APPEND_SYSTEM.md");
   let nextRoot;
   try {
     if (existsSync11(appendPath))
-      nextRoot = removeRootBlock(readFileSync9(appendPath, "utf8"));
+      nextRoot = removeRootBlock(readFileSync10(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);
+    const source = join8(options.piRoot, "skills", name);
     if (!existsSync11(source)) continue;
-    const canonical = join7(options.packageRoot, "skills", name);
+    const canonical = join8(options.packageRoot, "skills", name);
     const backup = `${source}.thoth-agents-legacy.bak`;
     if (!statSync2(source).isDirectory() || !identicalTrees(source, canonical) || existsSync11(backup)) {
       manualActions.push(
@@ -7078,7 +7525,7 @@ function migrateLegacyPiResources(options) {
     };
   try {
     if (nextRoot !== void 0) {
-      mkdirSync5(dirname6(appendPath), { recursive: true });
+      mkdirSync5(dirname7(appendPath), { recursive: true });
       copyFileSync4(appendPath, `${appendPath}.thoth-agents-legacy.bak`);
       const temporary = `${appendPath}.tmp-${process.pid}`;
       writeFileSync4(temporary, nextRoot);
@@ -7110,29 +7557,63 @@ function migrateLegacyPiResources(options) {
 
 // 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 {
+  existsSync as existsSync12,
+  mkdtempSync as mkdtempSync2,
+  readFileSync as readFileSync11,
+  rmSync as rmSync5,
+  writeFileSync as writeFileSync5
+} from "fs";
 import { tmpdir } from "os";
-import { dirname as dirname7, join as join8, resolve as resolve3 } from "path";
+import { dirname as dirname8, join as join9, resolve as resolve5, win32 } from "path";
+function resolvePiWindowsCliFromShim(shimPath, shimContents) {
+  const target = shimContents.match(
+    /"([^"\r\n]*@earendil-works[\\/]+pi-coding-agent[\\/]+dist[\\/]+bundle[\\/]+cli\.js)"\s+%\*/i
+  )?.[1];
+  if (!target) return void 0;
+  const expanded = target.replace(
+    /%~dp0|%dp0%/gi,
+    `${win32.dirname(shimPath)}\\`
+  );
+  return win32.isAbsolute(expanded) ? win32.normalize(expanded) : void 0;
+}
+function findPiWindowsCli() {
+  const located = spawnSync5("where.exe", ["pi.cmd"], {
+    windowsHide: true,
+    encoding: "utf8"
+  }).stdout?.split(/\r?\n/).find(Boolean);
+  if (!located) return void 0;
+  try {
+    const cli = resolvePiWindowsCliFromShim(
+      located,
+      readFileSync11(located, "utf8")
+    );
+    if (cli && existsSync12(cli)) return cli;
+  } catch {
+  }
+  const adjacentCli = join9(
+    dirname8(located),
+    "node_modules",
+    "@earendil-works",
+    "pi-coding-agent",
+    "dist",
+    "bundle",
+    "cli.js"
+  );
+  return existsSync12(adjacentCli) ? adjacentCli : void 0;
+}
 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)) {
+    const cli = findPiWindowsCli();
+    if (cli) {
       executable = process.execPath;
       executableArgs = [cli, ...args];
     }
   }
   const result = spawnSync5(executable, executableArgs, {
+    windowsHide: true,
     encoding: "utf8",
     timeout: 3e4,
     env: { ...process.env, ...env }
@@ -7149,8 +7630,8 @@ function occurrences(text, marker) {
 }
 function observePiNativeRoot(options) {
   const ownsIsolatedRoot = options.piHome === void 0;
-  const isolatedRoot = options.piHome ?? mkdtempSync2(join8(tmpdir(), "thoth-pi-observer-"));
-  const observerPath = join8(
+  const isolatedRoot = options.piHome ?? mkdtempSync2(join9(tmpdir(), "thoth-pi-observer-"));
+  const observerPath = join9(
     isolatedRoot,
     `observer-${process.pid}-${Date.now()}.mjs`
   );
@@ -7159,7 +7640,7 @@ function observePiNativeRoot(options) {
       observerPath,
       `import { existsSync, readdirSync, readFileSync } from 'node:fs';
 import { isAbsolute, join, relative, resolve } from 'node:path';
-import { createAssistantMessageEventStream } from '@earendil-works/pi-ai';
+import { createAssistantMessageEventStream, getCurrentSystemPrompt } from '@earendil-works/pi-ai';
 const manifestSha256=${JSON.stringify(options.manifestSha256)};
 const extensionSha256=${JSON.stringify(options.extensionSha256)};
 const packageRoot=${JSON.stringify(options.packageRoot)};
@@ -7204,12 +7685,16 @@ export default function observer(pi) {
       const stream=createAssistantMessageEventStream();
       queueMicrotask(async () => {
         try {
-          skills=discoveredSkills(context.systemPrompt);
-          const raw={systemPrompt:context.systemPrompt,messages:context.messages};
+          const systemPrompt=getCurrentSystemPrompt(context.messages);
+          skills=discoveredSkills(systemPrompt);
+          const raw={systemPrompt};
           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}); }
+          stream.push({type:'start',partial:message});
+          stream.push({type:'done',reason:'stop',message});
+        } catch (error) {
+          stream.push({type:'error',reason:'error',error:{role:'assistant',content:[],api:model.api,provider:model.provider,model:model.id,usage:{input:0,output:0,cacheRead:0,cacheWrite:0,totalTokens:0,cost:{input:0,output:0,cacheRead:0,cacheWrite:0,total:0}},stopReason:'error',errorMessage:String(error),timestamp:Date.now()}});
+        } finally { stream.end(); }
       });
       return stream;
     }
@@ -7225,7 +7710,7 @@ export default function observer(pi) {
       "--offline",
       "--no-extensions",
       "--extension",
-      resolve3(options.extensionPath),
+      resolve5(options.extensionPath),
       "--extension",
       observerPath,
       "--provider",
@@ -7278,8 +7763,8 @@ ${result.stderr}`.split(/\r?\n/).flatMap((line) => {
     ) : 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 ? {
+    const valid2 = 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 valid2 ? {
       state: "observed-at-install",
       basis: [
         "Real Pi final provider request contained exactly one receipt-bound root marker."
@@ -7298,8 +7783,8 @@ ${result.stderr}`.split(/\r?\n/).flatMap((line) => {
     };
   } finally {
     if (ownsIsolatedRoot)
-      rmSync4(isolatedRoot, { recursive: true, force: true });
-    else rmSync4(observerPath, { force: true });
+      rmSync5(isolatedRoot, { recursive: true, force: true });
+    else rmSync5(observerPath, { force: true });
   }
 }
 
@@ -7307,13 +7792,13 @@ ${result.stderr}`.split(/\r?\n/).flatMap((line) => {
 import {
   existsSync as existsSync13,
   mkdirSync as mkdirSync6,
-  readFileSync as readFileSync10,
+  readFileSync as readFileSync12,
   renameSync as renameSync5,
-  rmSync as rmSync5,
+  rmSync as rmSync6,
   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";
+import { dirname as dirname9, isAbsolute as isAbsolute3, join as join10, normalize, resolve as resolve6 } from "path";
 var keys = [
   "schemaVersion",
   "owner",
@@ -7328,16 +7813,16 @@ var keys = [
 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));
+  const normalizedLeft = normalize(resolve6(left));
+  const normalizedRight = normalize(resolve6(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");
+  const root = options.configRoot ?? env.XDG_CONFIG_HOME?.trim() ?? join10(options.homeDir ?? homedir5(), ".config");
+  return join10(root, "thoth-agents", "pi-package.json");
 }
-function parse(value) {
+function parse2(value) {
   if (!value || typeof value !== "object" || Array.isArray(value))
     throw new Error("Receipt must be a JSON object.");
   const record = value;
@@ -7349,7 +7834,7 @@ function parse(value) {
     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);
+  const localIdentity = typeof record.source === "string" && record.source.length > 0 && !isAbsolute3(record.source) && !/^[a-z][a-z+.-]*:/i.test(record.source) && typeof record.installSource === "string" && isAbsolute3(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))
@@ -7363,7 +7848,7 @@ function readPiPackageReceipt(options = {}) {
     return {
       status: "valid",
       path,
-      receipt: parse(JSON.parse(readFileSync10(path, "utf8")))
+      receipt: parse2(JSON.parse(readFileSync12(path, "utf8")))
     };
   } catch (error) {
     return {
@@ -7376,8 +7861,8 @@ function readPiPackageReceipt(options = {}) {
 function writePiPackageReceipt(receipt, options = {}) {
   const path = getPiPackageReceiptPath(options);
   try {
-    const validated = parse(receipt);
-    mkdirSync6(dirname8(path), { recursive: true });
+    const validated = parse2(receipt);
+    mkdirSync6(dirname9(path), { recursive: true });
     const temporary = `${path}.tmp-${process.pid}`;
     writeFileSync6(temporary, `${JSON.stringify(validated, null, 2)}
 `, {
@@ -7386,7 +7871,7 @@ function writePiPackageReceipt(receipt, options = {}) {
     try {
       renameSync5(temporary, path);
     } catch (error) {
-      rmSync5(temporary, { force: true });
+      rmSync6(temporary, { force: true });
       throw error;
     }
     return { success: true, path };
@@ -7421,76 +7906,78 @@ function classifyPiPackageOwnership(input) {
 
 // src/cli/pi-paths.ts
 import { homedir as homedir6 } from "os";
-import { join as join10, resolve as resolve5 } from "path";
+import { join as join11, resolve as resolve7 } from "path";
 function resolvePiPaths(options = {}) {
   const env = options.env ?? process.env;
-  const homeDir = resolve5(
+  const homeDir = resolve7(
     options.homeDir ?? env.HOME ?? env.USERPROFILE ?? homedir6()
   );
-  const defaultPiRoot = join10(homeDir, ".pi", "agent");
+  const defaultPiRoot = join11(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");
+  const piRoot = configured ? resolve7(configured) : defaultPiRoot;
+  const cwd = resolve7(options.cwd ?? process.cwd());
+  const configRoot = env.XDG_CONFIG_HOME?.trim() ? resolve7(env.XDG_CONFIG_HOME) : join11(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"),
+    appendSystemPath: join11(piRoot, "APPEND_SYSTEM.md"),
+    agentsRoot: join11(piRoot, "agents"),
+    alternateAgentsRoot: join11(piRoot, "subagents"),
+    ownedSkillsRoot: join11(piRoot, "skills"),
+    settingsPath: join11(piRoot, "settings.json"),
+    subagentsConfigPath: join11(piRoot, "subagents.json"),
+    mcpConfigPath: join11(configRoot, "mcp", "mcp.json"),
     projectAgentRoots: [
-      join10(cwd, ".pi", "agents"),
-      join10(cwd, ".pi", "subagents")
+      join11(cwd, ".pi", "agents"),
+      join11(cwd, ".pi", "subagents")
     ],
-    projectMcpPaths: [join10(cwd, ".mcp.json"), join10(cwd, ".pi", "mcp.json")]
+    projectMcpPaths: [join11(cwd, ".mcp.json"), join11(cwd, ".pi", "mcp.json")]
   };
 }
 
 // src/cli/pi-install.ts
-var PI_MINIMUM_VERSION = "0.84.4";
+var PI_MINIMUM_VERSION = "0.99.0";
 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"
+    source: "npm:@thoth-agents/pi-subagents@>=0.1.0",
+    packageName: "@thoth-agents/pi-subagents",
+    version: "0.1.0"
   },
   {
     id: "context7",
-    source: "npm:@upstash/context7-pi@0.1.2",
+    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",
+    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",
+    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"
+    source: "npm:@thoth-agents/pi-questions-user@>=0.1.0",
+    packageName: "@thoth-agents/pi-questions-user",
+    version: "0.1.0"
   },
   {
     id: "todo",
-    source: "npm:@juicesharp/rpiv-todo@2.9.0",
-    packageName: "@juicesharp/rpiv-todo",
-    version: "2.9.0"
+    source: "npm:@thoth-agents/pi-todo@>=0.1.0",
+    packageName: "@thoth-agents/pi-todo",
+    version: "0.1.0"
   }
 ];
 var PI_GREP_MCP_ENTRY = {
@@ -7502,7 +7989,7 @@ function getPiFirstPartySource(version) {
   return `npm:thoth-agents@${version}`;
 }
 function packageRootFor(options) {
-  const root = options.packageRoot ?? findPackageRoot(dirname9(fileURLToPath5(import.meta.url)));
+  const root = options.packageRoot ?? findPackageRoot(dirname10(fileURLToPath5(import.meta.url)));
   if (!root)
     throw new Error(
       "Unable to locate the executing thoth-agents package root."
@@ -7511,63 +7998,56 @@ function packageRootFor(options) {
 }
 function packageVersionFor(root) {
   const value = JSON.parse(
-    readFileSync11(join11(root, "package.json"), "utf8")
+    readFileSync13(join12(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");
+  return createHash5("sha256").update(readFileSync13(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(
+    const manifestPath = join12(input.packageRoot, "package.json");
+    const extensionPath = join12(input.packageRoot, "dist", "pi.js");
+    const assetsPath = join12(
       input.packageRoot,
       "pi",
       ".thoth-agents-assets.json"
     );
     for (const path of [manifestPath, extensionPath, assetsPath])
-      if (!existsSync14(path) || !lstatSync3(path).isFile() || lstatSync3(path).isSymbolicLink())
+      if (!existsSync14(path) || !lstatSync4(path).isFile() || lstatSync4(path).isSymbolicLink())
         throw new Error(
           `Required regular package asset is missing or symlinked: ${path}`
         );
-    const manifest = JSON.parse(readFileSync11(manifestPath, "utf8"));
+    const manifest = JSON.parse(readFileSync13(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 assets = JSON.parse(readFileSync13(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])
+      const path = join12(input.packageRoot, "pi", relativePath);
+      if (!existsSync14(path) || !lstatSync4(path).isFile() || lstatSync4(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())
+      const path = join12(input.packageRoot, "skills", skill, "SKILL.md");
+      if (!existsSync14(path) || !lstatSync4(path).isFile() || lstatSync4(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,
@@ -7600,11 +8080,264 @@ function isRecord6(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function readJsonObject(path) {
+  assertSafePiManagedPath(path);
   if (!existsSync14(path)) return {};
-  const parsed = JSON.parse(readFileSync11(path, "utf8"));
+  const parsed = JSON.parse(readFileSync13(path, "utf8"));
   if (!isRecord6(parsed)) throw new Error(`${path} must contain a JSON object.`);
   return parsed;
 }
+function isPiIncumbentDelegationSource(source) {
+  return /^npm:pi-subagents(?:-j0k3r)?(?:@|$)/.test(source);
+}
+function getPiExternalPackageSpecs(options = {}) {
+  const runtimePackageRoot = options.runtimePackageRoot;
+  if (!runtimePackageRoot) return PI_PACKAGE_SPECS;
+  return PI_PACKAGE_SPECS.map(
+    (spec) => spec.id === "delegation" ? { ...spec, source: runtimePackageRoot } : spec
+  );
+}
+var PI_INCUMBENT_TODO_NAME = "@juicesharp/rpiv-todo";
+var PI_INCUMBENT_QUESTIONS_NAME = "@juicesharp/rpiv-ask-user-question";
+function piQuestionSourceName(source) {
+  if (!source.startsWith("npm:")) return void 0;
+  const spec = source.slice(4).trim();
+  const alias = spec.indexOf("@npm:");
+  const target = alias >= 0 ? spec.slice(alias + 5) : spec;
+  return target.match(/^(@[^/@\s]+\/[^/@\s]+|[^/@\s]+)(?:@.+)?$/)?.[1];
+}
+function findPiIncumbentQuestions(packages) {
+  return packages.filter(
+    (candidate) => piQuestionSourceName(candidate.source) === PI_INCUMBENT_QUESTIONS_NAME || configuredPackageIdentity(candidate).packageName === PI_INCUMBENT_QUESTIONS_NAME
+  );
+}
+function piQuestionIdentityBlockers(packages, plan) {
+  return packages.flatMap((candidate) => {
+    const manifest = configuredPackageManifest(candidate);
+    if (typeof manifest?.name === "string" && manifest.name) return [];
+    const npmSource = candidate.source.startsWith("npm:");
+    const questionSource = /(?:^|[\\/:@?#._-])rpiv-ask-user-question(?:$|[\\/:@?#._-])/i.test(
+      candidate.source
+    );
+    const unresolvedNpmLocation = npmSource && !candidate.installedPath;
+    const unresolvedAlias = npmSource && candidate.source.includes("@npm:") && !piQuestionSourceName(candidate.source);
+    const previewedQuestion = candidate.scope === "user" && plan?.items.some(
+      ({ command }) => command?.command === "pi" && command.args[0] === "remove" && command.args[1] === candidate.source && command.args[2] === "--no-approve"
+    );
+    if (manifest && !previewedQuestion) return [];
+    if (!questionSource && !unresolvedNpmLocation && !unresolvedAlias && !previewedQuestion)
+      return [];
+    const flags = candidate.scope === "project" ? "--local --approve" : "--no-approve";
+    return [
+      `Cannot verify configured Pi package ${candidate.source}: installed manifest identity is unavailable. Review its ownership and inspect its package.json using pi list; if it is ${PI_INCUMBENT_QUESTIONS_NAME}, manually run pi remove ${candidate.source} ${flags}. Verify removal, then rerun setup preview.`
+    ];
+  });
+}
+function piUnpreviewedQuestionRecovery(plan, packages) {
+  const previewed = new Set(
+    plan.items.flatMap(
+      ({ command }) => command?.command === "pi" && command.args[0] === "remove" && command.args[2] === "--no-approve" ? [command.args[1]] : []
+    )
+  );
+  const unpreviewed = packages.filter(
+    ({ scope, source }) => scope === "user" && !previewed.has(source)
+  );
+  if (unpreviewed.length === 0) return void 0;
+  return unpreviewed.map(
+    ({ source }) => `Pi question migration blocked: incumbent ${source} was not previewed for removal. Review its ownership, then manually run: pi remove ${source} --no-approve. Verify with pi list, then rerun setup preview; no unpreviewed incumbent may be removed automatically.`
+  ).join("\n");
+}
+function piProjectQuestionConflict(candidate) {
+  const source = candidate.unmappedSource ? "<source>" : candidate.source;
+  return `Incumbent Pi question package ${candidate.source} conflicts with @thoth-agents/pi-questions-user. ${candidate.identityLimitation ? `${candidate.identityLimitation} ` : ""}Review the project's ownership and trust first; --approve trusts project-local settings for this command only without saving a trust decision. ${candidate.unmappedSource ? "Find the matching project settings entry, then" : "Then"} run: pi remove ${source} --local --approve. Verify removal, then rerun setup.`;
+}
+function isPiIncumbentTodoSource(source) {
+  return /^npm:@juicesharp\/rpiv-todo(?:@|$)/.test(source);
+}
+function piIncumbentTodoRecovery(source, scope, identityLimitation, unmappedSource = false) {
+  const flags = scope === "project" ? "--local --approve" : "--no-approve";
+  const review = scope === "project" ? "Review the project's ownership and trust first; --approve trusts project-local settings for this command only without saving a trust decision. Then run:" : "Review its ownership, then run:";
+  const localRecovery = unmappedSource ? " Find the matching project settings entry; after reviewing its ownership, remove it with: pi remove <source> --local --approve." : isPiIncumbentTodoSource(source) ? "" : ` For the actual configured source, run: pi remove ${source} ${flags}.`;
+  return `${identityLimitation ? `${identityLimitation} ` : ""}${review} pi remove npm:${PI_INCUMBENT_TODO_NAME} ${flags}.${localRecovery} Verify with pi list, then rerun setup.`;
+}
+function configuredPackageSources(settings) {
+  if (!Array.isArray(settings.packages)) return [];
+  return settings.packages.flatMap((entry) => {
+    const source = typeof entry === "string" ? entry : isRecord6(entry) && typeof entry.source === "string" ? entry.source : void 0;
+    return source ? [source] : [];
+  });
+}
+function configuredPackageSource(settings, matches) {
+  return configuredPackageSources(settings).find(matches);
+}
+function projectLocalPackagePath(source, projectRoot, homeDir) {
+  let path = source.trim();
+  if (process.platform === "win32" && !path.startsWith("//") && !path.includes("\\")) {
+    const drivePath = path.match(
+      /^\/(?:mnt\/|cygdrive\/)?([a-z])(?:\/(.*))?$/i
+    );
+    if (drivePath)
+      path = `${drivePath[1]?.toUpperCase()}:\\${drivePath[2]?.replaceAll("/", "\\") ?? ""}`;
+  }
+  if (path === "~") path = homeDir;
+  else if (path.startsWith("~/") || process.platform === "win32" && path.startsWith("~\\"))
+    path = join12(homeDir, path.slice(2));
+  else if (path.startsWith("file://")) path = fileURLToPath5(path);
+  return resolve8(projectRoot, path);
+}
+function legacyPiNpmPackagePath(name, settings, execute) {
+  try {
+    const commandParts = settings.npmCommand === void 0 ? ["npm"] : settings.npmCommand;
+    if (!Array.isArray(commandParts) || commandParts.length !== 1 || typeof commandParts[0] !== "string")
+      return void 0;
+    const command = commandParts[0];
+    if (/[\0\r\n&|<>^%"'`$;!]/.test(command)) return void 0;
+    const manager = basename3(command).replace(/\.(cmd|exe)$/i, "");
+    if (!["npm", "pnpm", "bun"].includes(manager)) return void 0;
+    if (/\s/.test(command) && !statSync3(command, { throwIfNoEntry: false })?.isFile())
+      return void 0;
+    const query = (args) => {
+      const result = execute(command, args);
+      if (result.error || result.exitCode !== 0)
+        throw new Error("Package metadata unavailable");
+      return (result.stdout || result.stderr).trim();
+    };
+    if (manager === "pnpm") {
+      const entries = JSON.parse(query(["list", "-g", "--json"]));
+      if (!Array.isArray(entries)) return void 0;
+      for (const entry of entries) {
+        const dependencies = isRecord6(entry) ? entry.dependencies : void 0;
+        const dependency = isRecord6(dependencies) ? dependencies[name] : void 0;
+        if (isRecord6(dependency) && typeof dependency.path === "string" && dependency.path)
+          return dependency.path;
+      }
+      return void 0;
+    }
+    const root = manager === "bun" ? join12(
+      dirname10(query(["pm", "bin", "-g"])),
+      "install",
+      "global",
+      "node_modules"
+    ) : query(["root", "-g"]);
+    return root ? join12(root, name) : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function parsePiPackageSource(source, baseDir) {
+  if (source.startsWith("npm:")) {
+    const spec = source.slice(4).trim();
+    const name = spec.match(/^(@?[^@]+(?:\/[^@]+)?)(?:@(.+))?$/)?.[1] ?? spec;
+    return { type: "npm", name };
+  }
+  const gitPath = projectGitPackagePath(source, baseDir);
+  return gitPath ? { type: "git", path: gitPath } : { type: "local", path: source };
+}
+function resolvePiPackage(candidate, options, userSettings) {
+  if (candidate.installedPath) return candidate;
+  const paths = resolvePiPaths(options);
+  const baseDir = candidate.scope === "user" ? paths.piRoot : join12(resolve8(options.cwd ?? process.cwd()), ".pi");
+  const parsed = parsePiPackageSource(candidate.source, baseDir);
+  const npmName = parsed.type === "npm" ? parsed.name : void 0;
+  let path = npmName ? join12(baseDir, "npm", "node_modules", npmName) : parsed.type === "git" ? parsed.path : projectLocalPackagePath(candidate.source, baseDir, paths.homeDir);
+  if (npmName && candidate.scope === "user" && !existsSync14(path))
+    path = legacyPiNpmPackagePath(
+      npmName,
+      userSettings,
+      options.commandExecutor ?? defaultCommandExecutor4
+    ) ?? path;
+  return {
+    ...candidate,
+    installedPath: existsSync14(path) ? path : candidate.installedPath
+  };
+}
+function resolvePiConfiguredPackages(settings, scope, options) {
+  return configuredPackageSources(settings).map(
+    (source) => resolvePiPackage({ scope, source }, options, settings)
+  );
+}
+function resolvePiListedPackages(output, options) {
+  const packages = parsePiPackageList(output);
+  const paths = resolvePiPaths(options);
+  const settings = readJsonObject(paths.settingsPath);
+  const projectRoot = join12(resolve8(options.cwd ?? process.cwd()), ".pi");
+  let projectSettings;
+  for (const { scope, source, installedPath } of packages) {
+    const baseDir = scope === "user" ? paths.piRoot : projectRoot;
+    if (parsePiPackageSource(source, baseDir).type !== "local") continue;
+    let inventory = settings;
+    if (scope === "project") {
+      projectSettings ??= readJsonObject(join12(projectRoot, "settings.json"));
+      inventory = projectSettings;
+    }
+    if (!configuredPackageSources(inventory).includes(source) && (Array.isArray(inventory.packages) || !installedPath || !isAbsolute4(installedPath)))
+      throw new Error(
+        `Pi package manifest identity cannot be verified: malformed pi list source ${source}. Rerun pi list --no-approve and inspect the configured sources before setup.`
+      );
+  }
+  return packages.map(
+    (candidate) => resolvePiPackage(candidate, options, settings)
+  );
+}
+function readPiProjectPackages(options) {
+  const projectRoot = join12(resolve8(options.cwd ?? process.cwd()), ".pi");
+  return resolvePiConfiguredPackages(
+    readJsonObject(join12(projectRoot, "settings.json")),
+    "project",
+    options
+  );
+}
+function scanPiProjectInstalledIncumbents(options, configuredPackages) {
+  const projectRoot = join12(resolve8(options.cwd ?? process.cwd()), ".pi");
+  const incumbents = [];
+  const visited = /* @__PURE__ */ new Set();
+  const pathKey = (path) => process.platform === "win32" ? path.toLowerCase() : path;
+  const knownPaths = new Set(
+    configuredPackages.flatMap(
+      ({ installedPath }) => installedPath ? [pathKey(realpathSync3(installedPath))] : []
+    )
+  );
+  for (const root of [join12(projectRoot, "git"), join12(projectRoot, "npm")]) {
+    if (!existsSync14(root)) continue;
+    const rootKey = pathKey(realpathSync3(root));
+    const pending = [root];
+    while (pending.length > 0) {
+      const path = pending.pop();
+      if (!path || !statSync3(path, { throwIfNoEntry: false })?.isDirectory())
+        continue;
+      const key = pathKey(realpathSync3(path));
+      if (visited.has(key)) continue;
+      visited.add(key);
+      const manifestPath = join12(path, "package.json");
+      if (existsSync14(manifestPath) && statSync3(manifestPath).isFile()) {
+        const candidate = {
+          scope: "project",
+          source: path,
+          installedPath: path,
+          unmappedSource: true
+        };
+        const identity = configuredPackageIdentity(candidate);
+        if ((identity.packageName === PI_INCUMBENT_TODO_NAME || identity.packageName === PI_INCUMBENT_QUESTIONS_NAME) && !knownPaths.has(key))
+          incumbents.push({
+            ...candidate,
+            ...identity,
+            identityLimitation: `Installed manifest at ${path} identifies ${identity.packageName}, but no configured settings source maps to this directory.`
+          });
+      }
+      if (key !== rootKey && !key.startsWith(`${rootKey}${sep3}`)) continue;
+      for (const entry of readdirSync3(path, { withFileTypes: true }))
+        if (entry.isDirectory() || entry.isSymbolicLink())
+          pending.push(join12(path, entry.name));
+    }
+  }
+  return incumbents;
+}
+function mergePiSubagentsConfig(current) {
+  return {
+    ...current,
+    session_resources: "lean",
+    enable_continue: false
+  };
+}
 function mergePiGrepMcpConfig(current) {
   const rawServers = current.mcpServers;
   if (rawServers !== void 0 && !isRecord6(rawServers)) {
@@ -7645,8 +8378,8 @@ function findAgentConflicts(paths) {
     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 path = join12(root, name);
+      const content = readFileSync13(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;
@@ -7678,8 +8411,57 @@ function buildPiSetupPlan(options = {}) {
     );
   }
   blockers.push(...findAgentConflicts(paths));
+  if (options.runtimePackageRoot) {
+    const runtimeRoot = options.runtimePackageRoot;
+    const spec = getPiExternalPackageSpecs(options)[0];
+    const sourceIsNormalizedAbsolutePath = isAbsolute4(runtimeRoot) && resolve8(runtimeRoot) === runtimeRoot;
+    const inspection = sourceIsNormalizedAbsolutePath ? inspectPiExternalPackage(
+      [{ scope: "user", source: runtimeRoot, installedPath: runtimeRoot }],
+      spec
+    ) : void 0;
+    if (inspection?.state !== "installed") {
+      blockers.push(
+        `Local Pi delegation runtime root ${runtimeRoot} is invalid: ${inspection?.reason ?? "the source must be a normalized absolute path"}.`
+      );
+    }
+  }
+  let plannedQuestionRemovals = [];
+  let subagentsConfigContent;
   let mcpContent;
   try {
+    const userSettings = readJsonObject(paths.settingsPath);
+    const incumbentSource = configuredPackageSource(
+      userSettings,
+      isPiIncumbentDelegationSource
+    );
+    const incumbentBlockers = [];
+    if (incumbentSource)
+      incumbentBlockers.push(
+        `Incumbent delegation runtime ${incumbentSource} is configured in ${paths.settingsPath}. Review its ownership, then run: pi remove ${incumbentSource} --no-approve. Rerun setup after removing it; ${PI_PACKAGE_SPECS[0].source} cannot be loaded beside it.`
+      );
+    const incumbentTodoSource = configuredPackageSource(
+      userSettings,
+      isPiIncumbentTodoSource
+    );
+    if (incumbentTodoSource)
+      incumbentBlockers.push(
+        `Incumbent Pi task-list package ${incumbentTodoSource} is configured in ${paths.settingsPath} and conflicts with @thoth-agents/pi-todo. ${piIncumbentTodoRecovery(incumbentTodoSource, "user")}`
+      );
+    if (incumbentBlockers.length > 0)
+      throw new Error(incumbentBlockers.join("\n"));
+    const userPackages = resolvePiConfiguredPackages(
+      userSettings,
+      "user",
+      options
+    );
+    blockers.push(...piQuestionIdentityBlockers(userPackages));
+    plannedQuestionRemovals = findPiIncumbentQuestions(userPackages);
+    subagentsConfigContent = `${JSON.stringify(
+      mergePiSubagentsConfig(readJsonObject(paths.subagentsConfigPath)),
+      null,
+      2
+    )}
+`;
     mcpContent = `${JSON.stringify(
       mergePiGrepMcpConfig(readJsonObject(paths.mcpConfigPath)),
       null,
@@ -7689,6 +8471,40 @@ function buildPiSetupPlan(options = {}) {
   } catch (error) {
     blockers.push(error instanceof Error ? error.message : String(error));
   }
+  const projectSettingsPath = join12(
+    resolve8(options.cwd ?? process.cwd()),
+    ".pi",
+    "settings.json"
+  );
+  let projectPackages = [];
+  try {
+    projectPackages = readPiProjectPackages(options);
+  } catch (error) {
+    blockers.push(error instanceof Error ? error.message : String(error));
+  }
+  try {
+    projectPackages.push(
+      ...scanPiProjectInstalledIncumbents(options, projectPackages)
+    );
+  } catch (error) {
+    blockers.push(error instanceof Error ? error.message : String(error));
+  }
+  blockers.push(...piQuestionIdentityBlockers(projectPackages));
+  const projectIncumbentTodos = findPiIncumbentTodos(projectPackages);
+  for (const incumbent of projectIncumbentTodos) {
+    const location = incumbent.unmappedSource ? "was found in the project install roots" : `is configured in ${projectSettingsPath}`;
+    const recovery = piIncumbentTodoRecovery(
+      incumbent.source,
+      "project",
+      incumbent.identityLimitation,
+      incumbent.unmappedSource
+    );
+    blockers.push(
+      `Incumbent Pi task-list package ${incumbent.source} ${location} and conflicts with @thoth-agents/pi-todo. ${recovery}`
+    );
+  }
+  for (const incumbent of findPiIncumbentQuestions(projectPackages))
+    blockers.push(piProjectQuestionConflict(incumbent));
   for (const path of [...paths.projectAgentRoots, ...paths.projectMcpPaths]) {
     if (existsSync14(path))
       diagnostics.push(
@@ -7706,7 +8522,7 @@ function buildPiSetupPlan(options = {}) {
   const items = [
     {
       kind: "preflight",
-      description: "Verify Node.js >=22.19 and Pi >=0.84.4 before mutation",
+      description: `Verify Node.js >=22.19 and Pi >=${PI_MINIMUM_VERSION} before mutation`,
       target: "node/pi runtime"
     },
     {
@@ -7718,12 +8534,26 @@ function buildPiSetupPlan(options = {}) {
         args: ["install", firstPartySource, "--no-approve"]
       }
     },
-    ...PI_PACKAGE_SPECS.map((pkg) => ({
+    ...plannedQuestionRemovals.map(({ source }) => ({
+      kind: "preflight",
+      description: "Remove the conflicting user question provider through native Pi removal after root-package verification",
+      target: source,
+      command: { command: "pi", args: ["remove", source, "--no-approve"] }
+    })),
+    ...getPiExternalPackageSpecs(options).map((pkg) => ({
       kind: "package",
       description: `Install and verify Pi package ${pkg.source}`,
       target: pkg.source,
       command: { command: "pi", args: ["install", pkg.source, "--no-approve"] }
     })),
+    ...subagentsConfigContent === void 0 ? [] : [
+      {
+        kind: "settings",
+        description: "Configure global subagent lean resources and disable continuation",
+        target: paths.subagentsConfigPath,
+        content: subagentsConfigContent
+      }
+    ],
     ...mcpContent === void 0 ? [] : [
       {
         kind: "mcp",
@@ -7735,7 +8565,7 @@ function buildPiSetupPlan(options = {}) {
     ...rendered.artifacts.filter((artifact) => artifact.kind === "agent-config").map((artifact) => ({
       kind: "agent",
       description: artifact.description ?? `Install ${artifact.path}`,
-      target: join11(paths.piRoot, artifact.path),
+      target: join12(paths.piRoot, artifact.path),
       content: String(artifact.content)
     }))
   ];
@@ -7746,10 +8576,12 @@ function buildPiSetupPlan(options = {}) {
     items,
     blockers,
     diagnostics,
+    projectIncumbentTodos,
     disclaimers: [
-      "Pi extensions execute with the invoking user's system permissions; package pins and tool allowlists are not a security sandbox.",
+      "Pi extensions execute with the invoking user's system permissions; package minimums 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."
+      "Project-local resources require Pi trust and may shadow global resources.",
+      "Global subagents.json requests lean session resources; project-local subagents.json may override it, and full child resource mode is unsupported."
     ],
     options: { ...options, expectedVersion, packageRoot, firstPartySource }
   };
@@ -7800,33 +8632,108 @@ function parsePiPackageList(output) {
   }
   return packages;
 }
+function npmPackageName2(source) {
+  if (!source.startsWith("npm:")) return void 0;
+  const spec = source.slice("npm:".length);
+  const separator = spec.lastIndexOf("@");
+  return separator <= 0 ? spec || void 0 : spec.slice(0, separator);
+}
+var incumbentDelegationNames = /* @__PURE__ */ new Set([
+  "pi-subagents",
+  "pi-subagents-j0k3r"
+]);
+function isPiLocalOrGitSource(source) {
+  return /^(?:git\+|https?:\/\/|ssh:\/\/|git@|github:|file:|\.\.?[\\/]|[a-z]:[\\/]|\/)/i.test(
+    source
+  );
+}
+function sourceSuggestsIncumbentDelegation(source) {
+  if (!isPiLocalOrGitSource(source)) return false;
+  return /(?:^|[\\/:@?#._-])pi-subagents(?:-j0k3r)?(?:$|[\\/:@?#._-])/i.test(
+    source
+  );
+}
+function findPiIncumbentDelegation(packages) {
+  for (const candidate of packages) {
+    const sourceName = npmPackageName2(candidate.source);
+    const { packageName: installedName } = configuredPackageIdentity(candidate);
+    if (installedName && incumbentDelegationNames.has(installedName)) {
+      return {
+        candidate,
+        classification: "confirmed",
+        reason: `installed manifest identifies ${installedName}`
+      };
+    }
+    if (sourceName && incumbentDelegationNames.has(sourceName)) {
+      return {
+        candidate,
+        classification: "ambiguous",
+        reason: installedName ? `source names ${sourceName}, but its installed manifest identifies ${installedName}` : `source names ${sourceName}, but its installed manifest is unavailable`
+      };
+    }
+    if (!installedName && !sourceName && sourceSuggestsIncumbentDelegation(candidate.source)) {
+      return {
+        candidate,
+        classification: "ambiguous",
+        reason: "the source suggests an incumbent, but its manifest is unavailable"
+      };
+    }
+  }
+  return void 0;
+}
+function findPiIncumbentTodos(packages) {
+  const incumbents = [];
+  for (const candidate of packages) {
+    const { packageName: installedName } = configuredPackageIdentity(candidate);
+    const matches = installedName === PI_INCUMBENT_TODO_NAME || isPiIncumbentTodoSource(candidate.source) || !installedName && !npmPackageName2(candidate.source) && (isPiLocalOrGitSource(candidate.source) || candidate.scope === "project") && /(?:^|[\\/:@?#._-])rpiv-todo(?:$|[\\/:@?#._-])/i.test(
+      candidate.source
+    );
+    if (!matches) continue;
+    incumbents.push(
+      candidate.scope === "project" && !installedName ? {
+        ...candidate,
+        identityLimitation: "Project package manifest identity is unavailable; detection relies on its source and read-only inspection cannot confirm its installed identity."
+      } : candidate
+    );
+  }
+  return incumbents;
+}
+function piIncumbentDelegationRecovery(incumbent) {
+  const source = incumbent.candidate.source;
+  const inspectManifest = incumbent.candidate.installedPath ? ` Inspect the installed manifest at ${incumbent.candidate.installedPath}.` : " Inspect the package manifest through Pi\u2019s package directory.";
+  return incumbent.classification === "confirmed" ? `Review its ownership, then run: pi remove ${source} --no-approve. Rerun setup after verifying it is removed.` : `${incumbent.reason}.${inspectManifest} If it is an incumbent delegation runtime, run: pi remove ${source} --no-approve. Verify with pi list, then rerun setup.`;
+}
 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")
+      readFileSync13(join12(candidate.installedPath, "package.json"), "utf8")
     );
     return manifest.name === "thoth-agents";
   } catch {
     return false;
   }
 }
-function configuredPackageIdentity(candidate) {
-  if (!candidate.installedPath) return { packageName: "", packageVersion: "" };
+function configuredPackageManifest(candidate) {
+  if (!candidate.installedPath) return void 0;
   try {
     const manifest = JSON.parse(
-      readFileSync11(join11(candidate.installedPath, "package.json"), "utf8")
+      readFileSync13(join12(candidate.installedPath, "package.json"), "utf8")
     );
-    return {
-      packageName: typeof manifest.name === "string" ? manifest.name : "",
-      packageVersion: typeof manifest.version === "string" ? manifest.version : ""
-    };
+    return isRecord6(manifest) ? manifest : void 0;
   } catch {
-    return { packageName: "", packageVersion: "" };
+    return void 0;
   }
 }
+function configuredPackageIdentity(candidate) {
+  const manifest = configuredPackageManifest(candidate);
+  return {
+    packageName: typeof manifest?.name === "string" ? manifest.name : "",
+    packageVersion: typeof manifest?.version === "string" ? manifest.version : ""
+  };
+}
 function getPiFirstPartyPackages(packages, knownSource) {
   return packages.filter((candidate) => isThothPackageLocation(candidate, knownSource)).map((candidate) => ({
     ...candidate,
@@ -7834,30 +8741,25 @@ function getPiFirstPartyPackages(packages, knownSource) {
   }));
 }
 function matchesInstallSource(candidate, installSource) {
-  return isAbsolute3(installSource) ? candidate.installedPath !== void 0 && piPackagePathsEqual(candidate.installedPath, installSource) : candidate.source === installSource;
+  return isAbsolute4(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)) {
+    const cli = findPiWindowsCli();
+    if (cli) {
       executable = process.execPath;
       executableArgs = [cli, ...args];
     }
   }
   const result = spawnSync6(executable, executableArgs, {
+    windowsHide: true,
     encoding: "utf8",
-    timeout: PI_COMMAND_TIMEOUT_MS
+    timeout: PI_COMMAND_TIMEOUT_MS,
+    // Like the SDK's cross-spawn, support npm/pnpm's Windows command shims
+    // for the offline metadata queries used by package resolution.
+    shell: process.platform === "win32" && /^(npm|pnpm)(\.cmd)?$/i.test(basename3(executable))
   });
   return {
     exitCode: result.status,
@@ -7866,21 +8768,6 @@ function defaultCommandExecutor4(command, args) {
     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)
@@ -7899,7 +8786,14 @@ function applyPiSetup(plan) {
   const installedPackages = [];
   let receiptCommitted = false;
   let configuredPackageRoot;
+  let manualRecovery;
   try {
+    for (const path of [
+      plan.paths.settingsPath,
+      plan.paths.subagentsConfigPath,
+      plan.paths.mcpConfigPath
+    ])
+      assertSafePiManagedPath(path);
     const node = execute("node", ["--version"]);
     if (node.exitCode !== 0 || !isVersionAtLeast(node.stdout.trim(), PI_NODE_MINIMUM))
       throw new Error(
@@ -7922,7 +8816,104 @@ function applyPiSetup(plan) {
       ...plan.options.receiptOptions
     };
     const receipt = readPiPackageReceipt(receiptOptions);
-    const configuredBefore = parsePiPackageList(before.stdout);
+    let configuredBefore;
+    try {
+      configuredBefore = resolvePiListedPackages(before.stdout, plan.options);
+    } catch (error) {
+      return {
+        success: false,
+        changed,
+        diagnostics,
+        error: error instanceof Error ? error.message : String(error),
+        failedStep: "preflight",
+        installedPackages
+      };
+    }
+    const incumbentDelegation = findPiIncumbentDelegation(configuredBefore);
+    let configuredProjectPackages;
+    try {
+      configuredProjectPackages = readPiProjectPackages(plan.options);
+      configuredProjectPackages.push(
+        ...scanPiProjectInstalledIncumbents(
+          plan.options,
+          configuredProjectPackages
+        )
+      );
+    } catch (error) {
+      return {
+        success: false,
+        changed,
+        diagnostics,
+        error: error instanceof Error ? error.message : String(error),
+        failedStep: "preflight",
+        installedPackages
+      };
+    }
+    const projectQuestions = findPiIncumbentQuestions([
+      ...configuredBefore.filter(({ scope }) => scope === "project"),
+      ...configuredProjectPackages
+    ]);
+    if (projectQuestions.length > 0) {
+      const recovery = projectQuestions.map(piProjectQuestionConflict).join("\n");
+      return {
+        success: false,
+        changed,
+        diagnostics,
+        error: recovery,
+        failedStep: "preflight",
+        installedPackages,
+        manualRecovery: recovery
+      };
+    }
+    const unpreviewedQuestions = piUnpreviewedQuestionRecovery(
+      plan,
+      findPiIncumbentQuestions(configuredBefore)
+    );
+    if (unpreviewedQuestions)
+      return {
+        success: false,
+        changed,
+        diagnostics,
+        error: unpreviewedQuestions,
+        failedStep: "preflight",
+        installedPackages,
+        manualRecovery: unpreviewedQuestions
+      };
+    const incumbentTodos = findPiIncumbentTodos([
+      ...configuredBefore,
+      ...configuredProjectPackages
+    ]);
+    if (incumbentDelegation || incumbentTodos.length > 0) {
+      const incumbentBlockers = [];
+      const recovery = [];
+      if (incumbentDelegation) {
+        incumbentBlockers.push(
+          `Pi delegation runtime preflight blocked ${incumbentDelegation.candidate.source}: ${incumbentDelegation.reason}. Loading it beside ${PI_PACKAGE_SPECS[0].source} is unsupported.`
+        );
+        recovery.push(piIncumbentDelegationRecovery(incumbentDelegation));
+      }
+      for (const incumbentTodo of incumbentTodos) {
+        const todoRecovery = piIncumbentTodoRecovery(
+          incumbentTodo.source,
+          incumbentTodo.scope,
+          incumbentTodo.identityLimitation,
+          incumbentTodo.unmappedSource
+        );
+        incumbentBlockers.push(
+          `Pi task-list preflight blocked ${incumbentTodo.source}: it conflicts with @thoth-agents/pi-todo. ${todoRecovery}`
+        );
+        recovery.push(todoRecovery);
+      }
+      return {
+        success: false,
+        changed,
+        diagnostics,
+        error: incumbentBlockers.join("\n"),
+        failedStep: "preflight",
+        installedPackages,
+        manualRecovery: `Manual recovery: ${recovery.join(" ")}`
+      };
+    }
     const knownReceiptSource = receipt.status === "valid" ? receipt.receipt.source : void 0;
     const firstPartyBefore = getPiFirstPartyPackages(
       configuredBefore,
@@ -7943,6 +8934,20 @@ function applyPiSetup(plan) {
       throw new Error(
         `First-party Pi package ownership conflict: ${ownership.reason ?? ownership.state}`
       );
+    const identityRecovery = piQuestionIdentityBlockers(
+      [...configuredBefore, ...configuredProjectPackages],
+      plan
+    ).join("\n");
+    if (identityRecovery)
+      return {
+        success: false,
+        changed,
+        diagnostics,
+        error: identityRecovery,
+        failedStep: "preflight",
+        installedPackages,
+        manualRecovery: identityRecovery
+      };
     const installed = execute("pi", ["install", desiredSource, "--no-approve"]);
     if (installed.exitCode !== 0)
       throw new Error(
@@ -7972,7 +8977,7 @@ function applyPiSetup(plan) {
           `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())
+      if (!resolvedPackageRoot || !isAbsolute4(resolvedPackageRoot) || !existsSync14(resolvedPackageRoot) || !lstatSync4(resolvedPackageRoot).isDirectory() || lstatSync4(resolvedPackageRoot).isSymbolicLink())
         throw new Error(
           `Pi did not report one absolute regular installed directory for ${desiredSource}.`
         );
@@ -8050,25 +9055,130 @@ function applyPiSetup(plan) {
     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)
+    const questionListing = execute("pi", ["list", "--no-approve"]);
+    if (questionListing.exitCode !== 0)
+      throw new Error(
+        `Unable to inspect conflicting Pi question packages: ${questionListing.stderr.trim() || "pi list unavailable"}`
+      );
+    const questionPackages = resolvePiListedPackages(
+      questionListing.stdout,
+      plan.options
+    );
+    const freshProjectQuestions = findPiIncumbentQuestions(
+      questionPackages
+    ).filter(({ scope }) => scope === "project");
+    const questionRecovery = freshProjectQuestions.length > 0 ? freshProjectQuestions.map(piProjectQuestionConflict).join("\n") : piUnpreviewedQuestionRecovery(
+      plan,
+      findPiIncumbentQuestions(questionPackages)
+    ) ?? (piQuestionIdentityBlockers(questionPackages, plan).join("\n") || void 0);
+    if (questionRecovery) {
+      manualRecovery = questionRecovery;
+      throw new Error(questionRecovery);
+    }
+    const incumbentQuestions = findPiIncumbentQuestions(
+      questionPackages
+    ).filter(({ scope }) => scope === "user");
+    for (const incumbent of incumbentQuestions) {
+      const unpreviewed = piUnpreviewedQuestionRecovery(plan, [incumbent]);
+      if (unpreviewed) {
+        manualRecovery = unpreviewed;
+        throw new Error(unpreviewed);
+      }
+      const removed = execute("pi", [
+        "remove",
+        incumbent.source,
+        "--no-approve"
+      ]);
+      if (removed.exitCode !== 0)
+        throw new Error(
+          `Failed to remove conflicting Pi question package ${incumbent.source}: ${removed.stderr.trim() || "unknown Pi error"}`
+        );
+    }
+    if (incumbentQuestions.length > 0) {
+      const afterRemoval = execute("pi", ["list", "--no-approve"]);
+      const remaining = resolvePiListedPackages(
+        afterRemoval.stdout,
+        plan.options
+      );
+      const identityRecovery2 = piQuestionIdentityBlockers(remaining, plan).join(
+        "\n"
+      );
+      if (identityRecovery2) {
+        manualRecovery = identityRecovery2;
+        throw new Error(identityRecovery2);
+      }
+      if (afterRemoval.exitCode !== 0 || findPiIncumbentQuestions(remaining).some(
+        ({ scope }) => scope === "user"
+      ) || remaining.some(
+        ({ scope, source }) => scope === "user" && incumbentQuestions.some((incumbent) => incumbent.source === source)
+      ))
         throw new Error(
-          `Failed to install ${pkg.source}: ${result.stderr.trim() || "unknown Pi error"}`
+          "Pi did not verify removal of the conflicting user question package; rerun pi list and remove it before retrying setup."
         );
+    }
+    for (const pkg of getPiExternalPackageSpecs(plan.options)) {
+      const beforeInstall = execute("pi", ["list", "--no-approve"]);
+      if (beforeInstall.exitCode !== 0)
+        throw new Error(
+          `Unable to inspect ${pkg.packageName} before installation: ${beforeInstall.stderr.trim() || "pi list unavailable"}`
+        );
+      const prior = inspectPiExternalPackage(
+        parsePiPackageList(beforeInstall.stdout),
+        pkg,
+        false
+      );
+      const priorSourceMatches = prior.state === "installed" && prior.source !== void 0 && prior.installedPath !== void 0 && piExternalSourceMatches(
+        {
+          scope: "user",
+          source: prior.source,
+          installedPath: prior.installedPath
+        },
+        pkg.source
+      );
+      if (!priorSourceMatches) {
+        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)) {
+      const verified = listed.exitCode === 0 ? inspectPiExternalPackage(parsePiPackageList(listed.stdout), pkg) : {
+        state: "drift",
+        version: void 0,
+        reason: listed.stderr.trim() || "pi list unavailable"
+      };
+      if (prior.state === "installed" && verified.version !== void 0 && lt(verified.version, prior.version)) {
+        const restoreSource = prior.source ?? `npm:${pkg.packageName}@${prior.version}`;
+        const restored = execute("pi", [
+          "install",
+          restoreSource,
+          "--no-approve"
+        ]);
+        const restoredListing = execute("pi", ["list", "--no-approve"]);
+        const restoredEvidence = restored.exitCode === 0 && restoredListing.exitCode === 0 ? inspectPiExternalPackage(
+          parsePiPackageList(restoredListing.stdout),
+          pkg,
+          false
+        ) : void 0;
+        const recoverySucceeded = restoredEvidence?.state === "installed" && restoredEvidence.source === prior.source && restoredEvidence.version === prior.version;
+        const recoveryGuidance = `Manual recovery: run pi install ${restoreSource} --no-approve, then verify with pi list and the installed package manifest.`;
+        manualRecovery = recoveryGuidance;
         throw new Error(
-          `Pi did not verify the exact installed package source ${pkg.source}.`
+          `Pi attempted to downgrade ${pkg.packageName} from ${prior.version} to ${verified.version}; exact-version recovery ${recoverySucceeded ? "verified" : "failed or unverifiable"}. ${recoveryGuidance}`
         );
       }
+      if (verified.state !== "installed")
+        throw new Error(`Pi did not verify ${pkg.source}: ${verified.reason}.`);
       installedPackages.push(pkg.source);
     }
     for (const item of plan.items.filter(
-      (candidate) => candidate.content !== void 0 && candidate.kind === "mcp"
+      (candidate) => candidate.content !== void 0 && (candidate.kind === "settings" || candidate.kind === "mcp")
     )) {
-      if (writePiManagedText(item.target, item.content ?? ""))
-        changed.push(item.target);
+      const content = item.target === plan.paths.subagentsConfigPath ? `${JSON.stringify(mergePiSubagentsConfig(readJsonObject(item.target)), null, 2)}
+` : item.target === plan.paths.mcpConfigPath ? `${JSON.stringify(mergePiGrepMcpConfig(readJsonObject(item.target)), null, 2)}
+` : item.content ?? "";
+      if (writePiManagedText(item.target, content)) changed.push(item.target);
     }
     const resources = syncPiSpecialists({
       packageRoot: configuredPackageRoot,
@@ -8097,7 +9207,8 @@ function applyPiSetup(plan) {
       error: error instanceof Error ? error.message : String(error),
       failedStep: installedPackages.length < plan.items.filter((item) => item.kind === "package").length ? "package" : "managed-surface",
       installedPackages,
-      receiptCommitted
+      receiptCommitted,
+      manualRecovery
     };
   }
 }
@@ -8177,7 +9288,11 @@ function disclaimers() {
     },
     {
       code: "pi-runtime-owned",
-      message: "Pi and pi-subagents own execution, concurrency, task/history storage, trust, and lifecycle."
+      message: `Pi and ${PI_PACKAGE_SPECS[0].packageName} own execution, concurrency, task/history storage, trust, and lifecycle.`
+    },
+    {
+      code: "pi-lean-resources-global-only",
+      message: "Global subagents.json requests lean session resources; project-local subagents.json may override it, and full child resource mode is unsupported."
     },
     {
       code: "pi-research-independent",
@@ -8237,6 +9352,12 @@ function runtimeTarget(provider, evidence) {
     description: evidence.basis.join("; ")
   };
 }
+function incumbentDelegationRecovery(incumbent) {
+  return `Incumbent Pi delegation runtime ${incumbent.candidate.source} conflicts with ${PI_PACKAGE_SPECS[0].source}. ${piIncumbentDelegationRecovery(incumbent)}`;
+}
+function incumbentTodoRecovery(incumbent) {
+  return `Incumbent Pi task-list package ${incumbent.source} conflicts with @thoth-agents/pi-todo. ${piIncumbentTodoRecovery(incumbent.source, incumbent.scope, incumbent.identityLimitation, incumbent.unmappedSource)}`;
+}
 function runtimeDiagnostic(provider, evidence) {
   if (evidence.state === "ready") return void 0;
   const code = `pi-${provider}-runtime-${evidence.state}`;
@@ -8252,12 +9373,13 @@ function statusFromPlan(plan, context2, evidence = {}) {
     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",
+    state: item.kind === "package" ? "unknown" : existsSync15(item.target) ? item.content === void 0 || readFileSync14(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
+    description: item.kind === "package" ? "Validated installed-package manifest evidence; this does not prove live tool availability." : void 0
   }));
   const execute = context2.piCommandExecutor ?? ((command, args) => {
     const result = spawnSync7(command, [...args], {
+      windowsHide: true,
       encoding: "utf8",
       timeout: 5e3,
       env: {
@@ -8293,19 +9415,64 @@ function statusFromPlan(plan, context2, evidence = {}) {
       observed: pi.stdout.trim() || pi.stderr.trim() || "unavailable"
     }
   );
+  const configuredPackages = packages.exitCode === 0 ? parsePiPackageList(packages.stdout) : [];
+  const incumbentDelegation = findPiIncumbentDelegation(configuredPackages);
+  const incumbentTodos = [
+    ...findPiIncumbentTodos(configuredPackages),
+    ...plan.projectIncumbentTodos ?? []
+  ];
+  const packageSpecs = getPiExternalPackageSpecs(plan.options);
   for (const target of targets.filter(
-    (candidate) => candidate.kind === "package" && candidate.path?.startsWith("npm:")
+    (candidate) => candidate.kind === "package" && packageSpecs.some(({ source }) => source === candidate.path)
   )) {
-    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 externalSpec = packageSpecs.find(
+      ({ source }) => source === target.path
+    );
+    if (packages.exitCode !== 0) {
+      target.state = "unknown";
+      target.observed = packages.stderr.trim() || "pi list unavailable";
+    } else if (externalSpec) {
+      const inspected = inspectPiExternalPackage(
+        configuredPackages,
+        externalSpec,
+        externalSpec.id !== "delegation" || plan.options.runtimePackageRoot !== void 0
+      );
+      target.state = inspected.state;
+      target.observed = inspected.state === "installed" ? inspected.version : inspected.reason;
+    } else {
+      const packageName = target.path?.replace(/^npm:/, "").replace(/@[^@]+$/, "");
+      target.state = hasExactInstalledPiPackage(
+        packages.stdout,
+        target.path ?? ""
+      ) ? "installed" : packageName && packages.stdout.includes(packageName) ? "drift" : "missing";
+      target.observed = target.state;
+    }
   }
+  if (incumbentDelegation)
+    targets.push({
+      kind: "package",
+      path: incumbentDelegation.candidate.source,
+      label: "Pi incumbent delegation runtime",
+      state: "drift",
+      expected: `not configured alongside ${PI_PACKAGE_SPECS[0].packageName}`,
+      observed: incumbentDelegation.candidate.source,
+      description: incumbentDelegationRecovery(incumbentDelegation)
+    });
+  for (const incumbentTodo of incumbentTodos)
+    targets.push({
+      kind: "package",
+      path: incumbentTodo.source,
+      label: "Pi incumbent task-list package",
+      state: "drift",
+      expected: "not configured alongside @thoth-agents/pi-todo",
+      observed: incumbentTodo.source,
+      description: incumbentTodoRecovery(incumbentTodo)
+    });
   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
@@ -8340,7 +9507,7 @@ function statusFromPlan(plan, context2, evidence = {}) {
     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;
+    const configured = ownership.state === "owned-current" && configuredCandidates.length === 1 && configuredPath !== void 0 && isAbsolute5(configuredPath) && localPathMatches;
     if (configured) validatedPackageRoot = configuredPath;
     targets.push({
       kind: "surface",
@@ -8350,11 +9517,11 @@ function statusFromPlan(plan, context2, evidence = {}) {
       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;
+    const extensionPath = configuredPath ? join13(configuredPath, "dist", "pi.js") : void 0;
+    const manifestPath = configuredPath ? join13(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;
+      receiptMatches = createHash6("sha256").update(readFileSync14(extensionPath)).digest("hex") === receipt.receipt.extensionSha256 && createHash6("sha256").update(readFileSync14(manifestPath)).digest("hex") === receipt.receipt.manifestSha256;
     targets.push({
       kind: "surface",
       path: extensionPath,
@@ -8381,7 +9548,7 @@ function statusFromPlan(plan, context2, evidence = {}) {
       } : void 0);
       return {
         kind: "skill",
-        path: join12(skill.destinationPath, "SKILL.md"),
+        path: join13(skill.destinationPath, "SKILL.md"),
         label: `Pi package-declared skill: ${skill.name}`,
         state: issue?.state ?? "installed",
         ...issue ? { observed: issue.message } : {}
@@ -8417,6 +9584,33 @@ function statusFromPlan(plan, context2, evidence = {}) {
     ...plan.blockers.map(
       (message) => warning3(message, "pi-preflight-blocked", "critical")
     ),
+    ...incumbentDelegation && !plan.blockers.some(
+      (message) => message.includes(incumbentDelegation.candidate.source)
+    ) ? [
+      warning3(
+        incumbentDelegationRecovery(incumbentDelegation),
+        "pi-incumbent-delegation-conflict",
+        "critical"
+      )
+    ] : [],
+    ...incumbentTodos.filter(
+      (incumbentTodo) => !plan.blockers.some(
+        (message) => message.includes(incumbentTodo.source) && message.includes(
+          piIncumbentTodoRecovery(
+            incumbentTodo.source,
+            incumbentTodo.scope,
+            incumbentTodo.identityLimitation,
+            incumbentTodo.unmappedSource
+          )
+        )
+      )
+    ).map(
+      (incumbentTodo) => warning3(
+        incumbentTodoRecovery(incumbentTodo),
+        "pi-incumbent-todo-conflict",
+        "critical"
+      )
+    ),
     ...plan.diagnostics.map(
       (message) => warning3(message, "pi-resource-shadowing")
     ),
@@ -8457,6 +9651,7 @@ function contextPlan(context2, dryRun = true) {
     homeDir: context2.homeDir,
     commandExecutor: context2.piCommandExecutor,
     packageRoot: context2.packageRoot ?? (version.ok ? version.packageRoot : void 0),
+    runtimePackageRoot: context2.runtimePackageRoot,
     expectedVersion: version.ok ? version.version : void 0,
     receiptOptions: context2.installLedgerOptions
   });
@@ -8476,7 +9671,7 @@ function configuredPackageRootFromStatus(status) {
   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;
+  return ownership?.observed === "owned-current" && configured?.state === "installed" && configured.path && isAbsolute5(configured.path) ? configured.path : void 0;
 }
 function piPlan(action, context2) {
   const setup = contextPlan(context2);
@@ -8502,7 +9697,7 @@ function piPlan(action, context2) {
   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"
+    preview: configuredPackageRoot ? getPiOwnedSkillEntries({ packageRoot: configuredPackageRoot }).map((entry) => join13(entry.destinationPath, "SKILL.md")).join(", ") : "unavailable until the first-party Pi package is receipt-validated"
   });
   if (complete) {
     items.push(
@@ -8553,6 +9748,25 @@ function piPlan(action, context2) {
       observed: `${ownershipState}; remove the configured first-party package manually or restore its matching receipt before applying ${action}.`
     }
   ] : [];
+  const incumbentDelegation = status.targets.find(
+    ({ label }) => label === "Pi incumbent delegation runtime"
+  );
+  const delegationBlockers = incumbentDelegation ? [
+    {
+      kind: "package",
+      path: incumbentDelegation.path,
+      label: "Pi delegation runtime blocker",
+      state: "drift",
+      observed: incumbentDelegation.description ?? `${incumbentDelegation.observed} conflicts with ${PI_PACKAGE_SPECS[0].source}. Remove it manually before applying ${action}.`
+    }
+  ] : [];
+  const todoBlockers = status.targets.filter(({ label }) => label === "Pi incumbent task-list package").map((incumbentTodo) => ({
+    kind: "package",
+    path: incumbentTodo.path,
+    label: "Pi task-list package blocker",
+    state: "drift",
+    observed: incumbentTodo.description ?? `${incumbentTodo.observed} conflicts with @thoth-agents/pi-todo. Remove it manually before applying ${action}.`
+  }));
   const syncSkillsUnavailable = action === "sync" && (!configuredPackageRoot || status.targets.some(
     ({ label, state }) => label?.startsWith("Pi package-declared skill:") && state !== "installed"
   ));
@@ -8571,7 +9785,7 @@ function piPlan(action, context2) {
     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,
+    canApply: setup.ready && (!complete || version.ok) && ownershipBlockers.length === 0 && delegationBlockers.length === 0 && todoBlockers.length === 0 && syncSkillBlockers.length === 0,
     targets: status.targets,
     blockerTargets: [
       ...setup.blockers.map((message) => ({
@@ -8581,6 +9795,8 @@ function piPlan(action, context2) {
         observed: message
       })),
       ...ownershipBlockers,
+      ...delegationBlockers,
+      ...todoBlockers,
       ...syncSkillBlockers
     ],
     surfaces: setup.items.filter((item) => item.kind !== "preflight").map((item) => ({
@@ -8628,17 +9844,18 @@ function defaultPiModelRoles(context2 = { cwd: process.cwd() }) {
     (role) => isPiSpecialistRole(role.name)
   ).map((role) => {
     const path = plan.items.find(
-      (item) => item.kind === "agent" && basename3(item.target) === `${piSpecialistName(role.name)}.md`
+      (item) => item.kind === "agent" && basename4(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();
+    if (path && existsSync15(path)) {
+      const configured = readPiModelConfig(dirname11(dirname11(path)), [
+        role.name
+      ]).roles[0];
+      if (configured) return configured;
+    }
     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" };
-      })()
+      model: "inherit",
+      effort: { kind: "inherit" }
     };
   });
 }
@@ -8656,7 +9873,7 @@ function buildPiModelPlan(input, context2 = { cwd: process.cwd() }) {
       target: {
         kind: "file",
         path: specialist ? setup.items.find(
-          (item) => item.kind === "agent" && basename3(item.target) === `${specialist}.md`
+          (item) => item.kind === "agent" && basename4(item.target) === `${specialist}.md`
         )?.target : void 0,
         label: `Pi ${role.role} specialist`
       },
@@ -8696,26 +9913,35 @@ function buildPiModelPlan(input, context2 = { cwd: process.cwd() }) {
     ],
     disclaimers: disclaimers()
   };
-  planSources.set(plan, { setup, context: context2, model: input });
+  let modelSnapshot;
+  if (!invalid && input.roles.length > 0) {
+    const path = items[0]?.target.path;
+    if (path && items.every((item) => item.target.path && existsSync15(item.target.path))) {
+      try {
+        modelSnapshot = readPiModelConfig(
+          dirname11(dirname11(path)),
+          input.roles.map(({ role }) => role)
+        );
+      } catch (error) {
+        plan.canApply = false;
+        plan.warnings.push(
+          warning3(
+            error instanceof Error ? error.message : String(error),
+            "pi-model-config-invalid",
+            "critical"
+          )
+        );
+      }
+    }
+  }
+  planSources.set(plan, {
+    setup,
+    context: context2,
+    model: structuredClone(input),
+    modelSnapshot
+  });
   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" }));
@@ -8737,28 +9963,23 @@ function applyPiPlan(plan) {
       "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
+    if (!source.modelSnapshot)
+      return reject(
+        "Owned Pi specialist definitions were missing at preview. Reopen model configuration."
+      );
+    const snapshot = source.modelSnapshot;
+    const result = savePiModelConfig(snapshot, source.model.roles);
+    const changedTargets = fileTargets(
+      result.changedRoles.map(
+        (role) => join13(snapshot.piRoot, "agents", `${piSpecialistName(role)}.md`)
+      )
+    );
+    source.modelSnapshot = result.snapshot;
+    if (!result.success)
+      return reject(
+        result.error ?? "Pi model configuration failed.",
+        changedTargets
       );
-      writePiManagedText(target, content);
-      changedTargets.push({
-        kind: "file",
-        path: target,
-        label: `Pi ${role.role} specialist`,
-        state: "installed"
-      });
-    }
     return {
       harness: "pi",
       action: plan.action,
@@ -8832,7 +10053,7 @@ function applyPiPlan(plan) {
       changedTargets: fileTargets(changed),
       diagnosticTargets: packageSkills.skills.map((skill) => ({
         kind: "skill",
-        path: join12(skill.destinationPath, "SKILL.md"),
+        path: join13(skill.destinationPath, "SKILL.md"),
         label: `Pi package-declared skill: ${skill.name}`,
         state: "installed"
       })),
@@ -8919,7 +10140,7 @@ function applyPiPlan(plan) {
       ],
       diagnosticTargets: packageSkills.skills.map((skill) => ({
         kind: "skill",
-        path: join12(skill.destinationPath, "SKILL.md"),
+        path: join13(skill.destinationPath, "SKILL.md"),
         label: `Pi package-declared skill: ${skill.name}`,
         state: "installed"
       })),
@@ -8956,14 +10177,14 @@ import { execFileSync } from "child_process";
 // src/cli/model-catalog/cache.ts
 import {
   existsSync as existsSync16,
-  mkdirSync as mkdirSync8,
-  readFileSync as readFileSync13,
-  renameSync as renameSync7,
+  mkdirSync as mkdirSync7,
+  readFileSync as readFileSync15,
+  renameSync as renameSync6,
   unlinkSync,
-  writeFileSync as writeFileSync8
+  writeFileSync as writeFileSync7
 } from "fs";
 import { homedir as homedir7 } from "os";
-import { dirname as dirname10, posix, win32 } from "path";
+import { dirname as dirname12, posix, win32 as win322 } from "path";
 import { z as z2 } from "zod";
 var modelCatalogSourceSchema = z2.enum(["remote", "lkg", "manual"]);
 var cachedModelOptionSchema = z2.object({
@@ -8985,7 +10206,7 @@ function resolveModelsDevCachePath(options = {}) {
   const env = options.env ?? process.env;
   const home = options.homeDir ?? homedir7();
   if (platform === "win32") {
-    const path = win32;
+    const path = win322;
     const base2 = env.LOCALAPPDATA ?? env.APPDATA ?? path.join(home, "AppData", "Local");
     return path.join(base2, "thoth-agents", "models-dev-v1.json");
   }
@@ -8995,7 +10216,7 @@ function resolveModelsDevCachePath(options = {}) {
 function readModelsDevCache(cachePath) {
   if (!existsSync16(cachePath)) return void 0;
   try {
-    const input = JSON.parse(readFileSync13(cachePath, "utf8"));
+    const input = JSON.parse(readFileSync15(cachePath, "utf8"));
     const parsed = modelsDevCacheSchema.safeParse(input);
     return parsed.success ? parsed.data : void 0;
   } catch {
@@ -9007,15 +10228,15 @@ function writeModelsDevCacheAtomic(cachePath, cache) {
   if (!validated.success) {
     throw new Error(`Invalid models.dev cache: ${validated.error.message}`);
   }
-  mkdirSync8(dirname10(cachePath), { recursive: true });
+  mkdirSync7(dirname12(cachePath), { recursive: true });
   const temporaryPath = `${cachePath}.${process.pid}.${Date.now()}.tmp`;
   try {
-    writeFileSync8(
+    writeFileSync7(
       temporaryPath,
       `${JSON.stringify(validated.data, null, 2)}
 `
     );
-    renameSync7(temporaryPath, cachePath);
+    renameSync6(temporaryPath, cachePath);
   } catch (error) {
     if (existsSync16(temporaryPath)) unlinkSync(temporaryPath);
     throw error;
@@ -9210,7 +10431,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);
+var PI_EFFORTS = new Set(PI_EFFORT_VALUES);
 function parseOpenCodeModels(output) {
   const seen = /* @__PURE__ */ new Set();
   const options = [];
@@ -9247,7 +10468,7 @@ function writableEfforts(harness, option) {
     );
   }
   if (harness === "pi") {
-    return option.efforts.filter((effort) => PI_EFFORTS2.has(effort));
+    return option.efforts.filter((effort) => PI_EFFORTS.has(effort));
   }
   return option.efforts.filter(
     (effort) => resolveOpenCodeEffort({
@@ -9280,7 +10501,10 @@ function getNativeOpenCodeOptions() {
   try {
     const invocation = getOpenCodeModelsInvocation();
     return parseOpenCodeModels(
-      execFileSync(invocation.command, invocation.args, invocation.options)
+      execFileSync(invocation.command, invocation.args, {
+        ...invocation.options,
+        windowsHide: true
+      })
     );
   } catch {
     return [];
@@ -9340,7 +10564,38 @@ async function getModelOptions(harness) {
 }
 
 // src/cli/tui/operations.ts
-import { existsSync as existsSync17, readFileSync as readFileSync14 } from "fs";
+import { existsSync as existsSync17, readFileSync as readFileSync16 } from "fs";
+
+// src/cli/model-defaults.ts
+function getShippedModelRoles(harness) {
+  if (harness === "opencode") {
+    return ALL_AGENT_NAMES.map((role) => ({
+      role,
+      model: getDefaultOpenCodeModel(role),
+      effort: { kind: "effort", value: getDefaultOpenCodeVariant(role) }
+    }));
+  }
+  return SUBAGENT_NAMES.map((role) => {
+    if (harness === "claude") {
+      return {
+        role,
+        model: CLAUDE_CODE_SUBAGENT_DEFAULT_MODELS[role],
+        effort: {
+          kind: "effort",
+          value: CLAUDE_CODE_SUBAGENT_DEFAULT_EFFORTS[role]
+        }
+      };
+    }
+    const preset = CONFIRMED_OPENAI_SUBAGENT_PRESET[role];
+    return {
+      role,
+      model: harness === "pi" ? `openai-codex/${preset.model}` : preset.model,
+      effort: { kind: "effort", value: preset.effort }
+    };
+  });
+}
+
+// src/cli/tui/operations.ts
 var context = { cwd: process.cwd() };
 var codexContext = { cwd: process.cwd() };
 var claudeCodeContext = {
@@ -9354,15 +10609,7 @@ var opencodeModelRoles = ALL_AGENT_NAMES.map(
     effort: { kind: "effort", value: getDefaultOpenCodeVariant(role) }
   })
 );
-var codexModelRoles = CODEX_ROLE_NAMES.map(
-  (role) => ({
-    role,
-    model: "gpt-5.4-mini"
-  })
-);
-var codexDefaultModels = new Map(
-  codexModelRoles.map((role) => [role.role, role.model])
-);
+var codexModelRoles = getShippedModelRoles("codex");
 function codexInstallConfig(source, dryRun) {
   return {
     dryRun,
@@ -9378,20 +10625,22 @@ function codexInstallConfig(source, dryRun) {
 function getCodexModelRoles(source = codexContext) {
   try {
     const plan = buildCodexSetupPlan(codexInstallConfig(source, true));
-    return CODEX_ROLE_NAMES.map((role) => {
-      const item = plan.items.find(
-        (candidate) => candidate.action === "write-role-toml" && candidate.role === role
-      );
-      const content = item && existsSync17(item.targetPath) ? readFileSync14(item.targetPath, "utf8") : item?.content;
-      const effort = content ? parseRoleTomlEffort(content) : void 0;
-      return {
-        role,
-        model: (content ? parseRoleTomlModel(content) : void 0) ?? codexDefaultModels.get(role) ?? "gpt-5.4-mini",
-        effort: effort ? { kind: "effort", value: effort } : { kind: "inherit" }
-      };
-    });
+    return getShippedModelRoles("codex").map(
+      ({ role, model: defaultModel }) => {
+        const item = plan.items.find(
+          (candidate) => candidate.action === "write-role-toml" && candidate.role === role
+        );
+        const content = item && existsSync17(item.targetPath) ? readFileSync16(item.targetPath, "utf8") : item?.content;
+        const effort = content ? parseRoleTomlEffort(content) : void 0;
+        return {
+          role,
+          model: (content ? parseRoleTomlModel(content) : void 0) ?? defaultModel,
+          effort: effort ? { kind: "effort", value: effort } : { kind: "inherit" }
+        };
+      }
+    );
   } catch {
-    return codexModelRoles.map((role) => ({ ...role }));
+    return getShippedModelRoles("codex");
   }
 }
 function getClaudeCodeModelRoles(_source = claudeCodeContext) {
@@ -9432,20 +10681,32 @@ function getOpenCodeModelRoles() {
     };
   });
 }
-function buildTuiModelPlan(harness, roles) {
+function buildTuiModelPlan(harness, roles, source = context) {
   if (harness === "opencode") {
-    return buildOpenCodeModelPlan({ harness, dryRun: true, roles }, context);
+    return buildOpenCodeModelPlan({ harness, dryRun: true, roles }, source);
   }
   if (harness === "claude") {
-    return buildClaudeCodeModelPlan(
-      { harness, dryRun: true, roles },
-      claudeCodeContext
-    );
+    return buildClaudeCodeModelPlan({ harness, dryRun: true, roles }, source);
   }
   if (harness === "pi") {
-    return buildPiModelPlan({ harness, dryRun: true, roles }, context);
+    return buildPiModelPlan({ harness, dryRun: true, roles }, source);
   }
-  return buildCodexModelPlan({ harness, dryRun: true, roles }, codexContext);
+  return buildCodexModelPlan({ harness, dryRun: true, roles }, source);
+}
+function buildRestoreModelPlan(harness, options, source = context) {
+  const roles = getShippedModelRoles(harness).map((role) => {
+    const catalogId = harness === "codex" ? `openai/${role.model}` : harness === "pi" ? role.model.replace(/^openai-codex\//, "openai/") : role.model;
+    const option = options.find((candidate) => candidate.id === role.model) ?? options.find((candidate) => candidate.catalogId === catalogId);
+    return {
+      ...role,
+      ...option ? {
+        provider: option.provider,
+        catalogId: option.catalogId,
+        availableEfforts: [...option.efforts]
+      } : {}
+    };
+  });
+  return buildTuiModelPlan(harness, roles, source);
 }
 var defaultTuiOperations = {
   status(harness, evidence) {
@@ -9501,6 +10762,9 @@ var defaultTuiOperations = {
   modelPlan(harness, roles) {
     return buildTuiModelPlan(harness, roles);
   },
+  restoreModelPlan(harness, options) {
+    return buildRestoreModelPlan(harness, options);
+  },
   apply(plan) {
     if (plan.harness === "opencode") return applyOpenCodePlan(plan);
     if (plan.harness === "claude") return applyClaudeCodePlan(plan);
@@ -9566,3 +10830,9 @@ export {
   getOpenCodeModelRoles,
   defaultTuiOperations
 };
+/*! @license
+ * Portions ported from @earendil-works/pi-coding-agent 1.0.2
+ * (dist/utils/git.js:parseGitUrl and its helpers).
+ * Copyright (c) 2025 Mario Zechner. MIT License; see the third-party notice
+ * in this package's LICENSE file.
+ */