@evandu/super-pi 0.1.145 → 0.1.146

package/dist/server/application/session-orchestrator-service.js

@@ -1,6 +1,7 @@
 import { mkdir, readFile, writeFile } from "node:fs/promises";
 import { join } from "node:path";
 import { capText } from "../workflow.js";
+import { assertSessionCwdInsideWorkspace } from "../session-cwd.js";
 export const SESSION_OUTPUT_CHAR_LIMIT = 64 * 1024;
 export const sessionResultRelativePath = (conversationId) => `.super-pi/session-results/${conversationId}.md`;
 /**
@@ -26,14 +27,15 @@ export class SessionOrchestratorService {
      * Spawns a new sibling conversation and immediately dispatches its initial task.
      */
     async spawn(options) {
-        let workspaceId = options.workspaceId;
-        if (!workspaceId && options.parentConversationId) {
-            const parent = this.store.conversation(options.parentConversationId);
-            workspaceId = parent?.workspaceId;
-        }
+        const workspaceId = options.workspaceId?.trim();
         if (!workspaceId) {
-            throw new Error("创建兄弟会话需要指定工作区（或提供有效的父会话 ID）。");
+            throw new Error("创建兄弟会话必须显式指定 workspaceId；父会话只记录树形关系，不能代替目标工作区。");
         }
+        const workspace = this.store.workspace(workspaceId);
+        if (!workspace)
+            throw new Error("找不到这个工作区。");
+        await assertSessionCwdInsideWorkspace(workspace.path, options.cwd);
+        const cwd = options.cwd;
         // THE PARENTAGE IS WRITTEN AT CREATION TIME, onto the conversation itself - not only into the
         // in-memory ledger below. The ledger is task/status/progress metadata and dies with the process;
         // the conversation's parentConversationId/origin is what the sidebar's session tree redraws
@@ -41,7 +43,7 @@ export class SessionOrchestratorService {
         const conversationId = await this.conversationService.createConversation(workspaceId, {
             parentConversationId: options.parentConversationId,
             origin: options.parentConversationId ? "orchestrator" : "user",
-        });
+        }, cwd);
         // Set title if requested or derive from task
         if (options.title) {
             await this.conversationService.renameConversation(conversationId, options.title);
@@ -88,7 +90,11 @@ export class SessionOrchestratorService {
         this.ledger.update(conversationId, {
             status: "running",
         });
-        const runPromise = this.runService.enqueueAndRun(conversationId, content);
+        // THE ORDER IS THE SYSTEM'S, NOT THE READER'S. It used to go through `enqueueAndRun`, which
+        // writes the words under the reader's own name - so the child's transcript showed an
+        // instruction the reader never typed, wearing the reader's avatar, and a reader who looked at
+        // the child session saw their own name on somebody else's order.
+        const runPromise = this.runService.enqueueAndRunAsAgent(conversationId, content);
         const completion = (async () => {
             let failure;
             try {
@@ -175,11 +181,22 @@ export class SessionOrchestratorService {
         if (conversation.status === "running" || conversation.status === "waiting") {
             const lastAssistant = [...messages].reverse().find((m) => m.role === "assistant");
             if (lastAssistant?.toolCalls?.length) {
-                const lastCall = lastAssistant.toolCalls[lastAssistant.toolCalls.length - 1];
-                if (!lastCall.status || lastCall.live || lastCall.preparing) {
-                    activeTool = { label: lastCall.label, detail: lastCall.detail };
+                const isCompleted = (t) => t.status === "ok" || t.status === "error" || t.status === "done" || t.status === "failed";
+                const isRunning = (t) => !isCompleted(t) && (Boolean(t.preparing) || Boolean(t.live) || !t.status || t.status === "running");
+                const runningCall = [...lastAssistant.toolCalls].reverse().find(isRunning)
+                    ?? (!isCompleted(lastAssistant.toolCalls[lastAssistant.toolCalls.length - 1])
+                        ? lastAssistant.toolCalls[lastAssistant.toolCalls.length - 1]
+                        : undefined);
+                if (runningCall) {
+                    activeTool = {
+                        label: runningCall.label || runningCall.name || "tool",
+                        detail: runningCall.detail || runningCall.live,
+                    };
                 }
             }
+            if (!activeTool && ledgerEntry?.activeTool) {
+                activeTool = { ...ledgerEntry.activeTool };
+            }
         }
         const hasPendingQuestion = this.store.pendingQuestions(conversationId).length > 0;
         let output;
@@ -200,54 +217,113 @@ export class SessionOrchestratorService {
                 }
             }
         }
+        const effectiveStatus = conversation.error
+            ? "failed"
+            : conversation.status;
+        const finalProgress = lastAssistantSnippet ?? ledgerEntry?.lastProgress ?? lastUserSnippet;
         // Sync ledger status if present
-        if (ledgerEntry && ledgerEntry.status !== conversation.status) {
+        if (ledgerEntry && (ledgerEntry.status !== effectiveStatus || ledgerEntry.activeTool !== activeTool || ledgerEntry.lastProgress !== finalProgress)) {
             this.ledger.update(conversationId, {
-                status: conversation.status,
-                lastProgress: lastAssistantSnippet ?? ledgerEntry.lastProgress,
+                status: effectiveStatus,
+                lastProgress: finalProgress,
+                activeTool,
+                ...(conversation.error ? { error: conversation.error } : {}),
             });
         }
         return {
             conversationId: conversation.id,
             workspaceId: conversation.workspaceId,
             title: conversation.title,
-            status: conversation.status,
-            origin: ledgerEntry?.origin ?? "user",
+            status: effectiveStatus,
+            origin: ledgerEntry?.origin ?? conversation.origin ?? "user",
             parentConversationId: conversation.parentConversationId ?? ledgerEntry?.parentConversationId,
-            task: ledgerEntry?.task,
+            task: ledgerEntry?.task ?? (conversation.title && conversation.title !== "新会话" ? conversation.title : undefined),
             messageCount: messages.length,
             turnCount,
             lastAssistantSnippet,
             lastUserSnippet,
             hasPendingQuestion,
             activeTool,
-            error: conversation.error,
+            error: conversation.error ?? ledgerEntry?.error,
             updatedAt: conversation.updatedAt,
-            createdAt: ledgerEntry?.createdAt,
-            lastProgress: ledgerEntry?.lastProgress ?? lastAssistantSnippet,
+            createdAt: ledgerEntry?.createdAt ?? (conversation.messages?.[0]?.createdAt ? new Date(conversation.messages[0].createdAt).getTime() : (conversation.updatedAt ? new Date(conversation.updatedAt).getTime() : Date.now())),
+            lastProgress: finalProgress,
             ...(options?.includeOutput ? { outputPath: resultPath } : {}),
             ...(output !== undefined ? { output, outputTruncated } : {}),
         };
     }
     /**
      * Lists summaries of all sessions, optionally filtered by parent conversation.
+     *
+     * Persisted store conversations are the authoritative source for session tree
+     * parent-child relationships across server restarts, while SessionLedger
+     * enriches live in-memory task, progress, and activeTool state.
      */
     async list(parentConversationId) {
-        const entries = parentConversationId
-            ? this.ledger.listByParent(parentConversationId)
-            : this.ledger.listAll();
+        const targetParentId = parentConversationId?.trim();
+        const candidateIds = new Set();
+        if (targetParentId) {
+            // 1. Check parent in store to know parent's workspace
+            const parentConv = this.store.conversation(targetParentId);
+            if (parentConv) {
+                const workspaceChildren = this.store.conversationsForWorkspace(parentConv.workspaceId);
+                for (const child of workspaceChildren) {
+                    if (child.parentConversationId === targetParentId) {
+                        candidateIds.add(child.id);
+                    }
+                }
+            }
+            else {
+                // Fallback: check all conversations in store
+                const allConversations = this.store.snapshot().conversations;
+                for (const conv of allConversations) {
+                    if (conv.parentConversationId === targetParentId) {
+                        candidateIds.add(conv.id);
+                    }
+                }
+            }
+            // 2. Also check in-memory ledger entries
+            const ledgerEntries = this.ledger.listByParent(targetParentId);
+            for (const entry of ledgerEntries) {
+                candidateIds.add(entry.conversationId);
+            }
+        }
+        else {
+            // No parent specified: list all orchestrator / child sessions
+            for (const conv of this.store.snapshot().conversations) {
+                if (conv.parentConversationId || conv.origin === "orchestrator") {
+                    candidateIds.add(conv.id);
+                }
+            }
+            for (const entry of this.ledger.listAll()) {
+                candidateIds.add(entry.conversationId);
+            }
+        }
+        const parentConv = targetParentId ? this.store.conversation(targetParentId) : undefined;
         const summaries = [];
-        for (const entry of entries) {
+        for (const conversationId of candidateIds) {
             try {
-                const summary = await this.status(entry.conversationId);
+                const summary = await this.status(conversationId);
+                // Workspace boundary enforcement: do not leak sessions across different workspaces
+                if (parentConv && summary.workspaceId !== parentConv.workspaceId) {
+                    continue;
+                }
+                if (targetParentId && summary.parentConversationId !== targetParentId) {
+                    continue;
+                }
                 summaries.push(summary);
             }
             catch {
                 // Conversation was removed from store; prune ledger
-                this.ledger.delete(entry.conversationId);
+                this.ledger.delete(conversationId);
             }
         }
-        return summaries;
+        // Sort newest first by creation time or updated timestamp
+        return summaries.sort((a, b) => {
+            const timeA = a.createdAt ?? (a.updatedAt ? new Date(a.updatedAt).getTime() : 0);
+            const timeB = b.createdAt ?? (b.updatedAt ? new Date(b.updatedAt).getTime() : 0);
+            return timeB - timeA;
+        });
     }
     /**
      * Stops a target session.

package/dist/server/command-handler.js

@@ -169,7 +169,7 @@ export class CommandHandler {
             return;
         }
         if (command.type === "conversation.create") {
-            return await this.conversationService.createConversation(command.workspaceId);
+            return await this.conversationService.createConversation(command.workspaceId, undefined, command.cwd);
         }
         if (command.type === "conversation.autoRename") {
             // Answered on a pushed event rather than through the return value: this spends real model time, and

package/dist/server/conversation-usage.d.ts

@@ -0,0 +1,19 @@
+import type { ConversationContextUsage, SubagentUsage } from "./types.js";
+export type TurnUsageReadout = {
+    usage?: SubagentUsage;
+    costKnown: boolean;
+    contextUsage?: ConversationContextUsage;
+};
+/** Collect only completed assistant messages, never the repeated usage on streaming deltas. */
+export declare class ConversationUsageCollector {
+    private readonly total;
+    private costKnown;
+    add(value: unknown): void;
+    readout(context: {
+        tokens: number | null;
+        contextWindow: number;
+    } | undefined, model: {
+        provider?: string;
+        id?: string;
+    } | undefined, agentDir: string): TurnUsageReadout;
+}

package/dist/server/conversation-usage.js

@@ -0,0 +1,40 @@
+import { effectiveContextWindow, readDeclaredWindows } from "./model-context-window.js";
+const nonnegative = (value) => typeof value === "number" && Number.isFinite(value) && value >= 0;
+/** Collect only completed assistant messages, never the repeated usage on streaming deltas. */
+export class ConversationUsageCollector {
+    total = { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, cost: 0, turns: 0 };
+    costKnown = true;
+    add(value) {
+        if (!value || typeof value !== "object") {
+            this.costKnown = false;
+            return;
+        }
+        const usage = value;
+        const keys = ["input", "output", "cacheRead", "cacheWrite"];
+        const cost = usage.cost?.total;
+        if (!nonnegative(cost))
+            this.costKnown = false;
+        if (!keys.some(key => nonnegative(usage[key])) && !nonnegative(cost))
+            return;
+        for (const key of keys)
+            if (nonnegative(usage[key]))
+                this.total[key] += usage[key];
+        if (nonnegative(cost))
+            this.total.cost += cost;
+        this.total.turns++;
+    }
+    readout(context, model, agentDir) {
+        let contextUsage;
+        if (context) {
+            const contextWindow = model?.provider && model.id
+                ? effectiveContextWindow(readDeclaredWindows(agentDir), model.provider, model.id, context.contextWindow) ?? context.contextWindow
+                : context.contextWindow;
+            if (nonnegative(contextWindow) && contextWindow > 0) {
+                // Pi returns null after compaction until another assistant supplies a trustworthy token count.
+                const tokens = nonnegative(context.tokens) ? context.tokens : null;
+                contextUsage = { tokens, contextWindow, percent: tokens === null ? null : tokens / contextWindow * 100 };
+            }
+        }
+        return { ...(this.total.turns ? { usage: { ...this.total } } : {}), costKnown: this.costKnown, ...(contextUsage ? { contextUsage } : {}) };
+    }
+}

package/dist/server/file-diff.d.ts

@@ -35,4 +35,7 @@ export declare function computeFileDiff(options: {
     preferred?: "auto" | DiffBaselineKind;
     tracker?: FileChangeTracker;
     workspaceId?: string;
+    /** Repository root and tracker key when `root` is a session subdirectory. */
+    gitRoot?: string;
+    trackerPath?: string;
 }): Promise<FileDiff>;

package/dist/server/file-diff.js

@@ -36,12 +36,12 @@ import { FilesError, resolveInsideRoot } from "./files.js";
  * they are looking at and it must not silently become a different one.
  */
 export async function computeFileDiff(options) {
-    const { root, path, preferred = "auto", tracker, workspaceId } = options;
+    const { root, path, preferred = "auto", tracker, workspaceId, gitRoot = root, trackerPath = path } = options;
     const after = await readAfter(root, path);
     // The agent's baseline. It is the RIGHT one whenever it exists, because it is the content the agent
     // actually started from - which is not necessarily HEAD, and not necessarily what the file looked
     // like when the server started.
-    const agentChange = tracker && workspaceId ? tracker.get(workspaceId, path) : undefined;
+    const agentChange = tracker && workspaceId ? tracker.get(workspaceId, trackerPath) : undefined;
     if ((preferred === "auto" || preferred === "agent") && agentChange) {
         return {
             path,
@@ -55,8 +55,8 @@ export async function computeFileDiff(options) {
         };
     }
     if (preferred === "auto" || preferred === "git") {
-        if (await isGitRepository(root)) {
-            const head = await gitHeadContent(root, path);
+        if (await isGitRepository(gitRoot)) {
+            const head = await gitHeadContent(gitRoot, trackerPath);
             if (head !== null) {
                 return { path, baseline: "git", before: head, after, label: "Git 已提交的版本" };
             }

package/dist/server/file-index.d.ts

@@ -10,6 +10,7 @@ export type IndexedFile = {
 export type FileIndexEvent = {
     type: "files.index";
     workspaceId: string;
+    cwd?: string;
     version: number;
     changed: IndexedFile[];
     removed: string[];
@@ -33,6 +34,7 @@ export type FileIndexSnapshot = {
 export declare class FileIndex {
     readonly workspaceId: string;
     private readonly broadcast;
+    readonly cwd: string;
     readonly entries: Map<string, IndexedFile>;
     private readonly history;
     private root;
@@ -42,7 +44,7 @@ export declare class FileIndex {
     version: number;
     builtAt: number;
     complete: boolean;
-    constructor(workspaceId: string, broadcast: (event: FileIndexEvent) => void);
+    constructor(workspaceId: string, broadcast: (event: FileIndexEvent) => void, cwd?: string);
     start(root: string): void;
     stop(): void;
     snapshot(since?: number): FileIndexSnapshot;
@@ -83,4 +85,4 @@ export declare class FileIndex {
  * said out loud, and the turn carries on. The index is a convenience; it must never be able to end a
  * conversation.
  */
-export declare function refreshWorkspaceIndex(indexes: Map<string, FileIndex> | undefined, workspaceId: string, path: string): void;
+export declare function refreshWorkspaceIndex(indexes: Map<string, FileIndex> | undefined, workspaceId: string, path: string, workspaceRoot?: string): void;

package/dist/server/file-index.js

@@ -1,4 +1,5 @@
 import { readdir, stat } from "node:fs/promises";
+import { resolve } from "node:path";
 import { SEARCH_SKIP_DIRS, createRootGuard, fileMeta, isTextName, toRelative, toWorkspaceRelative } from "./files.js";
 const MAX_DIRECTORIES = 4000;
 const MAX_FILES = 30000;
@@ -12,6 +13,7 @@ const MAX_MS = 4000;
 export class FileIndex {
     workspaceId;
     broadcast;
+    cwd;
     entries = new Map();
     history = [];
     root = "";
@@ -21,9 +23,10 @@ export class FileIndex {
     version = 0;
     builtAt = 0;
     complete = false;
-    constructor(workspaceId, broadcast) {
+    constructor(workspaceId, broadcast, cwd = "") {
         this.workspaceId = workspaceId;
         this.broadcast = broadcast;
+        this.cwd = cwd;
     }
     start(root) {
         if (this.building || this.builtAt)
@@ -162,7 +165,7 @@ export class FileIndex {
         if (!changed.length && !removed.length && !force)
             return;
         this.version += 1;
-        const event = { type: "files.index", workspaceId: this.workspaceId, version: this.version, changed, removed, complete: this.complete, skipped: this.skipped };
+        const event = { type: "files.index", workspaceId: this.workspaceId, ...(this.cwd ? { cwd: this.cwd } : {}), version: this.version, changed, removed, complete: this.complete, skipped: this.skipped };
         this.history.push({ version: this.version, changed, removed });
         if (this.history.length > 128)
             this.history.shift();
@@ -185,11 +188,13 @@ export class FileIndex {
  * said out loud, and the turn carries on. The index is a convenience; it must never be able to end a
  * conversation.
  */
-export function refreshWorkspaceIndex(indexes, workspaceId, path) {
-    const index = indexes?.get(workspaceId);
-    if (!index)
-        return;
-    void index.refresh(path).catch((error) => {
-        console.warn(`Super Pi: the file index did not refresh ${path}: ${error instanceof Error ? error.message : "unknown error"}`);
-    });
+export function refreshWorkspaceIndex(indexes, workspaceId, path, workspaceRoot) {
+    for (const index of indexes?.values() ?? []) {
+        if (index.workspaceId !== workspaceId)
+            continue;
+        const target = workspaceRoot && index.cwd ? resolve(workspaceRoot, path) : path;
+        void index.refresh(target).catch((error) => {
+            console.warn(`Super Pi: the file index did not refresh ${path}: ${error instanceof Error ? error.message : "unknown error"}`);
+        });
+    }
 }

package/dist/server/file-name-index.d.ts

@@ -5,7 +5,9 @@
  * the agent's writes - go through this one function, so there is exactly one index per workspace and
  * the two never drift into answering from different maps.
  */
-export declare function ensureNameIndex(indexes: Map<string, FileNameIndex>, workspaceId: string, root: string): FileNameIndex;
+export declare function ensureNameIndex(indexes: Map<string, FileNameIndex>, workspaceId: string, root: string, cwd?: string): FileNameIndex;
+/** Keeps every root/subdirectory index for a workspace in step with one observed write. */
+export declare function recordWorkspacePath(indexes: Map<string, FileNameIndex>, workspaceId: string, workspaceRoot: string, path: string): void;
 /** What the index knows about one path. Deliberately small: no size, no etag, no mtime. */
 export type NameEntry = {
     /** Workspace-relative, `/`-separated. */
@@ -60,6 +62,7 @@ export declare function compareNameHits(a: NameEntry, b: NameEntry, needle: stri
  */
 export declare class FileNameIndex {
     readonly workspaceId: string;
+    readonly cwd: string;
     readonly entries: Map<string, NameEntry>;
     private root;
     private building;
@@ -67,7 +70,7 @@ export declare class FileNameIndex {
     private scanned;
     private stopped;
     private incomplete;
-    constructor(workspaceId: string);
+    constructor(workspaceId: string, cwd?: string);
     /**
      * Whether the first pass has FINISHED.
      *

package/dist/server/file-name-index.js

@@ -32,7 +32,9 @@
  * replaces.
  */
 import { readdir } from "node:fs/promises";
+import { isAbsolute, relative, resolve, sep } from "node:path";
 import { createRootGuard, toRelative } from "./files.js";
+import { sessionScopeKey } from "./session-cwd.js";
 /**
  * THE INDEX FOR ONE WORKSPACE, created on demand and then kept.
  *
@@ -40,15 +42,28 @@ import { createRootGuard, toRelative } from "./files.js";
  * the agent's writes - go through this one function, so there is exactly one index per workspace and
  * the two never drift into answering from different maps.
  */
-export function ensureNameIndex(indexes, workspaceId, root) {
-    let index = indexes.get(workspaceId);
+export function ensureNameIndex(indexes, workspaceId, root, cwd = "") {
+    const key = sessionScopeKey(workspaceId, cwd);
+    let index = indexes.get(key);
     if (!index) {
-        index = new FileNameIndex(workspaceId);
-        indexes.set(workspaceId, index);
+        index = new FileNameIndex(workspaceId, cwd);
+        indexes.set(key, index);
     }
     index.start(root);
     return index;
 }
+/** Keeps every root/subdirectory index for a workspace in step with one observed write. */
+export function recordWorkspacePath(indexes, workspaceId, workspaceRoot, path) {
+    const absolute = resolve(workspaceRoot, path);
+    for (const index of indexes.values()) {
+        if (index.workspaceId !== workspaceId)
+            continue;
+        const scoped = relative(resolve(workspaceRoot, index.cwd), absolute);
+        if (!scoped || scoped === ".." || scoped.startsWith(`..${sep}`) || isAbsolute(scoped))
+            continue;
+        index.upsert(scoped.split(sep).join("/"));
+    }
+}
 const MAX_DIRECTORIES = 20000;
 const MAX_FILES = 200000;
 /**
@@ -92,6 +107,7 @@ function hitPosition(entry, needle) {
  */
 export class FileNameIndex {
     workspaceId;
+    cwd;
     entries = new Map();
     root = "";
     building = false;
@@ -99,8 +115,9 @@ export class FileNameIndex {
     scanned = 0;
     stopped = false;
     incomplete = false;
-    constructor(workspaceId) {
+    constructor(workspaceId, cwd = "") {
         this.workspaceId = workspaceId;
+        this.cwd = cwd;
     }
     /**
      * Whether the first pass has FINISHED.

package/dist/server/git.d.ts

@@ -13,8 +13,8 @@ export type GitFile = {
     name: string;
     xy: string;
 };
-export declare function gitStatus(root: string): Promise<GitWorkspace>;
-export declare function gitLog(root: string, limit: number): Promise<{
+export declare function gitStatus(root: string, cwd?: string): Promise<GitWorkspace>;
+export declare function gitLog(root: string, limit: number, cwd?: string): Promise<{
     commits: {
         hash: string;
         short: string;
@@ -138,4 +138,4 @@ export type GitBlameOptions = {
 export declare function gitBlame(root: string, path: string, options?: GitBlameOptions): Promise<GitBlameResponse>;
 /** Whether the directory is a git repository at all. The review view asks before it offers a git baseline. */
 export declare function isGitRepository(root: string): Promise<boolean>;
-export declare function gitMutate(root: string, op: string, path?: string, message?: string): Promise<GitWorkspace>;
+export declare function gitMutate(root: string, op: string, path?: string, message?: string, cwd?: string): Promise<GitWorkspace>;

package/dist/server/git.js

@@ -5,8 +5,9 @@ import { existsSync } from "node:fs";
 import { readFile, stat } from "node:fs/promises";
 const exec = promisify(execFile);
 async function git(cwd, args, options) { return exec("git", ["-c", "core.quotepath=false", ...args], { cwd, windowsHide: true, maxBuffer: options?.maxBuffer ?? 8 * 1024 * 1024 }); }
-function files(raw) { const staged = [], unstaged = [], untracked = []; for (const line of raw.split("\0").filter(Boolean)) {
-    const xy = line.slice(0, 2), path = line.slice(3).split("\0")[0].replaceAll("\\", "/");
+function files(raw, cwd = "") { const staged = [], unstaged = [], untracked = []; for (const line of raw.split("\0").filter(Boolean)) {
+    const xy = line.slice(0, 2), repoPath = line.slice(3).split("\0")[0].replaceAll("\\", "/");
+    const path = cwd && repoPath.startsWith(`${cwd}/`) ? repoPath.slice(cwd.length + 1) : repoPath;
     const item = { path, name: basename(path), xy };
     if (xy === "??")
         untracked.push(item);
@@ -17,14 +18,14 @@ function files(raw) { const staged = [], unstaged = [], untracked = []; for (con
             unstaged.push(item);
     }
 } return { staged, unstaged, untracked }; }
-export async function gitStatus(root) { try {
+export async function gitStatus(root, cwd = "") { try {
     await git(root, ["rev-parse", "--git-dir"]);
 }
 catch {
     throw Object.assign(new Error("此工作区不是 Git 仓库"), { code: "not_a_repo" });
-} const status = await git(root, ["status", "--porcelain=v1", "-z"]); const branch = await git(root, ["symbolic-ref", "--short", "-q", "HEAD"]).then(r => r.stdout.trim() || null).catch(() => null); const unborn = !(await git(root, ["rev-parse", "--verify", "HEAD"]).then(() => true).catch(() => false)); const ahead = await git(root, ["rev-list", "--left-right", "--count", "HEAD...@{upstream}"]).then(r => { const [a, b] = r.stdout.trim().split(/\s+/).map(Number); return Number.isFinite(a) ? a : null; }).catch(() => null); const behind = await git(root, ["rev-list", "--left-right", "--count", "HEAD...@{upstream}"]).then(r => { const [a, b] = r.stdout.trim().split(/\s+/).map(Number); return Number.isFinite(b) ? b : null; }).catch(() => null); return { branch, detached: !branch, unborn, ahead, behind, ...files(status.stdout) }; }
-export async function gitLog(root, limit) { const hasHead = await git(root, ["rev-parse", "--verify", "HEAD"]).then(() => true).catch(() => false); if (!hasHead)
-    return { commits: [], truncated: false }; const out = await git(root, ["log", `-${Math.min(Math.max(limit, 1), 50)}`, "--format=%H%x00%h%x00%s%x00%an%x00%aI%x00"]); const parts = out.stdout.split("\0").filter(Boolean); const commits = []; for (let i = 0; i + 4 < parts.length; i += 5)
+} const status = await git(root, ["status", "--porcelain=v1", "-z", ...(cwd ? ["--", cwd] : [])]); const branch = await git(root, ["symbolic-ref", "--short", "-q", "HEAD"]).then(r => r.stdout.trim() || null).catch(() => null); const unborn = !(await git(root, ["rev-parse", "--verify", "HEAD"]).then(() => true).catch(() => false)); const ahead = await git(root, ["rev-list", "--left-right", "--count", "HEAD...@{upstream}"]).then(r => { const [a, b] = r.stdout.trim().split(/\s+/).map(Number); return Number.isFinite(a) ? a : null; }).catch(() => null); const behind = await git(root, ["rev-list", "--left-right", "--count", "HEAD...@{upstream}"]).then(r => { const [a, b] = r.stdout.trim().split(/\s+/).map(Number); return Number.isFinite(b) ? b : null; }).catch(() => null); return { branch, detached: !branch, unborn, ahead, behind, ...files(status.stdout, cwd) }; }
+export async function gitLog(root, limit, cwd = "") { const hasHead = await git(root, ["rev-parse", "--verify", "HEAD"]).then(() => true).catch(() => false); if (!hasHead)
+    return { commits: [], truncated: false }; const out = await git(root, ["log", `-${Math.min(Math.max(limit, 1), 50)}`, "--format=%H%x00%h%x00%s%x00%an%x00%aI%x00", ...(cwd ? ["--", cwd] : [])]); const parts = out.stdout.split("\0").filter(Boolean); const commits = []; for (let i = 0; i + 4 < parts.length; i += 5)
     commits.push({ hash: parts[i], short: parts[i + 1], subject: parts[i + 2], author: parts[i + 3], date: new Date(parts[i + 4]).toISOString() }); return { commits, truncated: commits.length >= limit }; }
 export async function gitDiff(root, path, staged) { const safe = resolve(root, path); if (!safe.startsWith(resolve(root) + sep) || !existsSync(safe))
     throw Object.assign(new Error("文件路径无效"), { code: "path" }); const check = await git(root, ["ls-files", "--error-unmatch", "--", path]).then(() => true).catch(() => false); if (!check)
@@ -341,7 +342,7 @@ function safePath(root, path) {
         throw Object.assign(new Error("文件路径无效"), { code: "path" });
     return path;
 }
-export async function gitMutate(root, op, path, message) {
+export async function gitMutate(root, op, path, message, cwd = "") {
     if (op === "stage" || op === "unstage" || op === "discard") {
         if (!path)
             throw Object.assign(new Error("缺少文件路径"), { code: "path" });
@@ -356,7 +357,7 @@ export async function gitMutate(root, op, path, message) {
     else if (op === "commit") {
         if (!message?.trim())
             throw Object.assign(new Error("提交消息不能为空"), { code: "bad_message" });
-        await git(root, ["commit", "-m", message.trim()]);
+        await git(root, ["commit", "-m", message.trim(), ...(cwd ? ["--", cwd] : [])]);
     }
     else if (op === "pull")
         await git(root, ["pull", "--ff-only"]);
@@ -364,5 +365,5 @@ export async function gitMutate(root, op, path, message) {
         await git(root, ["push"]);
     else
         throw Object.assign(new Error("未知 Git 操作"), { code: "bad_op" });
-    return gitStatus(root);
+    return gitStatus(root, cwd);
 }