@co0ontty/wand 4.27.1 → 4.28.0

package/dist/mission-diff.js

@@ -0,0 +1,65 @@
+import { spawnSync } from "node:child_process";
+import { existsSync } from "node:fs";
+import { runGit, runGitRaw } from "./git-utils.js";
+const DEFAULT_MAX_PATCH_BYTES = 2 * 1024 * 1024;
+function appendBounded(current, next, maxBytes) {
+    const available = maxBytes - Buffer.byteLength(current);
+    if (available <= 0)
+        return { value: current, truncated: true };
+    if (Buffer.byteLength(next) <= available)
+        return { value: current + next, truncated: false };
+    return { value: current + Buffer.from(next).subarray(0, available).toString("utf8"), truncated: true };
+}
+function parseNameStatus(raw) {
+    return raw.split("\n").filter(Boolean).map((line) => {
+        const fields = line.split("\t");
+        return { status: fields[0] || "M", path: fields[fields.length - 1] || line };
+    });
+}
+function untrackedPatch(cwd, relativePath) {
+    const result = spawnSync("git", ["diff", "--no-index", "--no-color", "--", "/dev/null", relativePath], {
+        cwd,
+        encoding: "utf8",
+        maxBuffer: DEFAULT_MAX_PATCH_BYTES,
+        env: { ...process.env, GIT_PAGER: "cat", PAGER: "cat", GIT_TERMINAL_PROMPT: "0" },
+    });
+    if (result.status !== 0 && result.status !== 1) {
+        throw new Error(result.stderr?.trim() || `无法读取未跟踪文件 diff：${relativePath}`);
+    }
+    return result.stdout || "";
+}
+export function buildMissionDiff(options) {
+    if (!existsSync(options.cwd))
+        throw new Error("任务 worktree 不存在，无法生成 diff。");
+    runGit(["rev-parse", "--verify", `${options.baseRef}^{commit}`], options.cwd);
+    const maxBytes = options.maxPatchBytes ?? DEFAULT_MAX_PATCH_BYTES;
+    const trackedNames = parseNameStatus(runGitRaw(["diff", "--name-status", options.baseRef, "--", "."], options.cwd));
+    const untracked = runGitRaw(["ls-files", "--others", "--exclude-standard", "-z"], options.cwd)
+        .split("\0")
+        .filter(Boolean);
+    const files = [...trackedNames, ...untracked.map((file) => ({ path: file, status: "?" }))];
+    let patch = runGitRaw(["diff", "--no-color", "--find-renames", options.baseRef, "--", "."], options.cwd);
+    let truncated = false;
+    if (Buffer.byteLength(patch) > maxBytes) {
+        patch = Buffer.from(patch).subarray(0, maxBytes).toString("utf8");
+        truncated = true;
+    }
+    if (!truncated) {
+        for (const file of untracked) {
+            const appended = appendBounded(patch, untrackedPatch(options.cwd, file), maxBytes);
+            patch = appended.value;
+            if (appended.truncated) {
+                truncated = true;
+                break;
+            }
+        }
+    }
+    return {
+        missionId: options.missionId,
+        attemptId: options.attemptId,
+        baseRef: options.baseRef,
+        files,
+        patch,
+        truncated,
+    };
+}

package/dist/mission-types.d.ts

