codiedev 0.10.0-beta.5 → 0.10.0-beta.7

package/dist/mcp.js

@@ -222,29 +222,6 @@ const TOOLS = [
             required: ["body"],
         },
     },
-    {
-        name: "codiedev_promote",
-        description: "Promote an auto-extracted Codiedev artifact (spec/bugfix/decision " +
-            "produced by the session-capture pipeline) to an authored artifact " +
-            "so teammates can collaborate on it. Use when the user says 'publish " +
-            "the extracted spec', 'promote this', or 'make the auto-extracted X " +
-            "shareable'.",
-        inputSchema: {
-            type: "object",
-            properties: {
-                artifactId: {
-                    type: "string",
-                    description: "The extracted artifact's id from Codiedev.",
-                },
-                keyOverride: {
-                    type: "string",
-                    description: "Optional filename key for the promoted artifact. If omitted, " +
-                        "one is generated from the artifact's type + session id.",
-                },
-            },
-            required: ["artifactId"],
-        },
-    },
     {
         name: "codiedev_share_with",
         description: "Grant a teammate persistent read (or edit) access to an artifact " +
@@ -291,27 +268,6 @@ const TOOLS = [
             required: ["filename", "to"],
         },
     },
-    {
-        name: "codiedev_react",
-        description: "React to a feed post with an emoji. Use when the user says 'react " +
-            "to that post with X', 'mark as used', or 'upvote'. The 🛠 " +
-            "reaction is the signal for 'I used this' and bumps the linked " +
-            "artifact's reuse count. Pass the post id (get it from " +
-            "codiedev_get_library or a previous feed response).",
-        inputSchema: {
-            type: "object",
-            properties: {
-                postId: { type: "string", description: "Feed post id." },
-                emoji: {
-                    type: "string",
-                    enum: ["👍", "🔥", "💡", "🛠", "👑"],
-                    description: "Reaction emoji. 🛠 = 'I used this' (counts heaviest toward " +
-                        "the author's score and the artifact's reuse count).",
-                },
-            },
-            required: ["postId", "emoji"],
-        },
-    },
     {
         name: "codiedev_search",
         description: "Search the team's artifact library by natural-language query. Use " +
@@ -398,41 +354,6 @@ const TOOLS = [
             },
         },
     },
