@otto-code/server 0.5.0

package/dist/server/server/agent/mcp-server.d.ts

@@ -0,0 +1,5 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { type OttoToolHostDependencies } from "./tools/otto-tools.js";
+export type AgentMcpServerOptions = OttoToolHostDependencies;
+export declare function createAgentMcpServer(options: AgentMcpServerOptions): Promise<McpServer>;
+//# sourceMappingURL=mcp-server.d.ts.map

package/dist/server/server/agent/mcp-server.js

@@ -0,0 +1,66 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { createOttoToolCatalog } from "./tools/otto-tools.js";
+function formatStructuredContentForModel(structuredContent) {
+    if (!structuredContent ||
+        typeof structuredContent !== "object" ||
+        Array.isArray(structuredContent)) {
+        return JSON.stringify(structuredContent, null, 2);
+    }
+    const record = structuredContent;
+    const summary = [];
+    for (const [key, value] of Object.entries(record)) {
+        if (!Array.isArray(value)) {
+            continue;
+        }
+        summary.push(`${key}_count=${value.length}`);
+        const ids = value
+            .map((item) => item && typeof item === "object" && !Array.isArray(item)
+            ? item.id
+            : null)
+            .filter((id) => typeof id === "string" && id.length > 0);
+        if (ids.length === value.length && ids.length > 0) {
+            summary.push(`${key}_ids=${ids.join(",")}`);
+        }
+    }
+    const json = JSON.stringify(structuredContent, null, 2);
+    return summary.length > 0 ? `${summary.join("\n")}\n\n${json}` : json;
+}
+function addModelVisibleStructuredContent(result) {
+    if (result.structuredContent === undefined || result.content.length > 0) {
+        return result;
+    }
+    return {
+        ...result,
+        content: [
+            {
+                type: "text",
+                text: formatStructuredContentForModel(result.structuredContent),
+            },
+        ],
+    };
+}
+function toMcpToolResult(result) {
+    return addModelVisibleStructuredContent({
+        content: result.content,
+        ...(result.structuredContent !== undefined
+            ? { structuredContent: result.structuredContent }
+            : {}),
+        ...(result.isError !== undefined ? { isError: result.isError } : {}),
+    });
+}
+export async function createAgentMcpServer(options) {
+    const catalog = await createOttoToolCatalog(options);
+    const server = new McpServer({
+        name: "agent-mcp",
+        version: "2.0.0",
+    });
+    for (const tool of catalog.tools.values()) {
+        server.registerTool(tool.name, {
+            title: tool.title,
+            description: tool.description,
+            inputSchema: tool.inputSchema,
+        }, async (args, context) => toMcpToolResult(await catalog.executeTool(tool.name, args, { signal: context?.signal })));
+    }
+    return server;
+}
+//# sourceMappingURL=mcp-server.js.map

package/dist/server/server/agent/mcp-shared.d.ts