@@ -0,0 +1,90 @@
+import type { SessionProvider } from "./types.js";
+export type AgentActivityState = "working" | "needs_input" | "needs_permission" | "done" | "failed";
+export type MissionStatus = "dispatching" | "running" | "needs_input" | "completed" | "failed" | "archived";
+export type MissionAttemptState = AgentActivityState | "queued";
+export type MissionReviewStatus = "pending" | "sent" | "resolved";
+export interface MissionWorktreeOptions {
+    baseRef?: string;
+    sharedDirectories?: string[];
+    copyPaths?: string[];
+}
+export interface Mission {
+    id: string;
+    title: string;
+    prompt: string;
+    cwd: string;
+    status: MissionStatus;
+    worktree: MissionWorktreeOptions;
+    createdAt: string;
+    updatedAt: string;
+}
+export interface MissionAttempt {
+    id: string;
+    missionId: string;
+    sessionId: string | null;
+    provider: SessionProvider;
+    state: MissionAttemptState;
+    branch: string | null;
+    worktreePath: string | null;
+    baseRef: string | null;
+    summary: string | null;
+    error: string | null;
+    createdAt: string;
+    updatedAt: string;
+}
+export interface MissionReviewComment {
+    id: string;
+    missionId: string;
+    attemptId: string;
+    filePath: string;
+    line: number | null;
+    side: "old" | "new";
+    body: string;
+    status: MissionReviewStatus;
+    createdAt: string;
+    sentAt: string | null;
+    resolvedAt: string | null;
+}
+export interface AgentActivityItem {
+    sessionId: string;
+    missionId: string | null;
+    attemptId: string | null;
+    state: AgentActivityState;
+    title: string;
+    summary: string | null;
+    provider: SessionProvider | null;
+    cwd: string | null;
+    updatedAt: string;
+    readAt: string | null;
+}
+export interface MissionDetails extends Mission {
+    attempts: MissionAttempt[];
+    comments: MissionReviewComment[];
+}
+export interface MissionDiffFile {
+    path: string;
+    status: string;
+}
+export interface MissionDiff {
+    missionId: string;
+    attemptId: string;
+    baseRef: string;
+    files: MissionDiffFile[];
+    patch: string;
+    truncated: boolean;
+}
+export interface CreateMissionInput {
+    prompt: string;
+    title?: string;
+    cwd: string;
+    providers: SessionProvider[];
+    baseRef?: string;
+    sharedDirectories?: string[];
+    copyPaths?: string[];
+}
+export interface CreateReviewCommentInput {
+    filePath: string;
+    line?: number | null;
+    side?: "old" | "new";
+    body: string;
+}

package/dist/mission-types.js

@@ -0,0 +1 @@
+export {};

package/dist/missions.d.ts

@@ -0,0 +1,32 @@
+import type { AgentActivityItem, CreateMissionInput, CreateReviewCommentInput, MissionDetails, MissionDiff, MissionReviewComment } from "./mission-types.js";
+import type { SessionRegistry } from "./session-registry.js";
+import type { StructuredSessionManager } from "./structured-session-manager.js";
+import type { WandStorage } from "./storage.js";
+import type { ProcessEvent } from "./types.js";
+/**
+ * Deep task-orchestration module. Callers create missions, observe one inbox,
+ * and review diffs without coordinating session/worktree/storage details.
+ */
+export declare class Missions {
+    private readonly storage;
+    private readonly structured;
+    private readonly sessions;
+    constructor(storage: WandStorage, structured: StructuredSessionManager, sessions: SessionRegistry);
+    list(): MissionDetails[];
+    get(id: string): MissionDetails | null;
+    inbox(): AgentActivityItem[];
+    markInboxRead(sessionId?: string): void;
+    create(input: CreateMissionInput): MissionDetails;
+    ingest(event: ProcessEvent): AgentActivityItem | null;
+    diff(missionId: string, attemptId: string): MissionDiff;
+    addReviewComment(missionId: string, attemptId: string, input: CreateReviewCommentInput): MissionReviewComment;
+    sendReview(missionId: string, attemptId: string, commentIds?: string[]): MissionReviewComment[];
+    resolveReview(missionId: string, attemptId: string, commentIds: string[]): MissionReviewComment[];
+    archive(id: string): MissionDetails;
+    private dispatchAttempt;
+    private seedInbox;
+    private details;
+    private getIncludingArchived;
+    private requireAttempt;
+    private refreshMissionStatus;
+}

package/dist/missions.js

