@townco/agent 0.1.54 → 0.1.55

package/dist/acp-server/adapter.js

@@ -1,6 +1,6 @@
 import * as acp from "@agentclientprotocol/sdk";
 import { context, trace } from "@opentelemetry/api";
-import { createLogger } from "@townco/core";
+import { createLogger } from "../logger.js";
 import { HookExecutor, loadHookCallback } from "../runner/hooks";
 import { telemetry } from "../telemetry/index.js";
 import { calculateContextSize, } from "../utils/context-size-calculator.js";

package/dist/acp-server/http.js

@@ -3,13 +3,14 @@ import { join, resolve } from "node:path";
 import { gzipSync } from "node:zlib";
 import * as acp from "@agentclientprotocol/sdk";
 import { PGlite } from "@electric-sql/pglite";
-import { configureLogsDir, createLogger } from "@townco/core";
+import { configureLogsDir } from "@townco/core";
 import { Hono } from "hono";
 import { cors } from "hono/cors";
 import { streamSSE } from "hono/streaming";
+import { createLogger, isSubagent } from "../logger.js";
 import { makeRunnerFromDefinition } from "../runner";
 import { AgentAcpAdapter } from "./adapter";
-const logger = createLogger("agent");
+const logger = createLogger("http");
 /**
  * Compress a payload using gzip if it's too large for PostgreSQL NOTIFY
  * Returns an object with the payload and metadata about compression
@@ -49,11 +50,16 @@ function safeChannelName(prefix, id) {
     return `${prefix}_${hash}`;
 }
 export function makeHttpTransport(agent, agentDir, agentName) {
-    // Configure logger to write to .logs/ directory if agentDir is provided
-    if (agentDir) {
-        const logsDir = join(agentDir, ".logs");
+    // Configure logger to write to .logs/ directory
+    // Use TOWN_LOGS_DIR env var if set (for subagents), otherwise use agentDir
+    const logsDir = process.env.TOWN_LOGS_DIR ||
+        (agentDir ? join(agentDir, ".logs") : undefined);
+    if (logsDir) {
         configureLogsDir(logsDir);
-        logger.info("Configured logs directory", { logsDir });
+        logger.info("Configured logs directory", {
+            logsDir,
+            isSubagent: isSubagent(),
+        });
     }
     const inbound = new TransformStream();
     const outbound = new TransformStream();

package/dist/index.js

@@ -1,6 +1,6 @@
 import { basename } from "node:path";
-import { createLogger } from "@townco/core";
 import { makeHttpTransport, makeStdioTransport } from "./acp-server";
+import { createLogger } from "./logger.js";
 import { initializeOpenTelemetryFromEnv } from "./telemetry/setup.js";
 import { makeSubagentsTool } from "./utils";
 // Re-export telemetry configuration for library users

package/dist/logger.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Logger utilities for the agent package.
+ * Provides subagent-aware service name generation.
+ */
+import { createLogger as coreCreateLogger } from "@townco/core";
+/**
+ * Check if running as a subagent (detected via TOWN_LOGS_DIR env var)
+ */
+export declare function isSubagent(): boolean;
+/**
+ * Create a logger with subagent-aware service name.
+ * When running as a subagent, the service name is prefixed with "subagent:{port}:{name}:".
+ *
+ * @param service - The service name (e.g., "adapter", "hook-executor")
+ * @returns A logger instance with the appropriate service name
+ *
+ * @example
+ * // In main agent: creates logger with service "adapter"
+ * // In subagent on port 4001 named "researcher": creates logger with service "subagent:4001:researcher:adapter"
+ * const logger = createLogger("adapter");
+ */
+export declare function createLogger(service: string): import("@townco/core").Logger;
+/**
+ * Re-export the core createLogger for cases where subagent prefix is not wanted
+ */
+export { coreCreateLogger as createCoreLogger };

package/dist/logger.js