@@ -0,0 +1,192 @@
+import { z } from "zod";
+import type { Logger } from "pino";
+import type { AgentPermissionRequest } from "./agent-sdk-types.js";
+import type { AgentManager, ManagedAgent, WaitForAgentResult } from "./agent-manager.js";
+import type { AgentStorage } from "./agent-storage.js";
+import { StoredScheduleSchema } from "@otto-code/protocol/schedule/types";
+import type { AgentProvider } from "./agent-sdk-types.js";
+export declare const AgentProviderEnum: z.ZodString;
+export declare const AgentStatusEnum: z.ZodEnum<{
+    error: "error";
+    running: "running";
+    initializing: "initializing";
+    idle: "idle";
+    closed: "closed";
+}>;
+export declare const ProviderModeSchema: z.ZodObject<{
+    id: z.ZodString;
+    label: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    description: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    icon: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    colorTier: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    isUnattended: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+}, z.core.$loose>;
+export declare const ProviderSummarySchema: z.ZodObject<{
+    id: z.ZodString;
+    label: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    description: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    enabled: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    modes: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        label: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        description: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        icon: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        colorTier: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        isUnattended: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+    }, z.core.$loose>>>>;
+}, z.core.$loose>;
+export declare const AgentSelectOptionSchema: z.ZodObject<{
+    id: z.ZodString;
+    label: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    description: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    isDefault: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+    metadata: z.ZodOptional<z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+}, z.core.$loose>;
+export declare const AgentModelSchema: z.ZodObject<{
+    provider: z.ZodString;
+    id: z.ZodString;
+    label: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    description: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    isDefault: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+    metadata: z.ZodOptional<z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+    thinkingOptions: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        label: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        description: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        isDefault: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+        metadata: z.ZodOptional<z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+    }, z.core.$loose>>>>;
+    defaultThinkingOptionId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+}, z.core.$loose>;
+export declare const AGENT_WAIT_TIMEOUT_MS = 30000;
+export interface ResolvedProviderModel {
+    provider: AgentProvider;
+    model: string | undefined;
+}
+export declare function resolveRequiredProviderModel(providerValue: string): Required<ResolvedProviderModel>;
+/**
+ * Wraps agentManager.waitForAgentEvent with a self-imposed timeout.
+ * Returns a friendly message when timeout occurs, rather than letting
+ * the SDK tool timeout trigger a generic "tool failed" error.
+ */
+export declare function waitForAgentWithTimeout(agentManager: AgentManager, agentId: string, options?: {
+    signal?: AbortSignal;
+    waitForActive?: boolean;
+}): Promise<WaitForAgentResult>;
+export declare function sanitizePermissionRequest(permission: AgentPermissionRequest): AgentPermissionRequest;
+export declare function sanitizePermissionRequest(permission: null | undefined): null;
+export declare function sanitizePermissionRequest(permission: AgentPermissionRequest | null | undefined): AgentPermissionRequest | null;
+export declare function resolveAgentTitle(agentStorage: AgentStorage, agentId: string, logger: Logger): Promise<string | null>;
+export declare function serializeSnapshotWithMetadata(agentStorage: AgentStorage, snapshot: ManagedAgent, logger: Logger): Promise<{
+    id: string;
+    provider: string;
+    cwd: string;
+    model: string | null;
+    createdAt: string;
+    updatedAt: string;
+    lastUserMessageAt: string | null;
+    status: "error" | "running" | "initializing" | "idle" | "closed";
+    capabilities: import("@otto-code/protocol/agent-types").AgentCapabilityFlags;
+    currentModeId: string | null;
+    availableModes: import("@otto-code/protocol/agent-types").AgentMode[];
+    pendingPermissions: import("@otto-code/protocol/agent-types").AgentPermissionRequest[];
+    persistence: import("@otto-code/protocol/agent-types").AgentPersistenceHandle | null;
+    title: string | null;
+    labels: Record<string, string>;
+    workspaceId?: string | undefined;
+    features?: ({
+        type: "toggle";
+        id: string;
+        label: string;
+        value: boolean;
+        description?: string | undefined;
+        tooltip?: string | undefined;
+        icon?: string | undefined;
+    } | {
+        type: "select";
+        id: string;
+        label: string;
+        value: string | null;
+        options: {
+            id: string;
+            label: string;
+            description?: string | undefined;
+            isDefault?: boolean | undefined;
+            metadata?: Record<string, unknown> | undefined;
+        }[];
+        description?: string | undefined;
+        tooltip?: string | undefined;
+        icon?: string | undefined;
+    })[] | undefined;
+    thinkingOptionId?: string | null | undefined;
+    effectiveThinkingOptionId?: string | null | undefined;
+    runtimeInfo?: import("@otto-code/protocol/agent-types").AgentRuntimeInfo | undefined;
+    lastUsage?: import("@otto-code/protocol/agent-types").AgentUsage | undefined;
+    lastError?: string | undefined;
+    requiresAttention?: boolean | undefined;
+    attentionReason?: "finished" | "error" | "permission" | null | undefined;
+    attentionTimestamp?: string | null | undefined;
+    archivedAt?: string | null | undefined;
+    providerUnavailable?: boolean | undefined;
+    attend?: "attended" | "observed" | undefined;
+    personalitySpinner?: {
+        [x: string]: unknown;
+        glowA: string;
+        glowB: string;
+    } | undefined;
+    personalityName?: string | undefined;
+    personalityId?: string | undefined;
+}>;
+export declare function parseDurationString(input: string): number;
+export declare function toScheduleSummary(schedule: z.infer<typeof StoredScheduleSchema>): {
+    id: string;
+    name: string | null;
+    prompt: string;
+    cadence: {
+        type: "every";
+        everyMs: number;
+    } | {
+        type: "cron";
+        expression: string;
+        timezone?: string | undefined;
+    };
+    target: {
+        type: "agent";
+        agentId: string;
+    } | {
+        type: "new-agent";
+        config: {
+            provider: string;
+            cwd: string;
+            personality?: string | undefined;
+            modeId?: string | undefined;
+            model?: string | undefined;
+            thinkingOptionId?: string | undefined;
+            archiveOnFinish?: boolean | undefined;
+            isolation?: "worktree" | "local" | undefined;
+            title?: string | null | undefined;
+            approvalPolicy?: string | undefined;
+            sandboxMode?: string | undefined;
+            networkAccess?: boolean | undefined;
+            webSearch?: boolean | undefined;
+            featureValues?: Record<string, unknown> | undefined;
+            extra?: {
+                codex?: Record<string, unknown> | undefined;
+                claude?: Record<string, unknown> | undefined;
+            } | undefined;
+            systemPrompt?: string | undefined;
+            mcpServers?: Record<string, unknown> | undefined;
+        };
+    };
+    status: "completed" | "active" | "paused";
+    createdAt: string;
+    updatedAt: string;
+    nextRunAt: string | null;
+    lastRunAt: string | null;
+    pausedAt: string | null;
+    expiresAt: string | null;
+    maxRuns: number | null;
+    lastRunStatus?: "failed" | "succeeded" | null | undefined;
+    lastRunError?: string | null | undefined;
+};
+//# sourceMappingURL=mcp-shared.d.ts.map