-    {
-        name: "codiedev_reverse_ticket",
-        description: "Generate a Jira-ready reverse-ticket draft from the work the user has " +
-            "done in their CURRENT git branch — mid-session, before any PR exists. " +
-            "Reads local git state (current branch, divergence from main, diff, " +
-            "commits, files changed) and runs it through the codiedev reverse-" +
-            "ticket writer. The draft lands in the user's portal at " +
-            "/portal/agentic-ticketing where they can edit the title, description, " +
-            "and scope, then push to Jira. Use when the user asks to 'create a " +
-            "reverse ticket', 'draft a Jira ticket from this work', 'write up what " +
-            "I've done in this branch', or runs `codiedev reverse-ticket` directly. " +
-            "The webhook on PR-open later dedupes against this draft so the user " +
-            "never gets a double ticket. The draft is intentionally not auto-pushed " +
-            "to Jira — trust comes from the user reviewing in the portal first.",
-        inputSchema: {
-            type: "object",
-            properties: {
-                title: {
-                    type: "string",
-                    description: "Optional working title for the ticket. Defaults to the most " +
-                        "recent commit subject on the branch.",
-                },
-                base: {
-                    type: "string",
-                    description: "Optional base ref to diff against. Defaults to 'origin/main', " +
-                        "falls back to 'origin/master'.",
-                },
-                forcedArtifactKey: {
-                    type: "string",
-                    description: "Optional — force the writer to link to a specific artifact key " +
-                        "for context (e.g. 'spec-auth.md').",
-                },
-            },
-        },
-    },
 ];
 const server = new index_js_1.Server({ name: PKG_NAME, version: PKG_VERSION }, { capabilities: { tools: {} } });
 server.setRequestHandler(types_js_1.ListToolsRequestSchema, async () => ({
@@ -515,22 +436,16 @@ async function dispatchTool(name, args, config) {
             return await handleInbox(args, config);
         case "codiedev_note":
             return await handleNote(args, config);
-        case "codiedev_promote":
-            return await handlePromote(args, config);
         case "codiedev_share_with":
             return await handleShareWith(args, config);
         case "codiedev_send_to":
             return await handleSendTo(args, config);
-        case "codiedev_react":
-            return await handleReact(args, config);
         case "codiedev_ask":
             return await handleAsk(args, config);
         case "codiedev_search":
             return await handleSearch(args, config);
         case "codiedev_get_library":
             return await handleGetLibrary(args, config);
-        case "codiedev_reverse_ticket":
-            return await handleReverseTicket(args, config);
         default:
             return {
                 isError: true,
@@ -675,21 +590,6 @@ async function handleNote(args, config) {
         content: [{ type: "text", text: `✓ Noted (${res.key})` }],
     };
 }
-async function handlePromote(args, config) {
-    const artifactId = asString(args.artifactId);
-    const keyOverride = asStringOrUndefined(args.keyOverride);
-    if (!artifactId)
-        throw new Error("artifactId required");
-    const res = await (0, shared_1.apiRequest)("POST", "/api/cli/promote", { config, body: { artifactId, keyOverride } });
-    return {
-        content: [
-            {
-                type: "text",
-                text: `✓ Promoted to authored artifact ${res.key} (id=${res.artifactId}).`,
-            },
-        ],
-    };
-}
 async function handleShareWith(args, config) {
     const filename = asString(args.filename);
     const to = asString(args.to);
@@ -778,26 +678,6 @@ async function handleSendTo(args, config) {
         return formatAmbiguousRecipient(err, to);
     }
 }
-async function handleReact(args, config) {
-    const postId = asString(args.postId);
-    const emoji = asString(args.emoji);
-    if (!postId)
-        throw new Error("postId required");
-    if (!emoji)
-        throw new Error("emoji required");
-    const res = await (0, shared_1.apiRequest)("POST", "/api/cli/react", {
-        config,
-        body: { postId, emoji },
-    });
-    const verb = res.action === "added"
-        ? "Reacted"
-        : res.action === "removed"
-            ? "Removed reaction"
-            : "Swapped reaction to";
-    return {
-        content: [{ type: "text", text: `✓ ${verb} ${res.emoji}` }],
-    };
-}
 async function handleSearch(args, config) {
     const query = asString(args.query);
     const limit = asIntOrUndefined(args.limit);
@@ -902,193 +782,6 @@ function formatAmbiguousRecipient(err, to) {
     }
     throw err;
 }
-async function handleReverseTicket(args, config) {
-    const explicitTitle = asStringOrUndefined(args.title);
-    const explicitBase = asStringOrUndefined(args.base);
-    const forcedKey = asStringOrUndefined(args.forcedArtifactKey);
-    const { execSync } = await Promise.resolve().then(() => __importStar(require("child_process")));
-    const git = (cmd) => {
-        try {
-            return execSync(`git ${cmd}`, {
-                stdio: ["pipe", "pipe", "pipe"],
-                maxBuffer: 32 * 1024 * 1024,
-            })
-                .toString("utf8")
-                .trim();
-        }
-        catch (err) {
-            throw new Error(`git ${cmd} failed: ${err.message}`);
-        }
-    };
-    try {
-        git("rev-parse --is-inside-work-tree");
-    }
-    catch {
-        throw new Error("Not inside a git repository. Run this from a checked-out repo.");
-    }
-    const candidates = explicitBase
-        ? [explicitBase]
-        : ["origin/main", "origin/master"];
-    let baseRef = null;
-    for (const c of candidates) {
-        try {
-            git(`rev-parse --verify ${c}`);
-            baseRef = c;
-            break;
-        }
-        catch {
-        }
-    }
-    if (!baseRef) {
-        throw new Error(`Couldn't find a base ref (tried ${candidates.join(", ")}). ` +
-            `Pass an explicit base via the 'base' argument.`);
-    }
-    const branch = git("rev-parse --abbrev-ref HEAD");
-    if (branch === "HEAD") {
-        throw new Error("Detached HEAD — checkout a branch first.");
-    }
-    const baseSha = git(`merge-base HEAD ${baseRef}`);
-    const headSha = git("rev-parse HEAD");
-    const isNoise = (p) => /(^|\/)(node_modules|dist|build|\.next|\.turbo|coverage|out)\//.test(p) ||
-        /(^|\/)package-lock\.json$/.test(p) ||
-        /(^|\/)yarn\.lock$/.test(p) ||
-        /(^|\/)pnpm-lock\.yaml$/.test(p) ||
-        /(^|\/)bun\.lock(b)?$/.test(p) ||
-        /(^|\/)Cargo\.lock$/.test(p) ||
-        /(^|\/)Gemfile\.lock$/.test(p) ||
-        /(^|\/)poetry\.lock$/.test(p) ||
-        /(^|\/)go\.sum$/.test(p);
-    const shellTolerant = (cmd) => {
-        try {
-            return execSync(`${cmd} || true`, {
-                stdio: ["pipe", "pipe", "pipe"],
-                maxBuffer: 32 * 1024 * 1024,
-            })
-                .toString("utf8")
-                .trim();
-        }
-        catch {
-            return "";
-        }
-    };
-    const shQuote = (s) => `'${s.replace(/'/g, "'\\''")}'`;
-    const trackedRaw = git(`diff --name-only ${baseSha}`);
-    const trackedFiles = trackedRaw ? trackedRaw.split("\n").filter(Boolean) : [];
-    const untrackedRaw = safeGit(() => git("ls-files --others --exclude-standard"));
-    const untrackedFiles = untrackedRaw
-        ? untrackedRaw.split("\n").filter(Boolean)
-        : [];
-    const filesChanged = Array.from(new Set([...trackedFiles, ...untrackedFiles]));
-    if (filesChanged.length === 0) {
-        throw new Error(`No changes detected between ${baseRef} and your working tree on ${branch}.`);
-    }
-    let stat = "";
-    try {
-        const trackedStat = git(`diff --stat=200 ${baseSha}`);
-        const untrackedStatLines = untrackedFiles.map((f) => {
-            const wc = shellTolerant(`wc -l < ${shQuote(f)}`);
-            const n = parseInt(wc.split(/\s+/)[0] || "0", 10) || 0;
-            return ` ${f} | ${n} ++++++++++ (new file)`;
-        });
-        stat = [trackedStat, ...untrackedStatLines]
-            .filter(Boolean)
-            .join("\n")
-            .slice(0, 8_000);
-    }
-    catch {
-    }
-    let diff = "";
-    try {
-        const sourceTracked = trackedFiles.filter((f) => !isNoise(f));
-        const trackedDiff = sourceTracked.length > 0
-            ? git(`diff ${baseSha} -- ${sourceTracked.map(shQuote).join(" ")}`)
-            : git(`diff ${baseSha}`);
-        const sourceUntracked = untrackedFiles.filter((f) => !isNoise(f));
-        const untrackedDiffs = sourceUntracked.map((f) => shellTolerant(`git diff --no-index --no-color -- /dev/null ${shQuote(f)}`));
-        diff = [trackedDiff, ...untrackedDiffs]
-            .filter(Boolean)
-            .join("\n")
-            .slice(0, 40_000);
-    }
-    catch {
-    }
-    let repo;
-    try {
-        const remoteUrl = git("config --get remote.origin.url");
-        const m = remoteUrl.match(/[:/]([^/:]+)\/([^/:]+?)(?:\.git)?$/);
-        if (!m) {
-            throw new Error(`Couldn't parse owner/repo from remote: ${remoteUrl}`);
-        }
-        repo = `${m[1]}/${m[2]}`;
-    }
-    catch (err) {
-        throw new Error(`Couldn't read git remote.origin.url: ${err.message}`);
-    }
-    const title = explicitTitle ?? safeGit(() => git("log -1 --format=%s")) ?? `WIP: ${branch}`;
-    const author = safeGit(() => git("config --get user.name"));
-    const authorEmail = safeGit(() => git("config --get user.email"));
-    const res = await (0, shared_1.apiRequest)("POST", "/api/cli/reverseTicketFromBranch", {
-        config,
-        body: {
-            branch: {
-                repo,
-                branch,
-                baseSha,
-                headSha,
-                title,
-                author,
-                authorEmail,
-                filesChanged,
-                diff: diff || undefined,
-                stat: stat || undefined,
-            },
-            forcedArtifactKey: forcedKey,
-        },
-    });
-    if (!res.ok || !res.artifactId) {
-        return {
-            isError: true,
-            content: [
-                {
-                    type: "text",
-                    text: "Reverse-ticket generation returned no result. The writer may have " +
-                        "skipped due to missing context (no captured sessions, etc.). Try " +
-                        "again after working on the branch a bit more, or check the " +
-                        "server logs.",
-                },
-            ],
-        };
-    }
-    const portalHost = (process.env.CODIEDEV_PORTAL_URL || "https://codiedev.com").replace(/\/$/, "");
-    const portalLink = res.portalUrl.startsWith("http")
-        ? res.portalUrl
-        : `${portalHost}${res.portalUrl.startsWith("/") ? "" : "/"}${res.portalUrl}`;
-    const verb = res.action === "overwritten" ? "Updated" : "Created";
-    return {
-        content: [
-            {
-                type: "text",
-                text: `✓ ${verb} reverse-ticket draft for branch \`${branch}\` (${repo}).\n` +
-                    `  files changed: ${filesChanged.length}\n` +
-                    `  base: ${baseSha.slice(0, 12)} → head: ${headSha.slice(0, 12)} (${baseRef})\n` +
-                    `  diff size: ${diff.length} chars\n` +
-                    `  artifact: ${res.artifactKey ?? res.artifactId}\n\n` +
-                    `Open in your portal to review, edit, and push to Jira:\n` +
-                    `  ${portalLink}\n\n` +
-                    `Each call creates a fresh draft — if you've made several for the ` +
-                    `same branch, clean them up from the portal.`,
-            },
-        ],
-    };
-}
-function safeGit(fn) {
-    try {
-        return fn();
-    }
-    catch {
-        return undefined;
-    }
-}
 function asString(v) {
     return typeof v === "string" ? v : "";
 }

package/dist/packs/harnesses.js

@@ -33,7 +33,7 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ADAPTERS = exports.codieAdapter = exports.cursorAdapter = exports.CURSOR_MARKER = exports.codexAdapter = exports.copilotAdapter = exports.claudeAdapter = exports.HARNESSES = void 0;
+exports.ADAPTERS = exports.piAdapter = exports.codieAdapter = exports.cursorAdapter = exports.CURSOR_MARKER = exports.codexAdapter = exports.copilotAdapter = exports.claudeAdapter = exports.HARNESSES = void 0;
 exports.defaultRunner = defaultRunner;
 exports.onPath = onPath;
 exports.copyCursorSkills = copyCursorSkills;
@@ -48,7 +48,7 @@ const path = __importStar(require("path"));
 const child_process_1 = require("child_process");
 const harnessDirs_1 = require("../harnessDirs");
 const paths_1 = require("./paths");
-exports.HARNESSES = ["claude", "copilot", "codex", "cursor", "codie"];
+exports.HARNESSES = ["claude", "copilot", "codex", "cursor", "codie", "pi"];
 function defaultRunner(env) {
     return (command, args, options = {}) => {
         const result = (0, child_process_1.spawnSync)(command, args, {
@@ -362,7 +362,44 @@ exports.codieAdapter = {
     plan: () => "inject skills/agents/hook shim at next codie launch",
     uninstall: () => "removed from next `codie` launch",
 };
-exports.ADAPTERS = [exports.claudeAdapter, exports.copilotAdapter, exports.codexAdapter, exports.cursorAdapter, exports.codieAdapter];
+function piSettingsPath(env, home) {
+    return path.join((0, harnessDirs_1.piAgentDir)(env, home), "settings.json");
+}
+function updatePiSkillPaths(file, update) {
+    let settings = {};
+    if (fs.existsSync(file)) {
+        const parsed = JSON.parse(fs.readFileSync(file, "utf8"));
+        if (!parsed || typeof parsed !== "object" || Array.isArray(parsed))
+            throw new Error(`${file} is not a JSON object; leaving it alone`);
+        settings = parsed;
+    }
+    const current = Array.isArray(settings.skills) ? settings.skills.filter((p) => typeof p === "string") : [];
+    const next = update(current);
+    if (next.length === current.length && next.every((p, i) => p === current[i]))
+        return false;
+    settings.skills = next;
+    fs.mkdirSync(path.dirname(file), { recursive: true });
+    const tmp = `${file}.${process.pid}.tmp`;
+    fs.writeFileSync(tmp, JSON.stringify(settings, null, 2) + "\n");
+    fs.renameSync(tmp, file);
+    return true;
+}
+exports.piAdapter = {
+    name: "pi",
+    detect: (ctx) => onPath("pi", ctx.env) || fs.existsSync((0, harnessDirs_1.piAgentDir)(ctx.env, ctx.home)),
+    install: (ctx) => {
+        const skills = path.join(ctx.portablePluginDir, "skills");
+        const changed = updatePiSkillPaths(piSettingsPath(ctx.env, ctx.home), (paths) => paths.includes(skills) ? paths : [...paths, skills]);
+        return changed ? "installed" : "already installed";
+    },
+    plan: (ctx) => `add ${path.join(ctx.portablePluginDir, "skills")} to ${piSettingsPath(ctx.env, ctx.home)} skills`,
+    uninstall: (ctx) => {
+        const dir = (0, paths_1.pluginDir)((0, paths_1.portableRoot)(ctx.root), ctx.slug);
+        const changed = updatePiSkillPaths(piSettingsPath(ctx.env, ctx.home), (paths) => paths.filter((p) => p !== dir && !p.startsWith(dir + path.sep)));
+        return changed ? "uninstalled" : "already removed";
+    },
+};
+exports.ADAPTERS = [exports.claudeAdapter, exports.copilotAdapter, exports.codexAdapter, exports.cursorAdapter, exports.codieAdapter, exports.piAdapter];
 function parseHarnessList(value) {
     if (value === undefined)
         return undefined;

package/dist/packs/install.js

@@ -88,7 +88,8 @@ function codexPackTrustEntries(registry, codexDir) {
         if (!hooksPath)
             continue;
         try {
-            bySlug.set(slug, (0, codexHookTrust_1.packCodexHookTrustEntries)(hooksPath, JSON.parse(fs.readFileSync(hooksPath, "utf8"))));
+            const plugin = { id: `${slug}@${paths_1.MARKETPLACE_NAME}`, root: path.dirname(path.dirname(hooksPath)) };
+            bySlug.set(slug, (0, codexHookTrust_1.packCodexHookTrustEntries)(hooksPath, JSON.parse(fs.readFileSync(hooksPath, "utf8")), plugin));
         }
         catch {
         }

package/dist/piHooks.js

@@ -0,0 +1,216 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PI_CONTEXT_CUSTOM_TYPE = void 0;
+exports.normalizePiTranscript = normalizePiTranscript;
+exports.isPiTranscriptEmpty = isPiTranscriptEmpty;
+exports.piLaunchFromArgv = piLaunchFromArgv;
+exports.piExtensionPath = piExtensionPath;
+exports.inspectPiExtension = inspectPiExtension;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const harnessDirs_1 = require("./harnessDirs");
+exports.PI_CONTEXT_CUSTOM_TYPE = "codiedev";
+const SKILL_EXPANSION = /^<skill name="([^"]{1,200})" location="[^"]*">/;
+const num = (n) => (typeof n === "number" && Number.isFinite(n) ? Math.max(0, n) : 0);
+function textOf(content) {
+    if (typeof content === "string")
+        return content;
+    if (!Array.isArray(content))
+        return "";
+    return content
+        .map((block) => (block?.type === "text" && typeof block.text === "string" ? block.text : ""))
+        .filter(Boolean)
+        .join("\n");
+}
+function userBlocks(content) {
+    if (typeof content === "string")
+        return [{ type: "text", text: content }];
+    if (!Array.isArray(content))
+        return [];
+    return content.flatMap((block) => block?.type === "text" && typeof block.text === "string"
+        ? [{ type: "text", text: block.text }]
+        : block?.type === "image" ? [{ type: "text", text: "[image]" }] : []);
+}
+function skillFromPath(value) {
+    if (typeof value !== "string")
+        return null;
+    const m = value.replace(/\\/g, "/").match(/\/([^/]+)\/SKILL\.md$/);
+    return m ? m[1] : null;
+}
+function errorCode(message) {
+    return message.match(/^\s*(\d{3})\b/)?.[1] ?? "";
+}
+function normalizePiTranscript(content) {
+    const out = [];
+    const skillReads = new Map();
+    let errorStreakAt;
+    const push = (record) => out.push(JSON.stringify(record));
+    for (const line of content.split("\n")) {
+        if (!line.trim())
+            continue;
+        let entry;
+        try {
+            entry = JSON.parse(line);
+        }
+        catch {
+            continue;
+        }
+        if (!entry || typeof entry !== "object")
+            continue;
+        const timestamp = typeof entry.timestamp === "string" ? entry.timestamp : undefined;
+        const uuid = typeof entry.id === "string" ? entry.id : undefined;
+        if (entry.type !== "message" || !entry.message || typeof entry.message !== "object")
+            continue;
+        const message = entry.message;
+        if (!(message.role === "assistant" && message.stopReason === "error"))
+            errorStreakAt = undefined;
+        if (message.role === "user") {
+            const text = textOf(message.content);
+            const skill = text.match(SKILL_EXPANSION)?.[1];
+            if (skill)
+                push({ type: "pi.skill_invoked", timestamp, skill });
+            push({ type: "user", uuid, timestamp, message: { role: "user", content: userBlocks(message.content) } });
+            continue;
+        }
+        if (message.role === "assistant") {
+            const blocks = [];
+            for (const block of Array.isArray(message.content) ? message.content : []) {
+                if (block?.type === "text" && typeof block.text === "string")
+                    blocks.push({ type: "text", text: block.text });
+                else if (block?.type === "thinking" && typeof block.thinking === "string")
+                    blocks.push({ type: "thinking", thinking: block.thinking });
+                else if (block?.type === "toolCall") {
+                    const input = block.arguments && typeof block.arguments === "object" ? block.arguments : {};
+                    blocks.push({ type: "tool_use", id: block.id, name: block.name ?? "tool", input });
+                    const skill = block.name === "read" ? skillFromPath(input.path) : null;
+                    if (skill && typeof block.id === "string")
+                        skillReads.set(block.id, skill);
+                }
+            }
+            const usage = message.usage ?? {};
+            const tokens = num(usage.input) + num(usage.output) + num(usage.cacheRead) + num(usage.cacheWrite);
+            const measured = tokens > 0 || message.stopReason !== "error";
+            push({
+                type: "assistant",
+                uuid,
+                timestamp,
+                message: {
+                    id: typeof message.responseId === "string" ? message.responseId : uuid,
+                    role: "assistant",
+                    model: typeof message.model === "string" ? message.model : undefined,
+                    ...(measured ? {
+                        usage: {
+                            input_tokens: num(usage.input),
+                            output_tokens: num(usage.output),
+                            cache_read_input_tokens: num(usage.cacheRead),
+                            cache_creation_input_tokens: num(usage.cacheWrite),
+                        },
+                    } : {}),
+                    content: blocks,
+                },
+            });
+            if (message.stopReason === "aborted") {
+                push({ type: "user", timestamp, message: { role: "user", content: [{ type: "text", text: "[Request interrupted by user]" }] } });
+            }
+            if (message.stopReason === "error" && typeof message.errorMessage === "string") {
+                errorStreakAt ??= typeof message.timestamp === "number" ? new Date(message.timestamp).toISOString() : timestamp;
+                push({
+                    type: "agent.error",
+                    timestamp: errorStreakAt,
+                    data: { errorContext: "model_call", error: { code: errorCode(message.errorMessage), message: message.errorMessage } },
+                });
+            }
+            continue;
+        }
+        if (message.role === "toolResult") {
+            const id = typeof message.toolCallId === "string" ? message.toolCallId : undefined;
+            const skill = id ? skillReads.get(id) : undefined;
+            if (skill && message.isError !== true)
+                push({ type: "pi.skill_invoked", timestamp, skill });
+            push({
+                type: "user",
+                uuid,
+                timestamp,
+                message: {
+                    role: "user",
+                    content: [{ type: "tool_result", tool_use_id: id, content: textOf(message.content), is_error: message.isError === true }],
+                },
+            });
+            continue;
+        }
+        if (message.role === "bashExecution" && typeof message.command === "string") {
+            push({ type: "user", uuid, timestamp, message: { role: "user", content: [{ type: "text", text: `<bash-input>${message.command}</bash-input>` }] } });
+        }
+    }
+    return out.join("\n") + (out.length ? "\n" : "");
+}
+function isPiTranscriptEmpty(content) {
+    return !content.split("\n").some((line) => line.includes('"type":"message"'));
+}
+function piLaunchFromArgv(argv) {
+    for (let i = 0; i < argv.length; i++) {
+        const a = argv[i];
+        if (a === "-p" || a === "--print")
+            return "pi:print";
+        if (a === "--mode") {
+            const mode = argv[i + 1];
+            if (mode === "json" || mode === "rpc")
+                return `pi:${mode}`;
+        }
+        if (a === "--mode=json" || a === "--mode=rpc")
+            return `pi:${a.slice(7)}`;
+    }
+    return "pi:tui";
+}
+function piExtensionPath(agentDir = (0, harnessDirs_1.piAgentDir)()) {
+    return path.join(agentDir, "extensions", "codiedev.ts");
+}
+function inspectPiExtension(file = piExtensionPath()) {
+    if (!fs.existsSync(file))
+        return { status: "not-installed", detail: `${file} not found` };
+    let source;
+    try {
+        source = fs.readFileSync(file, "utf8");
+    }
+    catch {
+        return { status: "fail", detail: `${file} unreadable` };
+    }
+    const expected = ["session-start-pi", "backup-pi", "capture-pi-final"];
+    const missing = expected.filter((subcommand) => !source.includes(JSON.stringify(subcommand)));
+    if (missing.length)
+        return { status: "fail", detail: `missing ${missing.join(", ")} — re-run \`codiedev connect\`` };
+    return { status: "pass", detail: `session start, capture and backup events (${(0, harnessDirs_1.displayPath)(file)})` };
+}