@vellumai/assistant 0.12.2-staging.7 → 0.12.2

package/src/__tests__/subagent-tool-gate-mode.test.ts

@@ -66,34 +66,6 @@ mock.module("../daemon/conversation-skill-tools.js", () => ({
   })),
 }));
 
-// Records every wire tool surface the resolver persists (conversation id +
-// tool names + the hash it already knew), and lets a test make the write fail.
-let recordedSurfaces: Array<{
-  conversationId: string;
-  toolNames: string[];
-  knownHash: string | undefined;
-}> = [];
-let recordSurfaceThrows: Error | null = null;
-mock.module("../persistence/conversation-tool-surface.js", () => ({
-  recordConversationToolSurface: (
-    conversationId: string,
-    tools: ToolDefinition[],
-    knownHash?: string,
-  ) => {
-    recordedSurfaces.push({
-      conversationId,
-      toolNames: tools.map((t) => t.name),
-      knownHash,
-    });
-    if (recordSurfaceThrows) {
-      throw recordSurfaceThrows;
-    }
-    return `hash:${tools.map((t) => t.name).join(",")}`;
-  },
-  hashConversationToolSurface: (tools: ToolDefinition[]) =>
-    `hash:${tools.map((t) => t.name).join(",")}`,
-}));
-
 // ---------------------------------------------------------------------------
 // Imports after mocks are in place
 // ---------------------------------------------------------------------------
@@ -103,7 +75,6 @@ import { createSurfaceMutex } from "../daemon/conversation-surfaces.js";
 import {
   createResolveToolsCallback,
   createToolExecutor,
-  createWireToolSurfaceRecorder,
   isRefusedInReadOnlyPass,
   type SubagentToolStats,
 } from "../daemon/conversation-tool-setup.js";
@@ -1146,143 +1117,3 @@ describe("createResolveToolsCallback — read-only hides dynamic MCP tools", ()
     expect(resolve(EMPTY_HISTORY).map((t) => t.name)).toContain("srv_send");
   });
 });