package/dist/server/server/agent/mcp-shared.js

@@ -0,0 +1,201 @@
+import { z } from "zod";
+import { curateAgentActivity } from "./activity-curator.js";
+import { selectItemsByProjectedLimit } from "./timeline-projection.js";
+import { serializeAgentSnapshot } from "../messages.js";
+export const AgentProviderEnum = z.string();
+export const AgentStatusEnum = z.enum(["initializing", "idle", "running", "error", "closed"]);
+export const ProviderModeSchema = z
+    .object({
+    id: z.string(),
+    label: z.string().nullish(),
+    description: z.string().nullish(),
+    icon: z.string().nullish(),
+    colorTier: z.string().nullish(),
+    // True for bypass/no-approval modes. Declared (not just passthrough) so
+    // calling agents can see which modes are valid for unattended work such
+    // as create_artifact's modeId.
+    isUnattended: z.boolean().nullish(),
+})
+    .passthrough();
+export const ProviderSummarySchema = z
+    .object({
+    id: z.string(),
+    label: z.string().nullish(),
+    description: z.string().nullish(),
+    enabled: z.boolean().optional().default(true),
+    modes: z.array(ProviderModeSchema).nullish(),
+})
+    .passthrough();
+export const AgentSelectOptionSchema = z
+    .object({
+    id: z.string(),
+    label: z.string().nullish(),
+    description: z.string().nullish(),
+    isDefault: z.boolean().nullish(),
+    metadata: z.record(z.string(), z.unknown()).nullish(),
+})
+    .passthrough();
+export const AgentModelSchema = z
+    .object({
+    provider: z.string(),
+    id: z.string(),
+    label: z.string().nullish(),
+    description: z.string().nullish(),
+    isDefault: z.boolean().nullish(),
+    metadata: z.record(z.string(), z.unknown()).nullish(),
+    thinkingOptions: z.array(AgentSelectOptionSchema).nullish(),
+    defaultThinkingOptionId: z.string().nullish(),
+})
+    .passthrough();
+// 30 seconds - surface friendly message before SDK tool timeout (~60s)
+export const AGENT_WAIT_TIMEOUT_MS = 30000;
+export function resolveRequiredProviderModel(providerValue) {
+    const providerInput = providerValue.trim();
+    const slashIndex = providerInput.indexOf("/");
+    if (slashIndex <= 0 || slashIndex === providerInput.length - 1) {
+        throw new Error("provider must be provider/model, for example codex/gpt-5.4");
+    }
+    const provider = providerInput.slice(0, slashIndex).trim();
+    const model = providerInput.slice(slashIndex + 1).trim();
+    if (!provider || !model) {
+        throw new Error("provider must be provider/model, for example codex/gpt-5.4");
+    }
+    return {
+        provider: provider,
+        model,
+    };
+}
+/**
+ * Wraps agentManager.waitForAgentEvent with a self-imposed timeout.
+ * Returns a friendly message when timeout occurs, rather than letting
+ * the SDK tool timeout trigger a generic "tool failed" error.
+ */
+export async function waitForAgentWithTimeout(agentManager, agentId, options) {
+    const timeoutController = new AbortController();
+    const combinedController = new AbortController();
+    const timeoutId = setTimeout(() => {
+        timeoutController.abort(new Error("wait timeout"));
+    }, AGENT_WAIT_TIMEOUT_MS);
+    const forwardAbort = (reason) => {
+        if (!combinedController.signal.aborted) {
+            combinedController.abort(reason);
+        }
+    };
+    if (options?.signal) {
+        if (options.signal.aborted) {
+            forwardAbort(options.signal.reason);
+        }
+        else {
+            options.signal.addEventListener("abort", () => forwardAbort(options.signal.reason), {
+                once: true,
+            });
+        }
+    }
+    timeoutController.signal.addEventListener("abort", () => forwardAbort(timeoutController.signal.reason), { once: true });
+    try {
+        const result = await agentManager.waitForAgentEvent(agentId, {
+            signal: combinedController.signal,
+            waitForActive: options?.waitForActive,
+        });
+        return result;
+    }
+    catch (error) {
+        if (error instanceof Error && error.message === "wait timeout") {
+            const snapshot = agentManager.getAgent(agentId);
+            const timeline = agentManager.getTimeline(agentId);
+            const recent = selectItemsByProjectedLimit({
+                items: timeline,
+                direction: "tail",
+                limit: 5,
+            });
+            const recentActivity = curateAgentActivity(recent.items);
+            const waitedSeconds = Math.round(AGENT_WAIT_TIMEOUT_MS / 1000);
+            const message = `Awaiting the agent timed out after ${waitedSeconds}s. This does not mean the agent failed - it is still running. Call get_agent_status to check on it, or continue with other work if you will receive a finish notification.\n\nRecent activity:\n${recentActivity}`;
+            return {
+                status: snapshot?.lifecycle ?? "idle",
+                permission: null,
+                lastMessage: message,
+            };
+        }
+        throw error;
+    }
+    finally {
+        clearTimeout(timeoutId);
+    }
+}
+export function sanitizePermissionRequest(permission) {
+    if (!permission) {
+        return null;
+    }
+    const sanitized = { ...permission };
+    if (sanitized.title === undefined) {
+        delete sanitized.title;
+    }
+    if (sanitized.description === undefined) {
+        delete sanitized.description;
+    }
+    if (sanitized.input === undefined) {
+        delete sanitized.input;
+    }
+    if (sanitized.detail === undefined) {
+        delete sanitized.detail;
+    }
+    if (sanitized.suggestions === undefined) {
+        delete sanitized.suggestions;
+    }
+    if (sanitized.actions === undefined) {
+        delete sanitized.actions;
+    }
+    if (sanitized.metadata === undefined) {
+        delete sanitized.metadata;
+    }
+    return sanitized;
+}
+export async function resolveAgentTitle(agentStorage, agentId, logger) {
+    try {
+        const record = await agentStorage.get(agentId);
+        return record?.title ?? null;
+    }
+    catch (error) {
+        logger.error({ err: error, agentId }, "Failed to load agent title");
+        return null;
+    }
+}
+export async function serializeSnapshotWithMetadata(agentStorage, snapshot, logger) {
+    const title = await resolveAgentTitle(agentStorage, snapshot.id, logger);
+    return serializeAgentSnapshot(snapshot, { title });
+}
+export function parseDurationString(input) {
+    const trimmed = input.trim();
+    if (/^\d+$/.test(trimmed)) {
+        return Number.parseInt(trimmed, 10) * 1000;
+    }
+    let totalMs = 0;
+    let hasMatch = false;
+    const regex = /(\d+)([smh])/g;
+    let match;
+    while ((match = regex.exec(trimmed)) !== null) {
+        hasMatch = true;
+        const value = Number.parseInt(match[1], 10);
+        switch (match[2]) {
+            case "s":
+                totalMs += value * 1000;
+                break;
+            case "m":
+                totalMs += value * 60 * 1000;
+                break;
+            case "h":
+                totalMs += value * 60 * 60 * 1000;
+                break;
+        }
+    }
+    if (!hasMatch) {
+        throw new Error(`Invalid duration format: ${input}. Use formats like: 5m, 30s, 1h, 2h30m`);
+    }
+    return totalMs;
+}
+export function toScheduleSummary(schedule) {
+    const { runs: _runs, ...summary } = schedule;
+    return summary;
+}
+//# sourceMappingURL=mcp-shared.js.map

