@otto-code/server 0.5.0

package/dist/server/server/agent/create-agent-title.js

@@ -0,0 +1,34 @@
+import { MAX_EXPLICIT_AGENT_TITLE_CHARS } from "@otto-code/protocol/agent-title-limits";
+const MAX_INITIAL_AGENT_TITLE_CHARS = Math.min(60, MAX_EXPLICIT_AGENT_TITLE_CHARS);
+function deriveInitialAgentTitle(prompt) {
+    const firstContentLine = prompt
+        .split(/\r?\n/)
+        .map((line) => line.trim())
+        .find((line) => line.length > 0);
+    if (!firstContentLine) {
+        return null;
+    }
+    const normalized = firstContentLine.replace(/\s+/g, " ").trim();
+    if (!normalized) {
+        return null;
+    }
+    const clamped = normalized.slice(0, MAX_INITIAL_AGENT_TITLE_CHARS).trim();
+    return clamped.length > 0 ? clamped : null;
+}
+export function resolveCreateAgentTitles(options) {
+    const explicitTitle = typeof options.configTitle === "string" && options.configTitle.trim().length > 0
+        ? options.configTitle.trim()
+        : null;
+    const trimmedPrompt = options.initialPrompt?.trim();
+    const provisionalTitle = explicitTitle ?? (trimmedPrompt ? deriveInitialAgentTitle(trimmedPrompt) : null);
+    return {
+        explicitTitle,
+        provisionalTitle,
+    };
+}
+export function resolveFirstAgentPromptTitle(firstAgentContext) {
+    return (resolveCreateAgentTitles({
+        initialPrompt: firstAgentContext?.prompt,
+    }).provisionalTitle ?? null);
+}
+//# sourceMappingURL=create-agent-title.js.map

package/dist/server/server/agent/dictation-debug.d.ts

@@ -0,0 +1,13 @@
+import type pino from "pino";
+export interface DictationDebugAudioMetadata {
+    sessionId: string;
+    dictationId: string;
+    format: string;
+}
+export interface DictationDebugChunkWriter {
+    folder: string;
+    writeChunk: (seq: number, pcm16: Buffer) => Promise<void>;
+}
+export declare function createDictationDebugChunkWriter(metadata: Pick<DictationDebugAudioMetadata, "sessionId" | "dictationId">, logger: pino.Logger): DictationDebugChunkWriter | null;
+export declare function maybePersistDictationDebugAudio(audio: Buffer, metadata: DictationDebugAudioMetadata, logger: pino.Logger, chunkWriterFolder?: string | null): Promise<string | null>;
+//# sourceMappingURL=dictation-debug.d.ts.map

package/dist/server/server/agent/dictation-debug.js

@@ -0,0 +1,50 @@
+import { mkdir, writeFile } from "fs/promises";
+import { join } from "path";
+import { inferAudioExtension, sanitizeForFilename } from "./audio-utils.js";
+import { resolveRecordingsDebugDir } from "./recordings-debug.js";
+let announcedDir = null;
+export function createDictationDebugChunkWriter(metadata, logger) {
+    const debugDir = resolveRecordingsDebugDir("DICTATION_DEBUG_AUDIO_DIR");
+    if (!debugDir) {
+        return null;
+    }
+    if (announcedDir !== debugDir) {
+        logger.info({ debugDir }, "Dictation audio capture enabled");
+        announcedDir = debugDir;
+    }
+    const timestamp = new Date().toISOString().replace(/[:.]/g, "-");
+    const folder = join(debugDir, sanitizeForFilename(metadata.sessionId, "session"), `${timestamp}_${sanitizeForFilename(metadata.dictationId, "dictation")}`);
+    let folderCreated = false;
+    return {
+        folder,
+        writeChunk: async (seq, pcm16) => {
+            if (!folderCreated) {
+                await mkdir(folder, { recursive: true });
+                folderCreated = true;
+            }
+            const paddedSeq = String(seq).padStart(6, "0");
+            const filePath = join(folder, `chunk_${paddedSeq}.pcm`);
+            await writeFile(filePath, pcm16);
+        },
+    };
+}
+export async function maybePersistDictationDebugAudio(audio, metadata, logger, chunkWriterFolder) {
+    const debugDir = resolveRecordingsDebugDir("DICTATION_DEBUG_AUDIO_DIR");
+    if (!debugDir) {
+        return null;
+    }
+    if (announcedDir !== debugDir) {
+        logger.info({ debugDir }, "Dictation audio capture enabled");
+        announcedDir = debugDir;
+    }
+    const timestamp = new Date().toISOString().replace(/[:.]/g, "-");
+    const folder = chunkWriterFolder ?? join(debugDir, sanitizeForFilename(metadata.sessionId, "session"));
+    await mkdir(folder, { recursive: true });
+    const filename = chunkWriterFolder
+        ? `combined.${inferAudioExtension(metadata.format)}`
+        : `${timestamp}_${sanitizeForFilename(metadata.dictationId, "dictation")}.${inferAudioExtension(metadata.format)}`;
+    const filePath = join(folder, filename);
+    await writeFile(filePath, audio);
+    return filePath;
+}
+//# sourceMappingURL=dictation-debug.js.map