@@ -0,0 +1,344 @@
+import { randomUUID } from "node:crypto";
+import { existsSync, statSync } from "node:fs";
+import path from "node:path";
+import { buildMissionDiff } from "./mission-diff.js";
+const PROVIDERS = new Set(["claude", "codex", "opencode", "grok", "qoder", "pi"]);
+const MAX_ATTEMPTS = 6;
+function nowIso() {
+    return new Date().toISOString();
+}
+function normalizeStringList(value, field) {
+    const result = [...new Set((value ?? []).map((item) => item.trim()).filter(Boolean))];
+    if (result.length > 20)
+        throw new Error(`${field} 最多允许 20 个路径。`);
+    for (const item of result) {
+        if (item.length > 500)
+            throw new Error(`${field} 中的路径过长。`);
+    }
+    return result;
+}
+function firstPromptLine(prompt) {
+    const line = prompt.split("\n").map((part) => part.trim()).find(Boolean) || "新任务";
+    return line.length > 72 ? `${line.slice(0, 69)}…` : line;
+}
+function sessionSummary(snapshot) {
+    if (snapshot.description?.trim())
+        return snapshot.description.trim();
+    if (snapshot.currentTaskTitle?.trim())
+        return snapshot.currentTaskTitle.trim();
+    const messages = snapshot.messages ?? [];
+    for (let turnIndex = messages.length - 1; turnIndex >= 0; turnIndex--) {
+        const text = messages[turnIndex].content
+            .filter((block) => block.type === "text")
+            .map((block) => block.text.trim())
+            .filter(Boolean)
+            .join(" ");
+        if (text)
+            return text.length > 240 ? `${text.slice(0, 237)}…` : text;
+    }
+    return snapshot.summary?.trim() || null;
+}
+function hasUnansweredQuestion(messages) {
+    if (!messages?.length || messages[messages.length - 1]?.role === "user")
+        return false;
+    const answered = new Set();
+    for (const turn of messages) {
+        for (const block of turn.content) {
+            if (block.type === "tool_result")
+                answered.add(block.tool_use_id);
+        }
+    }
+    for (let turnIndex = messages.length - 1; turnIndex >= 0; turnIndex--) {
+        const turn = messages[turnIndex];
+        if (turn.role === "user" && turn.content.some((block) => block.type === "text"))
+            break;
+        if (turn.content.some((block) => block.type === "tool_use"
+            && (block.name === "AskUserQuestion" || block.semantic?.kind === "question_request")
+            && !answered.has(block.id)))
+            return true;
+    }
+    return false;
+}
+function activityState(snapshot, event) {
+    if (snapshot.pendingEscalation || snapshot.permissionBlocked)
+        return "needs_permission";
+    if (hasUnansweredQuestion(snapshot.messages))
+        return "needs_input";
+    if (snapshot.status === "failed" || (event?.type === "ended" && snapshot.exitCode !== null && snapshot.exitCode !== 0))
+        return "failed";
+    if (snapshot.status === "running" || snapshot.structuredState?.inFlight)
+        return "working";
+    return "done";
+}
+function missionStatus(attempts) {
+    if (attempts.length === 0)
+        return "dispatching";
+    if (attempts.some((attempt) => attempt.state === "needs_input" || attempt.state === "needs_permission"))
+        return "needs_input";
+    if (attempts.some((attempt) => attempt.state === "working" || attempt.state === "queued"))
+        return "running";
+    if (attempts.some((attempt) => attempt.state === "done"))
+        return "completed";
+    return "failed";
+}
+function reviewPrompt(comments) {
+    const lines = comments.map((comment, index) => {
+        const location = comment.line === null ? comment.filePath : `${comment.filePath}:${comment.line}`;
+        return `${index + 1}. ${location} [${comment.side}] — ${comment.body}`;
+    });
+    return [
+        "Please address the following review feedback for this task.",
+        "Apply all requested changes in the current worktree, preserve unrelated work, and run focused verification before replying.",
+        "",
+        ...lines,
+    ].join("\n");
+}
+/**
+ * Deep task-orchestration module. Callers create missions, observe one inbox,
+ * and review diffs without coordinating session/worktree/storage details.
+ */
+export class Missions {
+    storage;
+    structured;
+    sessions;
+    constructor(storage, structured, sessions) {
+        this.storage = storage;
+        this.structured = structured;
+        this.sessions = sessions;
+    }
+    list() {
+        return this.storage.listMissions().map((mission) => this.details(mission));
+    }
+    get(id) {
+        const mission = this.storage.getMission(id);
+        return mission ? this.details(mission) : null;
+    }
+    inbox() {
+        this.seedInbox();
+        return this.storage.listAgentActivity();
+    }
+    markInboxRead(sessionId) {
+        this.storage.markAgentActivityRead(sessionId);
+    }
+    create(input) {
+        const prompt = input.prompt?.trim();
+        if (!prompt)
+            throw new Error("任务提示词不能为空。");
+        if (prompt.length > 200_000)
+            throw new Error("任务提示词不能超过 200000 个字符。");
+        const cwd = path.resolve(input.cwd || "");
+        if (!existsSync(cwd) || !statSync(cwd).isDirectory())
+            throw new Error("任务工作目录不存在。");
+        const providers = [...new Set(input.providers ?? [])];
+        if (providers.length === 0 || providers.length > MAX_ATTEMPTS || providers.some((provider) => !PROVIDERS.has(provider))) {
+            throw new Error(`请选择 1-${MAX_ATTEMPTS} 个有效 provider。`);
+        }
+        const createdAt = nowIso();
+        const mission = {
+            id: randomUUID(),
+            title: input.title?.trim().slice(0, 120) || firstPromptLine(prompt),
+            prompt,
+            cwd,
+            status: "dispatching",
+            worktree: {
+                baseRef: input.baseRef?.trim() || undefined,
+                sharedDirectories: normalizeStringList(input.sharedDirectories, "sharedDirectories"),
+                copyPaths: normalizeStringList(input.copyPaths, "copyPaths"),
+            },
+            createdAt,
+            updatedAt: createdAt,
+        };
+        this.storage.saveMission(mission);
+        for (const provider of providers)
+            this.dispatchAttempt(mission, provider);
+        this.refreshMissionStatus(mission.id);
+        return this.get(mission.id);
+    }
+    ingest(event) {
+        if (!event.sessionId || event.sessionId === "__system__")
+            return null;
+        const snapshot = this.sessions.getLatest(event.sessionId);
+        if (!snapshot)
+            return null;
+        const attempt = this.storage.getMissionAttemptBySession(event.sessionId);
+        const mission = attempt ? this.storage.getMission(attempt.missionId) : null;
+        const state = activityState(snapshot, event);
+        const updatedAt = nowIso();
+        const item = {
+            sessionId: snapshot.id,
+            missionId: attempt?.missionId ?? null,
+            attemptId: attempt?.id ?? null,
+            state,
+            title: mission?.title || snapshot.title || `${snapshot.provider ?? "agent"} 会话`,
+            summary: sessionSummary(snapshot),
+            provider: snapshot.provider ?? snapshot.structuredState?.provider ?? null,
+            cwd: snapshot.cwd || null,
+            updatedAt,
+            readAt: null,
+        };
+        this.storage.upsertAgentActivity(item);
+        if (attempt) {
+            this.storage.saveMissionAttempt({
+                ...attempt,
+                state: state,
+                summary: item.summary,
+                error: state === "failed" ? snapshot.structuredState?.lastError ?? "任务执行失败" : null,
+                updatedAt,
+            });
+            this.refreshMissionStatus(attempt.missionId);
+        }
+        return item;
+    }
+    diff(missionId, attemptId) {
+        const attempt = this.requireAttempt(missionId, attemptId);
+        if (!attempt.worktreePath || !attempt.baseRef)
+            throw new Error("这个 attempt 没有可审查的 worktree。");
+        return buildMissionDiff({ missionId, attemptId, cwd: attempt.worktreePath, baseRef: attempt.baseRef });
+    }
+    addReviewComment(missionId, attemptId, input) {
+        this.requireAttempt(missionId, attemptId);
+        const body = input.body?.trim();
+        const filePath = input.filePath?.trim();
+        if (!body || !filePath)
+            throw new Error("文件和 review 内容不能为空。");
+        const createdAt = nowIso();
+        const comment = {
+            id: randomUUID(), missionId, attemptId, filePath,
+            line: typeof input.line === "number" && Number.isFinite(input.line) ? Math.max(1, Math.floor(input.line)) : null,
+            side: input.side === "old" ? "old" : "new",
+            body, status: "pending", createdAt, sentAt: null, resolvedAt: null,
+        };
+        this.storage.saveMissionReviewComment(comment);
+        return comment;
+    }
+    sendReview(missionId, attemptId, commentIds) {
+        const attempt = this.requireAttempt(missionId, attemptId);
+        if (!attempt.sessionId)
+            throw new Error("这个 attempt 没有关联会话。");
+        const selected = this.storage.listMissionReviewComments(missionId, attemptId)
+            .filter((comment) => comment.status === "pending" && (!commentIds?.length || commentIds.includes(comment.id)));
+        if (selected.length === 0)
+            throw new Error("没有待发送的 review 意见。");
+        const session = this.structured.get(attempt.sessionId);
+        if (!session)
+            throw new Error("任务会话当前不可用。");
+        const completion = this.structured.sendMessage(attempt.sessionId, reviewPrompt(selected));
+        completion.catch((error) => {
+            console.error(`[Missions] Review dispatch failed for ${attempt.id}:`, error);
+        });
+        this.storage.updateMissionReviewStatus(selected.map((comment) => comment.id), "sent");
+        this.storage.saveMissionAttempt({ ...attempt, state: "working", updatedAt: nowIso() });
+        this.refreshMissionStatus(missionId);
+        return this.storage.listMissionReviewComments(missionId, attemptId);
+    }
+    resolveReview(missionId, attemptId, commentIds) {
+        this.requireAttempt(missionId, attemptId);
+        this.storage.updateMissionReviewStatus(commentIds, "resolved");
+        return this.storage.listMissionReviewComments(missionId, attemptId);
+    }
+    archive(id) {
+        const mission = this.storage.getMission(id);
+        if (!mission)
+            throw new Error("任务不存在。");
+        this.storage.updateMissionStatus(id, "archived");
+        return this.getIncludingArchived(id);
+    }
+    dispatchAttempt(mission, provider) {
+        const attemptId = randomUUID();
+        const createdAt = nowIso();
+        let attempt = {
+            id: attemptId, missionId: mission.id, sessionId: null, provider, state: "queued",
+            branch: null, worktreePath: null, baseRef: mission.worktree.baseRef ?? null,
+            summary: null, error: null, createdAt, updatedAt: createdAt,
+        };
+        this.storage.saveMissionAttempt(attempt);
+        try {
+            const session = this.structured.createSession({
+                cwd: mission.cwd,
+                mode: "agent",
+                provider,
+                worktreeEnabled: true,
+                worktreeSpec: {
+                    baseRef: mission.worktree.baseRef,
+                    taskName: `${mission.title}-${provider}`,
+                    sharedDirectories: mission.worktree.sharedDirectories,
+                    copyPaths: mission.worktree.copyPaths,
+                },
+                sessionSource: "automation",
+                automationId: mission.id,
+            });
+            attempt = {
+                ...attempt,
+                sessionId: session.id,
+                state: "working",
+                branch: session.worktree?.branch ?? null,
+                worktreePath: session.worktree?.path ?? null,
+                baseRef: session.worktree?.baseRef ?? mission.worktree.baseRef ?? null,
+                updatedAt: nowIso(),
+            };
+            this.storage.saveMissionAttempt(attempt);
+            this.storage.upsertAgentActivity({
+                sessionId: session.id, missionId: mission.id, attemptId, state: "working",
+                title: mission.title, summary: `已分派给 ${provider}`, provider, cwd: session.cwd,
+                updatedAt: attempt.updatedAt, readAt: null,
+            });
+            const completion = this.structured.sendMessage(session.id, mission.prompt);
+            completion.catch((error) => {
+                console.error(`[Missions] Attempt ${attemptId} failed after dispatch:`, error);
+            });
+        }
+        catch (error) {
+            this.storage.saveMissionAttempt({
+                ...attempt,
+                state: "failed",
+                error: error instanceof Error ? error.message : String(error),
+                updatedAt: nowIso(),
+            });
+        }
+    }
+    seedInbox() {
+        const existing = new Set(this.storage.listAgentActivity().map((item) => item.sessionId));
+        for (const snapshot of this.sessions.listSlim()) {
+            if (existing.has(snapshot.id))
+                continue;
+            const attempt = this.storage.getMissionAttemptBySession(snapshot.id);
+            const mission = attempt ? this.storage.getMission(attempt.missionId) : null;
+            const at = nowIso();
+            this.storage.upsertAgentActivity({
+                sessionId: snapshot.id,
+                missionId: attempt?.missionId ?? null,
+                attemptId: attempt?.id ?? null,
+                state: activityState(snapshot),
+                title: mission?.title || snapshot.title || `${snapshot.provider ?? "agent"} 会话`,
+                summary: sessionSummary(snapshot),
+                provider: snapshot.provider ?? snapshot.structuredState?.provider ?? null,
+                cwd: snapshot.cwd || null,
+                updatedAt: snapshot.endedAt || snapshot.startedAt || at,
+                readAt: at,
+            });
+        }
+    }
+    details(mission) {
+        return {
+            ...mission,
+            attempts: this.storage.listMissionAttempts(mission.id),
+            comments: this.storage.listMissionReviewComments(mission.id),
+        };
+    }
+    getIncludingArchived(id) {
+        const mission = this.storage.getMission(id);
+        return mission ? this.details(mission) : null;
+    }
+    requireAttempt(missionId, attemptId) {
+        const attempt = this.storage.getMissionAttempt(attemptId);
+        if (!attempt || attempt.missionId !== missionId)
+            throw new Error("任务 attempt 不存在。");
+        return attempt;
+    }
+    refreshMissionStatus(missionId) {
+        const mission = this.storage.getMission(missionId);
+        if (!mission || mission.status === "archived")
+            return;
+        this.storage.updateMissionStatus(missionId, missionStatus(this.storage.listMissionAttempts(missionId)));
+    }
+}