package/dist/server/server/agent/pcm16-resampler.d.ts

@@ -0,0 +1,14 @@
+export declare class Pcm16MonoResampler {
+    private readonly inputRate;
+    private readonly outputRate;
+    private readonly step;
+    private pos;
+    private carrySample;
+    constructor(params: {
+        inputRate: number;
+        outputRate: number;
+    });
+    reset(): void;
+    processChunk(pcm16le: Buffer): Buffer;
+}
+//# sourceMappingURL=pcm16-resampler.d.ts.map

package/dist/server/server/agent/pcm16-resampler.js

@@ -0,0 +1,63 @@
+export class Pcm16MonoResampler {
+    constructor(params) {
+        this.inputRate = params.inputRate;
+        this.outputRate = params.outputRate;
+        this.step = this.inputRate / this.outputRate;
+        this.pos = 0;
+        this.carrySample = null;
+    }
+    reset() {
+        this.pos = 0;
+        this.carrySample = null;
+    }
+    processChunk(pcm16le) {
+        if (pcm16le.length === 0) {
+            return Buffer.alloc(0);
+        }
+        if (pcm16le.length % 2 !== 0) {
+            throw new Error(`PCM16 chunk byteLength must be even, got ${pcm16le.length}`);
+        }
+        const srcChunk = new Int16Array(pcm16le.buffer, pcm16le.byteOffset, pcm16le.byteLength / 2);
+        const hasCarry = this.carrySample !== null;
+        const srcLen = srcChunk.length + (hasCarry ? 1 : 0);
+        if (srcLen < 2) {
+            this.carrySample = srcChunk.length ? srcChunk[srcChunk.length - 1] : this.carrySample;
+            return Buffer.alloc(0);
+        }
+        const src = new Float32Array(srcLen);
+        let offset = 0;
+        if (hasCarry) {
+            src[0] = this.carrySample / 32768;
+            offset = 1;
+        }
+        for (let i = 0; i < srcChunk.length; i += 1) {
+            src[offset + i] = srcChunk[i] / 32768;
+        }
+        const out = [];
+        const maxPos = src.length - 1;
+        while (this.pos < maxPos) {
+            const i = Math.floor(this.pos);
+            const frac = this.pos - i;
+            const s0 = src[i];
+            const s1 = src[i + 1];
+            const sample = s0 + (s1 - s0) * frac;
+            const clamped = Math.max(-1, Math.min(1, sample));
+            const int16 = Math.round(clamped * 32767);
+            out.push(int16);
+            this.pos += this.step;
+        }
+        // Keep the last input sample as carry for the next chunk.
+        const lastInput = srcChunk[srcChunk.length - 1];
+        this.carrySample = lastInput;
+        // Shift position so next chunk (which will include carry sample) continues smoothly.
+        const shift = src.length - 1;
+        this.pos = this.pos - shift;
+        if (this.pos < 0) {
+            // Guard against floating point drift.
+            this.pos = 0;
+        }
+        const outArr = Int16Array.from(out);
+        return Buffer.from(outArr.buffer, outArr.byteOffset, outArr.byteLength);
+    }
+}
+//# sourceMappingURL=pcm16-resampler.js.map

