negotium 0.1.37 → 0.1.39

package/dist/runtime/src/runtime/turn-event-stream.ts

@@ -712,21 +712,38 @@ export async function runTurnEventStream(
       // message supersedes the turn. Adapters clean up transient tool status
       // separately when they receive ai_aborted.
       emitPendingAssistantMessage();
-      if (!silent) hub.broadcastAborted(topicId, queryId, wsAbortReason(control.abortReason));
       terminalEmitted = true;
-      outcome = { kind: "aborted" };
+      if (control.abortReason === AbortReason.Infrastructure) {
+        // Infrastructure loss is a failed turn, not a user stop. Defer the
+        // terminal event and settlement to turn-runner's provider-error path
+        // so visible turns, asks, subagents, and Cron all receive one
+        // consistent error outcome.
+        outcome = {
+          kind: "provider-error",
+          error: control.abortError ?? "Required browser infrastructure failed",
+        };
+      } else {
+        if (!silent) hub.broadcastAborted(topicId, queryId, wsAbortReason(control.abortReason));
+        outcome = { kind: "aborted" };
+      }
       // Internal abort = this turn is being replaced and (if it was a session
       // inject) re-queued — NOT a failure. Suppress the asker notification so
       // the caller doesn't get a spurious "Aborted" followed by the real reply
       // from the re-queued turn. Only External/stop notifies the asker.
-      if (control.abortReason !== AbortReason.Internal) {
-        deliverAskError(queryId, topicTitle, "Aborted");
+      if (
+        control.abortReason !== AbortReason.Internal &&
+        control.abortReason !== AbortReason.Infrastructure
+      ) {
+        const abortError = control.abortError ?? "Aborted";
+        deliverAskError(queryId, topicTitle, abortError);
         void settleSubagentFailure(queryId, "중지됨 (사용자가 실행을 멈췄습니다)");
       } else {
         // The replay receives a new queryId and registers a fresh callback.
         // Drop the superseded mapping now so it cannot leak until TTL expiry.
-        const { resolveAskCallback } = await import("#runtime/ask-callbacks");
-        resolveAskCallback(queryId);
+        if (control.abortReason === AbortReason.Internal) {
+          const { resolveAskCallback } = await import("#runtime/ask-callbacks");
+          resolveAskCallback(queryId);
+        }
       }
     }
   } catch (err) {

package/dist/runtime/src/runtime/turn-runner.ts

@@ -58,6 +58,7 @@ import {
 import { buildMentionOnlyChannelPrompt } from "#runtime/channel-context";
 import { classifyAgentError, stringifyError } from "#runtime/errors";
 import { withTurnSilenceHeartbeat } from "#runtime/event-heartbeat";
+import { trackPlaywrightTurn, untrackPlaywrightTurn } from "#runtime/playwright-turn-abort";
 import { getTopicConfig } from "#runtime/topic-config";
 import { runTurnEventStream, type StreamAgentOutcome } from "#runtime/turn-event-stream";
 import {
@@ -1289,6 +1290,7 @@ export function startAiTurn(params: StartAiTurnParams): string | null {
         if (!playwrightCapability) {
           throw new Error("browser MCP capability was not registered");
         }
+        trackPlaywrightTurn(playwrightInstanceKey, control);
       } catch (err) {
         logger.warn(
           { topicId, err },
@@ -1361,7 +1363,10 @@ export function startAiTurn(params: StartAiTurnParams): string | null {
         peerBridge,
       });
     } finally {
-      if (playwrightInstanceKey) unpinPlaywrightInstance(playwrightInstanceKey);
+      if (playwrightInstanceKey) {
+        untrackPlaywrightTurn(playwrightInstanceKey, control);
+        unpinPlaywrightInstance(playwrightInstanceKey);
+      }
     }
   }
   // Provider streams can stay silent while reasoning, starting MCPs, or

package/dist/runtime/src/version.ts

@@ -1 +1 @@
-export const NEGOTIUM_VERSION = "0.1.37";
+export const NEGOTIUM_VERSION = "0.1.39";

package/dist/types/packages/core/src/agents/api-topic-agent-switch.d.ts

@@ -0,0 +1,38 @@
+import { type TopicConfig } from "../storage/api-topic-config";
+import type { AgentKind, EffortLevel } from "../types";
+export type ApiTopicSwitchOutcome = {
+    kind: "fresh";
+    agent: AgentKind;
+    reason: "no-history" | "bridge-failed";
+} | {
+    kind: "bridged";
+    agent: AgentKind;
+    bridgedSessionId: string;
+    rolloutPath: string;
+};
+export type ApiTopicSwitchResult = {
+    ok: true;
+    outcome: ApiTopicSwitchOutcome;
+} | {
+    ok: false;
+    error: string;
+};
+export interface SwitchApiTopicAgentOptions {
+    topicId: string;
+    topicTitle: string;
+    userId: string;
+    fromAgent?: AgentKind;
+    agent: AgentKind;
+    cwd: string;
+    config: TopicConfig;
+    /** Topic base values used when config has no explicit override. */
+    defaultModel?: string;
+    defaultEffort?: EffortLevel;
+    reason: string;
+}
+/**
+ * API-topic equivalent of `switchTopicAgent`: all web/MCP agent changes must
+ * pass through this path so the synthetic SDK rollout, unified-log manifest,
+ * and durable topic session stay in sync.
+ */
+export declare function switchApiTopicAgent(opts: SwitchApiTopicAgentOptions): ApiTopicSwitchResult;

package/dist/types/packages/core/src/agents/archiver.d.ts

@@ -1,6 +1,6 @@
-import type { AgentKind } from "../types";
-import type { BackgroundSessionDto } from "../types/api";
-export declare function listActiveMemoryArchiverSessions(userId: string): BackgroundSessionDto[];
+import { type AgentDef } from "../prompts/builders";
+import type { AgentKind, AgentQueryOptions, UnifiedEvent } from "../types";
+import type { BackgroundSessionDto, MessageDto } from "../types/api";
 export interface RunArchiverTurnParams {
     /** Stringified user id (route layer hands us strings). */
     userId: string;
@@ -23,17 +23,53 @@ export interface RunArchiverTurnParams {
     /** Called once when an accepted background turn settles. */
     onSettled?: (success: boolean) => void;
 }
-/**
- * Fire a background wiki-archiver turn for a deleted topic or active idle
- * snapshot.
- *
- * Reads the forensic archive file produced by `archiveTopicMessages` and
- * distils it into the **shared** wiki (summaries / articles / topic brief /
- * indexes / skills) via the wiki MCP, which the turn launches in topic-id mode
- * so its writes land in the same root normal forum turns query.
- *
- * Fire-and-forget: the async generator is drained on a detached promise so the
- * caller's HTTP response returns immediately. Every failure is best-effort and
- * logged only — a broken archiver must never block or fail a topic deletion.
- */
+export interface ArchiverStorageHost {
+    getWikiDir(): string;
+    fileExists(path: string): boolean;
+    listDirectory(path: string): string[];
+    readTextFile(path: string): string;
+    fileSize(path: string): number;
+    fileModifiedAt(path: string): number;
+    getGeneralTopicId(userId: string): string;
+    getTopicBrief(topicId: string): {
+        briefMd: string;
+    } | null;
+    setTopicBrief(topicId: string, fields: {
+        briefMd: string;
+        latestSummaryMd?: string;
+        summaryDate?: string;
+    }): void;
+}
+export interface ArchiverMessagingHost {
+    appendMessage(message: MessageDto): void;
+    broadcastMessage(topicId: string, message: MessageDto): void;
+}
+export interface ArchiverConfigHost {
+    readonly workspaceDir: string;
+    readonly completedSessionRetentionMs: number;
+    loadAgentDefinition(): AgentDef;
+    sanitizeTopicName(topicTitle: string): string;
+    createId(): string;
+    now(): Date;
+    schedule(callback: () => void, delayMs: number): unknown;
+    cancelScheduled(handle: unknown): void;
+    unrefScheduled?(handle: unknown): void;
+    info(context: Record<string, unknown>, message: string): void;
+    warn(context: Record<string, unknown>, message: string): void;
+}
+export interface ArchiverAgentRuntimeHost {
+    run(options: AgentQueryOptions): AsyncIterable<UnifiedEvent>;
+}
+export interface ArchiverHost {
+    storage: ArchiverStorageHost;
+    messaging: ArchiverMessagingHost;
+    config: ArchiverConfigHost;
+    agentRuntime: ArchiverAgentRuntimeHost;
+}
+export interface ArchiverRuntime {
+    runArchiverTurn(params: RunArchiverTurnParams): boolean;
+    listActiveMemoryArchiverSessions(userId: string): BackgroundSessionDto[];
+}
+export declare function createArchiverRuntime(host: ArchiverHost): ArchiverRuntime;
 export declare function runArchiverTurn(params: RunArchiverTurnParams): boolean;
+export declare function listActiveMemoryArchiverSessions(userId: string): BackgroundSessionDto[];

package/dist/types/packages/core/src/agents/mcp-tools/ask-user.d.ts

@@ -1,6 +1,8 @@
 import { type SharedMcpTool } from "./common";
+import { type AskUserGateCardUpdate, type ClaimAskUserGateResult, type PrepareAskUserGateResult } from "../../storage/ask-user-gates";
+import { type RuntimeProcessLease, type RuntimeProcessLeaseHandle } from "../../storage/runtime-process-leases";
 import type { AgentKind } from "../../types";
-import type { MessageDto } from "../../types/api";
+import type { MessageDto, TopicDto } from "../../types/api";
 export type AskUserChoice = {
     label: string;
     description?: string;
@@ -20,8 +22,70 @@ export type AnswerAskUserQuestionResult = {
     ok: false;
     error: string;
 };
-export declare function startAskUserQuestionGateOwner(): void;
-export declare function stopAskUserQuestionGateOwner(): void;
+export interface AskUserRuntimeHost {
+    messaging: {
+        persistence: {
+            getMessage(topicId: string, messageId: string): MessageDto | null | undefined;
+            appendMessage(message: MessageDto): void;
+        };
+        publication: {
+            publishMessage(topicId: string, message: MessageDto): void;
+            publishCardUpdate(update: AskUserGateCardUpdate): void;
+        };
+    };
+    topics: {
+        getTopic(topicId: string): Pick<TopicDto, "participants"> | null | undefined;
+        getConfig(topicId: string): {
+            model?: string;
+        } | undefined;
+    };
+    durability: {
+        gates: {
+            prepare(args: {
+                gateId: string;
+                topicId: string;
+                queryId?: string;
+                idempotencyKey: string;
+                bodyHash: string;
+                messageId: string;
+                ownerId: string;
+                now: string;
+            }): PrepareAskUserGateResult;
+            claimAndSelect(args: {
+                topicId: string;
+                messageId: string;
+                label: string;
+                userId: string;
+                ownerId: string;
+                source: string;
+                now: string;
+            }): ClaimAskUserGateResult;
+            cancel(topicId: string, messageId: string, ownerId: string, now: string): AskUserGateCardUpdate | null;
+            quarantine(gateId: string, ownerId: string, now: string): AskUserGateCardUpdate | null;
+            quarantineForeign(liveOwnerIds: ReadonlySet<string>, now: string): AskUserGateCardUpdate[];
+        };
+        processLeases: {
+            acquire(role: string, ownerId: string): RuntimeProcessLeaseHandle | null;
+            list(rolePrefix: string): RuntimeProcessLease[];
+            isAlive(lease: RuntimeProcessLease): boolean;
+            removeDead(rolePrefix: string): void;
+        };
+    };
+    runtime: {
+        ownerId: string;
+        createId(): string;
+        now(): string;
+    };
+}
+export interface AskUserRuntime {
+    startGateOwner(): void;
+    stopGateOwner(): void;
+    reconcilePendingGates(): number;
+    hasPendingQuestion(topicId: string, messageId: string): boolean;
+    answerPendingQuestion(topicId: string, messageId: string, label: string, userId: string): AnswerAskUserQuestionResult;
+    cancelPendingQuestions(topicId: string, queryId: string): void;
+    createToolDefinition(ctx: AskUserToolContext): SharedMcpTool;
+}
 export declare function normalizeAskUserChoices(value: unknown): AskUserChoice[];
 export declare function normalizeAskUserQuestionInput(input: {
     question?: unknown;
@@ -32,8 +96,15 @@ export declare function normalizeAskUserQuestionInput(input: {
 } | {
     error: string;
 };
-export declare function hasPendingAskUserQuestion(topicId: string, messageId: string): boolean;
+/**
+ * Create an isolated ask-user lifecycle over host-provided messaging, topic,
+ * durability, and runtime services.
+ */
+export declare function createAskUserRuntime(host: AskUserRuntimeHost): AskUserRuntime;
+export declare function startAskUserQuestionGateOwner(): void;
+export declare function stopAskUserQuestionGateOwner(): void;
 export declare function reconcilePendingAskUserQuestionGates(): number;
+export declare function hasPendingAskUserQuestion(topicId: string, messageId: string): boolean;
 /**
  * Host-neutral answer path for runtime ask cards. Web, terminal, Telegram, and
  * future adapters should call this rather than reimplementing pending-map and

package/dist/types/packages/core/src/agents/mcp-tools/self-config.d.ts

@@ -0,0 +1,17 @@
+import { type SharedMcpTool } from "./common";
+import { SELF_CONFIG_MCP_KEY, type SelfConfigContext, type SelfConfigCore, type SelfConfigHost, type SelfConfigProductConfig } from "../self-config-core";
+export type { SelfConfigContext };
+export { SELF_CONFIG_MCP_KEY };
+export declare const SELF_CONFIG_DERIVED_TOPIC_LIMIT = 5;
+export interface SelfConfigRuntime {
+    readonly core: SelfConfigCore;
+    readonly mcpKey: string;
+    createToolDefinitions(ctx: SelfConfigContext | (() => SelfConfigContext)): SharedMcpTool[];
+}
+export interface SelfConfigRuntimeOptions {
+    host: SelfConfigHost;
+    product?: Partial<SelfConfigProductConfig>;
+}
+export declare function createSelfConfigRuntime(options: SelfConfigRuntimeOptions): SelfConfigRuntime;
+export declare function createSelfConfigToolDefinitionsForCore(core: SelfConfigCore, ctx: SelfConfigContext | (() => SelfConfigContext)): SharedMcpTool[];
+export declare function createSelfConfigToolDefinitions(ctx: SelfConfigContext | (() => SelfConfigContext)): SharedMcpTool[];

package/dist/types/packages/core/src/agents/mcp-tools/spawn-subagent.d.ts

@@ -1,7 +1,12 @@
 import { type SharedMcpTool } from "./common";
 import { type AgentKind } from "../../types";
-import type { SubagentReportMode } from "../../types/api";
+import type { MessageDto, SubagentCardDto, SubagentReportMode, TopicDto } from "../../types/api";
 export declare const MAX_SUBAGENT_DEPTH = 2;
+export interface SubagentLifecycleLimits {
+    readonly maxDepth: number;
+    readonly maxLiveChildrenPerParent: number;
+    readonly maxPreparedChildrenPerParent: number;
+}
 export interface SpawnSubagentToolContext {
     userId: string;
     topicId: string;
@@ -21,27 +26,109 @@ export interface SubagentWatch {
     queryId?: string;
     running: boolean;
 }
-/**
- * Walk the parent chain and count how many subagent ancestors this topic has.
- * Runs on every turn/MCP build, so it walks per-parent lookups (depth-capped)
- * instead of scanning the whole topic table.
- */
-export declare function computeSubagentDepth(topicId: string): number;
-export declare function canSpawnSubagentsFromTopic(topicId: string): boolean;
-/** Claim the watch for a finished child turn (delete-on-take). */
-export declare function takeSubagentWatch(queryId: string): SubagentWatch | null;
-/** Drop deferred/in-flight bookkeeping when a subagent room is hard-deleted. */
-export declare function cancelSubagentWatchForDeletedTopic(childTopicId: string): void;
-/** Settle a finished child run. NEVER rejects — call sites fire-and-forget. */
-export declare function settleSubagentSuccess(watch: SubagentWatch, finalText: string): Promise<void>;
-/** Settle a failed child run. NEVER rejects — call sites fire-and-forget. */
-export declare function settleSubagentFailure(queryId: string, reason: string): Promise<void>;
-/**
- * Boot-time sweep: watches don't survive a restart, so any card still marked
- * spawned/running belongs to a run whose completion can no longer be tracked.
- */
-export declare function sweepStaleSubagentCards(): void;
-export declare function subagentReportMode(childTopicId: string): SubagentReportMode;
-export declare function createSubagentManagementToolDefinitions(ctx: SubagentToolContext): SharedMcpTool[];
-export declare function createSpawnSubagentToolDefinition(ctx: SpawnSubagentToolContext): SharedMcpTool;
-export declare function createPrepareSubagentToolDefinition(ctx: SpawnSubagentToolContext): SharedMcpTool;
+export interface SubagentLifecycleHost<TContext extends SpawnSubagentToolContext = SpawnSubagentToolContext> {
+    storage: {
+        getTopic(topicId: string): TopicDto | null | undefined;
+        listTopics(): TopicDto[];
+        getTopicMemoryOrigin(topicId: string): TopicDto | null;
+        upsertTopic(topic: TopicDto): void;
+        getMessage(topicId: string, messageId: string): MessageDto | null | undefined;
+        listSubagentMessages(): MessageDto[];
+        appendMessage(message: MessageDto, options?: {
+            notify?: boolean;
+        }): void;
+        updateSubagentCard(topicId: string, messageId: string, card: SubagentCardDto, editedAt: string): MessageDto | null;
+        publishMessage(topicId: string, message: MessageDto): void;
+        publishCardUpdate(topicId: string, messageId: string, update: {
+            subagentCard: SubagentCardDto;
+            editedAt: string;
+        }): void;
+    };
+    topic: {
+        createDerived(input: {
+            context: TContext;
+            parentTopicId: string;
+            userId: string;
+            name?: string;
+            agent?: AgentKind;
+            model?: string;
+            memoryTopicId?: string;
+        }): Promise<{
+            ok: true;
+            topic: TopicDto | null;
+        } | {
+            ok: false;
+            reason: "busy" | "title-conflict";
+            message?: string;
+        }>;
+        delete(topic: TopicDto, userId: string): Promise<void>;
+    };
+    task: {
+        dispatch(input: {
+            child: TopicDto;
+            parent: TopicDto;
+            userId: string;
+            prompt: string;
+            requestId: string;
+            onDispatched(queryId: string): void;
+        }): Promise<{
+            accepted: boolean;
+            error?: string;
+        }>;
+    };
+    sessionCommunication: {
+        notifyParent(input: {
+            watch: SubagentWatch;
+            prompt: string;
+            requestId: string;
+        }): Promise<boolean>;
+        listTellTargetIds(sourceTopicId: string): string[];
+        grantTellTarget(sourceTopicId: string, targetTopicId: string, grantedByTopicId: string): void;
+        revokeTellTarget(sourceTopicId: string, targetTopicId: string): boolean;
+    };
+    runtime: {
+        ownerId: string;
+        now(): string;
+        ownerIsAlive(ownerId: string): boolean;
+        childExecutionQueryId(childTopicId: string): string | null;
+        childExecutionIsRecoverable(childTopicId: string): boolean;
+    };
+    config: {
+        limits?: Partial<SubagentLifecycleLimits>;
+        resolveAgentModel(input: {
+            context: TContext;
+            agent: AgentKind;
+            model?: string;
+            hasOverride: boolean;
+        }): Promise<{
+            model?: string;
+            error?: string;
+        }>;
+        memoryFilenames(topic: TopicDto): string[];
+    };
+}
+export interface SubagentLifecycle<TContext extends SpawnSubagentToolContext = SpawnSubagentToolContext> {
+    computeSubagentDepth(topicId: string): number;
+    canSpawnSubagentsFromTopic(topicId: string): boolean;
+    takeSubagentWatch(queryId: string): SubagentWatch | null;
+    cancelSubagentWatchForDeletedTopic(childTopicId: string): void;
+    settleSubagentSuccess(watch: SubagentWatch, finalText: string): Promise<void>;
+    settleSubagentFailure(queryId: string, reason: string): Promise<void>;
+    sweepStaleSubagentCards(): void;
+    subagentReportMode(childTopicId: string): SubagentReportMode;
+    createSubagentManagementToolDefinitions(ctx: SubagentToolContext): SharedMcpTool[];
+    createSpawnSubagentToolDefinition(ctx: TContext): SharedMcpTool;
+    createPrepareSubagentToolDefinition(ctx: TContext): SharedMcpTool;
+}
+export declare function createSubagentLifecycle<TContext extends SpawnSubagentToolContext>(host: SubagentLifecycleHost<TContext>): SubagentLifecycle<TContext>;
+export declare const computeSubagentDepth: (topicId: string) => number;
+export declare const canSpawnSubagentsFromTopic: (topicId: string) => boolean;
+export declare const takeSubagentWatch: (queryId: string) => SubagentWatch | null;
+export declare const cancelSubagentWatchForDeletedTopic: (childTopicId: string) => void;
+export declare const settleSubagentSuccess: (watch: SubagentWatch, finalText: string) => Promise<void>;
+export declare const settleSubagentFailure: (queryId: string, reason: string) => Promise<void>;
+export declare const sweepStaleSubagentCards: () => void;
+export declare const subagentReportMode: (childTopicId: string) => SubagentReportMode;
+export declare const createSubagentManagementToolDefinitions: (ctx: SubagentToolContext) => SharedMcpTool[];
+export declare const createSpawnSubagentToolDefinition: (ctx: SpawnSubagentToolContext) => SharedMcpTool;
+export declare const createPrepareSubagentToolDefinition: (ctx: SpawnSubagentToolContext) => SharedMcpTool;

package/dist/types/packages/core/src/agents/public-helpers.d.ts

@@ -1,9 +1,16 @@
+export { type ArchiverAgentRuntimeHost, type ArchiverConfigHost, type ArchiverHost, type ArchiverMessagingHost, type ArchiverRuntime, type ArchiverStorageHost, createArchiverRuntime, type RunArchiverTurnParams, } from "./archiver";
 export { type AgentAuthHost, type AuthCheckResult, checkAgentAuth, checkAgentModelAuth, } from "./auth-check";
 export { acquireCodexSpawnLock, type CodexProcStamp, type CodexTreeHost, type CodexTreeLogger, type CodexTreeManager, type CodexTreeManagerOptions, createCodexTreeManager, findNewCodexChildren, killCodexTrees, killOwnedCodexTreesForShutdown, registerOwnedCodexPids, snapshotCodexChildren, unregisterOwnedCodexPids, withCodexSpawnSerial, } from "./codex-tree-kill";
 export { type AgentForkHelpers, type AgentForkHost, cleanupAgentFork, createAgentForkHelpers, type ForkAgentSessionOptions, type ForkHandle, forkAgentSession, } from "./fork";
 export { type ActiveTopicArchiveOptions, archiveActiveTopicForMemory, } from "./idle-archiver";
+export { type AnswerAskUserQuestionResult, type AskUserChoice, type AskUserRuntime, type AskUserRuntimeHost, type AskUserToolContext, createAskUserRuntime, normalizeAskUserChoices, normalizeAskUserQuestionInput, } from "./mcp-tools/ask-user";
+export { createSelfConfigRuntime, createSelfConfigToolDefinitionsForCore, type SelfConfigRuntime, type SelfConfigRuntimeOptions, } from "./mcp-tools/self-config";
+export { createSubagentLifecycle, type SpawnSubagentToolContext, type SubagentLifecycle, type SubagentLifecycleHost, type SubagentLifecycleLimits, type SubagentToolContext, type SubagentWatch, } from "./mcp-tools/spawn-subagent";
 export { otiumVisualToolDefinitions, showPngTool, } from "./mcp-tools/visual-compat";
 export { showHtmlTool, showImageTool, showMermaidTool, showVideoTool, VISUALS_MCP_KEY, visualToolDefinitions, } from "./mcp-tools/visuals";
 export { MIN_MEMORY_ARCHIVE_EXCHANGES } from "./memory-archive-policy";
+export { createSelfConfigCore, DEFAULT_SELF_CONFIG_PRODUCT, type SelfConfigAgentPolicy, type SelfConfigAgentSwitchOptions, type SelfConfigAgentSwitchResult, type SelfConfigContext, type SelfConfigCore, type SelfConfigCreateScheduleResult, type SelfConfigDerivedTopics, type SelfConfigField, type SelfConfigHost, type SelfConfigModelPolicy, type SelfConfigProductConfig, type SelfConfigResult, type SelfConfigRuntimeBoundary, type SelfConfigSchedule, type SelfConfigSchedules, type SelfConfigTopic, type SelfConfigTopicConfig, type SelfConfigTopicStore, } from "./self-config-core";
 export { resolveTaskEventScope, type TaskEventHost, type TaskEventScope, withTaskSnapshots, } from "./task-events";
+export { buildNumberedDiffSummary, classifyShellToolName, formatToolUse, type NumberedDiffSummary, summarizeDisplayText, summarizeShellCommand, summarizeToolInput, type ToolCallSummaryInput, type ToolCallSummaryValue, } from "./tool-format";
+export { cleanupTopicRollouts, cleanupTopicRolloutsFromEntries, createTopicLogMaintenance, type PurgeSessionRef, type PurgeTopicLogsOptions, purgeTopicLogs, type RotateTopicLogsOptions, type RotateTopicLogsResult, rotateTopicLogs, type TopicConversationEntry, type TopicLogMaintenance, type TopicLogMaintenanceHost, } from "./topic-cleanup";
 export { createVaultToolPolicy, isVaultBrokerTool, referencesRuntimeSecretStorage, shouldRedirectVaultTool, VAULT_BROKER_REDIRECT_ERROR, type VaultToolPolicy, type VaultToolPolicyHost, } from "./vault-tool-policy";

package/dist/types/packages/core/src/agents/self-config-core.d.ts

@@ -0,0 +1,185 @@
+import type { AgentKind, EffortLevel } from "../types";
+export declare const SELF_CONFIG_MCP_KEY = "topic-config";
+export declare const SELF_SCHEDULE_MAX_DELAY_SECONDS = 86400;
+export declare const SELF_SCHEDULE_MAX_MESSAGE_LENGTH = 10000;
+export declare const SELF_CONFIG_DERIVED_TOPIC_LIMIT = 5;
+export type SelfConfigField = "agent" | "model" | "effort";
+export interface SelfConfigContext {
+    topicId: string;
+    userId: string;
+    cwd?: string;
+    /** Raw current user request. Used to prevent autonomous MCP agent switches. */
+    currentUserPrompt?: string;
+    /** Called after a successful set_* so the caller can trigger a follow-up turn. */
+    onConfigChanged?: (field: SelfConfigField) => void;
+}
+export interface SelfConfigResult {
+    text: string;
+    isError?: boolean;
+}
+export interface SelfConfigTopic {
+    id: string;
+    title: string;
+    agent?: AgentKind;
+    defaultModel: string;
+    defaultEffort: EffortLevel;
+    participants: readonly {
+        userId: string;
+    }[];
+}
+export interface SelfConfigTopicConfig {
+    model?: string;
+    effort?: EffortLevel;
+    mcp?: string[];
+    agentLocked?: boolean;
+    modelLocked?: boolean;
+    effortLocked?: boolean;
+}
+export interface SelfConfigAgentPolicy {
+    defaultEffort?: EffortLevel;
+    validEfforts: readonly EffortLevel[];
+    validateModel(model: string): boolean;
+    validateEffort(effort: EffortLevel): boolean;
+    resolveModel(model: string | undefined): string;
+}
+export interface SelfConfigTopicStore {
+    getTopic(topicId: string): SelfConfigTopic | null;
+    getConfig(topicId: string): SelfConfigTopicConfig | undefined;
+    setConfig(topicId: string, config: SelfConfigTopicConfig): void;
+}
+export interface SelfConfigModelPolicy {
+    forAgent(agent: AgentKind): SelfConfigAgentPolicy;
+    owner(model: string): AgentKind | undefined;
+    checkAuth(agent: AgentKind, model: string, userId: string): {
+        ok: true;
+    } | {
+        ok: false;
+        error: string;
+    };
+}
+export interface SelfConfigRuntimeBoundary {
+    resolveWorkspaceDir(topicId: string): string;
+    switchAgent(options: SelfConfigAgentSwitchOptions): SelfConfigAgentSwitchResult;
+    configChanged(topicId: string, field: SelfConfigField): void;
+}
+export type SelfConfigAgentSwitchResult = {
+    ok: true;
+    outcome: {
+        kind: "fresh";
+        agent: AgentKind;
+        reason: "no-history" | "bridge-failed";
+    } | {
+        kind: "bridged";
+        agent: AgentKind;
+        bridgedSessionId: string;
+        rolloutPath: string;
+    };
+} | {
+    ok: false;
+    error: string;
+};
+export interface SelfConfigAgentSwitchOptions {
+    topicId: string;
+    topicTitle: string;
+    userId: string;
+    fromAgent?: AgentKind;
+    agent: AgentKind;
+    cwd: string;
+    config: SelfConfigTopicConfig;
+    defaultModel?: string;
+    defaultEffort?: EffortLevel;
+    reason: string;
+}
+export interface SelfConfigDerivedTopics {
+    create(sourceTopicId: string, userId: string, copyHistory: boolean, options: {
+        name?: string;
+    }): Promise<SelfConfigTopic | null>;
+    link(topicId: string): string;
+    isTitleConflict(error: unknown): boolean;
+    isForkCompactionError(error: unknown): boolean;
+}
+export interface SelfConfigSchedules {
+    create(input: {
+        topicId: string;
+        userId: string;
+        message: string;
+        deliverAt: number;
+        now?: number;
+    }): SelfConfigCreateScheduleResult;
+    getPending(topicId: string): SelfConfigSchedule | null;
+    update(input: {
+        topicId: string;
+        scheduleId: string;
+        message?: string;
+        deliverAt?: number;
+        now?: number;
+    }): SelfConfigSchedule | null;
+    cancel(topicId: string, scheduleId: string): boolean;
+}
+export interface SelfConfigSchedule {
+    id: string;
+    topicId: string;
+    userId: string;
+    message: string;
+    deliverAt: number;
+}
+export type SelfConfigCreateScheduleResult = {
+    ok: true;
+    schedule: SelfConfigSchedule;
+} | {
+    ok: false;
+    existing: SelfConfigSchedule;
+};
+/** Product-level limits and copy that are shared by policy and MCP wrappers. */
+export interface SelfConfigProductConfig {
+    readonly mcpKey: string;
+    readonly scheduleMaxDelaySeconds: number;
+    readonly scheduleMaxMessageLength: number;
+    readonly derivedTopicLimit: number;
+    readonly toolDescriptions: Readonly<Record<string, string>>;
+}
+export interface SelfConfigHost {
+    topics: SelfConfigTopicStore;
+    models: SelfConfigModelPolicy;
+    runtime: SelfConfigRuntimeBoundary;
+    derivedTopics?: SelfConfigDerivedTopics;
+    schedules?: SelfConfigSchedules;
+}
+export interface SelfConfigCore {
+    readonly host: SelfConfigHost;
+    readonly product: SelfConfigProductConfig;
+    setModel(ctx: SelfConfigContext, model: string): SelfConfigResult;
+    getModel(ctx: SelfConfigContext): SelfConfigResult;
+    setAgent(ctx: SelfConfigContext, agent: AgentKind): SelfConfigResult;
+    getAgent(ctx: SelfConfigContext): SelfConfigResult;
+    setEffort(ctx: SelfConfigContext, effort: EffortLevel): SelfConfigResult;
+    getEffort(ctx: SelfConfigContext): SelfConfigResult;
+    scheduleContinue(ctx: SelfConfigContext, delaySeconds: number, message: string, nowMs?: number): SelfConfigResult;
+    getSchedule(ctx: SelfConfigContext, nowMs?: number): SelfConfigResult;
+    updateSchedule(ctx: SelfConfigContext, scheduleId: string, updates: {
+        delaySeconds?: number;
+        message?: string;
+    }, nowMs?: number): SelfConfigResult;
+    cancelSchedule(ctx: SelfConfigContext, scheduleId: string): SelfConfigResult;
+    spawnTopic(ctx: SelfConfigContext, name?: string): Promise<SelfConfigResult>;
+    forkTopic(ctx: SelfConfigContext, name?: string): Promise<SelfConfigResult>;
+}
+export declare const DEFAULT_SELF_CONFIG_PRODUCT: SelfConfigProductConfig;
+export declare function createSelfConfigCore(host: SelfConfigHost, productOverrides?: Partial<SelfConfigProductConfig>): SelfConfigCore;
+export declare const defaultSelfConfigHost: SelfConfigHost;
+export declare const defaultSelfConfigCore: SelfConfigCore;
+export declare function setSelfConfigModel(ctx: SelfConfigContext, model: string): SelfConfigResult;
+export declare function getSelfConfigModel(ctx: SelfConfigContext): SelfConfigResult;
+export declare function setSelfConfigAgent(ctx: SelfConfigContext, agent: AgentKind): SelfConfigResult;
+export declare function getSelfConfigAgent(ctx: SelfConfigContext): SelfConfigResult;
+export declare function setSelfConfigEffort(ctx: SelfConfigContext, effort: EffortLevel): SelfConfigResult;
+export declare function getSelfConfigEffort(ctx: SelfConfigContext): SelfConfigResult;
+export declare function scheduleSelfConfigContinue(ctx: SelfConfigContext, delaySeconds: number, message: string, nowMs?: number): SelfConfigResult;
+export declare function getSelfConfigSchedule(ctx: SelfConfigContext, nowMs?: number): SelfConfigResult;
+export declare function updateSelfConfigSchedule(ctx: SelfConfigContext, scheduleId: string, updates: {
+    delaySeconds?: number;
+    message?: string;
+}, nowMs?: number): SelfConfigResult;
+export declare function cancelSelfConfigSchedule(ctx: SelfConfigContext, scheduleId: string): SelfConfigResult;
+export declare function spawnSelfConfigTopic(ctx: SelfConfigContext, name?: string): Promise<SelfConfigResult>;
+export declare function forkSelfConfigTopic(ctx: SelfConfigContext, name?: string): Promise<SelfConfigResult>;