-
-// ---------------------------------------------------------------------------
-// Resolver: wire tool surface record + replay (fork cache parity)
-// ---------------------------------------------------------------------------
-
-describe("createResolveToolsCallback: wire tool surface record and replay", () => {
-  beforeEach(() => {
-    recordedSurfaces = [];
-    recordSurfaceThrows = null;
-    projectedSkillToolNames = [];
-  });
-
-  test("the resolver itself never records: out-of-band callers read it too", () => {
-    const toolDefs = [makeToolDef("remember"), makeToolDef("tool_b")];
-    const ctx = makeProjectionCtx({ conversationId: "conv-live" });
-    const resolve = createResolveToolsCallback(toolDefs, ctx)!;
-
-    // The `/compact` token count resolves outside any turn, where presence
-    // reads clientless; recording here would overwrite the sent surface.
-    resolve(EMPTY_HISTORY);
-
-    expect(recordedSurfaces).toEqual([]);
-    expect(ctx.recordedToolSurfaceHash).toBeUndefined();
-  });
-
-  test("the send-boundary recorder records the sent array, keyed by conversation, and remembers its hash", () => {
-    const ctx = makeProjectionCtx({ conversationId: "conv-live" });
-    const record = createWireToolSurfaceRecorder(ctx);
-    const sent = [makeToolDef("remember"), makeToolDef("web_search")];
-
-    record(sent);
-    record(sent);
-
-    // Every provider call records; the persistence layer dedupes on the hash
-    // handed back from the previous call.
-    expect(recordedSurfaces).toEqual([
-      {
-        conversationId: "conv-live",
-        toolNames: ["remember", "web_search"],
-        knownHash: undefined,
-      },
-      {
-        conversationId: "conv-live",
-        toolNames: ["remember", "web_search"],
-        knownHash: "hash:remember,web_search",
-      },
-    ]);
-    expect(ctx.recordedToolSurfaceHash).toBe("hash:remember,web_search");
-  });
-
-  test("a failed record is swallowed and still counts as recorded", () => {
-    recordSurfaceThrows = new Error("no such table");
-    const record = createWireToolSurfaceRecorder(
-      makeProjectionCtx({ conversationId: "conv-live" }),
-    );
-
-    expect(() => record([makeToolDef("remember")])).not.toThrow();
-    record([makeToolDef("remember")]);
-
-    // The second call carries the hash from the failed first one, so a
-    // persistent failure is retried once per distinct surface, not per call.
-    expect(recordedSurfaces.map((r) => r.knownHash)).toEqual([
-      undefined,
-      "hash:remember",
-    ]);
-  });
-
-  test("the recorder skips arrays that are not the conversation's own surface", () => {
-    const tools = [makeToolDef("remember")];
-
-    // A replaying wake sends its source's array.
-    createWireToolSurfaceRecorder(
-      makeProjectionCtx({ conversationId: "conv-fork", wireToolReplay: tools }),
-    )(tools);
-    // A tools-disabled call sends nothing; a fork replaying [] could never
-    // call remember.
-    createWireToolSurfaceRecorder(
-      makeProjectionCtx({ conversationId: "conv-live" }),
-    )([]);
-    // Disk-pressure cleanup narrows the wire to cleanup tools.
-    createWireToolSurfaceRecorder(
-      makeProjectionCtx({
-        conversationId: "conv-live",
-        diskPressureCleanupModeActive: true,
-      }),
-    )(tools);
-
-    expect(recordedSurfaces).toEqual([]);
-  });
-
-  test("replays wireToolReplay verbatim on the wire while execution still derives from the fork's own context", () => {
-    projectedSkillToolNames = ["scaffold_managed_skill"];
-    const replay: ToolDefinition[] = [
-      makeToolDef("bash"),
-      makeToolDef("remember"),
-      makeToolDef("bell_jingle"),
-      {
-        type: "web_search_20250305",
-        name: "web_search",
-        max_uses: 5,
-      } as unknown as ToolDefinition,
-    ];
-    // The fork's own registry lacks bell_jingle (a user-plugin tool the
-    // worker never loads) and web_search (a server tool the loop appends).
-    const toolDefs = [makeToolDef("remember"), makeToolDef("bash")];
-    const ctx = makeProjectionCtx({
-      conversationId: "conv-fork",
-      subagentAllowedTools: new Set(["remember"]),
-      subagentToolGateMode: "execution",
-      wireToolReplay: replay,
-    });
-    const resolve = createResolveToolsCallback(toolDefs, ctx)!;
-
-    const tools = resolve(EMPTY_HISTORY);
-
-    // Byte-identical to the source's recorded array, in the source's order,
-    // including definitions this process could never resolve.
-    expect(JSON.stringify(tools)).toBe(JSON.stringify(replay));
-    // Execution-side inventory is still the fork's own derivation (plus the
-    // preactivated skill tools), never widened by the replayed definitions.
-    expect(ctx.allowedToolNames).toEqual(
-      new Set(["remember", "bash", "scaffold_managed_skill"]),
-    );
-  });
-
-  test("replay returns a fresh array each call so the loop cannot mutate the recorded one", () => {
-    const replay = [makeToolDef("remember")];
-    const ctx = makeProjectionCtx({
-      conversationId: "conv-fork",
-      wireToolReplay: replay,
-    });
-    const resolve = createResolveToolsCallback([makeToolDef("remember")], ctx)!;
-
-    const first = resolve(EMPTY_HISTORY);
-    first.push(makeToolDef("injected"));
-
-    expect(resolve(EMPTY_HISTORY).map((t) => t.name)).toEqual(["remember"]);
-    expect(replay.map((t) => t.name)).toEqual(["remember"]);
-  });
-});

package/src/__tests__/terminal-tools.test.ts