package/dist/server/server/agent/effort-levels.d.ts

@@ -0,0 +1,2 @@
+export { EFFORT_LEVELS as EFFORT_LEVEL_SCALE, EffortResolutionError, parseEffortLevel, resolveEffortOption, type EffortLevel, type ResolvedEffortOption, } from "@otto-code/protocol/effort";
+//# sourceMappingURL=effort-levels.d.ts.map

package/dist/server/server/agent/effort-levels.js

@@ -0,0 +1,7 @@
+// Effort resolution now lives in the protocol package so the daemon, app, and
+// agent personalities all share one implementation (personality effort auto-fill
+// in the app pickers resolves the same way the daemon does at spawn). This module
+// stays as the daemon-side entry point; importers keep their `./effort-levels.js`
+// paths.
+export { EFFORT_LEVELS as EFFORT_LEVEL_SCALE, EffortResolutionError, parseEffortLevel, resolveEffortOption, } from "@otto-code/protocol/effort";
+//# sourceMappingURL=effort-levels.js.map

package/dist/server/server/agent/foreground-run-state.d.ts

@@ -0,0 +1,50 @@
+import { type AgentStreamEvent } from "./agent-sdk-types.js";
+export interface ForegroundTurnWaiter {
+    turnId: string;
+    callback: (event: AgentStreamEvent) => void;
+    settled: boolean;
+    settledPromise: Promise<void>;
+    resolveSettled: () => void;
+}
+export interface PendingForegroundRun {
+    token: string;
+    started: boolean;
+    settled: boolean;
+    settledPromise: Promise<void>;
+    resolveSettled: () => void;
+}
+export interface ForegroundRunAgentState {
+    foregroundTurnWaiters: Set<ForegroundTurnWaiter>;
+    finalizedForegroundTurnIds: Set<string>;
+}
+export declare class ForegroundRunState {
+    private readonly pendingRuns;
+    createPendingRun(agentId: string): PendingForegroundRun;
+    getPendingRun(agentId: string): PendingForegroundRun | null;
+    hasPendingRun(agentId: string): boolean;
+    settlePendingRun(agentId: string, token?: string): void;
+    createTurnStream(turnId: string): ForegroundTurnStream;
+    addWaiter(agent: ForegroundRunAgentState, waiter: ForegroundTurnWaiter): void;
+    deleteWaiter(agent: ForegroundRunAgentState, waiter: ForegroundTurnWaiter): void;
+    settleWaiter(waiter: ForegroundTurnWaiter): void;
+    getMatchingWaiters(agent: ForegroundRunAgentState, turnId: string | undefined): ForegroundTurnWaiter[];
+    notifyWaiters(waiters: Iterable<ForegroundTurnWaiter>, event: AgentStreamEvent, options: {
+        terminal: boolean;
+    }): void;
+    notifyAgentWaiters(agent: ForegroundRunAgentState, event: AgentStreamEvent, options?: {
+        terminal?: boolean;
+    }): void;
+    cancelWaiters(agent: ForegroundRunAgentState, createEvent: (turnId: string) => AgentStreamEvent): void;
+    clearAgent(agentId: string, agent: ForegroundRunAgentState): void;
+    rememberFinalizedTurn(agent: ForegroundRunAgentState, turnId: string): void;
+    hasFinalizedTurn(agent: ForegroundRunAgentState, turnId: string): boolean;
+}
+export declare class ForegroundTurnStream {
+    private readonly queue;
+    private queueResolve;
+    readonly waiter: ForegroundTurnWaiter;
+    constructor(turnId: string);
+    events(isTerminalEvent: (event: AgentStreamEvent) => boolean): AsyncGenerator<AgentStreamEvent>;
+    private wake;
+}
+//# sourceMappingURL=foreground-run-state.d.ts.map

