@oyasmi/pipiclaw 0.5.1 → 0.5.3

package/dist/{dingtalk.js → runtime/dingtalk.js}

@@ -11,8 +11,9 @@ import axios from "axios";
 import { DWClient, TOPIC_ROBOT } from "dingtalk-stream";
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
 import { dirname, join } from "path";
-import { parseBuiltInCommand, renderBuiltInHelp } from "./commands.js";
-import * as log from "./log.js";
+import { parseBuiltInCommand, renderBuiltInHelp } from "../commands.js";
+import * as log from "../log.js";
+import { isRecord } from "../shared/type-guards.js";
 class ChannelQueue {
     constructor() {
         this.queue = [];
@@ -72,6 +73,7 @@ export class DingTalkBot {
         this.lastSocketAvailableTime = Date.now();
         this.activeMessageProcessing = false;
         this.keepAliveTimer = null;
+        this.reconnectTimer = null;
         this.isReconnecting = false;
         this.isStopped = false;
         this.reconnectAttempts = 0;
@@ -95,6 +97,67 @@ export class DingTalkBot {
         }
         return true;
     }
+    getSocket() {
+        if (!this.client) {
+            return null;
+        }
+        const socket = Reflect.get(this.client, "socket");
+        return this.isSocketLike(socket) ? socket : null;
+    }
+    isSocketLike(value) {
+        if (!isRecord(value)) {
+            return false;
+        }
+        return typeof value.on === "function";
+    }
+    setTrackedTimeout(callback, delayMs) {
+        const timer = setTimeout(() => {
+            callback();
+        }, delayMs);
+        timer.unref?.();
+        return timer;
+    }
+    setTrackedInterval(callback, intervalMs) {
+        const timer = setInterval(callback, intervalMs);
+        timer.unref?.();
+        return timer;
+    }
+    clearKeepAliveTimer() {
+        if (this.keepAliveTimer) {
+            clearInterval(this.keepAliveTimer);
+            this.keepAliveTimer = null;
+        }
+    }
+    clearReconnectTimer() {
+        if (this.reconnectTimer) {
+            clearTimeout(this.reconnectTimer);
+            this.reconnectTimer = null;
+        }
+    }
+    clearAllTimers() {
+        this.clearKeepAliveTimer();
+        this.clearReconnectTimer();
+    }
+    async waitForDelay(delayMs) {
+        await new Promise((resolve) => {
+            this.reconnectTimer = this.setTrackedTimeout(() => {
+                this.reconnectTimer = null;
+                resolve();
+            }, delayMs);
+        });
+    }
+    scheduleReconnect(delayMs, immediate) {
+        if (this.isStopped) {
+            return;
+        }
+        this.clearReconnectTimer();
+        this.reconnectTimer = this.setTrackedTimeout(() => {
+            this.reconnectTimer = null;
+            this.doReconnect(immediate).catch((err) => {
+                log.logWarning("DingTalk: reconnect failed", err instanceof Error ? err.message : String(err));
+            });
+        }, delayMs);
+    }
     // ==========================================================================
     // Public API
     // ==========================================================================
@@ -110,10 +173,10 @@ export class DingTalkBot {
         if (process.env.DINGTALK_FORCE_PROXY !== "true") {
             axios.defaults.proxy = false;
         }
+        this.clearAllTimers();
         this.client = new DWClient({
             clientId: this.config.clientId,
             clientSecret: this.config.clientSecret,
-            autoReconnect: false,
             keepAlive: false,
         });
         this.client.registerCallbackListener(TOPIC_ROBOT, (msg) => {
@@ -133,7 +196,8 @@ export class DingTalkBot {
             return { status: "SUCCESS", message: "OK" };
         }
         try {
-            const data = typeof msg.data === "string" ? JSON.parse(msg.data) : msg.data;
+            const parsedData = typeof msg.data === "string" ? JSON.parse(msg.data) : msg.data;
+            const data = isRecord(parsedData) ? parsedData : {};
             // 3. Business logic deduplication
             const msgId = data.msgId;
             if (msgId && !this.markProcessed(msgId)) {
@@ -157,21 +221,24 @@ export class DingTalkBot {
         if (!immediate && this.reconnectAttempts > 0) {
             const delay = Math.min(1000 * 2 ** this.reconnectAttempts + Math.random() * 1000, 30000);
             log.logInfo(`DingTalk: waiting ${Math.round(delay / 1000)}s before reconnecting...`);
-            await new Promise((resolve) => setTimeout(resolve, delay));
+            await this.waitForDelay(delay);
+            if (this.isStopped || !this.client) {
+                this.isReconnecting = false;
+                return;
+            }
         }
         try {
-            const socket = this.client.socket;
+            const socket = this.getSocket();
             if (socket?.readyState === 1 || socket?.readyState === 3) {
-                await this.client.disconnect();
+                await Promise.resolve(this.client.disconnect());
             }
             await this.client.connect();
             this.lastSocketAvailableTime = Date.now();
             this.reconnectAttempts = 0; // Success, reset backoff
             log.logInfo("DingTalk: connected to stream.");
             // Setup keep alive
-            if (this.keepAliveTimer)
-                clearInterval(this.keepAliveTimer);
-            this.keepAliveTimer = setInterval(() => {
+            this.clearKeepAliveTimer();
+            this.keepAliveTimer = this.setTrackedInterval(() => {
                 if (this.isStopped)
                     return;
                 const elapsed = Date.now() - this.lastSocketAvailableTime;
@@ -179,9 +246,9 @@ export class DingTalkBot {
                     log.logWarning("DingTalk: connection timeout detected (>90s). Keeping active where possible...");
                 }
                 try {
-                    const s = this.client?.socket;
+                    const s = this.getSocket();
                     if (s?.readyState === 1) {
-                        s.ping();
+                        s.ping?.();
                     }
                 }
                 catch (_err) {
@@ -189,7 +256,7 @@ export class DingTalkBot {
                 }
             }, 30 * 1000);
             // Setup native socket events
-            const s = this.client.socket;
+            const s = this.getSocket();
             s?.on("pong", () => {
                 this.lastSocketAvailableTime = Date.now();
             });
@@ -197,11 +264,7 @@ export class DingTalkBot {
                 log.logWarning(`DingTalk: WebSocket closed: code=${code}, reason=${reason}`);
                 if (this.isStopped)
                     return;
-                setTimeout(() => {
-                    this.doReconnect(true).catch((err) => {
-                        log.logWarning("DingTalk: reconnect failed", err instanceof Error ? err.message : String(err));
-                    });
-                }, 1000);
+                this.scheduleReconnect(1000, true);
             });
             s?.on("message", (raw) => {
                 try {
@@ -228,20 +291,19 @@ export class DingTalkBot {
         }
         // Auto-retry on failure with exponential backoff
         if (connectionFailed && !this.isStopped) {
-            this.doReconnect().catch(() => { });
+            this.scheduleReconnect(0, false);
         }
     }
     async stop() {
         log.logInfo("DingTalk: stopping bot");
         this.isStopped = true;
-        if (this.keepAliveTimer)
-            clearInterval(this.keepAliveTimer);
+        this.clearAllTimers();
         for (const queue of this.queues.values()) {
             queue.stop();
         }
         if (this.client) {
             try {
-                await Promise.resolve(this.client.disconnect?.());
+                await Promise.resolve(this.client.disconnect());
             }
             catch (err) {
                 log.logWarning("DingTalk: failed to disconnect cleanly", err instanceof Error ? err.message : String(err));
@@ -553,11 +615,9 @@ export class DingTalkBot {
         if (textContent)
             return textContent;
         // 2. richText 类型消息：从 content.richText 列表提取文本片段
-        const raw = data;
-        const contentObj = raw.content;
-        if (contentObj?.richText) {
+        if (data.content?.richText) {
             const parts = [];
-            for (const item of contentObj.richText) {
+            for (const item of data.content.richText) {
                 if (item.text)
                     parts.push(item.text);
             }
@@ -577,7 +637,7 @@ export class DingTalkBot {
         const conversationId = data.conversationId || "";
         const conversationType = data.conversationType || "1";
         if (!content) {
-            const msgtype = data.msgtype || "unknown";
+            const msgtype = typeof data.msgtype === "string" ? data.msgtype : "unknown";
             log.logWarning(`DingTalk: empty message (type=${msgtype})`);
             return;
         }
@@ -704,4 +764,3 @@ export class DingTalkBot {
         return join(this.config.stateDir, channelId, ".channel-meta.json");
     }
 }
-//# sourceMappingURL=dingtalk.js.map

package/dist/{events.d.ts → runtime/events.d.ts}

@@ -48,4 +48,3 @@ export declare class EventsWatcher {
  * Create and start an events watcher.
  */
 export declare function createEventsWatcher(workspaceDir: string, bot: DingTalkBot): EventsWatcher;
-//# sourceMappingURL=events.d.ts.map

package/dist/{events.js → runtime/events.js}

@@ -2,7 +2,7 @@ import { Cron } from "croner";
 import { existsSync, mkdirSync, readdirSync, statSync, unlinkSync, watch } from "fs";
 import { readFile } from "fs/promises";
 import { join } from "path";
-import * as log from "./log.js";
+import * as log from "../log.js";
 // ============================================================================
 // EventsWatcher
 // ============================================================================
@@ -292,4 +292,3 @@ export function createEventsWatcher(workspaceDir, bot) {
     const eventsDir = join(workspaceDir, "events");
     return new EventsWatcher(eventsDir, bot);
 }
-//# sourceMappingURL=events.js.map

package/dist/{store.d.ts → runtime/store.d.ts}

@@ -45,6 +45,8 @@ export interface LoggedSubAgentRun {
 export declare class ChannelStore {
     private workingDir;
     private recentlyLogged;
+    private cleanupTimer;
+    private writeChains;
     constructor(config: ChannelStoreConfig);
     /**
      * Get or create the directory for a channel/DM
@@ -71,5 +73,7 @@ export declare class ChannelStore {
      * Returns null if no log exists
      */
     getLastTimestamp(channelId: string): string | null;
+    private enqueueWrite;
+    private startCleanupTimer;
+    private cleanupExpiredEntries;
 }
-//# sourceMappingURL=store.d.ts.map

package/dist/{store.js → runtime/store.js}

@@ -1,10 +1,14 @@
 import { closeSync, existsSync, mkdirSync, openSync, readSync, renameSync, statSync } from "fs";
 import { appendFile, writeFile } from "fs/promises";
 import { dirname, join } from "path";
+const MAX_LOG_SIZE_BYTES = 1_000_000;
+const DEDUPE_TTL_MS = 60_000;
+const DEDUPE_CLEANUP_INTERVAL_MS = 30_000;
 export class ChannelStore {
     constructor(config) {
-        // Track recently logged message timestamps to prevent duplicates
         this.recentlyLogged = new Map();
+        this.cleanupTimer = null;
+        this.writeChains = new Map();
         this.workingDir = config.workingDir;
         // Ensure working directory exists
         if (!existsSync(this.workingDir)) {
@@ -27,46 +31,50 @@ export class ChannelStore {
      * Returns false if message was already logged (duplicate)
      */
     async logMessage(channelId, message) {
-        // Check for duplicate (same channel + timestamp)
         const dedupeKey = `${channelId}:${message.ts}`;
-        if (this.recentlyLogged.has(dedupeKey)) {
-            return false; // Already logged
+        const now = Date.now();
+        const previousLogTime = this.recentlyLogged.get(dedupeKey);
+        if (previousLogTime !== undefined) {
+            if (now - previousLogTime < DEDUPE_TTL_MS) {
+                return false;
+            }
+            this.recentlyLogged.delete(dedupeKey);
         }
-        // Mark as logged and schedule cleanup after 60 seconds
-        this.recentlyLogged.set(dedupeKey, Date.now());
-        setTimeout(() => this.recentlyLogged.delete(dedupeKey), 60000);
+        this.recentlyLogged.set(dedupeKey, now);
+        this.startCleanupTimer();
         const logPath = join(this.getChannelDir(channelId), "log.jsonl");
-        // Rotate if file exceeds size limit
-        this.rotateIfNeeded(logPath);
-        // Ensure message has a date field
         if (!message.date) {
             message.date = new Date().toISOString();
         }
-        const line = `${JSON.stringify(message)}\n`;
-        await appendFile(logPath, line, "utf-8");
+        await this.enqueueWrite(logPath, async () => {
+            await this.rotateIfNeeded(logPath);
+            const line = `${JSON.stringify(message)}\n`;
+            await appendFile(logPath, line, "utf-8");
+        });
         return true;
     }
     async logSubAgentRun(channelId, run) {
         const logPath = join(this.getChannelDir(channelId), "subagent-runs.jsonl");
-        this.rotateIfNeeded(logPath);
-        const line = `${JSON.stringify(run)}\n`;
-        await appendFile(logPath, line, "utf-8");
+        await this.enqueueWrite(logPath, async () => {
+            await this.rotateIfNeeded(logPath);
+            const line = `${JSON.stringify(run)}\n`;
+            await appendFile(logPath, line, "utf-8");
+        });
     }
     /**
      * Rotate log file if it exceeds 1MB.
      * Keeps one backup (log.jsonl.1) and resets the sync offset.
      */
-    rotateIfNeeded(logPath) {
+    async rotateIfNeeded(logPath) {
         try {
             if (!existsSync(logPath))
                 return;
             const stats = statSync(logPath);
-            if (stats.size > 1_000_000) {
+            if (stats.size > MAX_LOG_SIZE_BYTES) {
                 renameSync(logPath, `${logPath}.1`);
-                // Reset sync offset since log.jsonl was replaced
                 const syncOffsetPath = join(dirname(logPath), ".sync-offset");
                 try {
-                    writeFile(syncOffsetPath, "0", "utf-8").catch(() => { });
+                    await writeFile(syncOffsetPath, "0", "utf-8");
                 }
                 catch {
                     /* ignore */
@@ -152,5 +160,37 @@ export class ChannelStore {
             return null;
         }
     }
+    enqueueWrite(logPath, work) {
+        const previous = this.writeChains.get(logPath) ?? Promise.resolve();
+        const result = previous.catch(() => undefined).then(() => work());
+        const completion = result.then(() => undefined, () => undefined);
+        this.writeChains.set(logPath, completion);
+        completion.finally(() => {
+            if (this.writeChains.get(logPath) === completion) {
+                this.writeChains.delete(logPath);
+            }
+        });
+        return result;
+    }
+    startCleanupTimer() {
+        if (this.cleanupTimer) {
+            return;
+        }
+        this.cleanupTimer = setInterval(() => {
+            this.cleanupExpiredEntries();
+        }, DEDUPE_CLEANUP_INTERVAL_MS);
+        this.cleanupTimer.unref?.();
+    }
+    cleanupExpiredEntries(now = Date.now()) {
+        const cutoff = now - DEDUPE_TTL_MS;
+        for (const [key, loggedAt] of this.recentlyLogged) {
+            if (loggedAt <= cutoff) {
+                this.recentlyLogged.delete(key);
+            }
+        }
+        if (this.recentlyLogged.size === 0 && this.cleanupTimer) {
+            clearInterval(this.cleanupTimer);
+            this.cleanupTimer = null;
+        }
+    }
 }
-//# sourceMappingURL=store.js.map

package/dist/sandbox.d.ts

@@ -32,4 +32,3 @@ export interface ExecResult {
     stderr: string;
     code: number;
 }
-//# sourceMappingURL=sandbox.d.ts.map

package/dist/sandbox.js

@@ -1,5 +1,5 @@
 import { spawn } from "child_process";
-import { shellEscape } from "./shell-escape.js";
+import { shellEscape } from "./shared/shell-escape.js";
 export function parseSandboxArg(value) {
     if (value === "host") {
         return { type: "host" };
@@ -219,4 +219,3 @@ function killProcessTree(pid) {
         }
     }
 }
-//# sourceMappingURL=sandbox.js.map

package/dist/{llm-json.d.ts → shared/llm-json.d.ts}

@@ -4,4 +4,3 @@ export declare class LlmJsonParseError extends Error {
 }
 export declare function extractJsonObject(text: string): string;
 export declare function parseJsonObject(text: string): unknown;
-//# sourceMappingURL=llm-json.d.ts.map

package/dist/{llm-json.js → shared/llm-json.js}

@@ -74,4 +74,3 @@ export function extractJsonObject(text) {
 export function parseJsonObject(text) {
     return JSON.parse(extractJsonObject(text));
 }
-//# sourceMappingURL=llm-json.js.map

package/dist/shared/markdown-sections.d.ts

@@ -0,0 +1,6 @@
+export interface MarkdownSection {
+    heading: string;
+    content: string;
+}
+export declare function splitH1Sections(content: string): MarkdownSection[];
+export declare function splitH2Sections(content: string): MarkdownSection[];

package/dist/{markdown-sections.js → shared/markdown-sections.js}

@@ -1,4 +1,4 @@
-export function splitLevelOneSections(content) {
+function splitSectionsByHeading(content, headingPrefix) {
     const normalized = content.replace(/\r/g, "").trim();
     if (!normalized) {
         return [];
@@ -7,6 +7,7 @@ export function splitLevelOneSections(content) {
     const sections = [];
     let currentHeading = "";
     let currentLines = [];
+    const prefixLength = headingPrefix.length;
     const flush = () => {
         if (!currentHeading) {
             return;
@@ -18,9 +19,9 @@ export function splitLevelOneSections(content) {
         sections.push({ heading: currentHeading, content: sectionContent });
     };
     for (const line of lines) {
-        if (line.startsWith("# ")) {
+        if (line.startsWith(headingPrefix)) {
             flush();
-            currentHeading = line.slice(2).trim();
+            currentHeading = line.slice(prefixLength).trim();
             currentLines = [];
             continue;
         }
@@ -31,4 +32,9 @@ export function splitLevelOneSections(content) {
     flush();
     return sections;
 }
-//# sourceMappingURL=markdown-sections.js.map
+export function splitH1Sections(content) {
+    return splitSectionsByHeading(content, "# ");
+}
+export function splitH2Sections(content) {
+    return splitSectionsByHeading(content, "## ");
+}

package/dist/{shell-escape.d.ts → shared/shell-escape.d.ts}

@@ -3,4 +3,3 @@
  * Wraps in single quotes and escapes internal single quotes.
  */
 export declare function shellEscape(s: string): string;
-//# sourceMappingURL=shell-escape.d.ts.map

package/dist/{shell-escape.js → shared/shell-escape.js}

@@ -5,4 +5,3 @@
 export function shellEscape(s) {
     return `'${s.replace(/'/g, "'\\''")}'`;
 }
-//# sourceMappingURL=shell-escape.js.map

package/dist/shared/text-utils.d.ts

@@ -0,0 +1,9 @@
+import type { AssistantMessage } from "@mariozechner/pi-ai";
+export declare function clipText(text: string, maxChars: number, opts?: {
+    headRatio?: number;
+    omitHint?: string;
+}): string;
+export declare function truncate(text: string, maxLen: number): string;
+export declare const HAN_REGEX: RegExp;
+export declare function extractLabelFromArgs(args: unknown): string | null;
+export declare function extractAssistantText(message: AssistantMessage): string;

package/dist/shared/text-utils.js

@@ -0,0 +1,36 @@
+export function clipText(text, maxChars, opts = {}) {
+    const normalized = text.replace(/\s+\n/g, "\n").replace(/\r/g, "").trim();
+    if (normalized.length <= maxChars) {
+        return normalized;
+    }
+    const headRatio = Math.max(0, Math.min(1, opts.headRatio ?? 0.45));
+    const omitHint = opts.omitHint ?? "[... omitted middle section ...]";
+    if (headRatio >= 1) {
+        const headChars = Math.max(0, maxChars - omitHint.length);
+        return `${normalized.slice(0, headChars).trimEnd()}${omitHint}`;
+    }
+    const headChars = Math.floor(maxChars * headRatio);
+    const tailChars = maxChars - headChars;
+    return `${normalized.slice(0, headChars)}\n\n${omitHint}\n\n${normalized.slice(-tailChars)}`;
+}
+export function truncate(text, maxLen) {
+    if (text.length <= maxLen) {
+        return text;
+    }
+    return `${text.substring(0, maxLen - 3)}...`;
+}
+export const HAN_REGEX = /\p{Script=Han}/u;
+export function extractLabelFromArgs(args) {
+    if (!args || typeof args !== "object" || !("label" in args)) {
+        return null;
+    }
+    const label = args.label;
+    return typeof label === "string" && label.trim() ? label.trim() : null;
+}
+export function extractAssistantText(message) {
+    return message.content
+        .filter((part) => part.type === "text")
+        .map((part) => part.text)
+        .join("\n")
+        .trim();
+}

package/dist/shared/type-guards.d.ts

@@ -0,0 +1,5 @@
+import type { AgentMessage } from "@mariozechner/pi-agent-core";
+import type { Message } from "@mariozechner/pi-ai";
+export declare function isRecord(value: unknown): value is Record<string, unknown>;
+export declare function isStandardAgentMessage(message: AgentMessage): message is Message;
+export declare function buildStandardMessages(messages: AgentMessage[]): Message[];

package/dist/shared/type-guards.js

@@ -0,0 +1,12 @@
+export function isRecord(value) {
+    return typeof value === "object" && value !== null;
+}
+export function isStandardAgentMessage(message) {
+    return (typeof message === "object" &&
+        message !== null &&
+        "role" in message &&
+        (message.role === "user" || message.role === "assistant" || message.role === "toolResult"));
+}
+export function buildStandardMessages(messages) {
+    return messages.filter(isStandardAgentMessage);
+}

package/dist/shared/types.d.ts

@@ -0,0 +1,14 @@
+export interface UsageTotals {
+    input: number;
+    output: number;
+    cacheRead: number;
+    cacheWrite: number;
+    total: number;
+    cost: {
+        input: number;
+        output: number;
+        cacheRead: number;
+        cacheWrite: number;
+        total: number;
+    };
+}

package/dist/shared/types.js

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

package/dist/sidecar-worker.d.ts

@@ -24,4 +24,3 @@ export declare class SidecarParseError extends Error {
     constructor(taskName: string, rawText: string, cause: unknown);
 }
 export declare function runSidecarTask<T>(task: SidecarTask<T>): Promise<SidecarResult<T>>;
-//# sourceMappingURL=sidecar-worker.d.ts.map

package/dist/sidecar-worker.js

@@ -1,5 +1,6 @@
 import { Agent } from "@mariozechner/pi-agent-core";
 import { convertToLlm } from "@mariozechner/pi-coding-agent";
+import { extractAssistantText } from "./shared/text-utils.js";
 export class SidecarTimeoutError extends Error {
     constructor(taskName, timeoutMs) {
         super(`Sidecar task "${taskName}" timed out after ${timeoutMs}ms`);
@@ -17,13 +18,6 @@ export class SidecarParseError extends Error {
         this.cause = cause;
     }
 }
-function extractAssistantText(message) {
-    return message.content
-        .filter((part) => part.type === "text")
-        .map((part) => part.text)
-        .join("\n")
-        .trim();
-}
 export async function runSidecarTask(task) {
     const apiKey = await task.resolveApiKey(task.model);
     const worker = new Agent({
@@ -102,4 +96,3 @@ export async function runSidecarTask(task) {
         removeAbortListener();
     }
 }
-//# sourceMappingURL=sidecar-worker.js.map

package/dist/{sub-agents.d.ts → subagents/discovery.d.ts}

@@ -58,4 +58,3 @@ export declare function resolveSubAgentConfig(availableModels: Model<Api>[], cur
 };
 export declare function formatSubAgentList(agents: SubAgentConfig[], maxItems?: number): string;
 export {};
-//# sourceMappingURL=sub-agents.d.ts.map

package/dist/{sub-agents.js → subagents/discovery.js}

@@ -1,8 +1,8 @@
 import { parseFrontmatter } from "@mariozechner/pi-coding-agent";
 import { existsSync, readdirSync, readFileSync } from "fs";
 import { join } from "path";
-import { findExactModelReferenceMatch, formatModelReference } from "./model-utils.js";
-import { SUB_AGENTS_DIR_NAME } from "./paths.js";
+import { findExactModelReferenceMatch, formatModelReference } from "../model-utils.js";
+import { SUB_AGENTS_DIR_NAME } from "../paths.js";
 const ALLOWED_SUB_AGENT_TOOLS = ["read", "bash", "edit", "write"];
 const DEFAULT_SUB_AGENT_TOOLS = ["read", "bash"];
 const DEFAULT_MAX_TURNS = 24;
@@ -366,4 +366,3 @@ export function formatSubAgentList(agents, maxItems = 12) {
     }
     return `${listed.join("\n")}\n- ... and ${agents.length - maxItems} more`;
 }
-//# sourceMappingURL=sub-agents.js.map

package/dist/{tools/subagent.d.ts → subagents/tool.d.ts}

@@ -2,7 +2,8 @@ import { type AgentEvent, type AgentMessage, type AgentTool } from "@mariozechne
 import type { Api, Model } from "@mariozechner/pi-ai";
 import type { PipiclawMemoryRecallSettings } from "../context.js";
 import type { Executor } from "../sandbox.js";
-import { type ResolvedSubAgentConfig, type SubAgentDiscoveryResult } from "../sub-agents.js";
+import type { UsageTotals } from "../shared/types.js";
+import { type ResolvedSubAgentConfig, type SubAgentDiscoveryResult } from "./discovery.js";
 declare const subagentSchema: import("@sinclair/typebox").TObject<{
     label: import("@sinclair/typebox").TString;
     agent: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
@@ -19,20 +20,6 @@ declare const subagentSchema: import("@sinclair/typebox").TObject<{
     memory: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
     paths: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TArray<import("@sinclair/typebox").TString>>;
 }>;
-interface UsageTotals {
-    input: number;
-    output: number;
-    cacheRead: number;
-    cacheWrite: number;
-    total: number;
-    cost: {
-        input: number;
-        output: number;
-        cacheRead: number;
-        cacheWrite: number;
-        total: number;
-    };
-}
 export interface SubAgentToolDetails {
     kind: "subagent";
     agent: string;
@@ -77,4 +64,3 @@ interface SubAgentWorker {
 }
 export declare function createSubAgentTool(options: SubAgentToolOptions): AgentTool<typeof subagentSchema, SubAgentToolDetails>;
 export {};
-//# sourceMappingURL=subagent.d.ts.map