@@ -0,0 +1,43 @@
+/**
+ * Logger utilities for the agent package.
+ * Provides subagent-aware service name generation.
+ */
+import { createLogger as coreCreateLogger } from "@townco/core";
+/**
+ * Check if running as a subagent (detected via TOWN_LOGS_DIR env var)
+ */
+export function isSubagent() {
+    return !!process.env.TOWN_LOGS_DIR;
+}
+/**
+ * Get the subagent prefix if running as a subagent.
+ * Returns format: "subagent:{port}:{name}:" or empty string if not a subagent.
+ */
+function getSubagentPrefix() {
+    if (!isSubagent()) {
+        return "";
+    }
+    const port = process.env.PORT || "unknown";
+    const name = process.env.TOWN_SUBAGENT_NAME || "agent";
+    return `subagent:${port}:${name}:`;
+}
+/**
+ * Create a logger with subagent-aware service name.
+ * When running as a subagent, the service name is prefixed with "subagent:{port}:{name}:".
+ *
+ * @param service - The service name (e.g., "adapter", "hook-executor")
+ * @returns A logger instance with the appropriate service name
+ *
+ * @example
+ * // In main agent: creates logger with service "adapter"
+ * // In subagent on port 4001 named "researcher": creates logger with service "subagent:4001:researcher:adapter"
+ * const logger = createLogger("adapter");
+ */
+export function createLogger(service) {
+    const prefix = getSubagentPrefix();
+    return coreCreateLogger(`${prefix}${service}`);
+}
+/**
+ * Re-export the core createLogger for cases where subagent prefix is not wanted
+ */
+export { coreCreateLogger as createCoreLogger };

package/dist/runner/hooks/executor.js

@@ -1,4 +1,4 @@
-import { createLogger } from "@townco/core";
+import { createLogger } from "../../logger.js";
 import { DEFAULT_CONTEXT_SIZE, MODEL_CONTEXT_WINDOWS } from "./constants";
 const logger = createLogger("hook-executor");
 /**

package/dist/runner/hooks/loader.js

@@ -1,5 +1,5 @@
 import { resolve } from "node:path";
-import { createLogger } from "@townco/core";
+import { createLogger } from "../../logger.js";
 import { getPredefinedHook, isPredefinedHook } from "./registry";
 const logger = createLogger("hook-loader");
 /**

package/dist/runner/hooks/predefined/compaction-tool.js

@@ -1,6 +1,6 @@
 import { ChatAnthropic } from "@langchain/anthropic";
 import { HumanMessage, SystemMessage } from "@langchain/core/messages";
-import { createLogger } from "@townco/core";
+import { createLogger } from "../../../logger.js";
 import { createContextEntry, createFullMessageEntry, } from "../types";
 const logger = createLogger("compaction-tool");
 /**

package/dist/runner/hooks/predefined/tool-response-compactor.js

@@ -1,6 +1,6 @@
 import { ChatAnthropic } from "@langchain/anthropic";
 import { HumanMessage, SystemMessage } from "@langchain/core/messages";
-import { createLogger } from "@townco/core";
+import { createLogger } from "../../../logger.js";
 import { countToolResultTokens } from "../../../utils/token-counter.js";
 const logger = createLogger("tool-response-compactor");
 // Haiku 4.5 for compaction (fast and cost-effective)

package/dist/runner/langchain/index.js

@@ -1,9 +1,9 @@
 import { MultiServerMCPClient } from "@langchain/mcp-adapters";
 import { context, propagation, trace } from "@opentelemetry/api";
-import { createLogger } from "@townco/core";
 import { AIMessageChunk, createAgent, ToolMessage, tool, } from "langchain";
 import { z } from "zod";
 import { SUBAGENT_MODE_KEY } from "../../acp-server/adapter";
+import { createLogger } from "../../logger.js";
 import { telemetry } from "../../telemetry/index.js";
 import { loadCustomToolModule, } from "../tool-loader.js";
 import { createModelFromString, detectProvider } from "./model-factory.js";

package/dist/runner/langchain/model-factory.js

@@ -1,7 +1,7 @@
 import { ChatAnthropic } from "@langchain/anthropic";
 import { ChatGoogleGenerativeAI } from "@langchain/google-genai";
 import { ChatVertexAI } from "@langchain/google-vertexai";
-import { createLogger } from "@townco/core";
+import { createLogger } from "../../logger.js";
 const logger = createLogger("model-factory");
 /**
  * Detects the provider from a model string and returns the appropriate

package/dist/runner/langchain/tools/port-utils.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Check if a port is available
+ */
+export declare function isPortAvailable(port: number): Promise<boolean>;
+/**
+ * Find the next available port starting from the given port
+ */
+export declare function findAvailablePort(startPort: number, maxAttempts?: number): Promise<number>;

package/dist/runner/langchain/tools/port-utils.js