package/dist/server/server/agent/foreground-run-state.js

@@ -0,0 +1,160 @@
+import { randomUUID } from "node:crypto";
+import { getAgentStreamEventTurnId } from "./agent-sdk-types.js";
+export class ForegroundRunState {
+    constructor() {
+        this.pendingRuns = new Map();
+    }
+    createPendingRun(agentId) {
+        const pendingRun = createPendingForegroundRun();
+        this.pendingRuns.set(agentId, pendingRun);
+        return pendingRun;
+    }
+    getPendingRun(agentId) {
+        return this.pendingRuns.get(agentId) ?? null;
+    }
+    hasPendingRun(agentId) {
+        return this.pendingRuns.has(agentId);
+    }
+    settlePendingRun(agentId, token) {
+        const pendingRun = this.pendingRuns.get(agentId);
+        if (!pendingRun) {
+            return;
+        }
+        if (token && pendingRun.token !== token) {
+            return;
+        }
+        this.pendingRuns.delete(agentId);
+        settlePendingForegroundRun(pendingRun);
+    }
+    createTurnStream(turnId) {
+        return new ForegroundTurnStream(turnId);
+    }
+    addWaiter(agent, waiter) {
+        agent.foregroundTurnWaiters.add(waiter);
+    }
+    deleteWaiter(agent, waiter) {
+        agent.foregroundTurnWaiters.delete(waiter);
+        this.settleWaiter(waiter);
+    }
+    settleWaiter(waiter) {
+        if (waiter.settled) {
+            return;
+        }
+        waiter.settled = true;
+        waiter.resolveSettled();
+    }
+    getMatchingWaiters(agent, turnId) {
+        if (turnId == null) {
+            return [];
+        }
+        return Array.from(agent.foregroundTurnWaiters).filter((waiter) => waiter.turnId === turnId && !waiter.settled);
+    }
+    notifyWaiters(waiters, event, options) {
+        for (const waiter of waiters) {
+            waiter.callback(event);
+            if (options.terminal) {
+                this.settleWaiter(waiter);
+            }
+        }
+    }
+    notifyAgentWaiters(agent, event, options) {
+        const waiters = this.getMatchingWaiters(agent, getAgentStreamEventTurnId(event));
+        this.notifyWaiters(waiters, event, { terminal: options?.terminal ?? false });
+    }
+    cancelWaiters(agent, createEvent) {
+        for (const waiter of agent.foregroundTurnWaiters) {
+            waiter.callback(createEvent(waiter.turnId));
+            this.settleWaiter(waiter);
+        }
+        agent.foregroundTurnWaiters.clear();
+    }
+    clearAgent(agentId, agent) {
+        for (const waiter of agent.foregroundTurnWaiters) {
+            this.settleWaiter(waiter);
+        }
+        agent.foregroundTurnWaiters.clear();
+        this.settlePendingRun(agentId);
+    }
+    rememberFinalizedTurn(agent, turnId) {
+        agent.finalizedForegroundTurnIds.add(turnId);
+        if (agent.finalizedForegroundTurnIds.size <= 50) {
+            return;
+        }
+        const oldest = agent.finalizedForegroundTurnIds.values().next().value;
+        if (oldest) {
+            agent.finalizedForegroundTurnIds.delete(oldest);
+        }
+    }
+    hasFinalizedTurn(agent, turnId) {
+        return agent.finalizedForegroundTurnIds.has(turnId);
+    }
+}
+export class ForegroundTurnStream {
+    constructor(turnId) {
+        this.queue = [];
+        this.queueResolve = null;
+        let resolveSettled;
+        const settledPromise = new Promise((resolvePromise) => {
+            resolveSettled = resolvePromise;
+        });
+        this.waiter = {
+            turnId,
+            settled: false,
+            settledPromise,
+            resolveSettled,
+            callback: (event) => {
+                this.queue.push(event);
+                this.wake();
+            },
+        };
+    }
+    async *events(isTerminalEvent) {
+        let done = false;
+        while (!done) {
+            while (this.queue.length > 0) {
+                const event = this.queue.shift();
+                yield event;
+                if (isTerminalEvent(event)) {
+                    done = true;
+                    break;
+                }
+            }
+            if (!done && this.queue.length === 0) {
+                if (this.waiter.settled) {
+                    break;
+                }
+                await new Promise((resolvePromise) => {
+                    this.queueResolve = resolvePromise;
+                });
+            }
+        }
+    }
+    wake() {
+        if (!this.queueResolve) {
+            return;
+        }
+        this.queueResolve();
+        this.queueResolve = null;
+    }
+}
+function createPendingForegroundRun() {
+    let resolveSettled;
+    const settledPromise = new Promise((resolvePromise) => {
+        resolveSettled = resolvePromise;
+    });
+    return {
+        token: randomUUID(),
+        started: false,
+        settled: false,
+        settledPromise,
+        resolveSettled,
+    };
+}
+function settlePendingForegroundRun(pendingRun) {
+    if (pendingRun.settled) {
+        return;
+    }
+    pendingRun.settled = true;
+    pendingRun.resolveSettled();
+}
+//# sourceMappingURL=foreground-run-state.js.map