package/dist/models.d.ts

@@ -42,6 +42,7 @@ export interface ModelCache {
     opencodeModels: ClaudeModelInfo[];
     grokModels: ClaudeModelInfo[];
     qoderModels: ClaudeModelInfo[];
+    piModels: ClaudeModelInfo[];
     claudeVersion: string | null;
     opencodeVersion: string | null;
     refreshedAt: string;

package/dist/models.js

@@ -53,6 +53,9 @@ const QODER_FALLBACK_MODELS = [
     { id: "performance", label: "Performance" },
     { id: "ultimate", label: "Ultimate" },
 ];
+const PI_FALLBACK_MODELS = [
+    { id: "default", label: "跟随 Pi 默认", alias: true },
+];
 function cloneModels(models) {
     return models.map((model) => ({
         ...model,
@@ -68,6 +71,7 @@ function cloneCache(cache) {
         opencodeModels: cloneModels(cache.opencodeModels),
         grokModels: cloneModels(cache.grokModels),
         qoderModels: cloneModels(cache.qoderModels),
+        piModels: cloneModels(cache.piModels),
         claudeVersion: cache.claudeVersion,
         opencodeVersion: cache.opencodeVersion,
         refreshedAt: cache.refreshedAt,
@@ -235,6 +239,7 @@ function createInitialCache(options) {
         opencodeModels: cloneModels(OPENCODE_FALLBACK_MODELS),
         grokModels: cloneModels(GROK_FALLBACK_MODELS),
         qoderModels: cloneModels(QODER_FALLBACK_MODELS),
+        piModels: cloneModels(PI_FALLBACK_MODELS),
         claudeVersion: null,
         opencodeVersion: null,
         refreshedAt: now.toISOString(),
@@ -523,6 +528,7 @@ function catalogRevision(cache) {
         opencodeModels: cache.opencodeModels,
         grokModels: cache.grokModels,
         qoderModels: cache.qoderModels,
+        piModels: cache.piModels,
         claudeVersion: cache.claudeVersion,
         opencodeVersion: cache.opencodeVersion,
     });
@@ -603,8 +609,9 @@ function parsePersistedModelCatalog(value) {
     const opencodeModels = parsePersistedModelList(catalog.opencodeModels);
     const grokModels = parsePersistedModelList(catalog.grokModels);
     const qoderModels = parsePersistedModelList(catalog.qoderModels);
+    const piModels = parsePersistedModelList(catalog.piModels);
     const refreshedAt = safePersistedString(catalog.refreshedAt, 64);
-    if (!models || !codexModels || !opencodeModels || !grokModels || !qoderModels
+    if (!models || !codexModels || !opencodeModels || !grokModels || !qoderModels || !piModels
         || !refreshedAt || Number.isNaN(Date.parse(refreshedAt))) {
         return null;
     }
@@ -619,6 +626,7 @@ function parsePersistedModelCatalog(value) {
         opencodeModels,
         grokModels,
         qoderModels,
+        piModels,
         claudeVersion,
         opencodeVersion,
         refreshedAt,
@@ -696,6 +704,7 @@ async function discoverModelCache(options, previous) {
         opencodeModels: opencodeProbe.models.ok ? opencodeProbe.models.value : cloneModels(previous.opencodeModels),
         grokModels: grokProbe.ok ? grokProbe.value : cloneModels(previous.grokModels),
         qoderModels: qoderProbe.ok ? qoderProbe.value : cloneModels(previous.qoderModels),
+        piModels: cloneModels(previous.piModels),
         claudeVersion,
         opencodeVersion: opencodeProbe.version.ok ? opencodeProbe.version.value : previous.opencodeVersion,
         refreshedAt: now.toISOString(),

package/dist/path-repair.js

@@ -6,7 +6,7 @@ import path from "node:path";
 import process from "node:process";
 import { spawn, spawnSync } from "node:child_process";
 /** 关键的 CLI 工具，会被诊断输出。 */
-const PROBE_COMMANDS = ["claude", "codex", "opencode", "grok", "qodercli"];
+const PROBE_COMMANDS = ["claude", "codex", "opencode", "grok", "qodercli", "pi"];
 const DEEP_PROBE_TIMEOUT_MS = 4000;
 /**
  * 构造候选 bin 目录列表（按优先级，前面的更可信）。

package/dist/process-manager.js

@@ -15,7 +15,7 @@ import { ensureNodePtyHelperExecutable } from "./ensure-node-pty-helper.js";
 import { buildLanguageDirective, buildManagedAutonomyDirective } from "./language-prompt.js";
 import { prepareSessionWorktree } from "./git-worktree.js";
 import { getProviderCommandSessionId, getProviderResumeCommandSessionId } from "./resume-policy.js";
-import { normalizeThinkingEffort, thinkingEffortToClaudeCliEffort, thinkingEffortToClaudeSlashEffort, thinkingEffortToCodexReasoningEffort, thinkingEffortToOpenCodeVariant } from "./structured-provider-common.js";
+import { normalizeThinkingEffort, thinkingEffortToClaudeCliEffort, thinkingEffortToClaudeSlashEffort, thinkingEffortToCodexReasoningEffort, thinkingEffortToOpenCodeVariant, thinkingEffortToPiLevel } from "./structured-provider-common.js";
 import { SessionTopicCoordinator } from "./session-topic.js";
 import { getErrorMessage } from "./error-utils.js";
 import { resolveSystemAiContext } from "./session-ai-context.js";
@@ -28,6 +28,8 @@ function resolveProviderFromCommand(command) {
         return "opencode";
     if (/^grok\b/.test(command.trim()))
         return "grok";
+    if (/^pi\b/.test(command.trim()))
+        return "pi";
     return /^qodercli\b/.test(command.trim()) ? "qoder" : "claude";
 }
 /**
@@ -2210,6 +2212,17 @@ export class ProcessManager extends EventEmitter {
             }
             return result;
         }
+        if (provider === "pi") {
+            let result = command;
+            const trimmedModel = model?.trim();
+            if (trimmedModel && trimmedModel !== "default" && !/--model(?:\s|=)/.test(result)) {
+                result += ` --model '${trimmedModel.replace(/'/g, "'\\''")}'`;
+            }
+            const level = thinkingEffortToPiLevel(thinkingEffort ?? null);
+            if (level && !/--thinking(?:\s|=)/.test(result))
+                result += ` --thinking '${level}'`;
+            return result;
+        }
         const isClaudeCmd = /^(?:claude|npx\s+claude|[^\s]+\/claude)(?:\s|$)/.test(command);
         if (!isClaudeCmd)
             return command;

package/dist/prompt-optimizer.d.ts

@@ -1,6 +1,6 @@
-import type { SystemAiConfig } from "./types.js";
+import { type QuickCommitAiOptions } from "./git-quick-commit.js";
 export declare class PromptOptimizeError extends Error {
     readonly code: string;
     constructor(message: string, code: string);
 }
-export declare function optimizePrompt(rawText: string, language: string, cwd?: string, systemAi?: SystemAiConfig): Promise<string>;
+export declare function optimizePrompt(rawText: string, language: string, cwd?: string, ai?: QuickCommitAiOptions): Promise<string>;