@@ -0,0 +1,35 @@
+import { createServer } from "node:net";
+/**
+ * Check if a port is available
+ */
+export async function isPortAvailable(port) {
+    return new Promise((resolve) => {
+        const server = createServer();
+        server.once("error", (err) => {
+            if (err.code === "EADDRINUSE") {
+                resolve(false);
+            }
+            else {
+                resolve(false);
+            }
+        });
+        server.once("listening", () => {
+            server.close();
+            resolve(true);
+        });
+        server.listen(port);
+    });
+}
+/**
+ * Find the next available port starting from the given port
+ */
+export async function findAvailablePort(startPort, maxAttempts = 100) {
+    for (let i = 0; i < maxAttempts; i++) {
+        const port = startPort + i;
+        const available = await isPortAvailable(port);
+        if (available) {
+            return port;
+        }
+    }
+    throw new Error(`Could not find an available port between ${startPort} and ${startPort + maxAttempts - 1}`);
+}

package/dist/runner/langchain/tools/subagent.js

@@ -1,15 +1,44 @@
 import { spawn } from "node:child_process";
 import * as fs from "node:fs/promises";
 import * as path from "node:path";
-import { Readable, Writable } from "node:stream";
-import { ClientSideConnection, ndJsonStream, PROTOCOL_VERSION, } from "@agentclientprotocol/sdk";
+import { PROTOCOL_VERSION } from "@agentclientprotocol/sdk";
 import { context, propagation, trace } from "@opentelemetry/api";
+import { createLogger as coreCreateLogger } from "@townco/core";
 import { z } from "zod";
 import { SUBAGENT_MODE_KEY } from "../../../acp-server/adapter.js";
+import { findAvailablePort } from "./port-utils.js";
 /**
  * Name of the Task tool created by makeSubagentsTool
  */
 export const SUBAGENT_TOOL_NAME = "subagent";
+/**
+ * Base port for subagent HTTP servers (avoid conflict with main agents at 3100+)
+ */
+const SUBAGENT_BASE_PORT = 4000;
+/**
+ * Wait for HTTP server to be ready by polling health endpoint
+ */
+async function waitForServerReady(port, timeoutMs = 30000) {
+    const startTime = Date.now();
+    const baseDelay = 50;
+    let attempt = 0;
+    while (Date.now() - startTime < timeoutMs) {
+        try {
+            const response = await fetch(`http://localhost:${port}/health`, {
+                signal: AbortSignal.timeout(1000),
+            });
+            if (response.ok) {
+                return;
+            }
+        }
+        catch {
+            // Server not ready yet
+        }
+        await new Promise((r) => setTimeout(r, baseDelay * Math.pow(1.5, attempt)));
+        attempt++;
+    }
+    throw new Error(`Subagent server at port ${port} did not become ready within ${timeoutMs}ms`);
+}
 /**
  * Creates a DirectTool that delegates work to one of multiple configured subagents.
  *
@@ -145,14 +174,14 @@ assistant: "I'm going to use the Task tool to launch the greeting-responder agen
             if (!agent) {
                 throw new Error(`Unknown agent: ${agentName}`);
             }
-            return await querySubagent(agent.agentPath, agent.agentDir, query);
+            return await querySubagent(agentName, agent.agentPath, agent.agentDir, query);
         },
     };
 }
 /**
- * Internal function that spawns a subagent process and collects its response.
+ * Internal function that spawns a subagent HTTP server and queries it.
  */