package/dist/server/server/agent/import-sessions.d.ts

@@ -0,0 +1,47 @@
+import type { z } from "zod";
+import type { Logger } from "pino";
+import type { ProviderSnapshotManager } from "./provider-snapshot-manager.js";
+import type { AgentManager, ManagedAgent } from "./agent-manager.js";
+import type { AgentStorage } from "./agent-storage.js";
+import type { AgentProvider } from "./agent-sdk-types.js";
+import type { FetchRecentProviderSessionsRequestMessage, ImportAgentRequestMessageSchema, RecentProviderSessionDescriptorPayload } from "@otto-code/protocol/messages";
+type ImportAgentRequestMessage = z.infer<typeof ImportAgentRequestMessageSchema>;
+export interface NormalizedImportAgentRequest {
+    provider: AgentProvider;
+    providerHandleId: string;
+    cwd?: string;
+    labels?: Record<string, string>;
+    requestId: string;
+}
+export declare class ImportSessionsRequestError extends Error {
+    readonly code: string;
+    constructor(code: string, message: string);
+}
+export interface ListImportableProviderSessionsInput {
+    request: FetchRecentProviderSessionsRequestMessage;
+    agentManager: Pick<AgentManager, "listAgents" | "listImportableSessions">;
+    agentStorage: Pick<AgentStorage, "list">;
+    providerSnapshotManager: Pick<ProviderSnapshotManager, "getProviderLabel">;
+}
+export interface ListImportableProviderSessionsResult {
+    entries: RecentProviderSessionDescriptorPayload[];
+    filteredAlreadyImportedCount: number;
+}
+export interface ImportProviderSessionInput {
+    request: NormalizedImportAgentRequest;
+    workspaceId: string;
+    agentManager: AgentManager;
+    agentStorage: AgentStorage;
+    logger: Logger;
+}
+export interface ImportProviderSessionResult {
+    snapshot: ManagedAgent;
+    timelineSize: number;
+}
+export declare function normalizeImportAgentRequest(msg: ImportAgentRequestMessage): NormalizedImportAgentRequest | {
+    error: string;
+};
+export declare function listImportableProviderSessions(input: ListImportableProviderSessionsInput): Promise<ListImportableProviderSessionsResult>;
+export declare function importProviderSession(input: ImportProviderSessionInput): Promise<ImportProviderSessionResult>;
+export {};
+//# sourceMappingURL=import-sessions.d.ts.map

package/dist/server/server/agent/import-sessions.js