package/dist/server/server/agent/permission-response.d.ts

@@ -0,0 +1,15 @@
+import type { Logger } from "pino";
+import type { AgentPermissionResponse, AgentPermissionResult } from "./agent-sdk-types.js";
+import { type AgentRunController } from "./agent-prompt.js";
+export interface PermissionResponseAgentManager extends AgentRunController {
+    respondToPermission(agentId: string, requestId: string, response: AgentPermissionResponse): Promise<AgentPermissionResult | void>;
+}
+export interface RespondToAgentPermissionParams {
+    agentManager: PermissionResponseAgentManager;
+    agentId: string;
+    requestId: string;
+    response: AgentPermissionResponse;
+    logger: Logger;
+}
+export declare function respondToAgentPermission(params: RespondToAgentPermissionParams): Promise<void>;
+//# sourceMappingURL=permission-response.d.ts.map

package/dist/server/server/agent/permission-response.js

@@ -0,0 +1,14 @@
+import { startAgentRun } from "./agent-prompt.js";
+export async function respondToAgentPermission(params) {
+    const { agentManager, agentId, requestId, response, logger } = params;
+    logger.debug({ agentId, requestId }, `Handling permission response for agent ${agentId}, request ${requestId}`);
+    const result = await agentManager.respondToPermission(agentId, requestId, response);
+    logger.debug({ agentId }, `Permission response forwarded to agent ${agentId}`);
+    if (result?.followUpPrompt) {
+        logger.debug({ agentId }, "Permission response requires follow-up turn, starting agent stream");
+        startAgentRun(agentManager, agentId, result.followUpPrompt, logger, {
+            replaceRunning: true,
+        });
+    }
+}
+//# sourceMappingURL=permission-response.js.map

