@bytetrue/byspace 0.17.0 → 0.18.0

package/node_modules/@bytetrue/server/dist/src/server/agent/providers/pi/agent.js

@@ -1,7 +1,7 @@
 import { randomUUID } from "node:crypto";
-import { existsSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { existsSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
 import { homedir, tmpdir } from "node:os";
-import { join, resolve as resolvePath } from "node:path";
+import { join } from "node:path";
 import stripAnsi from "strip-ansi";
 import { z } from "zod";
 import { importSessionFromPersistence } from "../../provider-session-import.js";
@@ -19,6 +19,8 @@ import { revertPiConversation } from "./rewind.js";
 import { listPiImportableSessions, readPiImportSessionConfig } from "./session-descriptor.js";
 import { PiUsagePoller } from "./usage-poller.js";
 import { buildPiNestedToolCallMetadata, mapToolDetail, parseToolArgs, parseToolResult, resolveToolCallName, } from "./tool-call-mapper.js";
+import { foldSubagentObservations } from "../../provider-subagents/observation.js";
+import { isPiSubagentToolName, observePiSubagentExit, observePiSubagentLaunch, observePiSubagentRecord, replayPiSubagentObservations, } from "./agent-subagents.js";
 const PI_PROVIDER = "pi";
 const DEFAULT_PI_THINKING_LEVEL = "medium";
 const PI_MODEL_PROBE_CACHE_MS = 30000;
@@ -79,7 +81,7 @@ const PI_CAPABILITIES = {
     supportsSessionPersistence: true,
     supportsSessionListing: true,
     supportsDynamicModes: true,
-    supportsMcpServers: false,
+    supportsMcpServers: true,
     supportsReasoningStream: true,
     supportsToolInvocations: true,
     supportsRewindConversation: true,
@@ -95,12 +97,6 @@ const PI_THINKING_OPTIONS = [
     { id: "xhigh", label: "XHigh", description: "Very deep reasoning" },
     { id: "max", label: "Max", description: "Extreme reasoning" },
 ];
-function capabilitiesForClient() {
-    return withPiCapabilities(false);
-}
-function capabilitiesForSession(hasMcpConfig) {
-    return withPiCapabilities(hasMcpConfig);
-}
 // COMPAT(piSteerFallback): added in v0.5.0, remove after 2027-03-01 once the pi floor
 // supports the steer RPC. Older binaries answer with "Unknown command: steer".
 function isPiDefinitiveSteerRejection(error) {
@@ -312,7 +308,6 @@ function buildResumeStartInput(input) {
         session: input.sessionFile,
         model: input.resumeConfig.model,
         thinkingOptionId: normalizePiThinkingOption(input.resumeConfig.thinkingOptionId) ?? undefined,
-        mcpConfigPath: input.mcpConfig?.path,
         extensionPaths: input.byspaceExtension ? [input.byspaceExtension.path] : undefined,
     };
 }
@@ -327,72 +322,10 @@ function toPiMcpConfig(config) {
     return {
         url: config.url,
         ...(config.headers ? { headers: config.headers } : {}),
-        auth: false,
-        oauth: false,
-    };
-}
-function resolvePiAgentDir(env) {
-    const configured = env?.PI_CODING_AGENT_DIR?.trim() || process.env.PI_CODING_AGENT_DIR?.trim();
-    if (!configured) {
-        return join(homedir(), ".pi", "agent");
-    }
-    if (configured === "~") {
-        return homedir();
-    }
-    if (configured.startsWith("~/")) {
-        return resolvePath(homedir(), configured.slice(2));
-    }
-    return resolvePath(configured);
-}
-function readPiGlobalMcpConfig(env) {
-    const globalConfigPath = join(resolvePiAgentDir(env), "mcp.json");
-    if (!existsSync(globalConfigPath)) {
-        return {};
-    }
-    let globalConfig;
-    try {
-        globalConfig = JSON.parse(readFileSync(globalConfigPath, "utf8"));
-    }
-    catch (error) {
-        if (error instanceof SyntaxError) {
-            throw new Error(`Failed to parse Pi MCP config: ${globalConfigPath}`, { cause: error });
-        }
-        throw error;
-    }
-    if (!isRecord(globalConfig)) {
-        throw new Error(`Pi MCP config must contain a JSON object: ${globalConfigPath}`);
-    }
-    return globalConfig;
-}
-function createPiMcpConfigFile(servers, options) {
-    const globalConfig = options?.piGlobalConfigEnv
-        ? readPiGlobalMcpConfig(options.piGlobalConfigEnv)
-        : {};
-    let configuredServers = {};
-    if (isRecord(globalConfig.mcpServers)) {
-        configuredServers = globalConfig.mcpServers;
-    }
-    else if (isRecord(globalConfig["mcp-servers"])) {
-        configuredServers = globalConfig["mcp-servers"];
-    }
-    const mcpServers = { ...configuredServers };
-    for (const [name, serverConfig] of Object.entries(servers)) {
-        mcpServers[name] = toPiMcpConfig(serverConfig);
-    }
-    const dir = mkdtempSync(join(tmpdir(), "byspace-pi-mcp-"));
-    const filePath = join(dir, "mcp.json");
-    const mergedConfig = { ...globalConfig, mcpServers };
-    delete mergedConfig["mcp-servers"];
-    writeFileSync(filePath, `${JSON.stringify(mergedConfig, null, 2)}\n`, {
-        encoding: "utf8",
-        mode: 0o600,
-    });
-    return {
-        path: filePath,
-        cleanup: () => rmSync(dir, { recursive: true, force: true }),
     };
 }
-function createPiBySpaceExtensionFile(systemPrompt) {
+function createPiBySpaceExtensionFile(systemPrompt, mcpServers) {
+    const byspaceMcpServers = Object.fromEntries(Object.entries(mcpServers ?? {}).map(([name, config]) => [name, toPiMcpConfig(config)]));
     const dir = mkdtempSync(join(tmpdir(), "byspace-pi-extension-"));
     const filePath = join(dir, "byspace-integration.mjs");
     writeFileSync(filePath, `
@@ -444,6 +377,50 @@ function createPiBySpaceExtensionFile(systemPrompt) {
 	}
 
 	export default function byspaceIntegration(pi) {
+	  const byspaceMcpServers = ${JSON.stringify(byspaceMcpServers)};
+	  const rejectedMcpServers = [];
+	  if (typeof pi.registerMcpServer === "function") {
+	    for (const [name, config] of Object.entries(byspaceMcpServers)) {
+	      // A duplicate name or an invalid config throws; the rest of this extension must still load.
+	      try {
+	        pi.registerMcpServer(name, config);
+	      } catch (error) {
+	        rejectedMcpServers.push({ name, message: error && error.message ? error.message : String(error) });
+	      }
+	    }
+	  }
+
+	  // Pi only connects registered MCP servers while its built-in MCP support is loaded. Another
+	  // extension that owns the "mcp" command replaces it, leaving these registrations stranded.
+	  function reportMcpInjection(ctx) {
+	    for (const rejected of rejectedMcpServers) {
+	      ctx.ui.notify(
+	        'BySpace could not register MCP server "' + rejected.name + '": ' + rejected.message,
+	        "warning",
+	      );
+	    }
+	    const registeredCount = Object.keys(byspaceMcpServers).length;
+	    if (registeredCount === 0 || rejectedMcpServers.length === registeredCount) {
+	      return;
+	    }
+	    if (typeof pi.getCommands !== "function") {
+	      return;
+	    }
+	    const builtinMcpLoaded = pi.getCommands().some(
+	      (command) =>
+	        command &&
+	        command.name === "mcp" &&
+	        command.sourceInfo &&
+	        command.sourceInfo.path === "builtin:mcp",
+	    );
+	    if (!builtinMcpLoaded) {
+	      ctx.ui.notify(
+	        "Pi's built-in MCP support is not loaded, so the MCP servers BySpace registered for this agent are not connected. Another extension may have replaced it.",
+	        "warning",
+	      );
+	    }
+	  }
+
 	  const submittedUserMessages = [];
 
 	  function emitSubmittedUserEntries(ctx) {
@@ -476,6 +453,7 @@ function createPiBySpaceExtensionFile(systemPrompt) {
 
 	  pi.on("session_start", async (_event, ctx) => {
 	    emitEntryCapture(ctx, "session_start");
+	    reportMcpInjection(ctx);
 	  });
 
 	  pi.on("message_end", async (event) => {
@@ -525,32 +503,6 @@ function createPiBySpaceExtensionFile(systemPrompt) {
         cleanup: () => rmSync(dir, { recursive: true, force: true }),
     };
 }
-function combineCleanup(cleanups) {
-    const activeCleanups = cleanups.filter((cleanup) => Boolean(cleanup));
-    if (activeCleanups.length === 0) {
-        return undefined;
-    }
-    return () => {
-        for (const cleanup of activeCleanups) {
-            cleanup();
-        }
-    };
-}
-function isPiMcpAdapterCommand(command) {
-    if (command.source !== "extension" || !/^mcp(?::\d+)?$/.test(command.name)) {
-        return false;
-    }
-    if (!command.sourceInfo) {
-        return true;
-    }
-    return JSON.stringify(command.sourceInfo).includes("pi-mcp-adapter");
-}
-function withPiCapabilities(supportsMcpServers) {
-    return {
-        ...PI_CAPABILITIES,
-        supportsMcpServers,
-    };
-}
 function isPiRequestAbortError(error) {
     if (error instanceof Error && error.name === "AbortError") {
         return true;
@@ -1117,6 +1069,11 @@ export class PiRpcAgentSession {
     async *streamHistory() {
         await this.requestEntryCapture("history");
         yield* streamPiHistory(this.provider, await this.runtimeSession.getMessages(), this.capturedUserEntries);
+        // Background subagent lifecycle lives in the transcript as tool result details and
+        // subagent-exit custom messages, not in a sidechain — derive it from the same messages.
+        for (const subagentEvent of foldSubagentObservations(replayPiSubagentObservations(await this.runtimeSession.getMessages()))) {
+            yield { type: "provider_subagent", provider: this.provider, event: subagentEvent };
+        }
     }
     async getRuntimeInfo() {
         await this.refreshState();
@@ -1904,6 +1861,23 @@ export class PiRpcAgentSession {
         this.emitToolCallEvent(event.toolCallId, toolCall, status, result, error, {
             parentToolCallId: event.parentToolCallId,
         });
+        this.emitPiSubagentToolObservations(event.toolCallId, toolCall, result);
+    }
+    /** Background subagents announce themselves through tool result details, not the stream. */
+    emitPiSubagentToolObservations(toolCallId, toolCall, result) {
+        if (!isPiSubagentToolName(toolCall.toolName)) {
+            return;
+        }
+        const details = typeof result === "object" && result !== null ? result.details : undefined;
+        const observation = toolCall.toolName === "subagent"
+            ? observePiSubagentLaunch({ toolCallId, args: toolCall.args, details })
+            : observePiSubagentRecord(details);
+        if (!observation) {
+            return;
+        }
+        for (const event of foldSubagentObservations([observation])) {
+            this.emit({ type: "provider_subagent", provider: this.provider, event });
+        }
     }
     emitCompactionTimeline(input) {
         const emitOutOfBand = this.outOfBandCompactionEmit;
@@ -1977,6 +1951,11 @@ export class PiRpcAgentSession {
             // Pi extension sendMessage() payloads surface as custom messages. display=false
             // means context-only (Pi's TUI hides them too). display is optional on older
             // runtimes; treat missing as true so exit notifications still surface.
+            if (event.message.customType === "subagent-exit") {
+                for (const subagentEvent of foldSubagentObservations(observePiSubagentExit(event.message.details))) {
+                    this.emit({ type: "provider_subagent", provider: this.provider, event: subagentEvent });
+                }
+            }
             if (event.message.display !== false) {
                 const text = getUserMessageText(event.message.content);
                 const details = limitTimelineDetails(event.message.details);
@@ -2077,7 +2056,7 @@ export class PiRpcAgentClient {
     constructor(options) {
         this.availableProvidersCache = null;
         this.provider = PI_PROVIDER;
-        this.capabilities = capabilitiesForClient();
+        this.capabilities = PI_CAPABILITIES;
         this.logger = options.logger;
         this.runtimeSettings = options.runtimeSettings;
         this.providerParams = PiProviderParamsSchema.parse(options.providerParams ?? {});
@@ -2087,12 +2066,7 @@ export class PiRpcAgentClient {
         this.usagePollScheduler = options.usagePollScheduler;
     }
     async createSession(config, launchContext) {
-        const mcpEnv = {
-            ...this.runtimeSettings?.env,
-            ...launchContext?.env,
-        };
-        const mcpConfig = await this.prepareMcpConfig(config.cwd, config.mcpServers, mcpEnv);
-        const byspaceExtension = createPiBySpaceExtensionFile(composeSystemPromptParts(config.systemPrompt, config.daemonAppendSystemPrompt));
+        const byspaceExtension = createPiBySpaceExtensionFile(composeSystemPromptParts(config.systemPrompt, config.daemonAppendSystemPrompt), config.mcpServers);
         const launchModel = await this.resolveLaunchModel(config.cwd, launchContext?.env, config.model, {
             skipProbe: config.internal === true,
         });
@@ -2104,12 +2078,10 @@ export class PiRpcAgentClient {
                 thinkingOptionId: normalizePiThinkingOption(config.thinkingOptionId) ?? DEFAULT_PI_THINKING_LEVEL,
                 noSession: config.internal === true,
                 env: launchContext?.env,
-                mcpConfigPath: mcpConfig?.path,
                 extensionPaths: byspaceExtension ? [byspaceExtension.path] : undefined,
             });
         }
         catch (error) {
-            mcpConfig?.cleanup();
             byspaceExtension?.cleanup();
             throw error;
         }
@@ -2118,8 +2090,8 @@ export class PiRpcAgentClient {
                 runtimeSession,
                 config: launchModel === config.model ? config : { ...config, model: launchModel },
                 initialState: await runtimeSession.getState(),
-                capabilities: capabilitiesForSession(mcpConfig !== null),
-                cleanup: combineCleanup([mcpConfig?.cleanup, byspaceExtension?.cleanup]),
+                capabilities: PI_CAPABILITIES,
+                cleanup: byspaceExtension?.cleanup,
                 extensionTimeoutMs: this.providerParams.extensionTimeoutMs,
                 logger: this.logger,
                 usagePollScheduler: this.usagePollScheduler,
@@ -2127,7 +2099,6 @@ export class PiRpcAgentClient {
         }
         catch (error) {
             await runtimeSession.close().catch(() => undefined);
-            mcpConfig?.cleanup();
             byspaceExtension?.cleanup();
             throw error;
         }
@@ -2139,12 +2110,7 @@ export class PiRpcAgentClient {
         }
         const persistenceMetadata = parsePersistenceMetadata(handle.metadata);
         const resumeConfig = buildResumeConfig(persistenceMetadata, overrides, this.provider);
-        const mcpEnv = {
-            ...this.runtimeSettings?.env,
-            ...launchContext?.env,
-        };
-        const mcpConfig = await this.prepareMcpConfig(resumeConfig.cwd, resumeConfig.config.mcpServers, mcpEnv);
-        const byspaceExtension = createPiBySpaceExtensionFile(composeSystemPromptParts(resumeConfig.config.systemPrompt, resumeConfig.config.daemonAppendSystemPrompt));
+        const byspaceExtension = createPiBySpaceExtensionFile(composeSystemPromptParts(resumeConfig.config.systemPrompt, resumeConfig.config.daemonAppendSystemPrompt), resumeConfig.config.mcpServers);
         const launchModel = await this.resolveLaunchModel(resumeConfig.cwd, launchContext?.env, resumeConfig.model);
         const resumedConfig = launchModel === resumeConfig.model
             ? resumeConfig
@@ -2159,12 +2125,10 @@ export class PiRpcAgentClient {
                 resumeConfig: resumedConfig,
                 sessionFile,
                 launchContext,
-                mcpConfig,
                 byspaceExtension,
             }));
         }
         catch (error) {
-            mcpConfig?.cleanup();
             byspaceExtension?.cleanup();
             throw error;
         }
@@ -2173,8 +2137,8 @@ export class PiRpcAgentClient {
                 runtimeSession,
                 config: resumedConfig.config,
                 initialState: await runtimeSession.getState(),
-                capabilities: capabilitiesForSession(mcpConfig !== null),
-                cleanup: combineCleanup([mcpConfig?.cleanup, byspaceExtension?.cleanup]),
+                capabilities: PI_CAPABILITIES,
+                cleanup: byspaceExtension?.cleanup,
                 extensionTimeoutMs: this.providerParams.extensionTimeoutMs,
                 logger: this.logger,
                 usagePollScheduler: this.usagePollScheduler,
@@ -2182,7 +2146,6 @@ export class PiRpcAgentClient {
         }
         catch (error) {
             await runtimeSession.close().catch(() => undefined);
-            mcpConfig?.cleanup();
             byspaceExtension?.cleanup();
             throw error;
         }
@@ -2335,34 +2298,6 @@ export class PiRpcAgentClient {
             await probeSession.close().catch(() => undefined);
         }
     }
-    async prepareMcpConfig(cwd, servers, env) {
-        if (!servers || Object.keys(servers).length === 0) {
-            return null;
-        }
-        if (!(await this.detectMcpAdapter(cwd, env))) {
-            return null;
-        }
-        return createPiMcpConfigFile(servers, { piGlobalConfigEnv: env });
-    }
-    async detectMcpAdapter(cwd, env) {
-        const runtimeSession = await this.runtime.startSession({ cwd, env }).catch((error) => {
-            this.logger.debug({ err: error, cwd }, "Pi MCP adapter probe failed to start");
-            return null;
-        });
-        if (!runtimeSession) {
-            return false;
-        }
-        try {
-            return (await runtimeSession.getCommands()).some(isPiMcpAdapterCommand);
-        }
-        catch (error) {
-            this.logger.debug({ err: error, cwd }, "Pi MCP adapter probe failed");
-            return false;
-        }
-        finally {
-            await runtimeSession.close().catch(() => undefined);
-        }
-    }
     async resolvePiLaunch() {
         return resolveProviderLaunch({
             commandConfig: this.runtimeSettings?.command,

package/node_modules/@bytetrue/server/dist/src/server/agent/providers/pi/runtime.js

@@ -20,7 +20,6 @@ export function buildPiLaunch(input) {
         modeId: input.session.modeId,
         session: input.session.session,
         noSession: input.session.noSession,
-        mcpConfigPath: input.session.mcpConfigPath,
         extensionPaths: input.session.extensionPaths,
         extraArgs: input.session.extraArgs,
     };
@@ -44,9 +43,6 @@ function appendPiLaunchArgs(argv, session, protocolMode) {
     else if (session.session) {
         argv.push("--session", session.session);
     }
-    if (session.mcpConfigPath) {
-        argv.push("--mcp-config", session.mcpConfigPath);
-    }
     for (const extensionPath of session.extensionPaths ?? []) {
         argv.push("--extension", extensionPath);
     }

package/node_modules/@bytetrue/server/dist/src/server/agent/providers/pi/session-descriptor.js

@@ -41,7 +41,7 @@ export async function readPiImportSessionConfig(filePath) {
         return {};
     return toPiImportSessionConfig(descriptor);
 }
-async function resolvePiSessionsDir(options) {
+export async function resolvePiSessionsDir(options) {
     const env = options.env ?? process.env;
     const homeDir = options.homeDir ?? homedir();
     const baseDir = options.cwd ?? process.cwd();
@@ -100,7 +100,7 @@ function resolveConfigPath(value, options) {
     }
     return path.isAbsolute(value) ? value : path.resolve(options.baseDir, value);
 }
-async function walkJsonlFiles(root) {
+export async function walkJsonlFiles(root) {
     let entries;
     try {
         entries = await readdir(root, { withFileTypes: true });

package/node_modules/@bytetrue/server/dist/src/server/agent/providers/pi/subagent-session-tailer.js

@@ -0,0 +1,212 @@
+import { open, stat } from "node:fs/promises";
+import { mapPiSubagentStatus } from "./agent-subagents.js";
+import { PiHistoryMapper } from "./history-mapper.js";
+import { resolvePiSessionsDir, walkJsonlFiles } from "./session-descriptor.js";
+export const PI_SUBAGENT_TERMINAL_STATUSES = ["completed", "failed", "canceled"];
+const DEFAULT_POLL_MS = 1000;
+const LOCATE_RETRY_MS = 5000;
+const TERMINAL_DRAIN_GRACE_MS = 3000;
+/**
+ * Extract the tailer-relevant fields from a pi-subagent report record. The subagent id is
+ * required (it keys the tailer); session references start the tail, status tracks the end.
+ * Status-only snapshots matter too: they flip the entry to terminal so the tail stops.
+ */
+export function parsePiSubagentTailerSnapshot(record) {
+    if (typeof record !== "object" || record === null)
+        return null;
+    const source = record;
+    const subagentId = readString(source.id);
+    if (!subagentId)
+        return null;
+    const snapshot = { subagentId };
+    for (const key of ["sessionId", "sessionFile", "cwd", "status"]) {
+        const value = source[key];
+        if (typeof value === "string" && value.trim())
+            snapshot[key] = value;
+    }
+    return snapshot.sessionId || snapshot.sessionFile || snapshot.cwd || snapshot.status
+        ? snapshot
+        : null;
+}
+function readString(value) {
+    return typeof value === "string" && value.trim() ? value : null;
+}
+async function drainPiSessionTailer(tailer, onTimeline) {
+    const info = await stat(tailer.file).catch(() => null);
+    if (!info?.isFile())
+        return;
+    if (info.size < tailer.offset) {
+        // File shrank (recreated): restart from the beginning with fresh mapper state.
+        tailer.offset = 0;
+        tailer.mapper = new PiHistoryMapper("pi");
+    }
+    if (info.size === tailer.offset)
+        return;
+    const handle = await open(tailer.file, "r");
+    try {
+        const length = info.size - tailer.offset;
+        const buffer = Buffer.alloc(length);
+        // A short read means the file was truncated between stat and read; parse only
+        // the bytes that actually arrived.
+        const { bytesRead } = await handle.read(buffer, 0, length, tailer.offset);
+        const text = buffer.toString("utf8", 0, bytesRead);
+        const lastNewline = text.lastIndexOf("\n");
+        if (lastNewline === -1)
+            return;
+        const chunk = text.slice(0, lastNewline + 1);
+        tailer.offset += Buffer.byteLength(chunk);
+        for (const line of chunk.split("\n")) {
+            const trimmed = line.trim();
+            if (!trimmed)
+                continue;
+            let entry;
+            try {
+                entry = JSON.parse(trimmed);
+            }
+            catch {
+                continue;
+            }
+            if (typeof entry !== "object" || entry === null)
+                continue;
+            const message = entry.message;
+            if (typeof message !== "object" || message === null)
+                continue;
+            const timestamp = readString(entry.timestamp) ?? undefined;
+            const events = tailer.mapper.mapMessages([message]);
+            for (const event of events) {
+                if (event.type === "timeline") {
+                    onTimeline(event.item, timestamp);
+                }
+            }
+        }
+    }
+    finally {
+        await handle.close();
+    }
+}
+export async function locatePiSubagentSessionFile(sessionId, options = {}) {
+    const sessionsDir = await resolvePiSessionsDir({
+        cwd: options.cwd ?? undefined,
+        env: options.env ?? process.env,
+        homeDir: options.homeDir,
+    });
+    const suffix = `_${sessionId}.jsonl`;
+    const files = await walkJsonlFiles(sessionsDir);
+    return files.find((file) => file.endsWith(suffix)) ?? null;
+}
+export class PiSubagentSessionTailers {
+    constructor(options) {
+        this.entries = new Map();
+        this.timer = null;
+        this.queue = Promise.resolve();
+        this.options = options;
+    }
+    start() {
+        if (this.timer)
+            return;
+        this.timer = setInterval(() => {
+            void this.tick();
+        }, DEFAULT_POLL_MS);
+        this.timer.unref?.();
+    }
+    stop() {
+        if (this.timer) {
+            clearInterval(this.timer);
+            this.timer = null;
+        }
+    }
+    update(agentId, snapshot) {
+        const subagentId = snapshot.subagentId;
+        const key = `${agentId}\u0000${subagentId}`;
+        let entry = this.entries.get(key);
+        if (!entry) {
+            entry = {
+                agentId,
+                subagentId,
+                sessionId: null,
+                sessionFile: null,
+                cwd: null,
+                tailer: null,
+                lastLocateAttempt: 0,
+                terminalAt: null,
+            };
+            this.entries.set(key, entry);
+            this.start();
+        }
+        if (snapshot.sessionId)
+            entry.sessionId = snapshot.sessionId;
+        if (snapshot.sessionFile)
+            entry.sessionFile = snapshot.sessionFile;
+        if (snapshot.cwd)
+            entry.cwd = snapshot.cwd;
+        const status = mapPiSubagentStatus(snapshot.status ?? "");
+        if (status &&
+            PI_SUBAGENT_TERMINAL_STATUSES.includes(status) &&
+            entry.terminalAt === null) {
+            entry.terminalAt = Date.now();
+        }
+        // No reopen-on-running: reports have no ordering guarantee, so a stale running
+        // snapshot must not resurrect a finished subagent's tail. New launches are new ids.
+    }
+    removeAgent(agentId) {
+        for (const [key, entry] of this.entries) {
+            if (entry.agentId === agentId)
+                this.entries.delete(key);
+        }
+    }
+    dispose() {
+        this.stop();
+        this.entries.clear();
+    }
+    /**
+     * Drain every entry once. Timer and manual (test) ticks serialize through a promise
+     * chain instead of skipping, so an awaited tick never no-ops behind an in-flight one.
+     */
+    tick() {
+        const run = this.queue.then(() => this.drain());
+        this.queue = run.catch(() => { });
+        return run;
+    }
+    async drain() {
+        const now = Date.now();
+        for (const [key, entry] of this.entries) {
+            if (!entry.tailer && now - entry.lastLocateAttempt >= LOCATE_RETRY_MS) {
+                entry.lastLocateAttempt = now;
+                entry.tailer = await this.locate(entry);
+            }
+            if (entry.tailer) {
+                try {
+                    await drainPiSessionTailer(entry.tailer, (item, timestamp) => {
+                        this.options.emit(entry.agentId, {
+                            kind: "timeline",
+                            id: entry.subagentId,
+                            item,
+                            ...(timestamp ? { timestamp } : {}),
+                        });
+                    });
+                }
+                catch {
+                    // Transient read failures (rotation, permissions): retry next tick.
+                }
+            }
+            if (entry.terminalAt !== null &&
+                now >= entry.terminalAt + (this.options.terminalGraceMs ?? TERMINAL_DRAIN_GRACE_MS)) {
+                this.entries.delete(key);
+            }
+        }
+    }
+    async locate(entry) {
+        const file = entry.sessionFile ??
+            (entry.sessionId
+                ? await locatePiSubagentSessionFile(entry.sessionId, {
+                    cwd: entry.cwd,
+                    env: this.options.env,
+                    homeDir: this.options.homeDir,
+                })
+                : null);
+        if (!file)
+            return null;
+        return { file, offset: 0, mapper: new PiHistoryMapper("pi") };
+    }
+}
+//# sourceMappingURL=subagent-session-tailer.js.map

package/node_modules/@bytetrue/server/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bytetrue/server",
-  "version": "0.17.0",
+  "version": "0.18.0",
   "description": "BySpace backend server",
   "files": [
     "dist/server",
@@ -77,10 +77,10 @@
     "test:e2e:ui": "vitest --ui e2e.test.ts"
   },
   "dependencies": {
-    "@bytetrue/client": "0.17.0",
-    "@bytetrue/highlight": "0.17.0",
-    "@bytetrue/protocol": "0.17.0",
-    "@bytetrue/relay": "0.17.0"
+    "@bytetrue/client": "0.18.0",
+    "@bytetrue/highlight": "0.18.0",
+    "@bytetrue/protocol": "0.18.0",
+    "@bytetrue/relay": "0.18.0"
   },
   "devDependencies": {
     "@playwright/test": "^1.56.1",