@@ -0,0 +1,145 @@
+import { unarchiveAgentState } from "./agent-prompt.js";
+import { toRecentProviderSessionDescriptorPayload } from "./agent-projections.js";
+import { createRealpathAwarePathMatcher } from "../../utils/path.js";
+const METADATA_GENERATION_PROMPT_PREFIX = "Generate metadata for a coding agent based on the user prompt.";
+export class ImportSessionsRequestError extends Error {
+    constructor(code, message) {
+        super(message);
+        this.code = code;
+        this.name = "ImportSessionsRequestError";
+    }
+}
+// COMPAT(import-agent-request-v1): accept legacy {provider, sessionId} shape
+// alongside the new {providerId, providerHandleId} shape. Old clients
+// (< target daemon floor) send the legacy fields. Drop the fallbacks and the
+// .optional() in messages.ts when the supported client floor is >= the daemon
+// version that ships the new shape (target: 2026-11-08).
+export function normalizeImportAgentRequest(msg) {
+    const provider = msg.providerId ?? msg.provider;
+    const providerHandleId = msg.providerHandleId ?? msg.sessionId;
+    if (!provider || !providerHandleId) {
+        return { error: "Import requires providerId and providerHandleId" };
+    }
+    return {
+        provider: provider,
+        providerHandleId,
+        cwd: msg.cwd,
+        labels: msg.labels,
+        requestId: msg.requestId,
+    };
+}
+export async function listImportableProviderSessions(input) {
+    const { request, agentManager, agentStorage, providerSnapshotManager } = input;
+    const limit = request.limit ?? 20;
+    const sinceTimestamp = parseRecentProviderSessionsSince(request.since);
+    const providerFilter = request.providers ? new Set(request.providers) : undefined;
+    const importedHandles = await collectImportedProviderSessionHandles(agentManager, agentStorage);
+    const sessions = await agentManager.listImportableSessions({
+        limit,
+        providerFilter,
+        cwd: request.cwd,
+    });
+    let filteredAlreadyImportedCount = 0;
+    const candidates = [];
+    const matchesRequestCwd = request.cwd ? createRealpathAwarePathMatcher(request.cwd) : null;
+    for (const session of sessions) {
+        if (matchesRequestCwd && !matchesRequestCwd(session.cwd)) {
+            continue;
+        }
+        if (sinceTimestamp !== null && session.lastActivityAt.getTime() < sinceTimestamp) {
+            continue;
+        }
+        if (isMetadataGenerationSession(session)) {
+            continue;
+        }
+        if (importedHandles.has(toProviderSessionHandleKey(session.provider, session.providerHandleId))) {
+            filteredAlreadyImportedCount += 1;
+            continue;
+        }
+        candidates.push(session);
+    }
+    const entries = candidates
+        .sort((a, b) => b.lastActivityAt.getTime() - a.lastActivityAt.getTime())
+        .slice(0, limit)
+        .map((descriptor) => toRecentProviderSessionDescriptorPayload(descriptor, {
+        providerLabel: providerSnapshotManager.getProviderLabel(descriptor.provider),
+    }));
+    return { entries, filteredAlreadyImportedCount };
+}
+export async function importProviderSession(input) {
+    const { provider, providerHandleId, cwd, labels } = input.request;
+    if (!cwd) {
+        throw new Error("Import requires cwd from the selected provider session");
+    }
+    const handle = buildImportPersistenceHandle({ provider, providerHandleId, cwd });
+    await unarchiveAgentByHandle(input.agentStorage, input.agentManager, handle);
+    const snapshot = await input.agentManager.importProviderSession({
+        provider,
+        providerHandleId,
+        cwd,
+        workspaceId: input.workspaceId,
+        labels,
+    });
+    await unarchiveAgentState(input.agentStorage, input.agentManager, snapshot.id);
+    return {
+        snapshot,
+        timelineSize: input.agentManager.getTimeline(snapshot.id).length,
+    };
+}
+async function unarchiveAgentByHandle(agentStorage, agentManager, handle) {
+    const records = await agentStorage.list();
+    const matched = records.find((record) => record.persistence?.provider === handle.provider &&
+        (record.persistence.sessionId === handle.sessionId ||
+            record.persistence.nativeHandle === handle.nativeHandle));
+    if (!matched) {
+        return;
+    }
+    await unarchiveAgentState(agentStorage, agentManager, matched.id);
+}
+function parseRecentProviderSessionsSince(since) {
+    if (!since) {
+        return null;
+    }
+    const timestamp = Date.parse(since);
+    if (Number.isNaN(timestamp)) {
+        throw new ImportSessionsRequestError("invalid_since", "Invalid recent provider sessions since");
+    }
+    return timestamp;
+}
+function buildImportPersistenceHandle(input) {
+    return {
+        provider: input.provider,
+        sessionId: input.providerHandleId,
+        nativeHandle: input.providerHandleId,
+        metadata: {
+            provider: input.provider,
+            cwd: input.cwd,
+        },
+    };
+}
+async function collectImportedProviderSessionHandles(agentManager, agentStorage) {
+    const handles = new Set();
+    for (const agent of agentManager.listAgents()) {
+        collectProviderSessionHandleKeys(handles, agent.provider, agent.persistence);
+    }
+    for (const record of await agentStorage.list()) {
+        collectProviderSessionHandleKeys(handles, record.provider, record.persistence);
+    }
+    return handles;
+}
+function toProviderSessionHandleKey(provider, providerHandleId) {
+    return `${provider}\0${providerHandleId}`;
+}
+function isMetadataGenerationSession(input) {
+    return (input.firstPromptPreview?.trimStart().startsWith(METADATA_GENERATION_PROMPT_PREFIX) ?? false);
+}
+function collectProviderSessionHandleKeys(target, provider, persistence) {
+    if (!persistence) {
+        return;
+    }
+    target.add(toProviderSessionHandleKey(provider, persistence.sessionId));
+    if (persistence.nativeHandle) {
+        target.add(toProviderSessionHandleKey(provider, persistence.nativeHandle));
+    }
+}
+//# sourceMappingURL=import-sessions.js.map

