@evandu/super-pi 0.1.145 → 0.1.147

package/dist/server/application/session-watchdog.d.ts

@@ -0,0 +1,159 @@
+/**
+ * THE WATCHDOG: A TIMER THAT SAYS "THE CHILD WENT QUIET".
+ *
+ * WHAT IT IS. A parent session declares, for one child session, how long it is willing to wait for a
+ * report before it wants to be told. When that silence runs out, the parent receives ONE message - a
+ * reminder - and the clock starts again. That is the whole contract.
+ *
+ * WHAT IT IS NOT. It has no power over the child. It does not stop the run, does not cancel a queue,
+ * does not send anything to the child. Interrupting is the PARENT's decision, and the parent has the
+ * tools for it (`session_stop`, `session_dispatch`). A watchdog that killed the run would take away the
+ * one judgement the user asked to keep: "父节点可以接受暂时不回报，然后让 watchdog 下一次再反馈".
+ *
+ * WHY THE REPORT ARRIVES AS A MESSAGE AND NOT AS AN EVENT. The parent is a conversation, and a
+ * conversation only knows something when a message says so. A watchdog that pushed a state change would
+ * leave the parent's model uninformed - it would keep waiting for a report that was never going to come,
+ * because the child had simply decided not to send one.
+ *
+ * WHY THE STATE IS ON DISK. The parent declared an expectation ("I want to hear from this child within
+ * five minutes"). An expectation that evaporates when the server restarts is worse than no watchdog at
+ * all: the parent believes it is being watched, and it is not. So the state lives in the workspace, next
+ * to the other `.super-pi/` artefacts, and the timers are re-armed when the server comes back.
+ */
+/** One watchdog: the parent that declared it, the child it watches, and the clock. */
+export interface WatchdogEntry {
+    /** The child session being watched. */
+    childConversationId: string;
+    /** The session the reminder is delivered to. */
+    parentConversationId: string;
+    /** The workspace whose `.super-pi/watchdogs.json` holds this entry. */
+    workspaceId: string;
+    /** How long a silence lasts before the parent is reminded. */
+    timeoutSeconds: number;
+    /** When the last sign of life was. A report moves it; the clock runs from here. */
+    lastSignalAt: number;
+    /** Whether the parent has ALREADY been told that the child is no longer working. */
+    endedReminded: boolean;
+}
+/** What the owner of a watchdog is told when the clock runs out. */
+export interface WatchdogTimeout {
+    childConversationId: string;
+    parentConversationId: string;
+    timeoutSeconds: number;
+    /** How long the silence actually was, in seconds. */
+    elapsedSeconds: number;
+    /** Whether the child still has work in flight when the clock ran out. */
+    childWorking: boolean;
+}
+/** The file name the state lives under, inside the workspace's `.super-pi` directory. */
+export declare const WATCHDOG_STATE_FILE = "watchdogs.json";
+/** The longest silence a parent may declare: a day. Beyond that it is not a watchdog, it is a plan. */
+export declare const WATCHDOG_MAX_TIMEOUT_SECONDS = 86400;
+/** The shortest silence a parent may declare. One second is a test's value, not a parent's. */
+export declare const WATCHDOG_MIN_TIMEOUT_SECONDS = 1;
+/**
+ * What the watchdog needs from the server it lives in.
+ *
+ * The watchdog knows NOTHING about sessions: it counts seconds and asks its owner to deliver a message.
+ * The owner is the session orchestrator, which is the only thing that knows how a message reaches a
+ * parent conversation.
+ */
+export interface WatchdogHost {
+    /** Delivers the reminder to the parent. */
+    onTimeout: (event: WatchdogTimeout) => Promise<void> | void;
+    /** The workspace directory a workspace's state file lives in. */
+    workspacePath: (workspaceId: string) => string | undefined;
+    /** Every workspace id the server knows about. */
+    workspaceIds: () => string[];
+    /** Whether the child still has work in flight: a live turn, or a queued message waiting for one. */
+    isChildWorking: (childConversationId: string) => boolean;
+    /** Where complaints go. */
+    warn?: (message: string) => void;
+}
+/**
+ * The watchdog manager: the timers, the state, and the state file.
+ *
+ * ONE WATCHDOG PER CHILD. The parent declares a duration for a child, and the duration belongs to that
+ * child - not to the pair of sessions in general - because "how long may this child be quiet" is a
+ * property of that child, and the parent may well declare different expectations for different children.
+ */
+export declare class SessionWatchdog {
+    private readonly host;
+    private readonly entries;
+    private readonly timers;
+    /** One write chain per workspace, so two watchdogs in one workspace cannot interleave a write. */
+    private readonly writes;
+    constructor(host: WatchdogHost);
+    /**
+     * Declares (or re-declares) the watchdog for a child.
+     *
+     * `timeoutSeconds` of 0 CANCELS the watchdog: "I am no longer waiting for a report from this one".
+     * That is the only way a parent takes the expectation back, and it is deliberately explicit - a
+     * watchdog that quietly switched itself off would leave the parent believing it was still watched.
+     */
+    arm(input: {
+        childConversationId: string;
+        parentConversationId: string;
+        workspaceId: string;
+        timeoutSeconds: number;
+    }): Promise<void>;
+    /**
+     * Records a sign of life: the child reported, so the clock starts again.
+     *
+     * A REPORT RESETS THE CLOCK, IT DOES NOT CANCEL THE WATCHDOG. The parent asked to hear from this
+     * child while the child was working; a report that says "the first stage is done, I am continuing"
+     * must not be read as "the work is over". Cancelling on the first report would turn the watchdog into
+     * a one-shot device, and the whole point of the parent's declaration is that it holds for as long as
+     * the child is out of sight.
+     */
+    noteSignal(childConversationId: string): Promise<void>;
+    /** Takes the watchdog away. The parent is no longer waiting. */
+    cancel(childConversationId: string): Promise<void>;
+    /** The watchdogs that are currently armed. */
+    list(): WatchdogEntry[];
+    /** The watchdog on one child, if there is one. */
+    get(childConversationId: string): WatchdogEntry | undefined;
+    /**
+     * Re-arms the watchdogs that were on disk when the server stopped.
+     *
+     * A watchdog whose silence had ALREADY run out while the server was down fires as soon as it comes
+     * back: the parent asked to be told after N minutes of silence, and the silence did happen. The
+     * remaining time is measured from the last sign of life, not from the restart.
+     */
+    restore(): Promise<void>;
+    /** Stops every timer. The process is going away; the state stays on disk. */
+    dispose(): void;
+    /**
+     * Arms the timer for one entry.
+     *
+     * THE TIMER IS UNREF'D. A pending reminder must not keep the Node process alive: the server is
+     * allowed to shut down with a watchdog in flight, and the state is on disk anyway.
+     */
+    private schedule;
+    private clearTimer;
+    /**
+     * The clock ran out.
+     *
+     * THE CHILD'S STATE DECIDES WHETHER THIS IS A REPEAT, AND THE REPEAT IS NOT LOUDER - IT IS THE
+     * SAME. Every interval the parent gets the same reminder, because the parent's need is the same:
+     * "I still have no news". An interval that grew would make the watchdog quietest exactly when the
+     * child has been silent longest, which is backwards.
+     *
+     * THE ONE EXCEPTION IS A CHILD THAT IS NO LONGER WORKING. A child whose turn ended without reporting
+     * is not going to report: the turn is over. The parent is told once that the child has gone quiet
+     * AND stopped, and the watchdog then takes itself off - a reminder that repeats for a child that
+     * cannot speak any more is noise, not information.
+     */
+    private fire;
+    /** The path of one workspace's state file, or undefined when the workspace is unknown. */
+    private statePath;
+    /**
+     * Writes one workspace's state file.
+     *
+     * THE WRITES ARE SERIALIZED PER WORKSPACE. Two watchdogs in one workspace each rewrite the same
+     * file, and an interleaved pair of writes would leave a file that describes one watchdog twice and
+     * loses the other.
+     */
+    private persist;
+    private writeStateFile;
+}