-async function querySubagent(agentPath, agentWorkingDirectory, query) {
+async function querySubagent(agentName, agentPath, agentWorkingDirectory, query) {
     // Validate that the agent exists
     try {
         await fs.access(agentPath);
@@ -160,153 +189,227 @@ async function querySubagent(agentPath, agentWorkingDirectory, query) {
     catch (_error) {
         throw new Error(`Agent not found at ${agentPath}. Make sure the agent exists and has an index.ts file.`);
     }
+    // Find an available port for this subagent
+    const port = await findAvailablePort(SUBAGENT_BASE_PORT, 100);
+    // Create a logger for this subagent instance with port prefix
+    // Use core logger directly since service name already identifies the subagent
+    const logger = coreCreateLogger(`subagent:${port}:${agentName}`);
     let agentProcess = null;
-    let connection = null;
+    let sseAbortController = null;
     try {
-        // Spawn the agent process
-        agentProcess = spawn("bun", [agentPath], {
+        // Get the parent's logs directory to pass to the subagent
+        const parentLogsDir = process.env.TOWN_LOGS_DIR || path.join(process.cwd(), ".logs");
+        // Spawn the agent process in HTTP mode
+        agentProcess = spawn("bun", [agentPath, "http"], {
             cwd: agentWorkingDirectory,
-            env: { ...process.env },
+            env: {
+                ...process.env,
+                PORT: String(port),
+                TOWN_LOGS_DIR: parentLogsDir,
+                TOWN_SUBAGENT_NAME: agentName,
+            },
             stdio: ["pipe", "pipe", "pipe"],
         });
-        if (!agentProcess.stdin || !agentProcess.stdout || !agentProcess.stderr) {
-            throw new Error("Failed to create stdio pipes for agent process");
+        if (!agentProcess.stderr) {
+            throw new Error("Failed to create stderr pipe for agent process");
         }
-        // Convert Node.js streams to Web streams
-        const outputStream = Writable.toWeb(agentProcess.stdin);
-        const inputStream = Readable.toWeb(agentProcess.stdout);
-        // Create the bidirectional stream using ndJsonStream
-        const stream = ndJsonStream(outputStream, inputStream);
-        // Track accumulated response text
-        let responseText = "";
-        // Create ACP client implementation factory
-        const clientFactory = (_agent) => {
-            return {
-                async requestPermission(_params) {
-                    // Deny all permission requests from the subagent
-                    return { outcome: { outcome: "cancelled" } };
-                },
-                async sessionUpdate(params) {
-                    // Handle session updates from the agent
-                    const paramsExtended = params;
-                    const update = paramsExtended.update;
-                    // Reset accumulated text when a tool call starts (marks a new message boundary)
-                    if (update?.sessionUpdate === "tool_call") {
-                        responseText = "";
-                    }
-                    // Accumulate agent_message_chunk text content
-                    if (update?.sessionUpdate === "agent_message_chunk") {
-                        const content = update.content;
-                        if (content &&
-                            content.type === "text" &&
-                            typeof content.text === "string") {
-                            responseText += content.text;
-                        }
-                    }
-                },
-                async writeTextFile() {
-                    // Subagents should not write files outside their scope
-                    throw new Error("Subagent attempted to write files, which is not allowed");
-                },
-                async readTextFile() {
-                    // Subagents should not read files outside their scope
-                    throw new Error("Subagent attempted to read files, which is not allowed");
-                },
-            };
-        };
-        // Create the client-side connection
-        connection = new ClientSideConnection(clientFactory, stream);
-        // Set up timeout for the entire operation
-        const timeoutMs = 5 * 60 * 1000; // 5 minutes
-        const timeoutPromise = new Promise((_resolve, reject) => {
-            setTimeout(() => {
-                reject(new Error(`Subagent query timed out after ${timeoutMs / 1000} seconds`));
-            }, timeoutMs);
-        });
-        // Handle process errors and exit
-        const processExitPromise = new Promise((_resolve, reject) => {
-            agentProcess?.on("exit", (code, signal) => {
-                if (code !== 0 && code !== null) {
-                    reject(new Error(`Agent process exited with code ${code} and signal ${signal}`));
+        // Capture stdout and forward to logger
+        if (agentProcess.stdout) {
+            agentProcess.stdout.on("data", (data) => {
+                const lines = data
+                    .toString()
+                    .split("\n")
+                    .filter((line) => line.trim());
+                for (const line of lines) {
+                    logger.info(line);
                 }
             });
+        }
+        // Capture stderr and forward to logger as errors
+        agentProcess.stderr.on("data", (data) => {
+            const lines = data
+                .toString()
+                .split("\n")
+                .filter((line) => line.trim());
+            for (const line of lines) {
+                logger.error(line);
+            }
+        });
+        // Handle process errors
+        const processErrorPromise = new Promise((_, reject) => {
             agentProcess?.on("error", (error) => {
+                logger.error(`Process error: ${error.message}`);
                 reject(new Error(`Agent process error: ${error.message}`));
             });
+            agentProcess?.on("exit", (code, signal) => {
+                if (code !== 0 && code !== null) {
+                    logger.error(`Process exited with code ${code}, signal ${signal}`);
+                    reject(new Error(`Agent process exited unexpectedly with code ${code}, signal ${signal}`));
+                }
+            });
         });
-        // Run the query with timeout and error handling
-        const queryPromise = (async () => {
-            // Initialize the connection
-            await connection?.initialize({
-                protocolVersion: PROTOCOL_VERSION,
-                clientCapabilities: {
-                    fs: {
-                        readTextFile: false,
-                        writeTextFile: false,
+        logger.info(`Starting subagent HTTP server on port ${port}`);
+        // Wait for server to be ready
+        await Promise.race([waitForServerReady(port), processErrorPromise]);
+        logger.info(`Subagent server ready on port ${port}`);
+        const baseUrl = `http://localhost:${port}`;
+        // Step 1: Initialize ACP connection
+        const initResponse = await fetch(`${baseUrl}/rpc`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({
+                jsonrpc: "2.0",
+                id: "init-1",
+                method: "initialize",
+                params: {
+                    protocolVersion: PROTOCOL_VERSION,
+                    clientCapabilities: {
+                        fs: { readTextFile: false, writeTextFile: false },
                     },
                 },
-            });
-            // Prepare OpenTelemetry trace context to propagate to the subagent.
-            // We inject from the current active context so the subagent's root
-            // invocation span can be a child of whatever span is active when
-            // this Task tool runs (ideally the agent.tool_call span).
-            if (process.env.DEBUG_TELEMETRY === "true") {
-                console.log(`[querySubagent] Tool function executing for agent: ${agentPath}`);
-            }
-            const otelCarrier = {};
-            const activeCtx = context.active();
-            const activeSpan = trace.getSpan(activeCtx);
-            if (process.env.DEBUG_TELEMETRY === "true") {
-                console.log(`[querySubagent] Active span when tool executes:`, activeSpan?.spanContext());
-            }
-            const ctxForInjection = activeSpan
-                ? trace.setSpan(activeCtx, activeSpan)
-                : activeCtx;
+            }),
+        });
+        if (!initResponse.ok) {
+            throw new Error(`Initialize failed: HTTP ${initResponse.status}`);
+        }
+        // Step 2: Create new session with subagent mode and OTEL context
+        // Prepare OpenTelemetry trace context to propagate to the subagent
+        const otelCarrier = {};
+        const activeCtx = context.active();
+        const activeSpan = trace.getSpan(activeCtx);
+        if (process.env.DEBUG_TELEMETRY === "true") {
+            console.log(`[querySubagent] Active span when tool executes:`, activeSpan?.spanContext());
+        }
+        if (activeSpan) {
+            const ctxForInjection = trace.setSpan(activeCtx, activeSpan);
             propagation.inject(ctxForInjection, otelCarrier);
-            const hasOtelContext = Object.keys(otelCarrier).length > 0;
-            // Create a new session with subagent mode flag and OTEL trace context
-            const sessionResponse = await connection?.newSession({
-                cwd: agentWorkingDirectory,
-                mcpServers: [],
-                _meta: {
-                    [SUBAGENT_MODE_KEY]: true,
-                    ...(hasOtelContext ? { otelTraceContext: otelCarrier } : {}),
+        }
+        const hasOtelContext = Object.keys(otelCarrier).length > 0;
+        const sessionResponse = await fetch(`${baseUrl}/rpc`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({
+                jsonrpc: "2.0",
+                id: "session-1",
+                method: "session/new",
+                params: {
+                    cwd: agentWorkingDirectory,
+                    mcpServers: [],
+                    _meta: {
+                        [SUBAGENT_MODE_KEY]: true,
+                        ...(hasOtelContext ? { otelTraceContext: otelCarrier } : {}),
+                    },
                 },
+            }),
+        });
+        if (!sessionResponse.ok) {
+            throw new Error(`Session creation failed: HTTP ${sessionResponse.status}`);
+        }
+        const sessionResult = (await sessionResponse.json());
+        const sessionId = sessionResult.result?.sessionId;
+        if (!sessionId) {
+            throw new Error("No sessionId in session/new response");
+        }
+        // Step 3: Connect to SSE for receiving streaming responses
+        sseAbortController = new AbortController();
+        let responseText = "";
+        const ssePromise = (async () => {
+            const sseResponse = await fetch(`${baseUrl}/events`, {
+                headers: { "X-Session-ID": sessionId },
+                signal: sseAbortController.signal,
             });
-            // Send the prompt
-            await connection?.prompt({
-                sessionId: sessionResponse.sessionId,
-                prompt: [
-                    {
-                        type: "text",
-                        text: query,
+            if (!sseResponse.ok || !sseResponse.body) {
+                throw new Error(`SSE connection failed: HTTP ${sseResponse.status}`);
+            }
+            const reader = sseResponse.body.getReader();
+            const decoder = new TextDecoder();
+            let buffer = "";
+            while (true) {
+                const { done, value } = await reader.read();
+                if (done)
+                    break;
+                buffer += decoder.decode(value, { stream: true });
+                const lines = buffer.split("\n");
+                buffer = lines.pop() || "";
+                for (const line of lines) {
+                    if (line.startsWith("data:")) {
+                        const data = line.substring(5).trim();
+                        if (!data)
+                            continue;
+                        try {
+                            const message = JSON.parse(data);
+                            // Handle session/update notifications for agent_message_chunk
+                            if (message.method === "session/update" &&
+                                message.params?.update?.sessionUpdate === "agent_message_chunk") {
+                                const content = message.params.update.content;
+                                if (content?.type === "text" &&
+                                    typeof content.text === "string") {
+                                    responseText += content.text;
+                                }
+                            }
+                            // Reset on tool_call (marks new message boundary)
+                            if (message.params?.update?.sessionUpdate === "tool_call") {
+                                responseText = "";
+                            }
+                        }
+                        catch {
+                            // Ignore malformed SSE data
+                        }
+                    }
+                }
+            }
+        })();
+        // Step 4: Send the prompt with timeout
+        const timeoutMs = 5 * 60 * 1000; // 5 minutes
+        const promptPromise = (async () => {
+            const promptResponse = await fetch(`${baseUrl}/rpc`, {
+                method: "POST",
+                headers: { "Content-Type": "application/json" },
+                body: JSON.stringify({
+                    jsonrpc: "2.0",
+                    id: "prompt-1",
+                    method: "session/prompt",
+                    params: {
+                        sessionId,
+                        prompt: [{ type: "text", text: query }],
                     },
-                ],
+                }),
             });
-            return responseText;
+            if (!promptResponse.ok) {
+                throw new Error(`Prompt failed: HTTP ${promptResponse.status}`);
+            }
+            // Wait for prompt to complete (this blocks until agent finishes processing)
+            const promptResult = (await promptResponse.json());
+            if (promptResult.error) {
+                throw new Error(`Prompt error: ${promptResult.error.message || JSON.stringify(promptResult.error)}`);
+            }
         })();
-        // Race between query execution, timeout, and process exit
-        return await Promise.race([
-            queryPromise,
-            timeoutPromise,
-            processExitPromise,
+        const timeoutPromise = new Promise((_, reject) => {
+            setTimeout(() => {
+                reject(new Error(`Subagent query timed out after ${timeoutMs / 1000} seconds`));
+            }, timeoutMs);
+        });
+        // Wait for prompt to complete with timeout
+        await Promise.race([promptPromise, timeoutPromise, processErrorPromise]);
+        // Give SSE a moment to flush remaining messages
+        await new Promise((r) => setTimeout(r, 100));
+        // Abort SSE connection
+        sseAbortController.abort();
+        // Wait for SSE to finish (with timeout)
+        await Promise.race([
+            ssePromise.catch(() => { }), // Ignore abort errors
+            new Promise((r) => setTimeout(r, 1000)),
         ]);
+        return responseText;
     }
     finally {
-        // Cleanup: kill process and close connection
+        // Cleanup: abort SSE and kill process
+        logger.info(`Shutting down subagent on port ${port}`);
+        if (sseAbortController) {
+            sseAbortController.abort();
+        }
         if (agentProcess) {
             agentProcess.kill();
         }
-        if (connection) {
-            try {
-                await Promise.race([
-                    connection.closed,
-                    new Promise((resolve) => setTimeout(resolve, 1000)),
-                ]);
-            }
-            catch {
-                // Ignore cleanup errors
-            }
-        }
     }
 }

package/dist/storage/index.js

@@ -1,7 +1,7 @@
 import { mkdir, readdir, rm, stat } from "node:fs/promises";
 import { homedir } from "node:os";
 import { dirname, join } from "node:path";
-import { createLogger } from "@townco/core";
+import { createLogger } from "../logger.js";
 const AGENTS_DIR = join(homedir(), ".config", "town", "agents");
 const logger = createLogger("storage");
 /**