package/dist/server/server/agent/lifecycle-command.d.ts

@@ -0,0 +1,73 @@
+import type { Logger } from "pino";
+import type { ManagedAgent } from "./agent-manager.js";
+import type { StoredAgentRecord } from "./agent-storage.js";
+import type { AgentProviderNotice } from "./agent-sdk-types.js";
+export type LifecycleAgentSnapshot = Pick<ManagedAgent, "id" | "cwd" | "lifecycle">;
+export interface LifecycleAgentManager {
+    getAgent(agentId: string): LifecycleAgentSnapshot | null;
+    hasInFlightRun(agentId: string): boolean;
+    cancelAgentRun(agentId: string): Promise<boolean>;
+    clearAgentAttention(agentId: string): Promise<void>;
+    archiveAgent(agentId: string): Promise<{
+        archivedAt: string;
+    }>;
+    archiveSnapshot(agentId: string, archivedAt: string): Promise<StoredAgentRecord>;
+    closeAgent(agentId: string): Promise<void>;
+    setLabels(agentId: string, labels: Record<string, string>): Promise<void>;
+    detachAgent(agentId: string): Promise<{
+        record: StoredAgentRecord;
+        live: boolean;
+        previousParentAgentId: string | null;
+    }>;
+    notifyAgentState(agentId: string): void;
+    setAgentMode(agentId: string, modeId: string): Promise<AgentProviderNotice | null>;
+    updateAgentMetadata(agentId: string, updates: {
+        title?: string;
+        labels?: Record<string, string>;
+    }): Promise<void>;
+}
+export interface LifecycleAgentStorage {
+    get(agentId: string): Promise<StoredAgentRecord | null>;
+    upsert(record: StoredAgentRecord): Promise<void>;
+}
+export interface AgentLifecycleCommandDependencies {
+    agentManager: LifecycleAgentManager;
+    agentStorage: LifecycleAgentStorage;
+    logger: Logger;
+}
+export interface CancelAgentRunResult {
+    agent: LifecycleAgentSnapshot;
+    cancelled: boolean;
+}
+export declare function cancelAgentRunCommand(dependencies: Pick<AgentLifecycleCommandDependencies, "agentManager" | "logger">, agentId: string): Promise<CancelAgentRunResult>;
+export interface ArchiveAgentResult {
+    agentId: string;
+    archivedAt: string;
+    record: StoredAgentRecord;
+}
+export declare function archiveAgentCommand(dependencies: AgentLifecycleCommandDependencies, agentId: string): Promise<ArchiveAgentResult>;
+export declare function closeAgentCommand(dependencies: Pick<AgentLifecycleCommandDependencies, "agentManager">, agentId: string): Promise<void>;
+export interface UpdateAgentResult {
+    accepted: boolean;
+    error: string | null;
+}
+export declare function updateAgentCommand(dependencies: Pick<AgentLifecycleCommandDependencies, "agentManager">, input: {
+    agentId: string;
+    name?: string;
+    labels?: Record<string, string>;
+}): Promise<UpdateAgentResult>;
+export interface DetachAgentResult {
+    agentId: string;
+    record: StoredAgentRecord;
+    live: boolean;
+    previousParentAgentId: string | null;
+}
+export declare function detachAgentCommand(dependencies: Pick<AgentLifecycleCommandDependencies, "agentManager">, agentId: string): Promise<DetachAgentResult>;
+export declare function setAgentModeCommand(dependencies: Pick<AgentLifecycleCommandDependencies, "agentManager">, input: {
+    agentId: string;
+    modeId: string;
+}): Promise<{
+    modeId: string;
+    notice: AgentProviderNotice | null;
+}>;
+//# sourceMappingURL=lifecycle-command.d.ts.map

