@staff0rd/assist 0.393.0 → 0.395.0

package/dist/index.js

@@ -6,7 +6,7 @@ import { Command } from "commander";
 // package.json
 var package_default = {
   name: "@staff0rd/assist",
-  version: "0.393.0",
+  version: "0.395.0",
   type: "module",
   main: "dist/index.js",
   bin: {
@@ -18,6 +18,7 @@ var package_default = {
     "dist",
     "claude",
     "codex",
+    "pi",
     "allowed.cli-reads",
     "allowed.cli-writes"
   ],
@@ -141,10 +142,10 @@ import { stringify as stringifyYaml } from "yaml";
 // src/shared/loadRawYaml.ts
 import { existsSync, readFileSync } from "fs";
 import { parse as parseYaml } from "yaml";
-function loadRawYaml(path64) {
-  if (!existsSync(path64)) return {};
+function loadRawYaml(path67) {
+  if (!existsSync(path67)) return {};
   try {
-    const content = readFileSync(path64, "utf8");
+    const content = readFileSync(path67, "utf8");
     return parseYaml(content) || {};
   } catch {
     return {};
@@ -344,8 +345,9 @@ var assistConfigSchema = z2.strictObject({
     autoConfirm: z2.boolean().default(false)
   }).default({ autoConfirm: false }),
   harness: z2.strictObject({
-    engine: z2.enum(["claude", "codex"]).default("claude"),
-    exposeCodexActions: z2.boolean().optional()
+    engine: z2.enum(["claude", "codex", "pi"]).default("claude"),
+    exposeCodexActions: z2.boolean().optional(),
+    exposePiActions: z2.boolean().optional()
   }).default({ engine: "claude" }),
   voice: z2.strictObject({
     wakeWords: z2.array(z2.string()).default(DEFAULT_WAKE_WORDS),
@@ -1361,8 +1363,8 @@ function findUnmergedPaths() {
   }
   const found = /* @__PURE__ */ new Set();
   for (const line of output.split("\n")) {
-    const path64 = line.split("	")[1];
-    if (path64) found.add(path64.trim());
+    const path67 = line.split("	")[1];
+    if (path67) found.add(path67.trim());
   }
   return [...found];
 }
@@ -1461,8 +1463,8 @@ function getPreferredRemoteRepo(cwd) {
 function gitRefUrl(kind, ref, cwd) {
   const repo = getPreferredRemoteRepo(cwd);
   if (!repo) return void 0;
-  const path64 = kind === "branch" ? "tree" : "commit";
-  return `https://github.com/${repo.org}/${repo.repo}/${path64}/${ref}`;
+  const path67 = kind === "branch" ? "tree" : "commit";
+  return `https://github.com/${repo.org}/${repo.repo}/${path67}/${ref}`;
 }
 
 // src/commands/commit/collectCommitRefs.ts
@@ -3233,9 +3235,9 @@ import { existsSync as existsSync12, readFileSync as readFileSync9 } from "fs";
 
 // src/commands/verify/forbiddenStrings/findForbiddenStrings.ts
 import { minimatch as minimatch2 } from "minimatch";
-function resolveStringsAtPath(data, path64) {
+function resolveStringsAtPath(data, path67) {
   let current = data;
-  for (const segment of path64.split(".")) {
+  for (const segment of path67.split(".")) {
     if (current === null || typeof current !== "object") return [];
     current = current[segment];
   }
@@ -3248,10 +3250,10 @@ function resolveStringsAtPath(data, path64) {
 }
 function findRuleViolations(data, rule) {
   const violations = [];
-  for (const path64 of rule.paths) {
-    for (const value of resolveStringsAtPath(data, path64)) {
+  for (const path67 of rule.paths) {
+    for (const value of resolveStringsAtPath(data, path67)) {
       if (minimatch2(value, rule.disallowed))
-        violations.push({ file: rule.file, path: path64, value });
+        violations.push({ file: rule.file, path: path67, value });
     }
   }
   return violations;
@@ -3290,8 +3292,8 @@ function forbiddenStrings() {
     process.exit(0);
   }
   console.log("Forbidden strings found:\n");
-  for (const { file, path: path64, value } of violations) {
-    console.log(`  ${file} ${path64}: ${value}`);
+  for (const { file, path: path67, value } of violations) {
+    console.log(`  ${file} ${path67}: ${value}`);
   }
   console.log(`
 Total: ${violations.length} forbidden string(s).`);
@@ -3583,15 +3585,15 @@ function readBaselineMigrations(repoRelativeDir, ref) {
   } catch {
     return baseline;
   }
-  const paths = listing.split("\n").map((line) => line.trim()).filter(Boolean).filter((path64) => MIGRATION_FILE3.test(basename(path64)));
-  for (const path64 of paths) {
+  const paths = listing.split("\n").map((line) => line.trim()).filter(Boolean).filter((path67) => MIGRATION_FILE3.test(basename(path67)));
+  for (const path67 of paths) {
     try {
-      const content = execSync12(`git show "${ref}:${path64}"`, {
+      const content = execSync12(`git show "${ref}:${path67}"`, {
         encoding: "utf8",
         maxBuffer: 16 * 1024 * 1024,
         stdio: ["pipe", "pipe", "pipe"]
       });
-      baseline.set(basename(path64), content);
+      baseline.set(basename(path67), content);
     } catch {
     }
   }
@@ -4956,15 +4958,15 @@ var hooksSettings = {
   }
 };
 function ensureHooksSettings() {
-  const path64 = daemonPaths.hooksSettings;
-  mkdirSync5(dirname12(path64), { recursive: true });
-  writeFileSync15(path64, JSON.stringify(hooksSettings, null, 2));
-  return path64;
+  const path67 = daemonPaths.hooksSettings;
+  mkdirSync5(dirname12(path67), { recursive: true });
+  writeFileSync15(path67, JSON.stringify(hooksSettings, null, 2));
+  return path67;
 }
 
 // src/shared/spawnInherit.ts
 import { spawn as spawn3 } from "child_process";
-function spawnInherit(command, args) {
+function spawnInherit(command, args, options2 = {}) {
   const {
     ASSIST_ACTIVITY_ID: _activityId,
     CLAUDE_CODE_CHILD_SESSION: _childSession,
@@ -4972,7 +4974,8 @@ function spawnInherit(command, args) {
   } = process.env;
   const child = spawn3(command, args, {
     stdio: "inherit",
-    env
+    env,
+    cwd: options2.cwd
   });
   const done2 = new Promise((resolve18, reject) => {
     child.on("close", (code) => resolve18(code ?? 0));
@@ -5223,9 +5226,9 @@ var LOCAL_FILES = ["backlog.jsonl", "backlog.db"];
 function backupLocalBacklogFiles(dir) {
   const moved = [];
   for (const name of LOCAL_FILES) {
-    const path64 = join15(dir, ".assist", name);
-    if (existsSync18(path64)) {
-      renameSync(path64, `${path64}.bak`);
+    const path67 = join15(dir, ".assist", name);
+    if (existsSync18(path67)) {
+      renameSync(path67, `${path67}.bak`);
       moved.push(`${name} \u2192 ${name}.bak`);
     }
   }
@@ -5664,8 +5667,8 @@ var backlogItemSchema = z3.strictObject({
 var backlogFileSchema = z3.array(backlogItemSchema);
 
 // src/commands/backlog/parseBacklogJsonl.ts
-function parseBacklogJsonl(path64) {
-  const content = readFileSync14(path64, "utf8").trim();
+function parseBacklogJsonl(path67) {
+  const content = readFileSync14(path67, "utf8").trim();
   if (content.length === 0) return [];
   return content.split("\n").map((line) => line.trim()).filter(Boolean).map((line) => backlogItemSchema.parse(JSON.parse(line)));
 }
@@ -5747,8 +5750,8 @@ function findBacklogUp(startDir) {
 
 // src/commands/backlog/getCurrentOrigin.ts
 import { execFileSync } from "child_process";
-function stripLeadingSlashes(path64) {
-  return path64.replace(/^\/+/, "");
+function stripLeadingSlashes(path67) {
+  return path67.replace(/^\/+/, "");
 }
 function normalizeOrigin(raw) {
   const trimmed = raw.trim().replace(/\.git$/i, "").replace(/\/+$/, "");
@@ -6288,24 +6291,24 @@ function getOwnerPath(itemId2) {
 function recordSignalOwner(itemId2) {
   const sessionId = process.env.ASSIST_SESSION_ID;
   if (!sessionId) return;
-  const path64 = getOwnerPath(itemId2);
-  mkdirSync7(dirname14(path64), { recursive: true });
-  writeFileSync17(path64, JSON.stringify({ sessionId }));
+  const path67 = getOwnerPath(itemId2);
+  mkdirSync7(dirname14(path67), { recursive: true });
+  writeFileSync17(path67, JSON.stringify({ sessionId }));
 }
 function readSignalOwner(itemId2) {
-  const path64 = getOwnerPath(itemId2);
-  if (!existsSync21(path64)) return void 0;
+  const path67 = getOwnerPath(itemId2);
+  if (!existsSync21(path67)) return void 0;
   try {
-    const parsed = JSON.parse(readFileSync15(path64, "utf8"));
+    const parsed = JSON.parse(readFileSync15(path67, "utf8"));
     return parsed.sessionId;
   } catch {
     return void 0;
   }
 }
 function clearSignalOwner(itemId2) {
-  const path64 = getOwnerPath(itemId2);
+  const path67 = getOwnerPath(itemId2);
   try {
-    rmSync(path64);
+    rmSync(path67);
   } catch {
   }
 }
@@ -6342,19 +6345,19 @@ function resolveSignalTarget(event, data) {
 function writeSignal(event, data) {
   const target = resolveSignalTarget(event, data);
   if (!target) return;
-  const path64 = getSignalPath(target);
-  if (!path64) return;
+  const path67 = getSignalPath(target);
+  if (!path67) return;
   const signal = { event, sessionId: target, ...data };
-  mkdirSync8(dirname15(path64), { recursive: true });
-  writeFileSync18(path64, JSON.stringify(signal));
+  mkdirSync8(dirname15(path67), { recursive: true });
+  writeFileSync18(path67, JSON.stringify(signal));
 }
 
 // src/commands/backlog/readSignal.ts
 function readSignal() {
-  const path64 = getSignalPath();
-  if (!path64 || !existsSync22(path64)) return void 0;
+  const path67 = getSignalPath();
+  if (!path67 || !existsSync22(path67)) return void 0;
   try {
-    return JSON.parse(readFileSync16(path64, "utf8"));
+    return JSON.parse(readFileSync16(path67, "utf8"));
   } catch {
     return void 0;
   }
@@ -6434,6 +6437,7 @@ import { dirname as dirname16, join as join20 } from "path";
 import { z as z4 } from "zod";
 var activitySchema = z4.object({
   kind: z4.enum(["command", "backlog"]),
+  harness: z4.enum(["claude", "codex", "pi"]).optional(),
   name: z4.string().optional(),
   itemId: z4.number().optional(),
   itemName: z4.string().optional(),
@@ -6449,13 +6453,13 @@ function activityPath(sessionId) {
 function emitActivity(activity2) {
   const sessionId = process.env.ASSIST_ACTIVITY_ID;
   if (!sessionId) return;
-  const path64 = activityPath(sessionId);
-  mkdirSync9(dirname16(path64), { recursive: true });
-  writeFileSync19(path64, JSON.stringify({ ...activity2, startedAt: Date.now() }));
+  const path67 = activityPath(sessionId);
+  mkdirSync9(dirname16(path67), { recursive: true });
+  writeFileSync19(path67, JSON.stringify({ ...activity2, startedAt: Date.now() }));
 }
-function readActivity(path64) {
+function readActivity(path67) {
   try {
-    return JSON.parse(readFileSync17(path64, "utf8"));
+    return JSON.parse(readFileSync17(path67, "utf8"));
   } catch {
     return void 0;
   }
@@ -6465,9 +6469,9 @@ function reconcileActivity(sessionId, activity2) {
     removeActivity(sessionId);
     return;
   }
-  const path64 = activityPath(sessionId);
-  mkdirSync9(dirname16(path64), { recursive: true });
-  writeFileSync19(path64, JSON.stringify(activity2));
+  const path67 = activityPath(sessionId);
+  mkdirSync9(dirname16(path67), { recursive: true });
+  writeFileSync19(path67, JSON.stringify(activity2));
 }
 function removeActivity(sessionId) {
   try {
@@ -7698,8 +7702,8 @@ async function getBacklogExists(req, res) {
 // src/commands/backlog/originDisplayName.ts
 function originDisplayName(origin) {
   if (origin.startsWith("local:")) {
-    const path64 = origin.slice("local:".length).replace(/\/+$/, "");
-    const segments = path64.split("/").filter(Boolean);
+    const path67 = origin.slice("local:".length).replace(/\/+$/, "");
+    const segments = path67.split("/").filter(Boolean);
     return segments[segments.length - 1] ?? origin;
   }
   const firstSlash = origin.indexOf("/");
@@ -8102,7 +8106,7 @@ function findSynthesisForBranch(repoReviewsDir, branch2) {
   const parent = dirname20(branchKeyPath);
   const branchPrefix = basename5(branchKeyPath);
   if (!existsSync25(parent)) return null;
-  const synthesisFiles = readdirSync2(parent).filter((name) => name.startsWith(branchPrefix)).map((name) => join23(parent, name, "synthesis.md")).filter((path64) => existsSync25(path64)).map((path64) => ({ path: path64, mtime: statSync2(path64).mtimeMs })).sort((a, b) => b.mtime - a.mtime);
+  const synthesisFiles = readdirSync2(parent).filter((name) => name.startsWith(branchPrefix)).map((name) => join23(parent, name, "synthesis.md")).filter((path67) => existsSync25(path67)).map((path67) => ({ path: path67, mtime: statSync2(path67).mtimeMs })).sort((a, b) => b.mtime - a.mtime);
   return synthesisFiles[0]?.path ?? null;
 }
 
@@ -8156,12 +8160,12 @@ async function getReviewSynthesis(req, res) {
   const cwd = getCwdParam(req, res);
   if (!cwd) return;
   try {
-    const path64 = await resolveSynthesisPath(cwd);
-    if (!path64) {
+    const path67 = await resolveSynthesisPath(cwd);
+    if (!path67) {
       respondJson(res, 404, { error: "No synthesis found" });
       return;
     }
-    respondJson(res, 200, { synthesis: readFileSync19(path64, "utf8") });
+    respondJson(res, 200, { synthesis: readFileSync19(path67, "utf8") });
   } catch {
     respondJson(res, 404, { error: "No synthesis found" });
   }
@@ -8272,6 +8276,15 @@ var harnesses = {
       agentsFile: "AGENTS.md",
       commandDest: (name) => path25.join("skills", name, "SKILL.md")
     }
+  },
+  pi: {
+    kind: "pi",
+    command: "pi",
+    homeDir: path25.join(os2.homedir(), ".pi", "agent"),
+    sync: {
+      agentsFile: "AGENTS.md",
+      commandDest: (name) => path25.join("prompts", `${name}.md`)
+    }
   }
 };
 function isHarnessAvailable(kind) {
@@ -8280,9 +8293,12 @@ function isHarnessAvailable(kind) {
 
 // src/commands/sessions/web/harnessCapabilities.ts
 function harnessCapabilities(_req, res) {
-  const forcedOff = loadConfig().harness.exposeCodexActions === false;
-  const exposeCodexActions = !forcedOff && isHarnessAvailable("codex");
-  respondJson(res, 200, { exposeCodexActions });
+  const config = loadConfig().harness;
+  const codexForcedOff = config.exposeCodexActions === false;
+  const exposeCodexActions = !codexForcedOff && isHarnessAvailable("codex");
+  const piForcedOff = config.exposePiActions === false;
+  const exposePiActions = !piForcedOff && isHarnessAvailable("pi");
+  respondJson(res, 200, { exposeCodexActions, exposePiActions });
 }
 
 // src/shared/loadJson.ts
@@ -8296,10 +8312,10 @@ function getStorePath(filename) {
   return join26(getStoreDir(), filename);
 }
 function loadJson(filename) {
-  const path64 = getStorePath(filename);
-  if (existsSync26(path64)) {
+  const path67 = getStorePath(filename);
+  if (existsSync26(path67)) {
     try {
-      return JSON.parse(readFileSync20(path64, "utf8"));
+      return JSON.parse(readFileSync20(path67, "utf8"));
     } catch {
       return {};
     }
@@ -10092,11 +10108,20 @@ function spawnCodex(prompt, options2 = {}) {
   return spawnInherit(harnesses.codex.command, ["-C", cwd, prompt]);
 }
 
+// src/shared/spawnPi.ts
+function spawnPi(prompt, options2 = {}) {
+  const cwd = options2.cwd ?? process.cwd();
+  return spawnInherit(harnesses.pi.command, [prompt], { cwd });
+}
+
 // src/shared/spawnHarness.ts
 function spawnHarness(harness, prompt, options2 = {}) {
   if (harness === "codex") {
     return spawnCodex(prompt, { cwd: options2.cwd });
   }
+  if (harness === "pi") {
+    return spawnPi(prompt, { cwd: options2.cwd });
+  }
   return spawnClaude(prompt, {
     allowEdits: true,
     sessionId: options2.sessionId,
@@ -10261,7 +10286,7 @@ async function refine(id, options2) {
 
 // src/commands/backlog/resolveHarness.ts
 function resolveHarness(value) {
-  if (value === "claude" || value === "codex") return value;
+  if (value === "claude" || value === "codex" || value === "pi") return value;
   return loadConfig().harness.engine;
 }
 
@@ -10269,7 +10294,7 @@ function resolveHarness(value) {
 function registerRefineCommand(cmd) {
   cmd.command("refine").argument("[id]", "Backlog item ID").description("Alias for refine").option("--once", "Exit when the initial task completes").option(
     "--harness <kind>",
-    "Coding harness to launch (claude|codex); defaults to the configured harness.engine"
+    "Coding harness to launch (claude|codex|pi); defaults to the configured harness.engine"
   ).action(
     (id, opts) => refine(id, {
       once: opts.once,
@@ -11543,9 +11568,9 @@ var __dirname4 = dirname21(__filename3);
 function packageRoot() {
   return __dirname4;
 }
-function readLines(path64) {
-  if (!existsSync27(path64)) return [];
-  return readFileSync23(path64, "utf8").split("\n").filter((line) => line.trim() !== "");
+function readLines(path67) {
+  if (!existsSync27(path67)) return [];
+  return readFileSync23(path67, "utf8").split("\n").filter((line) => line.trim() !== "");
 }
 var cachedReads;
 var cachedWrites;
@@ -12037,14 +12062,14 @@ function showProgress(p, label2) {
   const pct = Math.round(p.done / p.total * 100);
   process.stderr.write(`\r\x1B[K[${pct}%] Scanning ${label2}...`);
 }
-async function resolveCommand(cli, path64, description, depth, p) {
-  showProgress(p, path64.join(" "));
-  const subHelp = await runHelp([cli, ...path64]);
+async function resolveCommand(cli, path67, description, depth, p) {
+  showProgress(p, path67.join(" "));
+  const subHelp = await runHelp([cli, ...path67]);
   if (!subHelp || !hasSubcommands(subHelp)) {
-    return [{ path: path64, description }];
+    return [{ path: path67, description }];
   }
-  const children = await discoverAt(cli, path64, depth + 1, p);
-  return children.length > 0 ? children : [{ path: path64, description }];
+  const children = await discoverAt(cli, path67, depth + 1, p);
+  return children.length > 0 ? children : [{ path: path67, description }];
 }
 async function discoverAt(cli, parentPath, depth, p) {
   if (depth > SAFETY_DEPTH) return [];
@@ -12192,9 +12217,9 @@ function logPath(cli) {
   return join30(homedir16(), ".assist", `cli-discover-${safeName}.log`);
 }
 function readCache(cli) {
-  const path64 = logPath(cli);
-  if (!existsSync29(path64)) return void 0;
-  return readFileSync25(path64, "utf8");
+  const path67 = logPath(cli);
+  if (!existsSync29(path67)) return void 0;
+  return readFileSync25(path67, "utf8");
 }
 function writeCache(cli, output) {
   const dir = join30(homedir16(), ".assist");
@@ -12366,9 +12391,9 @@ function sweepRestrictedDir(dir = getRestrictedDir()) {
   }
   const cutoff = Date.now() - STALE_AFTER_MS;
   for (const entry of entries) {
-    const path64 = join32(dir, entry);
+    const path67 = join32(dir, entry);
     try {
-      if (statSync3(path64).mtimeMs < cutoff) unlinkSync7(path64);
+      if (statSync3(path67).mtimeMs < cutoff) unlinkSync7(path67);
     } catch {
       continue;
     }
@@ -12378,10 +12403,10 @@ function sweepRestrictedDir(dir = getRestrictedDir()) {
 // src/commands/codeComment/readPinState.ts
 import { existsSync as existsSync30, readFileSync as readFileSync26 } from "fs";
 function readPinState(pin) {
-  const path64 = getPinStatePath(pin);
-  if (!existsSync30(path64)) return void 0;
+  const path67 = getPinStatePath(pin);
+  if (!existsSync30(path67)) return void 0;
   try {
-    const state = JSON.parse(readFileSync26(path64, "utf8"));
+    const state = JSON.parse(readFileSync26(path67, "utf8"));
     if (state.pin !== pin) return void 0;
     return state;
   } catch {
@@ -13206,8 +13231,8 @@ function stepIntoNested(container, key, nextKey) {
   }
   return ensureObject(container, resolved);
 }
-function setNestedValue(obj, path64, value) {
-  const keys = path64.split(".");
+function setNestedValue(obj, path67, value) {
+  const keys = path67.split(".");
   const result = { ...obj };
   let current = result;
   for (let i = 0; i < keys.length - 1; i++) {
@@ -13287,9 +13312,9 @@ function isTraversable(value) {
 function stepInto(current, key) {
   return isTraversable(current) ? current[key] : void 0;
 }
-function getNestedValue(obj, path64) {
+function getNestedValue(obj, path67) {
   let current = obj;
-  for (const key of path64.split(".")) current = stepInto(current, key);
+  for (const key of path67.split(".")) current = stepInto(current, key);
   return current;
 }
 
@@ -15428,17 +15453,22 @@ function registerJira(program2) {
 }
 
 // src/commands/backlog/registerRefineLaunch.ts
-var HARNESS_FLAG = "Coding harness to launch (claude|codex); defaults to the configured harness.engine";
+var HARNESS_FLAG = "Coding harness to launch (claude|codex|pi); defaults to the configured harness.engine";
 var HARNESS_CONFIG_HELP = [
   {
     key: "harness.engine",
-    setter: "assist config set harness.engine <claude|codex>",
+    setter: "assist config set harness.engine <claude|codex|pi>",
     note: "default coding harness launched by refine and other flows"
   },
   {
     key: "harness.exposeCodexActions",
     setter: "assist config set harness.exposeCodexActions <true|false>",
     note: "force the web UI 'with Codex' actions off even when codex is on PATH"
+  },
+  {
+    key: "harness.exposePiActions",
+    setter: "assist config set harness.exposePiActions <true|false>",
+    note: "force the web UI 'with pi' actions off even when pi is on PATH"
   }
 ];
 function runRefine(id, opts) {
@@ -15875,9 +15905,9 @@ function parseRscRows(flight) {
 }
 function makeRscResolver(rows) {
   return (ref) => {
-    const [id, ...path64] = ref.slice(1).replace(/^[L@]/, "").split(":");
+    const [id, ...path67] = ref.slice(1).replace(/^[L@]/, "").split(":");
     let v = rows[id];
-    for (const key of path64) {
+    for (const key of path67) {
       if (v == null || typeof v !== "object") return void 0;
       v = v[key];
     }
@@ -16354,6 +16384,43 @@ function registerNews(program2) {
   newsCommand.command("add").description("Add an RSS feed URL").argument("<url>", "RSS feed URL").action(add2);
 }
 
+// src/commands/piHook/index.ts
+var TOOL_MAP = {
+  bash: "Bash",
+  powershell: "PowerShell"
+};
+function parseInput2(raw) {
+  try {
+    const data = JSON.parse(raw);
+    const command = data.command;
+    if (typeof command !== "string" || !command.trim()) return void 0;
+    const toolName = TOOL_MAP[(data.toolName ?? "bash").toLowerCase()];
+    if (!toolName) return void 0;
+    return { toolName, command: command.trim() };
+  } catch {
+    return void 0;
+  }
+}
+async function piHook() {
+  const input = parseInput2(await readStdin());
+  if (!input) return;
+  const decision = decideCommand(input.toolName, input.command);
+  const output = decision ? {
+    decision: decision.permissionDecision,
+    reason: decision.permissionDecisionReason
+  } : { decision: "gate" };
+  console.log(JSON.stringify(output));
+}
+
+// src/commands/registerPiHook.ts
+function registerPiHook(program2) {
+  program2.command("pi-hook").description(
+    "pi tool-call permission gate: reads pi's tool-call JSON from stdin and emits an allow/deny/gate decision, auto-approving read-only CLI commands via the shared cli-hook allowlist"
+  ).action(() => {
+    piHook();
+  });
+}
+
 // src/commands/prompts/printPromptsTable.ts
 import chalk153 from "chalk";
 function truncate(str, max) {
@@ -16524,15 +16591,15 @@ function postComment(vars) {
   const stdout = startLine === void 0 ? runGhGraphql(MUTATION_SINGLE, base) : runGhGraphql(MUTATION_MULTI, { ...base, startLine });
   assertThreadCreated(stdout);
 }
-function comment2(path64, line, body, startLine) {
+function comment2(path67, line, body, startLine) {
   validateBody(body);
   validateLine(line);
   if (startLine !== void 0) validateLine(startLine);
   try {
     const prId = getCurrentPrNodeId();
-    postComment({ prId, body, path: path64, line, startLine });
+    postComment({ prId, body, path: path67, line, startLine });
     const range = startLine !== void 0 ? `${startLine}-${line}` : `${line}`;
-    console.log(`Added review comment on ${path64}:${range}`);
+    console.log(`Added review comment on ${path67}:${range}`);
   } catch (error) {
     if (isGhNotInstalled(error)) {
       console.error("Error: GitHub CLI (gh) is not installed.");
@@ -17393,8 +17460,8 @@ function registerPrs(program2) {
   prsCommand.command("reply <comment-id> <body>").description("Reply to a comment thread without resolving it").action((commentId, body) => {
     reply(Number.parseInt(commentId, 10), body);
   });
-  prsCommand.command("comment <path> <line> <body>").description("Add a line comment to the pending review").action((path64, line, body) => {
-    comment2(path64, Number.parseInt(line, 10), body);
+  prsCommand.command("comment <path> <line> <body>").description("Add a line comment to the pending review").action((path67, line, body) => {
+    comment2(path67, Number.parseInt(line, 10), body);
   });
   configHelp(prsCommand, prsConfigHelp);
 }
@@ -17647,10 +17714,10 @@ function resolveOpSecret(reference) {
 }
 
 // src/commands/ravendb/ravenFetch.ts
-async function ravenFetch(connection, path64) {
+async function ravenFetch(connection, path67) {
   const apiKey = resolveOpSecret(connection.apiKeyRef);
   let accessToken = await getAccessToken(apiKey);
-  const url = `${connection.url}${path64}`;
+  const url = `${connection.url}${path67}`;
   const headers = {
     Authorization: `Bearer ${accessToken}`,
     "Content-Type": "application/json"
@@ -17754,16 +17821,16 @@ import chalk166 from "chalk";
 // src/commands/ravendb/buildQueryPath.ts
 function buildQueryPath(opts) {
   const db = encodeURIComponent(opts.db);
-  let path64;
+  let path67;
   if (opts.collection) {
-    path64 = `/databases/${db}/indexes/dynamic/${encodeURIComponent(opts.collection)}?start=${opts.start}&pageSize=${opts.pageSize}&sort=${encodeURIComponent(opts.sort)}`;
+    path67 = `/databases/${db}/indexes/dynamic/${encodeURIComponent(opts.collection)}?start=${opts.start}&pageSize=${opts.pageSize}&sort=${encodeURIComponent(opts.sort)}`;
   } else {
-    path64 = `/databases/${db}/queries?start=${opts.start}&pageSize=${opts.pageSize}`;
+    path67 = `/databases/${db}/queries?start=${opts.start}&pageSize=${opts.pageSize}`;
   }
   if (opts.query) {
-    path64 += `&query=${encodeURIComponent(opts.query)}`;
+    path67 += `&query=${encodeURIComponent(opts.query)}`;
   }
-  return path64;
+  return path67;
 }
 
 // src/commands/ravendb/fetchAllPages.ts
@@ -17772,7 +17839,7 @@ async function fetchAllPages(connection, opts) {
   let start3 = 0;
   while (true) {
     const effectivePageSize = opts.limit !== void 0 ? Math.min(opts.pageSize, opts.limit - allResults.length) : opts.pageSize;
-    const path64 = buildQueryPath({
+    const path67 = buildQueryPath({
       db: connection.database,
       collection: opts.collection,
       start: start3,
@@ -17780,7 +17847,7 @@ async function fetchAllPages(connection, opts) {
       sort: opts.sort,
       query: opts.query
     });
-    const data = await ravenFetch(connection, path64);
+    const data = await ravenFetch(connection, path67);
     const results = data.Results ?? [];
     const totalResults = data.TotalResults ?? 0;
     if (results.length === 0) break;
@@ -20168,8 +20235,8 @@ async function handlePostSynthesis(synthesisPath, options2) {
 // src/commands/review/prepareReviewDir.ts
 import { existsSync as existsSync41, mkdirSync as mkdirSync17, unlinkSync as unlinkSync14, writeFileSync as writeFileSync34 } from "fs";
 function clearReviewFiles(paths) {
-  for (const path64 of [paths.claudePath, paths.codexPath, paths.synthesisPath]) {
-    if (existsSync41(path64)) unlinkSync14(path64);
+  for (const path67 of [paths.claudePath, paths.codexPath, paths.synthesisPath]) {
+    if (existsSync41(path67)) unlinkSync14(path67);
   }
 }
 function prepareReviewDir(paths, requestBody, force) {
@@ -21317,8 +21384,8 @@ import chalk187 from "chalk";
 
 // src/commands/seq/fetchSeq.ts
 import chalk184 from "chalk";
-async function fetchSeq(conn, path64, params) {
-  const url = `${conn.url}${path64}?${params}`;
+async function fetchSeq(conn, path67, params) {
+  const url = `${conn.url}${path67}?${params}`;
   const response = await fetch(url, {
     headers: {
       Accept: "application/json",
@@ -22805,9 +22872,9 @@ function findPortFile(roamDir) {
     return void 0;
   }
   const candidates = entries.filter((name) => /^roam-local-api(-[^.]+)?\.port$/.test(name)).map((name) => {
-    const path64 = join60(roamDir, name);
+    const path67 = join60(roamDir, name);
     try {
-      return { path: path64, mtimeMs: statSync8(path64).mtimeMs };
+      return { path: path67, mtimeMs: statSync8(path67).mtimeMs };
     } catch {
       return void 0;
     }
@@ -23226,11 +23293,11 @@ function findLinkIndex() {
 function parseLinkArgs() {
   const idx = findLinkIndex();
   if (idx === -1) return null;
-  const path64 = process.argv[idx + 1];
+  const path67 = process.argv[idx + 1];
   const rest = process.argv.slice(idx + 2);
   const { value: prefix2 } = extractOption(rest, "--prefix");
   if (!prefix2) return null;
-  return { path: path64, prefix: prefix2 };
+  return { path: path67, prefix: prefix2 };
 }
 function hasDuplicateLink(runList, linkPath) {
   return runList.some(
@@ -23600,9 +23667,6 @@ function reportStrays(pids) {
 // src/commands/sessions/daemon/drainDaemon.ts
 import { createInterface as createInterface6 } from "readline";
 
-// src/commands/sessions/daemon/loadPersistedSessions.ts
-import { z as z5 } from "zod";
-
 // src/commands/sessions/daemon/daemonLog.ts
 var RING_CAPACITY = 1e3;
 var ring = [];
@@ -23626,13 +23690,14 @@ function recentDaemonLogLines() {
   return [...ring];
 }
 
-// src/commands/sessions/daemon/loadPersistedSessions.ts
-var SESSIONS_FILE = "sessions.json";
+// src/commands/sessions/daemon/persistedSessionSchema.ts
+import { z as z5 } from "zod";
 var persistedSessionSchema = z5.object({
   name: z5.string(),
   title: z5.string().optional(),
   subtitle: z5.string().optional(),
   commandType: z5.enum(["claude", "run", "assist"]),
+  harness: z5.enum(["claude", "codex", "pi"]).optional(),
   status: z5.enum(["running", "waiting", "done", "error"]).optional(),
   cwd: z5.string(),
   startedAt: z5.number(),
@@ -23645,6 +23710,34 @@ var persistedSessionSchema = z5.object({
   activity: activitySchema.optional(),
   starred: z5.boolean().optional()
 });
+
+// src/commands/sessions/daemon/toPersistedSession.ts
+function toPersistedSession(session) {
+  return {
+    name: session.name,
+    title: session.title,
+    subtitle: session.subtitle,
+    commandType: session.commandType,
+    harness: session.harness,
+    status: session.status,
+    cwd: session.cwd ?? process.cwd(),
+    startedAt: session.startedAt,
+    runningMs: accumulatedRunningMs(session),
+    claudeSessionId: session.claudeSessionId,
+    initialPrompt: session.initialPrompt,
+    runName: session.runName,
+    runArgs: session.runArgs,
+    assistArgs: session.assistArgs,
+    activity: session.activity,
+    starred: session.starred
+  };
+}
+function accumulatedRunningMs(session) {
+  return session.runningSince != null ? session.runningMs + Date.now() - session.runningSince : session.runningMs;
+}
+
+// src/commands/sessions/daemon/loadPersistedSessions.ts
+var SESSIONS_FILE = "sessions.json";
 function loadPersistedSessions() {
   const data = loadJson(SESSIONS_FILE);
   if (!Array.isArray(data)) return [];
@@ -23672,28 +23765,6 @@ function logPersist(live) {
     live.length > 0 ? `persisted ${live.length} session(s): ${live.map((s) => s.name).join(", ")}` : "persisted 0 sessions (sessions.json cleared)"
   );
 }
-function toPersistedSession(session) {
-  return {
-    name: session.name,
-    title: session.title,
-    subtitle: session.subtitle,
-    commandType: session.commandType,
-    status: session.status,
-    cwd: session.cwd ?? process.cwd(),
-    startedAt: session.startedAt,
-    runningMs: accumulatedRunningMs(session),
-    claudeSessionId: session.claudeSessionId,
-    initialPrompt: session.initialPrompt,
-    runName: session.runName,
-    runArgs: session.runArgs,
-    assistArgs: session.assistArgs,
-    activity: session.activity,
-    starred: session.starred
-  };
-}
-function accumulatedRunningMs(session) {
-  return session.runningSince != null ? session.runningMs + Date.now() - session.runningSince : session.runningMs;
-}
 
 // src/commands/sessions/daemon/drainDaemon.ts
 var DRAIN_TIMEOUT_MS = 5e3;
@@ -23804,6 +23875,7 @@ function toSessionInfo({
   title,
   subtitle,
   commandType,
+  harness,
   status: status3,
   startedAt,
   runningMs,
@@ -23827,6 +23899,7 @@ function toSessionInfo({
     title,
     subtitle,
     commandType,
+    harness,
     status: status3,
     startedAt,
     runningMs,
@@ -24034,6 +24107,13 @@ function buildArgs3(opts) {
   return base;
 }
 
+// src/commands/sessions/daemon/spawnPi.ts
+function spawnPi2(opts = {}) {
+  const args = ["pi"];
+  if (opts.prompt) args.push(opts.prompt);
+  return spawnPty(args, opts.cwd, opts.sessionId);
+}
+
 // src/commands/sessions/daemon/spawnRun.ts
 function spawnRun(opts) {
   return spawnPty(["assist", "run", opts.name, ...opts.args ?? []], opts.cwd);
@@ -24053,7 +24133,8 @@ function sessionBase(id, status3) {
     scrollback: ""
   };
 }
-function createSession(id, prompt, cwd, design) {
+function createSession(id, prompt, cwd, design, harness) {
+  if (harness === "pi") return createPiSession(id, prompt, cwd);
   const claudeSessionId = randomUUID4();
   return {
     ...sessionBase(id, prompt ? "running" : "waiting"),
@@ -24066,6 +24147,17 @@ function createSession(id, prompt, cwd, design) {
     design
   };
 }
+function createPiSession(id, prompt, cwd) {
+  return {
+    ...sessionBase(id, prompt ? "running" : "waiting"),
+    name: prompt?.slice(0, 40) || `Session ${id}`,
+    commandType: "claude",
+    harness: "pi",
+    pty: spawnPi2({ prompt, cwd, sessionId: id }),
+    cwd,
+    initialPrompt: prompt
+  };
+}
 function createRunSession(id, runName, runArgs, cwd) {
   return {
     ...sessionBase(id, "running"),
@@ -24510,8 +24602,8 @@ async function seedRunningMsFromUsage(session, notify2) {
 var DEBOUNCE_MS = 50;
 function watchActivity(session, notify2) {
   if (session.commandType !== "assist" || !session.cwd) return;
-  const path64 = activityPath(session.id);
-  const dir = dirname29(path64);
+  const path67 = activityPath(session.id);
+  const dir = dirname29(path67);
   try {
     mkdirSync24(dir, { recursive: true });
   } catch {
@@ -24521,7 +24613,7 @@ function watchActivity(session, notify2) {
   let timer = null;
   const read = () => {
     timer = null;
-    const activity2 = readActivity(path64);
+    const activity2 = readActivity(path67);
     if (!activity2) return;
     session.activity = activity2;
     if (activity2.claudeSessionId)
@@ -24531,11 +24623,11 @@ function watchActivity(session, notify2) {
     notify2();
   };
   session.activityWatcher = watch(dir, (_event, filename) => {
-    if (filename && !path64.endsWith(filename)) return;
+    if (filename && !path67.endsWith(filename)) return;
     if (timer) clearTimeout(timer);
     timer = setTimeout(read, DEBOUNCE_MS);
   });
-  if (existsSync54(path64)) read();
+  if (existsSync54(path67)) read();
 }
 function refreshActivity(session) {
   if (session.commandType !== "assist" || !session.cwd) return;
@@ -24730,6 +24822,7 @@ function restoreBase(id, persisted) {
     title: persisted.title,
     subtitle: persisted.subtitle,
     commandType: persisted.commandType,
+    harness: persisted.harness,
     scrollback: "",
     cwd: persisted.cwd,
     assistArgs: persisted.assistArgs,
@@ -25743,8 +25836,10 @@ var SessionManager = class {
     return session.id;
   }
   spawnWith = (create) => this.add(create(sessionLimits.nextId(this.sessions.size, this.idCounter)));
-  spawn(prompt, cwd, design) {
-    return this.spawnWith((id) => createSession(id, prompt, cwd, design));
+  spawn(prompt, cwd, design, harness) {
+    return this.spawnWith(
+      (id) => createSession(id, prompt, cwd, design, harness)
+    );
   }
   spawnRun(runName, runArgs, cwd) {
     return this.spawnWith((id) => createRunSession(id, runName, runArgs, cwd));
@@ -25943,12 +26038,16 @@ var lifecycleHandlers = {
 // src/commands/sessions/daemon/spawnCreate.ts
 function spawnCreate(m, d) {
   const design = d.design === true;
+  const harness = d.harness;
   if (design)
     daemonLog(`create: design session (cwd=${d.cwd ?? ""})`);
+  if (harness && harness !== "claude")
+    daemonLog(`create: ${harness} session (cwd=${d.cwd ?? ""})`);
   return m.spawn(
     d.prompt,
     d.cwd,
-    design
+    design,
+    harness
   );
 }
 
@@ -26624,9 +26723,9 @@ async function statusLine() {
 }
 
 // src/commands/sync.ts
-import * as fs44 from "fs";
+import * as fs45 from "fs";
 import * as os3 from "os";
-import * as path62 from "path";
+import * as path65 from "path";
 import { fileURLToPath as fileURLToPath9 } from "url";
 
 // src/commands/sync/syncClaudeMd.ts
@@ -26660,12 +26759,33 @@ async function syncClaudeMd(claudeDir, targetBase, options2) {
 }
 
 // src/commands/sync/syncCodex.ts
-import * as fs41 from "fs";
-import * as path59 from "path";
+import * as path60 from "path";
 
-// src/commands/sync/syncCodexHooks.ts
+// src/commands/sync/installHarnessCommands.ts
 import * as fs40 from "fs";
 import * as path58 from "path";
+function installHarnessCommands(claudeDir, harness, transform) {
+  const commandsSource = path58.join(claudeDir, "commands");
+  const files = fs40.readdirSync(commandsSource);
+  let synced = 0;
+  for (const file of files) {
+    if (!file.endsWith(".md")) continue;
+    const name = file.replace(/\.md$/, "");
+    const content = fs40.readFileSync(path58.join(commandsSource, file), "utf8");
+    const target = path58.join(harness.homeDir, harness.sync.commandDest(name));
+    fs40.mkdirSync(path58.dirname(target), { recursive: true });
+    fs40.writeFileSync(target, transform(name, content));
+    synced++;
+  }
+  const agentsTarget = path58.join(harness.homeDir, harness.sync.agentsFile);
+  fs40.mkdirSync(path58.dirname(agentsTarget), { recursive: true });
+  fs40.copyFileSync(path58.join(claudeDir, "CLAUDE.md"), agentsTarget);
+  return { total: files.length, synced };
+}
+
+// src/commands/sync/syncCodexHooks.ts
+import * as fs41 from "fs";
+import * as path59 from "path";
 var BEGIN = "# >>> assist codex hooks (managed) \u2014 do not edit >>>";
 var END = "# <<< assist codex hooks (managed) <<<";
 function upsertManagedBlock(existing, body) {
@@ -26695,11 +26815,11 @@ ${rest}
 `;
 }
 function syncCodexHooks(sourcePath) {
-  const body = fs40.readFileSync(sourcePath, "utf8");
-  const configPath = path58.join(harnesses.codex.homeDir, "config.toml");
-  const existing = fs40.existsSync(configPath) ? fs40.readFileSync(configPath, "utf8") : "";
-  fs40.mkdirSync(path58.dirname(configPath), { recursive: true });
-  fs40.writeFileSync(configPath, upsertManagedBlock(existing, body));
+  const body = fs41.readFileSync(sourcePath, "utf8");
+  const configPath = path59.join(harnesses.codex.homeDir, "config.toml");
+  const existing = fs41.existsSync(configPath) ? fs41.readFileSync(configPath, "utf8") : "";
+  fs41.mkdirSync(path59.dirname(configPath), { recursive: true });
+  fs41.writeFileSync(configPath, upsertManagedBlock(existing, body));
   console.log(
     "Registered assist codex-hook in ~/.codex/config.toml (PreToolUse, PermissionRequest)"
   );
@@ -26725,58 +26845,108 @@ description: ${quoteYaml(description)}
 }
 function syncCodex(claudeDir) {
   if (!isHarnessAvailable("codex")) return;
-  const codex = harnesses.codex;
-  const commandsSource = path59.join(claudeDir, "commands");
-  const files = fs41.readdirSync(commandsSource);
-  for (const file of files) {
-    if (!file.endsWith(".md")) continue;
-    const name = file.replace(/\.md$/, "");
-    const content = fs41.readFileSync(path59.join(commandsSource, file), "utf8");
-    const target = path59.join(codex.homeDir, codex.sync.commandDest(name));
-    fs41.mkdirSync(path59.dirname(target), { recursive: true });
-    fs41.writeFileSync(target, commandToSkill(name, content));
-  }
-  const agentsTarget = path59.join(codex.homeDir, codex.sync.agentsFile);
-  fs41.mkdirSync(path59.dirname(agentsTarget), { recursive: true });
-  fs41.copyFileSync(path59.join(claudeDir, "CLAUDE.md"), agentsTarget);
-  syncCodexHooks(path59.join(claudeDir, "..", "codex", "config.toml"));
+  const { total } = installHarnessCommands(
+    claudeDir,
+    harnesses.codex,
+    commandToSkill
+  );
+  syncCodexHooks(path60.join(claudeDir, "..", "codex", "config.toml"));
   console.log(
-    `Synced ${files.length} skill(s) to ~/.codex/skills and CLAUDE.md to ~/.codex/AGENTS.md`
+    `Synced ${total} skill(s) to ~/.codex/skills and CLAUDE.md to ~/.codex/AGENTS.md`
   );
 }
 
 // src/commands/sync/syncDesign.ts
 import * as fs42 from "fs";
-import * as path60 from "path";
+import * as path61 from "path";
 function syncDesign(claudeDir, targetBase) {
-  const systemPromptSource = path60.join(claudeDir, "system-prompt.md");
-  const systemPromptTarget = path60.join(targetBase, "system-prompt.md");
+  const systemPromptSource = path61.join(claudeDir, "system-prompt.md");
+  const systemPromptTarget = path61.join(targetBase, "system-prompt.md");
   fs42.copyFileSync(systemPromptSource, systemPromptTarget);
   console.log("Copied system-prompt.md to ~/.claude/system-prompt.md");
-  const skillsSource = path60.join(claudeDir, "skills");
-  const skillsTarget = path60.join(targetBase, "skills");
+  const skillsSource = path61.join(claudeDir, "skills");
+  const skillsTarget = path61.join(targetBase, "skills");
   fs42.mkdirSync(skillsTarget, { recursive: true });
   const files = fs42.readdirSync(skillsSource);
   for (const file of files) {
     fs42.copyFileSync(
-      path60.join(skillsSource, file),
-      path60.join(skillsTarget, file)
+      path61.join(skillsSource, file),
+      path61.join(skillsTarget, file)
     );
   }
   console.log(`Synced ${files.length} design skill(s) to ~/.claude/skills`);
 }
 
-// src/commands/sync/syncSettings.ts
+// src/commands/sync/syncPi.ts
+import * as path63 from "path";
+
+// src/commands/sync/syncPiHooks.ts
 import * as fs43 from "fs";
-import * as path61 from "path";
+import * as path62 from "path";
+function piExtensionsDir() {
+  return path62.join(harnesses.pi.homeDir, "extensions");
+}
+function syncPiHooks(sourceDir) {
+  const target = piExtensionsDir();
+  fs43.mkdirSync(target, { recursive: true });
+  const files = fs43.readdirSync(sourceDir).filter((f) => f.endsWith(".ts"));
+  for (const file of files) {
+    fs43.copyFileSync(
+      path62.join(sourceDir, file),
+      path62.join(target, `assist-${file}`)
+    );
+  }
+  console.log(
+    `Registered ${files.length} assist extension(s) in ~/.pi/agent/extensions`
+  );
+}
+
+// src/commands/sync/syncPi.ts
+function unquote(value) {
+  return value.trim().replace(/^["']|["']$/g, "");
+}
+function commandToPrompt(name, content) {
+  const match = content.match(/^---\r?\n([\s\S]*?)\r?\n---\r?\n?/);
+  const frontmatter = match ? match[1] : "";
+  const body = match ? content.slice(match[0].length) : content;
+  const descriptionMatch = frontmatter.match(/^description:\s*(.*)$/m);
+  const description = descriptionMatch ? unquote(descriptionMatch[1]) : name;
+  const argsMatch = frontmatter.match(/^allowed_args:\s*(.*)$/m);
+  const argumentHint = argsMatch ? unquote(argsMatch[1]) : void 0;
+  const header = [
+    "---",
+    `description: ${description}`,
+    ...argumentHint ? [`argument-hint: ${argumentHint}`] : [],
+    "---",
+    "",
+    ""
+  ].join("\n");
+  return header + body.replace(/^\r?\n+/, "");
+}
+function syncPi(claudeDir) {
+  if (!isHarnessAvailable("pi")) return;
+  const { synced } = installHarnessCommands(
+    claudeDir,
+    harnesses.pi,
+    commandToPrompt
+  );
+  syncPiHooks(path63.join(claudeDir, "..", "pi"));
+  console.log(
+    `Synced ${synced} prompt(s) to ~/.pi/agent/prompts and CLAUDE.md to ~/.pi/agent/AGENTS.md`
+  );
+}
+
+// src/commands/sync/syncSettings.ts
+import * as fs44 from "fs";
+import * as path64 from "path";
 import chalk200 from "chalk";
 async function syncSettings(claudeDir, targetBase, options2) {
-  const source = path61.join(claudeDir, "settings.json");
-  const target = path61.join(targetBase, "settings.json");
-  const sourceContent = fs43.readFileSync(source, "utf8");
+  const source = path64.join(claudeDir, "settings.json");
+  const target = path64.join(targetBase, "settings.json");
+  const sourceContent = fs44.readFileSync(source, "utf8");
   const sourceSettings = JSON.parse(sourceContent);
-  const targetExists = fs43.existsSync(target);
-  const targetContent = targetExists ? fs43.readFileSync(target, "utf8") : "";
+  const targetExists = fs44.existsSync(target);
+  const targetContent = targetExists ? fs44.readFileSync(target, "utf8") : "";
   const preservedUserSettings = targetExists ? JSON.parse(targetContent) : {};
   const mergedContent = JSON.stringify(
     { ...preservedUserSettings, ...sourceSettings },
@@ -26805,31 +26975,32 @@ async function syncSettings(claudeDir, targetBase, options2) {
       }
     }
   }
-  fs43.writeFileSync(target, mergedContent);
+  fs44.writeFileSync(target, mergedContent);
   console.log("Copied settings.json to ~/.claude/settings.json");
 }
 
 // src/commands/sync.ts
 var __filename5 = fileURLToPath9(import.meta.url);
-var __dirname7 = path62.dirname(__filename5);
+var __dirname7 = path65.dirname(__filename5);
 async function sync(options2) {
   const config = loadConfig();
   const yes = options2?.yes ?? config.sync.autoConfirm;
-  const claudeDir = path62.join(__dirname7, "..", "claude");
-  const targetBase = path62.join(os3.homedir(), ".claude");
+  const claudeDir = path65.join(__dirname7, "..", "claude");
+  const targetBase = path65.join(os3.homedir(), ".claude");
   syncCommands(claudeDir, targetBase);
   syncDesign(claudeDir, targetBase);
   await syncSettings(claudeDir, targetBase, { yes });
   await syncClaudeMd(claudeDir, targetBase, { yes });
   syncCodex(claudeDir);
+  syncPi(claudeDir);
 }
 function syncCommands(claudeDir, targetBase) {
-  const sourceDir = path62.join(claudeDir, "commands");
-  const targetDir = path62.join(targetBase, "commands");
-  fs44.mkdirSync(targetDir, { recursive: true });
-  const files = fs44.readdirSync(sourceDir);
+  const sourceDir = path65.join(claudeDir, "commands");
+  const targetDir = path65.join(targetBase, "commands");
+  fs45.mkdirSync(targetDir, { recursive: true });
+  const files = fs45.readdirSync(sourceDir);
   for (const file of files) {
-    fs44.copyFileSync(path62.join(sourceDir, file), path62.join(targetDir, file));
+    fs45.copyFileSync(path65.join(sourceDir, file), path65.join(targetDir, file));
     console.log(`Copied ${file} to ${targetDir}`);
   }
   console.log(`Synced ${files.length} command(s) to ~/.claude/commands`);
@@ -26837,7 +27008,7 @@ function syncCommands(claudeDir, targetBase) {
 
 // src/commands/update.ts
 import { execSync as execSync57 } from "child_process";
-import * as path63 from "path";
+import * as path66 from "path";
 
 // src/commands/restartDaemonAfterUpdate.ts
 async function restartDaemonAfterUpdate() {
@@ -26856,12 +27027,12 @@ async function restartDaemonAfterUpdate() {
 // src/commands/update.ts
 function isGlobalNpmInstall(dir) {
   try {
-    const resolved = path63.resolve(dir);
-    if (resolved.split(path63.sep).includes("node_modules")) {
+    const resolved = path66.resolve(dir);
+    if (resolved.split(path66.sep).includes("node_modules")) {
       return true;
     }
     const globalPrefix = execSync57("npm prefix -g", { stdio: "pipe" }).toString().trim();
-    return resolved.toLowerCase().startsWith(path63.resolve(globalPrefix).toLowerCase());
+    return resolved.toLowerCase().startsWith(path66.resolve(globalPrefix).toLowerCase());
   } catch {
     return false;
   }
@@ -26907,7 +27078,7 @@ function reportCliError(error) {
 var program = new Command();
 program.name("assist").description("CLI application").version(package_default.version).option("--no-open", "Do not open a browser on startup").action((options2) => web({ port: "3100", open: options2.open }));
 var syncCommand = program.command("sync").description(
-  "Copy command files to ~/.claude/commands; when codex is detected, also install commands as ~/.codex/skills/<name>/SKILL.md, CLAUDE.md as ~/.codex/AGENTS.md, and register the assist codex-hook auto-approval hook in ~/.codex/config.toml"
+  "Copy command files to ~/.claude/commands; when codex is detected, also install commands as ~/.codex/skills/<name>/SKILL.md, CLAUDE.md as ~/.codex/AGENTS.md, and register the assist codex-hook auto-approval hook in ~/.codex/config.toml; when pi is detected, also install commands as ~/.pi/agent/prompts/<name>.md, CLAUDE.md as ~/.pi/agent/AGENTS.md, and register the assist pi-hook permission-gate extension in ~/.pi/agent/extensions"
 ).option("-y, --yes", "Overwrite settings.json without prompting").action((options2) => sync(options2));
 configHelp(syncCommand, rootConfigHelp.sync);
 program.command("init").description("Initialize VS Code and verify configurations").action(init5);
@@ -26935,6 +27106,7 @@ registerDb(program);
 registerCliHook(program);
 registerCodeComment(program);
 registerCodexHook(program);
+registerPiHook(program);
 registerEditHook(program);
 registerGithub(program);
 registerHandover(program);