@femtomc/mu-agent 26.2.33

package/dist/meta_agent.js

@@ -0,0 +1,424 @@
+import { spawn } from "node:child_process";
+import { randomUUID } from "node:crypto";
+import { createInterface } from "node:readline";
+import { z } from "zod";
+import { CommandContextResolver } from "./command_context.js";
+const SAFE_RESPONSE_RE = /^[\s\S]{1,2000}$/;
+export const MetaApprovedCommandSchema = z.discriminatedUnion("kind", [
+    z.object({ kind: z.literal("status") }),
+    z.object({ kind: z.literal("ready") }),
+    z.object({ kind: z.literal("issue_list") }),
+    z.object({ kind: z.literal("issue_get"), issue_id: z.string().trim().min(1).optional() }),
+    z.object({
+        kind: z.literal("forum_read"),
+        topic: z.string().trim().min(1).optional(),
+        limit: z.number().int().min(1).max(500).optional(),
+    }),
+    z.object({
+        kind: z.literal("run_resume"),
+        root_issue_id: z.string().trim().min(1).optional(),
+        max_steps: z.number().int().min(1).max(500).optional(),
+    }),
+    z.object({
+        kind: z.literal("run_start"),
+        prompt: z.string().trim().min(1),
+        max_steps: z.number().int().min(1).max(500).optional(),
+    }),
+]);
+export const MetaAgentBackendTurnResultSchema = z.discriminatedUnion("kind", [
+    z.object({ kind: z.literal("respond"), message: z.string().trim().min(1).max(2000) }),
+    z.object({ kind: z.literal("command"), command: MetaApprovedCommandSchema }),
+]);
+function splitPromptIntoTokens(prompt) {
+    return prompt
+        .split(/\s+/)
+        .map((token) => token.trim())
+        .filter((token) => token.length > 0);
+}
+function normalizeArg(arg) {
+    return arg.trim();
+}
+export class ApprovedCommandBroker {
+    #contextResolver;
+    #runTriggersEnabled;
+    constructor(opts = {}) {
+        this.#contextResolver = opts.contextResolver ?? new CommandContextResolver();
+        this.#runTriggersEnabled = opts.runTriggersEnabled ?? true;
+    }
+    approve(opts) {
+        let commandKey;
+        let args;
+        switch (opts.proposal.kind) {
+            case "status":
+                commandKey = "status";
+                args = [];
+                break;
+            case "ready":
+                commandKey = "ready";
+                args = [];
+                break;
+            case "issue_list":
+                commandKey = "issue list";
+                args = [];
+                break;
+            case "issue_get":
+                commandKey = "issue get";
+                args = opts.proposal.issue_id ? [normalizeArg(opts.proposal.issue_id)] : [];
+                break;
+            case "forum_read": {
+                commandKey = "forum read";
+                args = [];
+                if (opts.proposal.topic) {
+                    args.push(normalizeArg(opts.proposal.topic));
+                }
+                if (opts.proposal.limit != null) {
+                    args.push(String(Math.trunc(opts.proposal.limit)));
+                }
+                break;
+            }
+            case "run_resume": {
+                if (!this.#runTriggersEnabled) {
+                    return { kind: "reject", reason: "meta_agent_action_disallowed", details: "run triggers disabled" };
+                }
+                commandKey = "run resume";
+                args = [];
+                if (opts.proposal.root_issue_id) {
+                    args.push(normalizeArg(opts.proposal.root_issue_id));
+                }
+                if (opts.proposal.max_steps != null) {
+                    args.push(String(Math.trunc(opts.proposal.max_steps)));
+                }
+                break;
+            }
+            case "run_start": {
+                if (!this.#runTriggersEnabled) {
+                    return { kind: "reject", reason: "meta_agent_action_disallowed", details: "run triggers disabled" };
+                }
+                commandKey = "run start";
+                args = splitPromptIntoTokens(opts.proposal.prompt);
+                break;
+            }
+            default:
+                return { kind: "reject", reason: "meta_agent_action_disallowed" };
+        }
+        const resolved = this.#contextResolver.resolve({
+            repoRoot: opts.inbound.repo_root,
+            commandKey,
+            args,
+            inboundTargetType: opts.inbound.target_type,
+            inboundTargetId: opts.inbound.target_id,
+            metadata: opts.inbound.metadata,
+        });
+        if (resolved.kind === "reject") {
+            return {
+                kind: "reject",
+                reason: resolved.reason,
+                details: resolved.details,
+            };
+        }
+        return {
+            kind: "approved",
+            commandText: `/mu ${resolved.normalizedText}`,
+        };
+    }
+}
+function defaultSessionId() {
+    return `meta-${randomUUID()}`;
+}
+function defaultTurnId() {
+    return `turn-${randomUUID()}`;
+}
+function conversationKey(inbound, binding) {
+    return `${inbound.channel}:${inbound.channel_tenant_id}:${inbound.channel_conversation_id}:${binding.binding_id}`;
+}
+export class MessagingMetaAgentRuntime {
+    #backend;
+    #broker;
+    #enabled;
+    #enabledChannels;
+    #sessionIdFactory;
+    #turnIdFactory;
+    #sessionByConversation = new Map();
+    constructor(opts) {
+        this.#backend = opts.backend;
+        this.#broker = opts.broker ?? new ApprovedCommandBroker();
+        this.#enabled = opts.enabled ?? true;
+        this.#enabledChannels = opts.enabledChannels ? new Set(opts.enabledChannels.map((v) => v.toLowerCase())) : null;
+        this.#sessionIdFactory = opts.sessionIdFactory ?? defaultSessionId;
+        this.#turnIdFactory = opts.turnIdFactory ?? defaultTurnId;
+    }
+    #resolveSessionId(inbound, binding) {
+        const key = conversationKey(inbound, binding);
+        const existing = this.#sessionByConversation.get(key);
+        if (existing) {
+            return existing;
+        }
+        const created = this.#sessionIdFactory();
+        this.#sessionByConversation.set(key, created);
+        return created;
+    }
+    async handleInbound(opts) {
+        const sessionId = this.#resolveSessionId(opts.inbound, opts.binding);
+        const turnId = this.#turnIdFactory();
+        if (!this.#enabled) {
+            return {
+                kind: "reject",
+                reason: "meta_agent_disabled",
+                metaSessionId: sessionId,
+                metaTurnId: turnId,
+            };
+        }
+        if (this.#enabledChannels && !this.#enabledChannels.has(opts.inbound.channel.toLowerCase())) {
+            return {
+                kind: "reject",
+                reason: "meta_agent_disabled",
+                metaSessionId: sessionId,
+                metaTurnId: turnId,
+            };
+        }
+        let backendResult;
+        try {
+            backendResult = MetaAgentBackendTurnResultSchema.parse(await this.#backend.runTurn({
+                sessionId,
+                turnId,
+                inbound: opts.inbound,
+                binding: opts.binding,
+            }));
+        }
+        catch (err) {
+            return {
+                kind: "reject",
+                reason: "meta_agent_invalid_output",
+                details: err instanceof Error ? err.message : "meta_agent_backend_error",
+                metaSessionId: sessionId,
+                metaTurnId: turnId,
+            };
+        }
+        if (backendResult.kind === "respond") {
+            const message = backendResult.message.trim();
+            if (!SAFE_RESPONSE_RE.test(message)) {
+                return {
+                    kind: "reject",
+                    reason: "meta_agent_invalid_output",
+                    details: "invalid response payload",
+                    metaSessionId: sessionId,
+                    metaTurnId: turnId,
+                };
+            }
+            return {
+                kind: "response",
+                message,
+                metaSessionId: sessionId,
+                metaTurnId: turnId,
+            };
+        }
+        const approved = this.#broker.approve({
+            proposal: backendResult.command,
+            inbound: opts.inbound,
+        });
+        if (approved.kind === "reject") {
+            return {
+                kind: "reject",
+                reason: approved.reason,
+                details: approved.details,
+                metaSessionId: sessionId,
+                metaTurnId: turnId,
+            };
+        }
+        return {
+            kind: "command",
+            commandText: approved.commandText,
+            metaSessionId: sessionId,
+            metaTurnId: turnId,
+        };
+    }
+}
+const DEFAULT_META_SYSTEM_PROMPT = [
+    "You are mu's dedicated messaging meta-agent.",
+    "Your priorities:",
+    "- Answer core mu operational questions (status, ready work, issue/forum navigation, run lifecycle).",
+    "- Guide users through control-plane setup (Slack/Discord/Telegram env vars, identity linking, serve workflow).",
+    "- Keep answers practical and actionable.",
+    "",
+    "You must return exactly one JSON object and nothing else.",
+    "Valid shape:",
+    '  {"kind":"respond","message":"..."}',
+    "or",
+    '  {"kind":"command","command":{...}}',
+    "Allowed command kinds: status, ready, issue_list, issue_get, forum_read, run_resume, run_start.",
+    "Use kind=respond for explanations, setup guidance, or when context is missing.",
+    "Use kind=command only when one allowed command will materially help answer the user.",
+    "Never output shell commands.",
+].join("\n");
+function extractAssistantTextFromJsonEvent(event) {
+    if (!event || typeof event !== "object") {
+        return null;
+    }
+    if (event.type !== "message_end") {
+        return null;
+    }
+    if (!event.message || typeof event.message !== "object") {
+        return null;
+    }
+    if (event.message.role !== "assistant") {
+        return null;
+    }
+    const message = event.message;
+    if (typeof message.text === "string" && message.text.trim().length > 0) {
+        return message.text;
+    }
+    if (typeof message.content === "string" && message.content.trim().length > 0) {
+        return message.content;
+    }
+    if (Array.isArray(message.content)) {
+        const parts = [];
+        for (const item of message.content) {
+            if (!item) {
+                continue;
+            }
+            if (typeof item === "string") {
+                if (item.trim().length > 0) {
+                    parts.push(item);
+                }
+                continue;
+            }
+            if (typeof item === "object") {
+                const text = item.text;
+                if (typeof text === "string" && text.trim().length > 0) {
+                    parts.push(text);
+                }
+            }
+        }
+        if (parts.length > 0) {
+            return parts.join("\n");
+        }
+    }
+    return null;
+}
+function extractFirstJsonObject(text) {
+    const trimmed = text.trim();
+    if (trimmed.startsWith("{") && trimmed.endsWith("}")) {
+        return trimmed;
+    }
+    const match = /\{[\s\S]*\}/.exec(trimmed);
+    if (!match) {
+        return null;
+    }
+    return match[0] ?? null;
+}
+function buildPiPrompt(input) {
+    return [
+        `session_id: ${input.sessionId}`,
+        `turn_id: ${input.turnId}`,
+        `channel: ${input.inbound.channel}`,
+        `channel_tenant_id: ${input.inbound.channel_tenant_id}`,
+        `channel_conversation_id: ${input.inbound.channel_conversation_id}`,
+        `actor_binding_id: ${input.binding.binding_id}`,
+        `assurance_tier: ${input.binding.assurance_tier}`,
+        `request_id: ${input.inbound.request_id}`,
+        `repo_root: ${input.inbound.repo_root}`,
+        `incoming_text: ${input.inbound.command_text}`,
+        `target_type: ${input.inbound.target_type}`,
+        `target_id: ${input.inbound.target_id}`,
+        `metadata: ${JSON.stringify(input.inbound.metadata)}`,
+        "Decide whether to respond or propose one approved command.",
+    ].join("\n");
+}
+export class PiMessagingMetaAgentBackend {
+    #provider;
+    #model;
+    #thinking;
+    #systemPrompt;
+    #timeoutMs;
+    #piBinary;
+    constructor(opts = {}) {
+        this.#provider = opts.provider;
+        this.#model = opts.model;
+        this.#thinking = opts.thinking ?? "minimal";
+        this.#systemPrompt = opts.systemPrompt ?? DEFAULT_META_SYSTEM_PROMPT;
+        this.#timeoutMs = Math.max(1_000, Math.trunc(opts.timeoutMs ?? 90_000));
+        this.#piBinary = opts.piBinary ?? "pi";
+    }
+    async runTurn(input) {
+        const argv = [
+            this.#piBinary,
+            "--mode",
+            "json",
+            "--no-session",
+            "--thinking",
+            this.#thinking,
+            "--system-prompt",
+            this.#systemPrompt,
+        ];
+        if (this.#provider) {
+            argv.push("--provider", this.#provider);
+        }
+        if (this.#model) {
+            argv.push("--model", this.#model);
+        }
+        argv.push(buildPiPrompt(input));
+        const assistantText = await new Promise((resolve, reject) => {
+            const proc = spawn(argv[0], argv.slice(1), {
+                cwd: input.inbound.repo_root,
+                stdio: ["ignore", "pipe", "pipe"],
+                env: process.env,
+            });
+            const rl = createInterface({ input: proc.stdout, crlfDelay: Number.POSITIVE_INFINITY });
+            const stderrChunks = [];
+            let resolvedText = "";
+            let finished = false;
+            let timeout = null;
+            const finish = (fn) => {
+                if (finished) {
+                    return;
+                }
+                finished = true;
+                if (timeout) {
+                    clearTimeout(timeout);
+                }
+                void rl.close();
+                fn();
+            };
+            proc.stderr?.on("data", (chunk) => {
+                stderrChunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+            });
+            void (async () => {
+                for await (const line of rl) {
+                    let parsed;
+                    try {
+                        parsed = JSON.parse(String(line));
+                    }
+                    catch {
+                        continue;
+                    }
+                    const maybeText = extractAssistantTextFromJsonEvent(parsed);
+                    if (maybeText) {
+                        resolvedText = maybeText;
+                    }
+                }
+            })().catch((err) => {
+                finish(() => reject(err));
+            });
+            proc.once("error", (err) => {
+                finish(() => reject(err));
+            });
+            proc.once("close", (code) => {
+                if ((code ?? 0) !== 0) {
+                    finish(() => reject(new Error(`pi exited with code ${code ?? 0}: ${Buffer.concat(stderrChunks).toString("utf8")}`)));
+                    return;
+                }
+                finish(() => resolve(resolvedText));
+            });
+            timeout = setTimeout(() => {
+                proc.kill("SIGKILL");
+                finish(() => reject(new Error("pi meta-agent timeout")));
+            }, this.#timeoutMs);
+        });
+        const jsonPayload = extractFirstJsonObject(assistantText);
+        if (!jsonPayload) {
+            throw new Error("meta_agent_invalid_output");
+        }
+        const parsed = JSON.parse(jsonPayload);
+        return MetaAgentBackendTurnResultSchema.parse(parsed);
+    }
+}

package/dist/mu_roles.d.ts

@@ -0,0 +1,15 @@
+export type MuRole = "orchestrator" | "worker";
+/** Determine role from tags. Defaults to orchestrator if no role tag present. */
+export declare function roleFromTags(tags: readonly string[]): MuRole;
+export declare const DEFAULT_ORCHESTRATOR_PROMPT: string;
+export declare const DEFAULT_WORKER_PROMPT: string;
+/**
+ * Load the system prompt for a role.
+ *
+ * When `repoRoot` is provided, tries `.mu/roles/${role}.md` first.
+ * The file body IS the entire system prompt — no auto-appending.
+ * Frontmatter is stripped via `splitFrontmatter`.
+ * Falls back to the hardcoded default on any error.
+ */
+export declare function systemPromptForRole(role: MuRole, repoRoot?: string): Promise<string>;
+//# sourceMappingURL=mu_roles.d.ts.map

package/dist/mu_roles.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mu_roles.d.ts","sourceRoot":"","sources":["../src/mu_roles.ts"],"names":[],"mappings":"AAIA,MAAM,MAAM,MAAM,GAAG,cAAc,GAAG,QAAQ,CAAC;AAE/C,iFAAiF;AACjF,wBAAgB,YAAY,CAAC,IAAI,EAAE,SAAS,MAAM,EAAE,GAAG,MAAM,CAM5D;AAgED,eAAO,MAAM,2BAA2B,QAwC5B,CAAC;AAEb,eAAO,MAAM,qBAAqB,QA0BtB,CAAC;AAMb;;;;;;;GAOG;AACH,wBAAsB,mBAAmB,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAY1F"}

package/dist/mu_roles.js

@@ -0,0 +1,165 @@
+import { readFile } from "node:fs/promises";
+import { join } from "node:path";
+import { splitFrontmatter } from "./prompt.js";
+/** Determine role from tags. Defaults to orchestrator if no role tag present. */
+export function roleFromTags(tags) {
+    for (const tag of tags) {
+        if (tag === "role:worker")
+            return "worker";
+        if (tag === "role:orchestrator")
+            return "orchestrator";
+    }
+    return "orchestrator";
+}
+/* ------------------------------------------------------------------ */
+/*  mu CLI reference                                                   */
+/* ------------------------------------------------------------------ */
+const MU_CLI_REFERENCE = `
+## mu CLI
+
+You are running inside **mu**, an issue-driven orchestration system.
+You have four tools: bash, read, write, edit.
+
+- Orchestrator: use bash to run \`mu\` commands; do NOT use write/edit (and avoid read).
+- Worker: use tools as needed to implement your assigned issue.
+
+Tip: run \`mu <command> --help\` for details.
+
+### Issues
+
+\`\`\`bash
+# Create a child issue (always set --parent and --role)
+mu issues create "<title>" --parent <parent-id> --role worker [--body "<text>"] [--priority N] [--tag TAG]
+
+# Inspect
+mu issues get <id>                          # full issue detail
+mu issues list --root <root-id> [--status open|in_progress|closed]
+mu issues children <id>                     # direct children
+mu issues ready --root <root-id>            # executable leaves
+
+# Status transitions
+mu issues claim <id>                        # open → in_progress
+mu issues close <id> --outcome <outcome>    # close with outcome
+
+# Dependencies
+mu issues dep <src> blocks <dst>            # src must close before dst starts
+mu issues dep <child> parent <parent>       # set parent-child edge
+mu issues undep <src> blocks <dst>          # remove blocking edge
+
+# Update fields
+mu issues update <id> [--title "..."] [--body "..."] [--role worker|orchestrator] [--priority N] [--add-tag TAG]
+\`\`\`
+
+### Outcomes
+
+| Outcome      | Meaning                                             |
+|--------------|-----------------------------------------------------|
+| \`success\`    | Work completed successfully (terminal)              |
+| \`failure\`    | Work failed — triggers re-orchestration             |
+| \`needs_work\` | Partial — triggers re-orchestration                 |
+| \`expanded\`   | Decomposed into children (orchestrator closes self) |
+| \`skipped\`    | Not applicable (terminal)                           |
+
+### Forum (logging & coordination)
+
+\`\`\`bash
+mu forum post issue:<id> -m "<message>" --author <role>
+mu forum read issue:<id> [--limit N]
+\`\`\`
+`.trim();
+/* ------------------------------------------------------------------ */
+/*  Default role prompts (exported for mu init + tests)                */
+/* ------------------------------------------------------------------ */
+export const DEFAULT_ORCHESTRATOR_PROMPT = [
+    "# Mu Orchestrator",
+    "",
+    "You are mu's orchestrator: the hierarchical planner for the issue DAG.",
+    "",
+    "## Non-Negotiable Constraints",
+    "",
+    "1. You MUST NOT execute work directly. No code changes, no file edits, no git commits.",
+    "2. You MUST decompose the assigned issue into worker child issues, then close the assigned issue with `--outcome expanded`.",
+    "3. Decomposition MUST be deterministic and minimal. Use `blocks` edges for sequencing.",
+    "",
+    "Even if the task looks atomic: create exactly one worker child issue rather than doing the work yourself.",
+    "If you catch yourself about to implement: STOP and create/refine worker issues instead.",
+    "",
+    "Your only job is to create child issues, add any required `blocks` dependencies, and then close yourself with outcome=expanded.",
+    "",
+    "## Workflow",
+    "",
+    "1. Investigate: `mu issues get <id>`, `mu forum read issue:<id> --limit 20`, `mu issues children <id>`.",
+    "2. Decompose: create child issues with `mu issues create` (always set `--parent` and `--role worker`).",
+    "3. Order: add `blocks` edges between children where sequencing matters.",
+    "4. Close: `mu issues close <id> --outcome expanded`.",
+    "",
+    "The ONLY valid outcome for you is `expanded`.",
+    "Never close with `success`, `failure`, `needs_work`, or `skipped` — those are for workers.",
+    "",
+    "## Rules",
+    "",
+    "- Use only roles: orchestrator, worker.",
+    "- Every executable leaf MUST be `--role worker`.",
+    "- Never create a child without an explicit role.",
+    "",
+    "## Strategies For Good Plans",
+    "",
+    "- Include feedback loops in worker issues: tests, typecheck, build, lint, repro steps.",
+    "- Prefer small issues with crisp acceptance criteria over large ambiguous ones.",
+    "- If the work needs verification, add a worker review issue blocked by implementation.",
+    "  If review fails, that worker should close with outcome=needs_work and describe what failed.",
+    "",
+    MU_CLI_REFERENCE,
+].join("\n");
+export const DEFAULT_WORKER_PROMPT = [
+    "# Mu Worker",
+    "",
+    "You are mu's worker. You execute exactly one atomic issue end-to-end.",
+    "",
+    "## Responsibilities",
+    "",
+    "- Implement the work described in your assigned issue.",
+    "- Keep scope tight to the issue specification.",
+    "- Verify results (tests, typecheck, build, lint, etc.) and report what changed.",
+    "- Close your issue with a terminal outcome when done.",
+    "",
+    "## Workflow",
+    "",
+    "1. Inspect: `mu issues get <id>` and `mu forum read issue:<id> --limit 20`.",
+    "2. Implement: edit files, run commands, and keep changes scoped to the issue.",
+    "3. Verify: run tests/build/typecheck/lint as appropriate. Prefer hard feedback loops.",
+    "4. Close: `mu issues close <id> --outcome success` (or `failure`/`skipped`).",
+    "5. Log key notes: `mu forum post issue:<id> -m '...' --author worker`.",
+    "",
+    "## Rules",
+    "",
+    "- Do NOT create child issues — that is the orchestrator's job.",
+    "- If the issue is too large/unclear, close with `--outcome needs_work` and explain what is missing.",
+    "",
+    MU_CLI_REFERENCE,
+].join("\n");
+/* ------------------------------------------------------------------ */
+/*  Role-specific system prompts                                       */
+/* ------------------------------------------------------------------ */
+/**
+ * Load the system prompt for a role.
+ *
+ * When `repoRoot` is provided, tries `.mu/roles/${role}.md` first.
+ * The file body IS the entire system prompt — no auto-appending.
+ * Frontmatter is stripped via `splitFrontmatter`.
+ * Falls back to the hardcoded default on any error.
+ */
+export async function systemPromptForRole(role, repoRoot) {
+    if (repoRoot) {
+        try {
+            const filePath = join(repoRoot, ".mu", "roles", `${role}.md`);
+            const raw = await readFile(filePath, "utf8");
+            const { body } = splitFrontmatter(raw);
+            return body;
+        }
+        catch {
+            // File missing or unreadable — fall through to default.
+        }
+    }
+    return role === "orchestrator" ? DEFAULT_ORCHESTRATOR_PROMPT : DEFAULT_WORKER_PROMPT;
+}

package/dist/pi_backend.d.ts

@@ -0,0 +1,20 @@
+import type { MuRole } from "./mu_roles.js";
+export type BackendRunOpts = {
+    issueId: string;
+    role: MuRole;
+    systemPrompt: string;
+    prompt: string;
+    provider: string;
+    model: string;
+    thinking: string;
+    cwd: string;
+    cli: string;
+    logSuffix: string;
+    onLine?: (line: string) => void;
+    teePath?: string;
+};
+export interface BackendRunner {
+    run(opts: BackendRunOpts): Promise<number>;
+}
+export declare function piStreamHasError(line: string): boolean;
+//# sourceMappingURL=pi_backend.d.ts.map

package/dist/pi_backend.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pi_backend.d.ts","sourceRoot":"","sources":["../src/pi_backend.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,eAAe,CAAC;AAE5C,MAAM,MAAM,cAAc,GAAG;IAC5B,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,EAAE,MAAM,CAAC;IACb,YAAY,EAAE,MAAM,CAAC;IACrB,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,MAAM,CAAC;IACjB,KAAK,EAAE,MAAM,CAAC;IACd,QAAQ,EAAE,MAAM,CAAC;IACjB,GAAG,EAAE,MAAM,CAAC;IACZ,GAAG,EAAE,MAAM,CAAC;IACZ,SAAS,EAAE,MAAM,CAAC;IAClB,MAAM,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;IAChC,OAAO,CAAC,EAAE,MAAM,CAAC;CACjB,CAAC;AAEF,MAAM,WAAW,aAAa;IAC7B,GAAG,CAAC,IAAI,EAAE,cAAc,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC;CAC3C;AAED,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CA4BtD"}

package/dist/pi_backend.js

@@ -0,0 +1,27 @@
+export function piStreamHasError(line) {
+    let event;
+    try {
+        event = JSON.parse(line);
+    }
+    catch {
+        return false;
+    }
+    const etype = event?.type;
+    if (etype === "message_update") {
+        const assistantEvent = event?.assistantMessageEvent;
+        if (assistantEvent && typeof assistantEvent === "object" && assistantEvent.type === "error") {
+            return true;
+        }
+    }
+    if (etype === "message_end") {
+        const message = event?.message;
+        if (!message || typeof message !== "object") {
+            return false;
+        }
+        if (message.role !== "assistant") {
+            return false;
+        }
+        return message.stopReason === "error" || message.stopReason === "aborted";
+    }
+    return false;
+}

package/dist/pi_sdk_backend.d.ts

@@ -0,0 +1,20 @@
+import { DefaultResourceLoader, SettingsManager } from "@mariozechner/pi-coding-agent";
+import type { BackendRunner, BackendRunOpts } from "./pi_backend.js";
+/**
+ * In-process backend using the pi SDK.
+ *
+ * Replaces subprocess spawning of the `pi` CLI with direct use of
+ * `createAgentSession` from `@mariozechner/pi-coding-agent`.
+ */
+export declare class PiSdkBackend implements BackendRunner {
+    run(opts: BackendRunOpts): Promise<number>;
+}
+export type CreateMuResourceLoaderOpts = {
+    cwd: string;
+    systemPrompt: string;
+    agentDir?: string;
+    settingsManager?: SettingsManager;
+    additionalSkillPaths?: string[];
+};
+export declare function createMuResourceLoader(opts: CreateMuResourceLoaderOpts): DefaultResourceLoader;
+//# sourceMappingURL=pi_sdk_backend.d.ts.map

package/dist/pi_sdk_backend.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pi_sdk_backend.d.ts","sourceRoot":"","sources":["../src/pi_sdk_backend.ts"],"names":[],"mappings":"AAMA,OAAO,EAQN,qBAAqB,EAErB,eAAe,EACf,MAAM,+BAA+B,CAAC;AACvC,OAAO,KAAK,EAAE,aAAa,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAC;AAwCrE;;;;;GAKG;AACH,qBAAa,YAAa,YAAW,aAAa;IAC3C,GAAG,CAAC,IAAI,EAAE,cAAc,GAAG,OAAO,CAAC,MAAM,CAAC;CAiGhD;AAED,MAAM,MAAM,0BAA0B,GAAG;IACxC,GAAG,EAAE,MAAM,CAAC;IACZ,YAAY,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,eAAe,CAAC,EAAE,eAAe,CAAC;IAClC,oBAAoB,CAAC,EAAE,MAAM,EAAE,CAAC;CAChC,CAAC;AAEF,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,0BAA0B,GAAG,qBAAqB,CAsB9F"}