package/dist/server/server/agent/lifecycle-command.js

@@ -0,0 +1,92 @@
+export async function cancelAgentRunCommand(dependencies, agentId) {
+    const { agentManager, logger } = dependencies;
+    const agent = agentManager.getAgent(agentId);
+    if (!agent) {
+        logger.trace({ agentId }, "cancelAgentRunCommand: agent not found");
+        throw new Error(`Agent ${agentId} not found`);
+    }
+    const hasInFlightRun = agentManager.hasInFlightRun(agentId);
+    if (!hasInFlightRun) {
+        logger.trace({ agentId, lifecycle: agent.lifecycle, hasInFlightRun }, "cancelAgentRunCommand: skipping because agent is not running");
+        return { agent, cancelled: false };
+    }
+    logger.debug({ agentId, lifecycle: agent.lifecycle, hasInFlightRun }, "cancelAgentRunCommand: interrupting");
+    const startedAt = Date.now();
+    const cancelled = await agentManager.cancelAgentRun(agentId);
+    logger.debug({ agentId, cancelled, durationMs: Date.now() - startedAt }, "cancelAgentRunCommand: cancelAgentRun completed");
+    if (!cancelled) {
+        logger.warn({ agentId }, "cancelAgentRunCommand: reported running but no active run was cancelled");
+    }
+    return {
+        agent,
+        cancelled,
+    };
+}
+export async function archiveAgentCommand(dependencies, agentId) {
+    const liveAgent = dependencies.agentManager.getAgent(agentId);
+    let record;
+    if (liveAgent) {
+        await cancelAgentRunCommand(dependencies, agentId);
+        await dependencies.agentManager.clearAgentAttention(agentId).catch(() => undefined);
+        await dependencies.agentManager.archiveAgent(agentId);
+        record = await dependencies.agentStorage.get(agentId);
+    }
+    else {
+        record = await archiveStoredAgent(dependencies, agentId);
+    }
+    if (!record) {
+        throw new Error(`Agent not found in storage after archive: ${agentId}`);
+    }
+    if (!record.archivedAt) {
+        throw new Error(`Agent missing archivedAt after archive: ${agentId}`);
+    }
+    return {
+        agentId,
+        archivedAt: record.archivedAt,
+        record,
+    };
+}
+export async function closeAgentCommand(dependencies, agentId) {
+    await dependencies.agentManager.closeAgent(agentId);
+}
+export async function updateAgentCommand(dependencies, input) {
+    const title = input.name?.trim();
+    const labels = input.labels && Object.keys(input.labels).length > 0 ? input.labels : undefined;
+    if (!title && !labels) {
+        return {
+            accepted: false,
+            error: "Nothing to update (provide name and/or labels)",
+        };
+    }
+    await dependencies.agentManager.updateAgentMetadata(input.agentId, {
+        ...(title ? { title } : {}),
+        ...(labels ? { labels } : {}),
+    });
+    return {
+        accepted: true,
+        error: null,
+    };
+}
+export async function detachAgentCommand(dependencies, agentId) {
+    const result = await dependencies.agentManager.detachAgent(agentId);
+    return {
+        agentId,
+        ...result,
+    };
+}
+export async function setAgentModeCommand(dependencies, input) {
+    const notice = await dependencies.agentManager.setAgentMode(input.agentId, input.modeId);
+    return { modeId: input.modeId, notice };
+}
+async function archiveStoredAgent(dependencies, agentId) {
+    const existing = await dependencies.agentStorage.get(agentId);
+    if (!existing) {
+        throw new Error(`Agent not found: ${agentId}`);
+    }
+    if (existing.archivedAt) {
+        return existing;
+    }
+    const archivedAt = new Date().toISOString();
+    return dependencies.agentManager.archiveSnapshot(agentId, archivedAt);
+}
+//# sourceMappingURL=lifecycle-command.js.map