@@ -44,7 +44,6 @@ import {
   formatShellOutput,
   MAX_OUTPUT_LENGTH,
   OUTPUT_TRUNCATED_TAG,
-  SHELL_DID_NOT_START_MESSAGE,
 } from "../tools/shared/shell-output.js";
 import {
   ALWAYS_INJECTED_ENV_VARS,
@@ -335,13 +334,6 @@ describe("formatShellOutput", () => {
     expect(result.isError).toBe(false);
   });
 
-  test("a close with exit 0 and empty pipes is an error when the process never started", () => {
-    const result = formatShellOutput("", "", 0, false, 120, { started: false });
-    expect(result.content).toBe(SHELL_DID_NOT_START_MESSAGE);
-    expect(result.isError).toBe(true);
-    expect(result.content).not.toBe("<command_completed />");
-  });
-
   test("failed command with no output shows exit code tag and descriptive message", () => {
     const result = formatShellOutput("", "", 1, false, 120);
     expect(result.content).toContain('<command_exit code="1" />');

package/src/__tests__/unicode.test.ts

@@ -4,7 +4,6 @@ import {
   safeStringSlice,
   stripOrphanedSurrogates,
   stripOrphanedSurrogatesDeep,
-  surrogateSafeWindow,
 } from "../util/unicode.js";
 
 // U+1F389 PARTY POPPER = "\uD83C\uDF89" (a surrogate pair).
@@ -303,38 +302,3 @@ describe("stripOrphanedSurrogatesDeep", () => {
     expect(() => JSON.parse(json)).not.toThrow();
   });
 });
-
-describe("surrogateSafeWindow", () => {
-  const codeAt = (text: string) => (i: number) => text.charCodeAt(i);
-
-  test("a start that lands on a low surrogate backs up to include the pair", () => {
-    const text = `a${EMOJI}b`;
-    expect(surrogateSafeWindow(text.length, codeAt(text), 2, 10)).toEqual({
-      start: 1,
-      end: 4,
-    });
-  });
-
-  test("an end that would cut a pair backs off one unit", () => {
-    const text = `ab${EMOJI}cd`;
-    expect(surrogateSafeWindow(text.length, codeAt(text), 0, 3)).toEqual({
-      start: 0,
-      end: 2,
-    });
-  });
-
-  test("a one-unit window on a pair takes the whole pair so paging advances", () => {
-    const text = `${EMOJI}x`;
-    expect(surrogateSafeWindow(text.length, codeAt(text), 0, 1)).toEqual({
-      start: 0,
-      end: 2,
-    });
-  });
-
-  test("clamps to the text bounds", () => {
-    expect(surrogateSafeWindow(3, codeAt("abc"), 10, 5)).toEqual({
-      start: 3,
-      end: 3,
-    });
-  });
-});

package/src/agent/loop.ts

@@ -1047,17 +1047,6 @@ export interface AgentLoopConstructorOptions {
   tools?: ToolDefinition[];
   toolExecutor?: LoopToolExecutor;
   resolveTools?: (history: Message[]) => ToolDefinition[];
-  /**
-   * Observer for the final tool array of each provider call, invoked
-   * immediately before the request leaves with exactly what goes on the wire
-   * (after any provider-native tool is appended, past the inter-call throttle
-   * and the pre-model hooks, and not at all once the run is aborted). This is
-   * the only point that sees the sent array: the dynamic `resolveTools`
-   * callback is also consulted out of band (token counting, compaction
-   * estimates), so a consumer that needs "what the last request sent"
-   * subscribes here rather than wrapping the resolver. Must not throw.
-   */
-  onToolsSent?: (tools: ToolDefinition[]) => void;
   /**
    * Conversation this loop drives. Scopes the loop-held compaction circuit
    * breaker and is the source of truth the loop's pipeline contexts and
@@ -1098,7 +1087,6 @@ export class AgentLoop {
   private config: AgentLoopConfig;
   private tools: ToolDefinition[];
   private resolveTools: ((history: Message[]) => ToolDefinition[]) | null;
-  private onToolsSent: ((tools: ToolDefinition[]) => void) | null;
   private toolExecutor: LoopToolExecutor | null;
 
   /**
@@ -1134,7 +1122,6 @@ export class AgentLoop {
       tools,
       toolExecutor,
       resolveTools,
-      onToolsSent,
       conversationId,
       resolveConversationDir,
       transformCompactedHistory,
@@ -1144,7 +1131,6 @@ export class AgentLoop {
     this.config = { ...DEFAULT_CONFIG, ...config };
     this.tools = tools ?? [];
     this.resolveTools = resolveTools ?? null;
-    this.onToolsSent = onToolsSent ?? null;
     this.toolExecutor = toolExecutor ?? null;
     this.conversationId = conversationId;
     this.resolveConversationDir = resolveConversationDir ?? null;
@@ -2255,11 +2241,6 @@ export class AgentLoop {
         // Latency: the request is about to leave for the provider. The span
         // from here to the first streamed token is time-to-first-token.
         latencyTracker?.mark("request_sent");
-        // Every await that could cancel the call is behind us; a run aborted
-        // during the throttle or a hook never reports an array it did not send.
-        if (!signal?.aborted) {
-          this.onToolsSent?.(currentTools);
-        }
         let response: ProviderResponse;
         try {
           response = await traceAsyncSection("agent-loop:provider-send", () =>

package/src/api/index.ts

@@ -34,7 +34,6 @@ import { ConversationErrorEventSchema } from "./events/conversation-error.js";
 import { ConversationInferenceProfileUpdatedEventSchema } from "./events/conversation-inference-profile-updated.js";
 import { ConversationNoticeEventSchema } from "./events/conversation-notice.js";
 import { ConversationTitleUpdatedEventSchema } from "./events/conversation-title-updated.js";
-import { DesktopActivityChangedEventSchema } from "./events/desktop-activity-changed.js";
 import { DiskPressureStatusChangedEventSchema } from "./events/disk-pressure-status-changed.js";
 import { DocumentCommentCreatedEventSchema } from "./events/document-comment-created.js";
 import { DocumentCommentDeletedEventSchema } from "./events/document-comment-deleted.js";
@@ -343,10 +342,6 @@ export {
   type ConversationTitleUpdatedEvent,
   ConversationTitleUpdatedEventSchema,
 } from "./events/conversation-title-updated.js";
-export {
-  type DesktopActivityChangedEvent,
-  DesktopActivityChangedEventSchema,
-} from "./events/desktop-activity-changed.js";
 export {
   type DiskPressureBlockedCapability,
   DiskPressureBlockedCapabilitySchema,
@@ -1005,7 +1000,6 @@ export const AssistantEventSchema = z.discriminatedUnion("type", [
   ConversationInferenceProfileUpdatedEventSchema,
   ConversationNoticeEventSchema,
   ConversationTitleUpdatedEventSchema,
-  DesktopActivityChangedEventSchema,
   DiskPressureStatusChangedEventSchema,
   DocumentCommentCreatedEventSchema,
   DocumentCommentDeletedEventSchema,

package/src/approvals/approval-primitive.ts

@@ -213,10 +213,7 @@ function consumeGrantSync(params: ConsumeGrantParams): ConsumeGrantResult {
       return { ok: true, grant: reqResult.grant };
     }
 
-    // Debug, not info: `consumeGrantForInvocation` and the inline grant wait
-    // poll this function, so a miss is the expected steady state while a
-    // guardian decides. Hits and the wait's outcome are logged at info.
-    log.debug(
+    log.info(
       {
         event: "approval_primitive_consume_miss",
         mode: "request_id",
@@ -258,7 +255,7 @@ function consumeGrantSync(params: ConsumeGrantParams): ConsumeGrantResult {
     return { ok: true, grant: sigResult.grant };
   }
 
-  log.debug(
+  log.info(
     {
       event: "approval_primitive_consume_miss",
       mode: "tool_signature",

package/src/approvals/scoped-approval-grants.ts

@@ -193,10 +193,7 @@ function consumeScopedApprovalGrantByRequestId(
       .get();
 
     if (!candidate) {
-      // Debug, not info: the inline grant wait and the voice retry loop call
-      // this every poll, so a miss is the expected steady state while a
-      // guardian decides. The caller logs the outcome of the wait.
-      log.debug(
+      log.info(
         {
           event: "scoped_grant_consume_miss",
           requestId,
@@ -367,8 +364,7 @@ function consumeScopedApprovalGrantByToolSignature(
       .get();
 
     if (!candidate) {
-      // Debug for the same reason as the request-id miss above: polled.
-      log.debug(
+      log.info(
         {
           event: "scoped_grant_consume_miss",
           toolName: params.toolName,

package/src/daemon/__tests__/conversation-tool-setup.test.ts

@@ -6,7 +6,6 @@
 
 import { beforeEach, describe, expect, mock, test } from "bun:test";
 
-import { CONSOLIDATION_ALLOWED_TOOLS } from "../../plugins/defaults/memory/substrate/consolidation-tool-surface.js";
 import type { Conversation } from "../conversation.js";
 import type { ChannelCapabilities } from "../conversation-runtime-assembly.js";
 
@@ -780,45 +779,3 @@ describe("isToolActiveForContext — allowlist-only tools (delete_memory_page)",
     ).toBe(false);
   });
 });
-
-describe("isToolActiveForContext — memory consolidation surface resolves onto the wire", () => {
-  // A background job conversation is not a subagent, so SUBAGENT_ONLY tools
-  // are filtered off before the allowlist applies. Every name the
-  // consolidation run allowlists must survive that gate, or the tool is
-  // silently missing from the run while the allowlist still claims it.
-  const consolidationCtx = () =>
-    makeCtx({
-      subagentAllowedTools: new Set(CONSOLIDATION_ALLOWED_TOOLS),
-      subagentToolGateMode: "wire",
-    });
-
-  test("every allowlisted tool is active for a background conversation", () => {
-    for (const name of CONSOLIDATION_ALLOWED_TOOLS) {
-      expect(isToolActiveForContext(name, consolidationCtx()), name).toBe(true);
-    }
-  });
-
-  test("the shell and the page-delete primitive are on the surface", () => {
-    expect(isToolActiveForContext("bash", consolidationCtx())).toBe(true);
-    expect(
-      isToolActiveForContext("delete_memory_page", consolidationCtx()),
-    ).toBe(true);
-  });
-
-  test("network egress and host-proxy tools stay off the wire", () => {
-    for (const name of [
-      "web_fetch",
-      "web_search",
-      "network_request",
-      "host_bash",
-      "host_file_read",
-      "host_file_write",
-      "host_file_edit",
-      "host_cu",
-    ]) {
-      expect(isToolActiveForContext(name, consolidationCtx()), name).toBe(
-        false,
-      );
-    }
-  });
-});

package/src/daemon/conversation-agent-loop.ts

@@ -38,7 +38,6 @@ import {
 import { getConfig } from "../config/loader.js";
 import type { LLMCallSite } from "../config/schemas/llm.js";
 import { isSendUserMessageActiveForTurn } from "../config/send-user-message-gate.js";
-import { desktopAutomationLease } from "../desktop/desktop-automation-lease.js";
 import { writeRelationshipState } from "../home/relationship-state-writer.js";
 import type { UserPromptSubmitInputContext } from "../hooks/types.js";
 import {
@@ -914,7 +913,6 @@ export async function runAgentLoopImpl(
     if (ctx.pendingReactionRecords?.length) {
       ownedReactionRecords.push(...ctx.pendingReactionRecords.splice(0));
     }
-    desktopAutomationLease.releaseForConversation(ctx.conversationId);
     ctx.abortController = null;
     ctx.setProcessing(false);
     unregisterInflightTurn(ctx.conversationId, state);

package/src/daemon/conversation-tool-setup.ts

@@ -22,10 +22,6 @@ import {
 import { supportsChannelReaction } from "../messaging/providers/index.js";
 import type { PermissionPrompter } from "../permissions/prompter.js";
 import type { SecretPrompter } from "../permissions/secret-prompter.js";
-import {
-  hashConversationToolSurface,
-  recordConversationToolSurface,
-} from "../persistence/conversation-tool-surface.js";
 import { getBindingByConversation } from "../persistence/external-conversation-store.js";
 import { getAllDefaultPluginNames } from "../plugins/defaults/main.js";
 import { isActivationSession } from "../plugins/defaults/memory/activation-session-store.js";
@@ -947,50 +943,6 @@ export function canSpawnSubagentsForTurn(ctx: Conversation): boolean {
   );
 }
 
-/**
- * Build the agent loop's `onToolsSent` observer for a conversation: record
- * the tool array each provider call sends so a later fork wake can replay it
- * (`recordConversationToolSurface`). Only the loop's send boundary sees the
- * sent array. The resolver is also consulted out of band (the token count
- * behind `/compact` and `/clean`, compaction estimates), where a read outside
- * any turn resolves a clientless surface that would overwrite the one the
- * conversation's turns actually send.
- *
- * Arrays that are not the conversation's own surface are skipped: a replaying
- * wake sends its source's array, an empty array is a tools-disabled call (a
- * fork replaying it could never call `remember`), and disk-pressure cleanup
- * mode narrows the wire to cleanup tools. Best-effort: a failed write is
- * logged and the array still counts as recorded, so a persistent failure logs
- * once per distinct surface rather than once per provider call.
- */
-export function createWireToolSurfaceRecorder(
-  ctx: Conversation,
-): (tools: ToolDefinition[]) => void {
-  return (tools) => {
-    if (
-      !ctx.conversationId ||
-      ctx.wireToolReplay ||
-      tools.length === 0 ||
-      ctx.diskPressureCleanupModeActive === true
-    ) {
-      return;
-    }
-    try {
-      ctx.recordedToolSurfaceHash = recordConversationToolSurface(
-        ctx.conversationId,
-        tools,
-        ctx.recordedToolSurfaceHash,
-      );
-    } catch (err) {
-      log.warn(
-        { err, conversationId: ctx.conversationId },
-        "failed to record the conversation's wire tool surface; continuing",
-      );
-      ctx.recordedToolSurfaceHash = hashConversationToolSurface(tools);
-    }
-  };
-}
-
 /**
  * Build a resolveTools callback that merges base tool definitions with
  * dynamically projected skill tools on each agent turn. Also updates
@@ -1285,14 +1237,6 @@ export function createResolveToolsCallback(
 
     ctx.allowedToolNames = turnAllowed;
 
-    // A wake replaying its source's recorded surface sends that array
-    // verbatim: the wire tool block is the first tier of the provider cache
-    // prefix (tools → system → messages), so only the same bytes read the
-    // source's cached prefix instead of rewriting it. Execution is unaffected:
-    // `allowedToolNames` above and the executor's allowlist gate still decide
-    // what may run.
-    return ctx.wireToolReplay
-      ? [...ctx.wireToolReplay]
-      : applyActivityField(allBaseDefs);
+    return applyActivityField(allBaseDefs);
   };
 }

package/src/daemon/conversation.ts

@@ -181,7 +181,6 @@ import {
   canSpawnSubagentsForTurn,
   createResolveToolsCallback,
   createToolExecutor,
-  createWireToolSurfaceRecorder,
 } from "./conversation-tool-setup.js";
 import { canonicalizeTimeZone } from "./date-context.js";
 import { HostAppControlProxy } from "./host-app-control-proxy.js";
@@ -453,21 +452,6 @@ export class Conversation {
    * @internal
    */
   toolContextPin?: WakeToolContextPin;
-  /**
-   * Tool definitions sent verbatim in place of the resolved wire array, for
-   * a wake replaying its source conversation's recorded surface
-   * (`recordConversationToolSurface`). Set and restored alongside the
-   * allowlist by `scopeWakeAllowedTools`; read only where the resolver returns
-   * the wire array, so it never widens what may execute.
-   * @internal
-   */
-  wireToolReplay?: readonly ToolDefinition[];
-  /**
-   * Hash of the wire tool array last recorded for this conversation in this
-   * process, so an unchanged surface is not rewritten on every provider call.
-   * @internal
-   */
-  recordedToolSurfaceHash?: string;
   /** @internal */ readonly skillProjectionState = new Map<string, string>();
   /** @internal */ readonly skillProjectionCache: SkillProjectionCache = {};
   /** @internal */ usageStats: UsageStats = {
@@ -1054,7 +1038,6 @@ export class Conversation {
       tools: toolDefs.length > 0 ? toolDefs : undefined,
       toolExecutor: toolDefs.length > 0 ? toolExecutor : undefined,
       resolveTools,
-      onToolsSent: createWireToolSurfaceRecorder(this),
       resolveConversationDir: () => {
         const conv = getConversation(this.conversationId);
         if (!conv) {

package/src/daemon/daemon-control.ts

@@ -258,11 +258,15 @@ async function getDaemonStatus(): Promise<{
   return { running: true, pid };
 }
 
+function getStartupLockPath(): string {
+  return getDaemonStartupLockPath();
+}
+
 /** Attempt to acquire a startup lock. Returns true on success. Stale locks
  *  (older than STARTUP_LOCK_STALE_MS) are forcibly removed to prevent
  *  permanent deadlocks from a crashed caller. */
 function acquireStartupLock(): boolean {
-  const lockPath = getDaemonStartupLockPath();
+  const lockPath = getStartupLockPath();
   try {
     // Ensure the root directory exists before attempting the lock file write.
     // On a first-time run, getRootDir() may not exist yet, and writeFileSync
@@ -289,7 +293,7 @@ function acquireStartupLock(): boolean {
 
 function releaseStartupLock(): void {
   try {
-    unlinkSync(getDaemonStartupLockPath());
+    unlinkSync(getStartupLockPath());
   } catch {
     /* already removed */
   }

package/src/daemon/orphan-reaper.ts

@@ -1,10 +1,9 @@
 /**
  * Periodic reaper for orphaned subprocesses that reparent to the daemon.
  *
- * POSIX tools run commands in their own process group (`detached: true`) and,
- * on timeout/abort, group-kill with `process.kill(-pgid, SIGKILL)` (the bash
- * and host_bash tools, and the skill sandbox runner). Windows piped shell
- * children stay attached and are torn down with `taskkill /T`. The
+ * Tools run commands in their own process group (`detached: true`) and, on
+ * timeout/abort, group-kill with `process.kill(-pgid, SIGKILL)` (the bash and
+ * host_bash tools, and the skill sandbox runner). The
  * immediate child is reaped by Bun/libuv, but its descendants — e.g. git's
  * transport helpers or a skill runner's `bun` process — were never spawned by
  * the daemon, so when the group dies they reparent to PID 1. When the daemon

package/src/daemon/tool-setup-types.ts

@@ -59,12 +59,6 @@ export interface SubagentToolStats {
  * parity for desktop/web sources; channel-routed sources resolve every tool
  * gate identically under `hasNoClient: true` with or without them.)
  *
- * A wake that also carries its source's recorded wire array
- * (`Conversation.wireToolReplay`, set by `scopeWakeAllowedTools`) sends that
- * array verbatim, so the pin then shapes only the execution-side inventory
- * (`allowedToolNames`); the pin alone carries wire parity for a source with
- * no recorded surface.
- *
  * Tool-definition resolution ONLY. The executor callback and host-proxy
  * attachment paths never read the pin, so it cannot make a host tool
  * runnable: in execution gate mode every non-allowlisted call is rejected