negotium 0.2.2 → 0.2.4

package/dist/runtime/src/agents/fork.ts

@@ -1,4 +1,5 @@
 import { existsSync, unlinkSync } from "node:fs";
+import type { ForkRegistryResult } from "#agents/contracts";
 import { getRegistryOperations } from "#agents/registry";
 import { logger } from "#platform/logger";
 import type { AgentKind, EffortLevel } from "#types";
@@ -7,9 +8,10 @@ import type { AgentKind, EffortLevel } from "#types";
  * Agent-aware fork primitives.
  *
  * Strategy lives in each agent's registry (`*-registry.ts:forkSession`).
- * Claude uses the SDK's native `forkSession` (byte-equivalent rollout copy);
- * Codex synthesizes a rollout from the provider-agnostic conversation log
- * because the SDK has no fork API. Both surfaces converge on `ForkHandle`.
+ * Claude uses the SDK's native `forkSession`, Codex uses App Server's native
+ * `thread/fork`, and Maestro uses the SDK's `forkSessionAt`. Providers without
+ * a native branch primitive synthesize from the provider-agnostic conversation
+ * log. All surfaces converge on ForkHandle.
  */
 
 export interface ForkAgentSessionOptions {
@@ -35,13 +37,15 @@ export interface ForkHandle {
   forkId: string;
   /** Absolute path of the rollout file to remove on cleanup. */
   rolloutPath: string;
+  /** Additional provider-owned files removed with the primary rollout. */
+  cleanupPaths?: string[];
 }
 
 export interface AgentForkHost {
   forkSession(
     agent: AgentKind,
     options: Omit<ForkAgentSessionOptions, "agent">,
-  ): Promise<{ forkId: string; rolloutPath: string }>;
+  ): Promise<ForkRegistryResult>;
   exists(path: string): boolean;
   unlink(path: string): void;
   warn(details: Record<string, unknown>, message: string): void;
@@ -56,22 +60,24 @@ export function createAgentForkHelpers(host: AgentForkHost): AgentForkHelpers {
   return {
     async forkAgentSession(options) {
       const { agent, ...forkOptions } = options;
-      const { forkId, rolloutPath } = await host.forkSession(agent, forkOptions);
-      return { agent, forkId, rolloutPath };
+      const { forkId, rolloutPath, cleanupPaths } = await host.forkSession(agent, forkOptions);
+      return { agent, forkId, rolloutPath, ...(cleanupPaths?.length ? { cleanupPaths } : {}) };
     },
     cleanupAgentFork(handle) {
-      try {
-        if (host.exists(handle.rolloutPath)) host.unlink(handle.rolloutPath);
-      } catch (error) {
-        host.warn(
-          {
-            error,
-            agent: handle.agent,
-            forkId: handle.forkId,
-            rolloutPath: handle.rolloutPath,
-          },
-          "cleanupAgentFork: failed to remove rollout",
-        );
+      for (const path of [handle.rolloutPath, ...(handle.cleanupPaths ?? [])]) {
+        try {
+          if (host.exists(path)) host.unlink(path);
+        } catch (error) {
+          host.warn(
+            {
+              error,
+              agent: handle.agent,
+              forkId: handle.forkId,
+              path,
+            },
+            "cleanupAgentFork: failed to remove rollout",
+          );
+        }
       }
     },
   };

package/dist/runtime/src/agents/idle-archiver.ts

@@ -1,5 +1,8 @@
 import { runArchiverTurn } from "#agents/archiver";
-import { countMemoryArchiveExchanges } from "#agents/memory-archive-policy";
+import {
+  countMemoryArchiveExchanges,
+  meetsMemoryArchiveExchangeThreshold,
+} from "#agents/memory-archive-policy";
 import { logger } from "#platform/logger";
 import { getRoomQuery } from "#query/active-rooms";
 import { getMessagesForTopicAfterRowid } from "#storage/api-messages";
@@ -141,7 +144,9 @@ export function archiveActiveTopicForMemory(
       return null;
     }
     const exchangeCount = countMemoryArchiveExchanges(pending);
-    skipMemoryTurn = options.minExchanges !== undefined && exchangeCount < options.minExchanges;
+    skipMemoryTurn =
+      options.minExchanges !== undefined &&
+      !meetsMemoryArchiveExchangeThreshold(exchangeCount, options.minExchanges, topic);
     const archived = (options.archiveMessages ?? archiveTopicMessages)(topicId, topic.title, {
       afterRowid,
       reason: options.reason,

package/dist/runtime/src/agents/index.ts

@@ -1,6 +1,7 @@
 import { existsSync } from "node:fs";
 import { homedir } from "node:os";
 import { join } from "node:path";
+import { hostedCodexHomePath } from "#agents/execution-host";
 import { getRegistryOperations } from "#agents/registry";
 import { encodeClaudeCwd } from "#agents/rollout/claude";
 import { resolveTaskEventScope, withTaskSnapshots } from "#agents/task-events";
@@ -108,7 +109,7 @@ export async function resolveSessionFileMissing(
       return !existsSync(path);
     }
     case "codex": {
-      const sessionsDir = join(process.env.CODEX_HOME || join(homedir(), ".codex"), "sessions");
+      const sessionsDir = join(hostedCodexHomePath(), "sessions");
       const glob = new Bun.Glob(`**/rollout-*-${sessionId}.jsonl`);
       for await (const _rel of glob.scan({ cwd: sessionsDir, onlyFiles: true })) {
         return false; // found at least one match → session exists

package/dist/runtime/src/agents/maestro-registry.ts

@@ -5,7 +5,6 @@ import { join, resolve } from "node:path";
 import type { AgentRegistry, AgentRegistryOperations } from "#agents/contracts";
 import { assertUuidLike, ensureCwdExists, extractChatPairs } from "#agents/rollout/shared";
 import { logger } from "#platform/logger";
-import { readConversation } from "#storage/conversations";
 import { MAESTRO_EFFORT_VALUES } from "#types";
 
 const ALIAS_MAP: Record<string, string> = {
@@ -80,7 +79,7 @@ function writeRollout(options: Parameters<AgentRegistryOperations["writeRollout"
         version: 1,
         cwd: options.cwd,
         createdAt: existingCreatedAt(path) ?? new Date().toISOString(),
-        sdkVersion: "0.1.54",
+        sdkVersion: "0.2.0",
       },
     },
     ...messages,
@@ -96,13 +95,33 @@ export const maestroRegistryOperations: AgentRegistryOperations = {
     return writeRollout(options);
   },
   async forkSession(options) {
-    const rollout = writeRollout({
+    // Fork the full raw history while preserving the compacted working view.
+    // A compacted parent that cannot copy its active projection is not a usable
+    // cache-preserving fork, so let the caller fall back to bounded synthesis.
+    const { deleteMaestroSession, forkSessionAt, loadRawMaestroSession } = await import(
+      "maestro-agent-sdk"
+    );
+    const parentMessages = loadRawMaestroSession(options.parentSessionId);
+    if (!parentMessages) {
+      throw new Error(`Maestro parent session not found: ${options.parentSessionId}`);
+    }
+    const parentHasActiveProjection = existsSync(maestroActiveSessionPath(options.parentSessionId));
+    const fork = forkSessionAt({
+      parentSessionId: options.parentSessionId,
+      messageIndex: parentMessages.length,
       cwd: options.cwd,
-      entries: readConversation(options.userId, options.topicName),
-      ...(options.model ? { model: options.model } : {}),
-      ...(options.effort ? { effort: options.effort } : {}),
+      userId: String(options.userId),
     });
-    return { forkId: rollout.sessionId, rolloutPath: rollout.rolloutPath };
+    if (parentHasActiveProjection && !fork.activeProjectionForked) {
+      deleteMaestroSession(fork.sessionId);
+      throw new Error(`Maestro active projection could not be forked: ${options.parentSessionId}`);
+    }
+    const activePath = maestroActiveSessionPath(fork.sessionId);
+    return {
+      forkId: fork.sessionId,
+      rolloutPath: fork.rolloutPath,
+      ...(existsSync(activePath) ? { cleanupPaths: [activePath] } : {}),
+    };
   },
   async cleanupRollouts(options) {
     // Keep the SDK off the daemon startup path, but use its canonical cleanup

package/dist/runtime/src/agents/memory-archive-policy.ts

@@ -12,6 +12,26 @@ export interface MemoryArchiveMessage {
  */
 export const MIN_MEMORY_ARCHIVE_EXCHANGES = 6;
 
+export interface MemoryArchiveTopicContext {
+  isSubagent?: boolean;
+  memoryTopicId?: string;
+}
+
+/**
+ * Explicit-memory subagents are usually short, focused turns. Persist one
+ * completed exchange back to their selected memory topic, while retaining the
+ * normal threshold for regular topics and incomplete/failed turns.
+ */
+export function meetsMemoryArchiveExchangeThreshold(
+  exchangeCount: number,
+  minExchanges: number,
+  topic: MemoryArchiveTopicContext,
+): boolean {
+  if (exchangeCount <= 0) return false;
+  if (topic.isSubagent && topic.memoryTopicId) return true;
+  return exchangeCount >= minExchanges;
+}
+
 /** Count completed conversational exchanges while ignoring system/tool/card noise. */
 export function countMemoryArchiveExchanges(rows: readonly MemoryArchiveMessage[]): number {
   let waitingForAssistant = false;

package/dist/runtime/src/agents/rollout/codex.ts

@@ -10,14 +10,15 @@
  * synthesized `response_item`/`event_msg` pairs per turn.
  *
  * Tool history is folded into assistant text as `[Tool: ...]` annotations
- * (see shared.ts:extractChatPairs) — the SDK has no fork API and synthetic
- * tool_use IDs across SDKs are too fragile to reconstruct structurally.
+ * (see shared.ts:extractChatPairs). Native same-agent forks use App Server's
+ * `thread/fork`; this encoder remains the fallback and cross-agent bridge,
+ * where synthetic tool_use IDs are too fragile to reconstruct structurally.
  */
 
 import { randomBytes } from "node:crypto";
 import { existsSync, readFileSync, realpathSync, statSync, unlinkSync } from "node:fs";
-import { homedir } from "node:os";
 import { basename, dirname, join, resolve } from "node:path";
+import { hostedCodexHomePath } from "#agents/execution-host";
 import {
   assertUuidLike,
   type ChatPair,
@@ -40,7 +41,7 @@ interface CodexShell {
 }
 
 function codexSessionsDir(): string {
-  return join(process.env.CODEX_HOME || join(homedir(), ".codex"), "sessions");
+  return join(hostedCodexHomePath(), "sessions");
 }
 
 let _shellCache: CodexShell | null = null;
@@ -420,7 +421,7 @@ export function migrateCodexRolloutNativeMultiAgentMetadata(threadId: string): b
   }
 }
 
-function latestCodexRolloutPath(threadId: string): string | undefined {
+export function latestCodexRolloutPath(threadId: string): string | undefined {
   const sessionsDir = codexSessionsDir();
   const candidates: string[] = [];
   const buckets = candidateDateBuckets(threadId);

package/dist/runtime/src/agents/rollout/shared.ts

@@ -8,10 +8,10 @@
  */
 
 import { mkdirSync } from "node:fs";
-import { dirname, join, resolve } from "node:path";
-import { fileURLToPath } from "node:url";
+import { resolve } from "node:path";
 import {
   DM_WORKSPACE_DIR,
+  PROJECT_ROOT,
   SESSION_WORKSPACE_DIR,
   TOPIC_WORKSPACE_DIR,
   WORKSPACE_DIR,
@@ -20,8 +20,6 @@ import { logger } from "#platform/logger";
 import { renderUserPromptBatch } from "#runtime/user-turn-envelope";
 import type { ConversationEntry } from "#storage/conversations";
 
-const __dirname = dirname(fileURLToPath(import.meta.url));
-
 export interface RolloutHostOptions {
   /** Absolute workspace roots under which synthetic provider sessions may be written. */
   workspaceRoots?: readonly string[];
@@ -69,7 +67,7 @@ export function configureRolloutHost(options: RolloutHostOptions): () => void {
  * non-conversational entries from the resulting rollout file, and update
  * `src/agents/fixtures/{codex-shell,claude-attachments}.jsonl`.
  */
-export let FIXTURES_DIR = join(__dirname, "..", "fixtures");
+export let FIXTURES_DIR = resolve(PROJECT_ROOT, "src", "agents", "fixtures");
 
 /** Deep-clone to avoid mutating cached fixture objects. */
 export function clone<T>(obj: T): T {

package/dist/runtime/src/mcp/factories/session-comm.ts

@@ -22,6 +22,10 @@ export interface SessionCommMcpHost {
     context: SessionCommContext,
     profile: string,
   ): MaybePromise<SessionCommMcpResult>;
+  deleteBrowserProfile?(
+    context: SessionCommContext,
+    profile: string,
+  ): MaybePromise<SessionCommMcpResult>;
   peekSession(context: SessionCommContext): MaybePromise<SessionCommMcpResult>;
   setDescription(
     context: SessionCommContext,
@@ -90,6 +94,14 @@ export function createSessionCommMcpServer(
       async ({ profile }) => host.setBrowserProfile!(context, profile),
     );
   }
+  if (host.deleteBrowserProfile) {
+    server.tool(
+      "delete_browser_profile",
+      "Delete an unused named browser profile and its on-disk data. The default or an assigned profile cannot be deleted.",
+      { profile: z.string() },
+      async ({ profile }) => host.deleteBrowserProfile!(context, profile),
+    );
+  }
   server.tool(
     "peek_session",
     "Inspect running and idle sessions, including pending ask_session calls.",

package/dist/runtime/src/mcp/session-comm/default-host.ts

@@ -11,6 +11,7 @@ import { ACTIVE_QUERY_STALE_MS, MAX_TELL_DEPTH, USERS_LOG_DIR } from "#platform/
 import { appendJsonlEntry, readJsonFile } from "#platform/jsonl";
 import { OPTIONAL_FORUM_MCP_SERVERS, REQUIRED_FORUM_MCP_SERVERS } from "#platform/mcp-config";
 import { closeBrowserOwnerTabs } from "#platform/playwright/manager";
+import { deleteManagedBrowserProfile } from "#platform/playwright/profile-management";
 import { sessionInboxPath } from "#query/session-inbox-path";
 import { sanitizeId } from "#security/sanitize";
 import { getApiTopicConfig, setApiTopicConfig } from "#storage/api-topic-config";
@@ -199,6 +200,21 @@ export function createDefaultSessionCommMcpHost(): SessionCommMcpHost {
       }
     },
 
+    async deleteBrowserProfile(context, profile) {
+      const topic = currentTopic(context);
+      if (!topic) return error("Error: No current API topic.");
+      if (!isTopicBrowserProfileOwner(topic.id, context.userId)) {
+        return error("Error: Only the topic owner can delete its browser profiles.");
+      }
+      try {
+        const ownerId = getBrowserProfileOwner(topic.id, context.userId);
+        const result = await deleteManagedBrowserProfile(ownerId, profile);
+        return ok(JSON.stringify(result, null, 2));
+      } catch (err) {
+        return error(`Error: ${err instanceof Error ? err.message : String(err)}`);
+      }
+    },
+
     peekSession(context) {
       const targets = targetCatalog(context).listTargets();
       const running: string[] = [];

package/dist/runtime/src/mcp/session-comm/server.ts

@@ -12,6 +12,7 @@ import {
   REQUIRED_FORUM_MCP_SERVERS,
 } from "#platform/mcp-config";
 import { closeBrowserOwnerTabs } from "#platform/playwright/manager";
+import { deleteManagedBrowserProfile } from "#platform/playwright/profile-management";
 import { sanitizeId } from "#security/sanitize";
 import { getTopic } from "#storage/api-topics";
 import {
@@ -318,6 +319,30 @@ server.tool(
   },
 );
 
+server.tool(
+  "delete_browser_profile",
+  "Delete an unused named browser profile and its on-disk data. The default or an assigned profile cannot be deleted.",
+  {
+    profile: z
+      .string()
+      .describe("Unused named profile to delete; the default profile cannot be deleted"),
+  },
+  async ({ profile }) => {
+    const topicId = currentApiTopicId();
+    if (!topicId || !userId) return mcpError("Error: No current API topic.");
+    if (!isTopicBrowserProfileOwner(topicId, userId)) {
+      return mcpError("Error: Only the topic owner can delete its browser profiles.");
+    }
+    try {
+      const ownerId = getBrowserProfileOwner(topicId, userId);
+      const result = await deleteManagedBrowserProfile(ownerId, profile);
+      return mcpOk(JSON.stringify(result, null, 2));
+    } catch (err) {
+      return mcpError(`Error: ${errMsg(err)}`);
+    }
+  },
+);
+
 // --- always-available session inspection / self-config ---
 
 server.tool(

package/dist/runtime/src/platform/config.ts

@@ -453,7 +453,10 @@ export const MAX_TELL_DEPTH =
 /** Codex CLI auth file. 호출 시점에 env를 읽는다 — 테스트가 런타임에
  *  NEGOTIUM_CODEX_AUTH_FILE을 바꾸므로 모듈 로드 상수로 만들면 안 된다. */
 export function codexAuthFilePath(): string {
-  return process.env.NEGOTIUM_CODEX_AUTH_FILE || join(homedir(), ".codex", "auth.json");
+  return (
+    process.env.NEGOTIUM_CODEX_AUTH_FILE ||
+    join(process.env.CODEX_HOME || join(homedir(), ".codex"), "auth.json")
+  );
 }
 
 // System defaults moved to per-agent registries

package/dist/runtime/src/platform/playwright/manager.ts

@@ -84,10 +84,23 @@ export interface PlaywrightManagerHost {
   ) => NodeJS.ProcessEnv;
   /** Reap an orphan that owns this exact host-managed data directory. */
   readonly cleanupBrowserProcessesForDataDir: (userDataDir: string) => void;
+  /** Remove an exact host-managed profile directory, rejecting paths outside the host's root. */
+  readonly removeProfileDataDir?: (userDataDir: string) => boolean;
   /** Reap host-managed browsers that are not represented by the supplied live directories. */
   readonly reapOrphanBrowsers: (liveUserDataDirs: Iterable<string>) => void;
 }
 
+function removeDefaultProfileDataDir(userDataDir: string): boolean {
+  const root = resolve(BROWSER_PROFILES_DIR);
+  const target = resolve(userDataDir);
+  if (dirname(target) !== root) {
+    throw new Error(`Refusing to delete browser profile outside managed root: ${target}`);
+  }
+  const existed = existsSync(target);
+  rmSync(target, { recursive: true, force: true });
+  return existed;
+}
+
 export {
   cleanupZombiePlaywright,
   isBrowserJanitorOwner,
@@ -210,6 +223,7 @@ const defaultManagerHost: Readonly<PlaywrightManagerHost> = Object.freeze({
   },
   createChildEnvironment: defaultChildEnvironment,
   cleanupBrowserProcessesForDataDir: killBrowserProcsForUserDataDir,
+  removeProfileDataDir: removeDefaultProfileDataDir,
   reapOrphanBrowsers,
 });
 
@@ -239,10 +253,12 @@ export function configurePlaywrightManagerHost(
     next.resolveInstanceDataDir !== defaultManagerHost.resolveInstanceDataDir &&
     (next.cleanupBrowserProcessesForDataDir ===
       defaultManagerHost.cleanupBrowserProcessesForDataDir ||
+      !next.removeProfileDataDir ||
+      next.removeProfileDataDir === defaultManagerHost.removeProfileDataDir ||
       next.reapOrphanBrowsers === defaultManagerHost.reapOrphanBrowsers)
   ) {
     throw new Error(
-      "custom Playwright profile paths require host crash cleanup and orphan sweep hooks",
+      "custom Playwright profile paths require host crash cleanup, profile removal, and orphan sweep hooks",
     );
   }
   managerHost = Object.freeze(next);
@@ -293,6 +309,7 @@ function deletePortFile(instanceKey: string) {
   try {
     unlinkSync(join(managerHost.portsDir, portFileName(instanceKey)));
   } catch (e) {
+    if ((e as NodeJS.ErrnoException).code === "ENOENT") return;
     logger.warn({ err: e, instanceKey }, "Failed to delete playwright port file");
   }
 }
@@ -433,6 +450,45 @@ export function stopPlaywrightProfile(ownerId: string, rawProfile: string): Prom
   );
 }
 
+export interface RemovePlaywrightProfileDataResult {
+  dataDir: string;
+  processStopped: boolean;
+  dataRemoved: boolean;
+}
+
+export interface RemovePlaywrightProfileDataOptions {
+  /** Revalidate external ownership immediately before the synchronous removal. */
+  beforeRemove?: () => void;
+  /** Commit external metadata before releasing the profile lifecycle barrier. */
+  afterRemove?: () => void;
+}
+
+/** Stop all exact-profile processes and remove its data through the configured host boundary. */
+export function removePlaywrightProfileData(
+  ownerId: string,
+  rawProfile: string,
+  options: RemovePlaywrightProfileDataOptions = {},
+): Promise<RemovePlaywrightProfileDataResult> {
+  return withPlaywrightProfileMaintenance(
+    ownerId,
+    rawProfile,
+    async (binding, { stopInstance }) => {
+      const dataDir = resolveUserDataDir(binding.instanceKey);
+      const processStopped = await stopInstance(binding.instanceKey);
+      managerHost.cleanupBrowserProcessesForDataDir(dataDir);
+      deletePortFile(binding.instanceKey);
+      options.beforeRemove?.();
+      const removeProfileDataDir = managerHost.removeProfileDataDir;
+      if (!removeProfileDataDir) {
+        throw new Error("Browser profile deletion is not configured for this host.");
+      }
+      const dataRemoved = removeProfileDataDir(dataDir);
+      options.afterRemove?.();
+      return { dataDir, processStopped, dataRemoved };
+    },
+  );
+}
+
 // A shared profile may have several concurrent turns. Reference counts keep an
 // idle sweep from evicting the process until every borrower has finished.
 const pinnedInstances = new Map<string, number>();

package/dist/runtime/src/platform/playwright/profile-management.ts

@@ -0,0 +1,33 @@
+import { removePlaywrightProfileData } from "#platform/playwright/manager";
+import { assertBrowserProfileDeletable, deleteBrowserProfile } from "#storage/browser-profiles";
+
+export interface DeleteManagedBrowserProfileResult {
+  profile: string;
+  metadataRemoved: boolean;
+  dataRemoved: boolean;
+  processStopped: boolean;
+}
+
+/** Delete an unused named profile while serialized against browser startup. */
+export async function deleteManagedBrowserProfile(
+  ownerId: string,
+  rawProfile: string,
+): Promise<DeleteManagedBrowserProfileResult> {
+  const profile = assertBrowserProfileDeletable(ownerId, rawProfile);
+  let metadataRemoved = false;
+  const removed = await removePlaywrightProfileData(ownerId, profile, {
+    beforeRemove: () => {
+      assertBrowserProfileDeletable(ownerId, profile);
+    },
+    afterRemove: () => {
+      metadataRemoved = deleteBrowserProfile(ownerId, profile);
+    },
+  });
+
+  return {
+    profile,
+    metadataRemoved,
+    dataRemoved: removed.dataRemoved,
+    processStopped: removed.processStopped,
+  };
+}

package/dist/runtime/src/platform/playwright/public-runtime.ts

@@ -20,6 +20,7 @@ export {
   type PlaywrightProfileBinding,
   pinPlaywrightInstance,
   reapPlaywrightOrphans,
+  removePlaywrightProfileData,
   resetPlaywrightManagerHost,
   resolvePlaywrightCapabilityOwner,
   resolvePlaywrightProfileBinding,
@@ -39,6 +40,10 @@ export {
   waitForChildProcessExit,
   waitForChildProcessSpawnError,
 } from "./manager-utils";
+export {
+  type DeleteManagedBrowserProfileResult,
+  deleteManagedBrowserProfile,
+} from "./profile-management";
 export {
   probeMcpTransport,
   probePlaywrightMcpTransports,

package/dist/runtime/src/platform/playwright/vault-broker.ts

@@ -3,7 +3,7 @@ import { chmodSync } from "node:fs";
 import { createServer, type Server, type Socket } from "node:net";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
-import { normalizeVaultKey, redactVaultSecrets, vaultListWithValues } from "#storage/vault-public";
+import { redactVaultSecrets, vaultGetValue, vaultSubstituteDetailed } from "#storage/vault-public";
 
 const MAX_REQUEST_BYTES = 16 * 1024 * 1024;
 const DEFAULT_OUTPUT_LIMIT = 100_000;
@@ -158,16 +158,15 @@ export async function createBrowserVaultBroker(userId: string): Promise<BrowserV
       if (leases.size >= MAX_ACTIVE_LEASES) {
         return { id, ok: false, error: "too many active leases" };
       }
-      const entries = new Map(vaultListWithValues(userId).map((entry) => [entry.key, entry.value]));
-      const substituted = deepMapStrings(request.value, (text) =>
-        text.replace(/\{\{([^}]+)\}\}/g, (match, rawKey: string) => {
-          const key = normalizeVaultKey(rawKey);
-          const secret = entries.get(key);
-          if (secret === undefined) return match;
+      const substituted = deepMapStrings(request.value, (text) => {
+        const result = vaultSubstituteDetailed(userId, text);
+        for (const key of result.usedKeys) {
+          const secret = vaultGetValue(userId, key);
+          if (secret === undefined) continue;
           for (const form of encodedSecretForms(secret)) retainedForms.set(form, key);
-          return secret;
-        }),
-      );
+        }
+        return result.text;
+      });
       const prepared = prepareInput(request.tool, substituted);
       const lease = randomBytes(24).toString("hex");
       leases.set(lease, { boundary: prepared.boundary, createdAt: Date.now() });

package/dist/runtime/src/storage/browser-profiles.ts

@@ -6,6 +6,7 @@ export interface BrowserProfileRecord {
   name: string;
   createdAt: string | null;
   topics: Array<{ id: string; title: string }>;
+  deletable: boolean;
 }
 
 export function normalizeBrowserProfileName(name: string): string {
@@ -103,14 +104,26 @@ export function listBrowserProfiles(ownerId: string): BrowserProfileRecord[] {
     name: DEFAULT_BROWSER_PROFILE,
     createdAt: null,
     topics: [],
+    deletable: false,
   });
   for (const row of records) {
-    byName.set(row.name, { name: row.name, createdAt: row.created_at, topics: [] });
+    byName.set(row.name, {
+      name: row.name,
+      createdAt: row.created_at,
+      topics: [],
+      deletable: true,
+    });
   }
   for (const topic of topics) {
     const name = topic.browser_profile || DEFAULT_BROWSER_PROFILE;
-    const record = byName.get(name) ?? { name, createdAt: null, topics: [] };
+    const record = byName.get(name) ?? {
+      name,
+      createdAt: null,
+      topics: [],
+      deletable: name !== DEFAULT_BROWSER_PROFILE,
+    };
     record.topics.push({ id: topic.id, title: topic.title });
+    record.deletable = false;
     byName.set(name, record);
   }
   return [...byName.values()].sort((a, b) => {
@@ -120,16 +133,28 @@ export function listBrowserProfiles(ownerId: string): BrowserProfileRecord[] {
   });
 }
 
-export function deleteBrowserProfile(ownerId: string, rawName: string): void {
+export function assertBrowserProfileDeletable(ownerId: string, rawName: string): string {
   void ownerId;
   const name = normalizeBrowserProfileName(rawName);
   if (name === DEFAULT_BROWSER_PROFILE) throw new Error("The default profile cannot be deleted.");
-  const used = db
-    .query<{ count: number }, string>(
-      `SELECT COUNT(*) AS count FROM api_topics t
-       WHERE t.browser_profile = ?`,
+  const topics = db
+    .query<{ id: string; title: string }, string>(
+      `SELECT t.id, t.title FROM api_topics t
+       WHERE t.browser_profile = ?
+       ORDER BY t.title`,
     )
-    .get(name)?.count;
-  if (used) throw new Error(`Profile "${name}" is assigned to ${used} topic(s).`);
-  db.query("DELETE FROM browser_profiles WHERE owner_id = ? AND name = ?").run("local", name);
+    .all(name);
+  if (topics.length > 0) {
+    const assigned = topics.map((topic) => `${topic.title} (${topic.id})`).join(", ");
+    throw new Error(`Profile "${name}" is assigned to ${topics.length} topic(s): ${assigned}.`);
+  }
+  return name;
+}
+
+export function deleteBrowserProfile(ownerId: string, rawName: string): boolean {
+  const name = assertBrowserProfileDeletable(ownerId, rawName);
+  const result = db
+    .query("DELETE FROM browser_profiles WHERE owner_id = ? AND name = ?")
+    .run("local", name);
+  return Number(result.changes ?? 0) > 0;
 }