package/dist/server/server/agent/personality-stats-store.d.ts

@@ -0,0 +1,23 @@
+import type { Logger } from "pino";
+/** Per-personality spawn counts, keyed by personality id. */
+export type PersonalityUsageStats = Record<string, number>;
+/**
+ * A tiny file-backed counter for personality spawns. Kept OUT of the daemon
+ * config on purpose: config writes fire the `status:daemon_config_changed`
+ * broadcast, and incrementing on every spawn would spam it. This lives in its
+ * own JSON file with atomic writes and a serialized read-modify-write queue so
+ * concurrent spawns can't lose increments.
+ */
+export declare class PersonalityStatsStore {
+    private readonly filePath;
+    private cache;
+    private queue;
+    private readonly logger?;
+    constructor(filePath: string, logger?: Logger);
+    private load;
+    /** A snapshot copy of the current counts. */
+    get(): Promise<PersonalityUsageStats>;
+    /** Increment one personality's spawn count, persisting atomically. */
+    increment(personalityId: string): Promise<void>;
+}
+//# sourceMappingURL=personality-stats-store.d.ts.map

package/dist/server/server/agent/personality-stats-store.js

@@ -0,0 +1,65 @@
+import { readFile } from "node:fs/promises";
+import { writeJsonFileAtomic } from "../atomic-file.js";
+/**
+ * A tiny file-backed counter for personality spawns. Kept OUT of the daemon
+ * config on purpose: config writes fire the `status:daemon_config_changed`
+ * broadcast, and incrementing on every spawn would spam it. This lives in its
+ * own JSON file with atomic writes and a serialized read-modify-write queue so
+ * concurrent spawns can't lose increments.
+ */
+export class PersonalityStatsStore {
+    constructor(filePath, logger) {
+        this.filePath = filePath;
+        this.cache = null;
+        this.queue = Promise.resolve();
+        this.logger = logger?.child({ component: "personality-stats-store" });
+    }
+    async load() {
+        if (this.cache) {
+            return this.cache;
+        }
+        try {
+            const raw = await readFile(this.filePath, "utf8");
+            this.cache = sanitizeStats(JSON.parse(raw));
+        }
+        catch (error) {
+            if (error.code !== "ENOENT") {
+                this.logger?.warn({ err: error }, "Failed to read personality stats; starting empty");
+            }
+            this.cache = {};
+        }
+        return this.cache;
+    }
+    /** A snapshot copy of the current counts. */
+    async get() {
+        return { ...(await this.load()) };
+    }
+    /** Increment one personality's spawn count, persisting atomically. */
+    increment(personalityId) {
+        this.queue = this.queue.then(async () => {
+            const stats = await this.load();
+            stats[personalityId] = (stats[personalityId] ?? 0) + 1;
+            try {
+                await writeJsonFileAtomic(this.filePath, stats);
+            }
+            catch (error) {
+                this.logger?.warn({ err: error, personalityId }, "Failed to persist personality stats");
+            }
+            return undefined;
+        });
+        return this.queue;
+    }
+}
+function sanitizeStats(value) {
+    if (!value || typeof value !== "object") {
+        return {};
+    }
+    const out = {};
+    for (const [key, count] of Object.entries(value)) {
+        if (typeof count === "number" && Number.isFinite(count) && count >= 0) {
+            out[key] = count;
+        }
+    }
+    return out;
+}
+//# sourceMappingURL=personality-stats-store.js.map

package/dist/server/server/agent/prompt-attachments.d.ts

@@ -0,0 +1,7 @@
+import type { AgentAttachment } from "@otto-code/protocol/messages";
+export declare function renderPromptAttachmentAsText(attachment: AgentAttachment): string;
+export declare function buildAgentBranchNameSeed(firstAgentContext: {
+    prompt?: string;
+    attachments?: readonly AgentAttachment[];
+} | undefined): string | undefined;
+//# sourceMappingURL=prompt-attachments.d.ts.map