package/dist/server/application/session-watchdog.js

@@ -0,0 +1,244 @@
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+/** The file name the state lives under, inside the workspace's `.super-pi` directory. */
+export const WATCHDOG_STATE_FILE = "watchdogs.json";
+/** The longest silence a parent may declare: a day. Beyond that it is not a watchdog, it is a plan. */
+export const WATCHDOG_MAX_TIMEOUT_SECONDS = 86_400;
+/** The shortest silence a parent may declare. One second is a test's value, not a parent's. */
+export const WATCHDOG_MIN_TIMEOUT_SECONDS = 1;
+/**
+ * The watchdog manager: the timers, the state, and the state file.
+ *
+ * ONE WATCHDOG PER CHILD. The parent declares a duration for a child, and the duration belongs to that
+ * child - not to the pair of sessions in general - because "how long may this child be quiet" is a
+ * property of that child, and the parent may well declare different expectations for different children.
+ */
+export class SessionWatchdog {
+    host;
+    entries = new Map();
+    timers = new Map();
+    /** One write chain per workspace, so two watchdogs in one workspace cannot interleave a write. */
+    writes = new Map();
+    constructor(host) {
+        this.host = host;
+    }
+    /**
+     * Declares (or re-declares) the watchdog for a child.
+     *
+     * `timeoutSeconds` of 0 CANCELS the watchdog: "I am no longer waiting for a report from this one".
+     * That is the only way a parent takes the expectation back, and it is deliberately explicit - a
+     * watchdog that quietly switched itself off would leave the parent believing it was still watched.
+     */
+    async arm(input) {
+        const { childConversationId } = input;
+        if (!childConversationId.trim())
+            return;
+        this.clearTimer(childConversationId);
+        if (!Number.isFinite(input.timeoutSeconds) || input.timeoutSeconds <= 0) {
+            // CANCEL. The entry is removed and the file rewritten, so a cancelled watchdog stays cancelled
+            // across a restart.
+            if (this.entries.delete(childConversationId))
+                await this.persist(input.workspaceId);
+            return;
+        }
+        const timeoutSeconds = Math.min(WATCHDOG_MAX_TIMEOUT_SECONDS, Math.max(WATCHDOG_MIN_TIMEOUT_SECONDS, Math.floor(input.timeoutSeconds)));
+        const entry = {
+            childConversationId,
+            parentConversationId: input.parentConversationId,
+            workspaceId: input.workspaceId,
+            timeoutSeconds,
+            lastSignalAt: Date.now(),
+            endedReminded: false,
+        };
+        this.entries.set(childConversationId, entry);
+        await this.persist(input.workspaceId);
+        this.schedule(entry);
+    }
+    /**
+     * Records a sign of life: the child reported, so the clock starts again.
+     *
+     * A REPORT RESETS THE CLOCK, IT DOES NOT CANCEL THE WATCHDOG. The parent asked to hear from this
+     * child while the child was working; a report that says "the first stage is done, I am continuing"
+     * must not be read as "the work is over". Cancelling on the first report would turn the watchdog into
+     * a one-shot device, and the whole point of the parent's declaration is that it holds for as long as
+     * the child is out of sight.
+     */
+    async noteSignal(childConversationId) {
+        const entry = this.entries.get(childConversationId);
+        if (!entry)
+            return;
+        entry.lastSignalAt = Date.now();
+        entry.endedReminded = false;
+        this.clearTimer(childConversationId);
+        this.schedule(entry);
+        await this.persist(entry.workspaceId);
+    }
+    /** Takes the watchdog away. The parent is no longer waiting. */
+    async cancel(childConversationId) {
+        const entry = this.entries.get(childConversationId);
+        this.clearTimer(childConversationId);
+        if (!entry)
+            return;
+        this.entries.delete(childConversationId);
+        await this.persist(entry.workspaceId);
+    }
+    /** The watchdogs that are currently armed. */
+    list() {
+        return [...this.entries.values()].map((entry) => ({ ...entry }));
+    }
+    /** The watchdog on one child, if there is one. */
+    get(childConversationId) {
+        const entry = this.entries.get(childConversationId);
+        return entry ? { ...entry } : undefined;
+    }
+    /**
+     * Re-arms the watchdogs that were on disk when the server stopped.
+     *
+     * A watchdog whose silence had ALREADY run out while the server was down fires as soon as it comes
+     * back: the parent asked to be told after N minutes of silence, and the silence did happen. The
+     * remaining time is measured from the last sign of life, not from the restart.
+     */
+    async restore() {
+        for (const workspaceId of this.host.workspaceIds()) {
+            const path = this.statePath(workspaceId);
+            if (!path)
+                continue;
+            let parsed;
+            try {
+                parsed = JSON.parse(await readFile(path, "utf8"));
+            }
+            catch {
+                // A missing file is the normal case (no watchdog was ever declared). A corrupt one is not
+                // fatal either: the worst case of losing it is that the parent stops being reminded, which
+                // is the state it was in before this feature existed.
+                continue;
+            }
+            const records = parsed?.watchdogs;
+            if (!records || typeof records !== "object")
+                continue;
+            for (const [childConversationId, record] of Object.entries(records)) {
+                if (!record || typeof record.timeoutSeconds !== "number" || !record.parentConversationId)
+                    continue;
+                const entry = {
+                    childConversationId,
+                    parentConversationId: record.parentConversationId,
+                    workspaceId: record.workspaceId ?? workspaceId,
+                    timeoutSeconds: record.timeoutSeconds,
+                    lastSignalAt: typeof record.lastSignalAt === "number" ? record.lastSignalAt : Date.now(),
+                    endedReminded: Boolean(record.endedReminded),
+                };
+                this.entries.set(childConversationId, entry);
+                this.schedule(entry);
+            }
+        }
+    }
+    /** Stops every timer. The process is going away; the state stays on disk. */
+    dispose() {
+        for (const timer of this.timers.values())
+            clearTimeout(timer);
+        this.timers.clear();
+    }
+    /**
+     * Arms the timer for one entry.
+     *
+     * THE TIMER IS UNREF'D. A pending reminder must not keep the Node process alive: the server is
+     * allowed to shut down with a watchdog in flight, and the state is on disk anyway.
+     */
+    schedule(entry) {
+        this.clearTimer(entry.childConversationId);
+        const elapsed = Date.now() - entry.lastSignalAt;
+        const remaining = Math.max(0, entry.timeoutSeconds * 1000 - elapsed);
+        const timer = setTimeout(() => {
+            void this.fire(entry.childConversationId);
+        }, remaining);
+        timer.unref?.();
+        this.timers.set(entry.childConversationId, timer);
+    }
+    clearTimer(childConversationId) {
+        const timer = this.timers.get(childConversationId);
+        if (timer)
+            clearTimeout(timer);
+        this.timers.delete(childConversationId);
+    }
+    /**
+     * The clock ran out.
+     *
+     * THE CHILD'S STATE DECIDES WHETHER THIS IS A REPEAT, AND THE REPEAT IS NOT LOUDER - IT IS THE
+     * SAME. Every interval the parent gets the same reminder, because the parent's need is the same:
+     * "I still have no news". An interval that grew would make the watchdog quietest exactly when the
+     * child has been silent longest, which is backwards.
+     *
+     * THE ONE EXCEPTION IS A CHILD THAT IS NO LONGER WORKING. A child whose turn ended without reporting
+     * is not going to report: the turn is over. The parent is told once that the child has gone quiet
+     * AND stopped, and the watchdog then takes itself off - a reminder that repeats for a child that
+     * cannot speak any more is noise, not information.
+     */
+    async fire(childConversationId) {
+        const entry = this.entries.get(childConversationId);
+        if (!entry)
+            return;
+        const childWorking = this.host.isChildWorking(childConversationId);
+        if (!childWorking && entry.endedReminded) {
+            await this.cancel(childConversationId);
+            return;
+        }
+        const elapsedSeconds = Math.max(0, Math.round((Date.now() - entry.lastSignalAt) / 1000));
+        try {
+            await this.host.onTimeout({
+                childConversationId,
+                parentConversationId: entry.parentConversationId,
+                timeoutSeconds: entry.timeoutSeconds,
+                elapsedSeconds,
+                childWorking,
+            });
+        }
+        catch (error) {
+            this.host.warn?.(`Super Pi: watchdog reminder for ${childConversationId} failed: ${error instanceof Error ? error.message : String(error)}`);
+        }
+        entry.endedReminded = !childWorking;
+        entry.lastSignalAt = Date.now();
+        await this.persist(entry.workspaceId);
+        this.schedule(entry);
+    }
+    /** The path of one workspace's state file, or undefined when the workspace is unknown. */
+    statePath(workspaceId) {
+        const workspacePath = this.host.workspacePath(workspaceId);
+        if (!workspacePath)
+            return undefined;
+        return join(workspacePath, ".super-pi", WATCHDOG_STATE_FILE);
+    }
+    /**
+     * Writes one workspace's state file.
+     *
+     * THE WRITES ARE SERIALIZED PER WORKSPACE. Two watchdogs in one workspace each rewrite the same
+     * file, and an interleaved pair of writes would leave a file that describes one watchdog twice and
+     * loses the other.
+     */
+    async persist(workspaceId) {
+        const path = this.statePath(workspaceId);
+        if (!path)
+            return;
+        const previous = this.writes.get(workspaceId) ?? Promise.resolve();
+        const next = previous.then(() => this.writeStateFile(path, workspaceId)).catch((error) => {
+            this.host.warn?.(`Super Pi: watchdog state could not be written: ${error instanceof Error ? error.message : String(error)}`);
+        });
+        this.writes.set(workspaceId, next);
+        await next;
+    }
+    async writeStateFile(path, workspaceId) {
+        const watchdogs = {};
+        for (const entry of this.entries.values()) {
+            if (entry.workspaceId !== workspaceId)
+                continue;
+            watchdogs[entry.childConversationId] = {
+                parentConversationId: entry.parentConversationId,
+                workspaceId: entry.workspaceId,
+                timeoutSeconds: entry.timeoutSeconds,
+                lastSignalAt: entry.lastSignalAt,
+                endedReminded: entry.endedReminded,
+            };
+        }
+        await mkdir(join(path, ".."), { recursive: true });
+        await writeFile(path, `${JSON.stringify({ version: 1, watchdogs }, null, 2)}\n`, "utf8");
+    }
+}

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.
      *