@yannelli/paseo-linear-plugin 1.1.0-beta.0 → 1.1.0-beta.2

package/server/agent-runs.ts

@@ -20,6 +20,8 @@ export interface InternalRun<T> {
   /** Folder the agent works in; its reads must stay inside. */
   cwd: string;
   provider: string;
+  /** Thinking option for the model in `provider`; ignored when another model runs. */
+  effort?: string;
   title: string;
   prompt: string;
   labels: Record<string, string>;
@@ -144,7 +146,7 @@ export async function agentConfigFor(paseo: Paseo, preferred: string) {
   return { provider, ...(modeId ? { modeId } : {}) };
 }
 
-async function lastReply(handle: AgentHandle) {
+export async function lastReply(handle: AgentHandle) {
   const page = await handle.timeline.refetch({
     direction: "tail",
     limit: 60,
@@ -221,8 +223,14 @@ export interface StartedRun<T> {
   result: Promise<T>;
 }
 
+/** Adds the chosen effort only when the chosen model runs, not a fallback provider. */
+export function withEffort<C extends { provider: string }>(config: C, chosen: string, effort?: string) {
+  const applies = Boolean(effort) && chosen.includes("/") && config.provider === chosen;
+  return applies ? { ...config, thinkingOptionId: effort as string } : config;
+}
+
 export async function startInternalRun<T>(run: InternalRun<T>): Promise<StartedRun<T>> {
-  const config = await agentConfigFor(run.paseo, run.provider);
+  const config = withEffort(await agentConfigFor(run.paseo, run.provider), run.provider, run.effort);
   const handle = await run.workspace.agents.create({
     config,
     title: run.title,
@@ -239,6 +247,8 @@ export interface JobStore<T> {
   start(id: string | null, begin: () => Promise<StartedRun<T>>): Promise<Job>;
   /** Resolves with the job once it is done or failed; null for an unknown id. */
   wait(id: string): Promise<Job | null>;
+  /** Drops a finished job, so the next start makes a new run. A running job is kept. */
+  forget(id: string): void;
 }
 
 interface JobRecord<T> {
@@ -254,6 +264,9 @@ export function createJobStore<T>(): JobStore<T> {
       const record = jobs.get(id);
       return record ? { job: record.job, value: record.value } : null;
     },
+    forget(id) {
+      if (jobs.get(id)?.job.status !== "running") jobs.delete(id);
+    },
     async wait(id) {
       const record = jobs.get(id);
       if (!record) return null;

package/server/agent-tools.ts

@@ -0,0 +1,240 @@
+import { createHash, randomBytes } from "node:crypto";
+import path from "node:path";
+import type { PluginServerContext } from "@getpaseo/plugin/server";
+import { z } from "zod";
+import {
+  AGENT_TOOLS,
+  agentToolsRpc,
+  childBrief,
+  EditIssueInput,
+  editText,
+  issueText,
+  LINEAR_TOOLS,
+  ReadIssueInput,
+  StartAgentInput,
+  TOOLS_SERVER,
+  taskCount,
+  type ToolScope,
+  ToolScopeSchema,
+  toolPolicy,
+  WaitAgentInput,
+} from "../shared/agent-tools";
+import { AGENT_LABELS } from "../shared/prompts";
+import { lastReply, type Paseo } from "./agent-runs";
+import type { LinearAccess } from "./handlers";
+import { createMcpServer, listenLocal, type McpTool, tool } from "./mcp-http";
+import type { LinearService } from "./queries";
+import { createJsonFile } from "./stores";
+
+// Each launch gets a grant: a random token for the agent's MCP config, and the issue tree it
+// reaches. The file keeps the port and a hash of each token, never the token, so agents keep
+// their tools after a restart.
+
+const MAX_GRANTS = 500;
+
+const GrantSchema = z.object({
+  id: z.string(),
+  hash: z.string(),
+  scope: ToolScopeSchema,
+  /** Only agents started from an issue may start agents, so the tree is one level deep. */
+  canStart: z.boolean(),
+  createdAt: z.string(),
+});
+export type Grant = z.infer<typeof GrantSchema>;
+
+const FileSchema = z.object({ port: z.number().int().nullable(), grants: z.array(GrantSchema) });
+
+const hashOf = (token: string) => createHash("sha256").update(token).digest("hex");
+
+export interface AgentToolsDependencies {
+  access: LinearAccess;
+  dataDirectory: string;
+}
+
+/** The root issue or one of its sub-issues; any other key is refused. */
+async function treeIssue(linear: LinearService, scope: ToolScope, key: string | undefined) {
+  const wanted = (key ?? scope.home).toUpperCase();
+  const root = await linear.getIssue(scope.root);
+  if (wanted === root.identifier.toUpperCase()) return root;
+  if (!root.children.some((child) => child.identifier.toUpperCase() === wanted)) {
+    throw new Error(`${wanted} is not ${root.identifier} or one of its sub-issues.`);
+  }
+  return linear.getIssue(wanted);
+}
+
+export function linearTools(deps: AgentToolsDependencies, paseo: () => Paseo, mint: Mint): McpTool<Grant>[] {
+  const callers = new Map<string, string>();
+  async function callerAgent(api: Paseo, grant: Grant): Promise<string | null> {
+    const known = callers.get(grant.id);
+    if (known) return known;
+    const result = await api.agents.list({ filter: { labels: { [AGENT_LABELS.tools]: grant.id } }, page: { limit: 1 } });
+    const id = result.entries[0]?.agent.id ?? null;
+    if (id) callers.set(grant.id, id);
+    return id;
+  }
+  return [
+    tool({
+      name: "read_issue",
+      description: "Read a Linear issue of your issue tree: status, description with its task list, and sub-issues.",
+      input: ReadIssueInput,
+      async run(input, grant) {
+        const { linear } = await deps.access.connect(grant.scope.keyScope);
+        return issueText(await treeIssue(linear, grant.scope, input.issue));
+      },
+    }),
+    tool({
+      name: "edit_issue",
+      description:
+        "Change the description of a Linear issue of your issue tree. Replace exact text, for example `- [ ] Add the form` with `- [x] Add the form` to check off a task list item.",
+      input: EditIssueInput,
+      run(input, grant) {
+        return deps.access.mutate(grant.scope.keyScope, async (linear) => {
+          const issue = await treeIssue(linear, grant.scope, input.issue);
+          const edited = editText(issue.description ?? "", input.old_text, input.new_text);
+          if ("error" in edited) throw new Error(edited.error);
+          await linear.updateIssue(issue.id, { description: edited.body });
+          const tasks = taskCount(edited.body);
+          const count = tasks.total > 0 ? ` ${tasks.done} of ${tasks.total} task list items are checked.` : "";
+          return `Updated the description of ${issue.identifier}.${count}`;
+        });
+      },
+    }),
+    tool({
+      name: "start_agent",
+      description:
+        "Start a Paseo agent on a sub-issue, in your workspace, on your provider and model. It gets read_issue and edit_issue. Returns its id at once.",
+      input: StartAgentInput,
+      allowed: (grant) => grant.canStart,
+      async run(input, grant) {
+        const api = paseo();
+        const key = input.issue.toUpperCase();
+        const { linear } = await deps.access.connect(grant.scope.keyScope);
+        await treeIssue(linear, grant.scope, key);
+        const parent = await callerAgent(api, grant);
+        const child = await mint({ ...grant.scope, home: key }, false);
+        const { keyScope } = grant.scope;
+        const create = (config: ToolScope["config"]) =>
+          api.workspaces.ref(grant.scope.workspaceId).agents.create({
+            config: { ...config, mcpServers: { [TOOLS_SERVER]: child.server }, toolPolicy: child.toolPolicy },
+            ...(parent ? { parent } : {}),
+            title: input.title,
+            prompt: `${childBrief(key, grant.scope.root)}\n\n${input.prompt}`,
+            labels: {
+              [AGENT_LABELS.issue]: key,
+              [AGENT_LABELS.action]: "implement",
+              ...(keyScope ? { [AGENT_LABELS.project]: keyScope } : {}),
+              [AGENT_LABELS.tools]: child.grantId,
+              [AGENT_LABELS.startedBy]: grant.id,
+            },
+          });
+        const base = grant.scope.config;
+        let note = "";
+        let handle: Awaited<ReturnType<typeof create>>;
+        try {
+          handle = await create(input.thinking ? { ...base, thinkingOptionId: input.thinking } : base);
+        } catch (error) {
+          if (!input.thinking) throw error;
+          handle = await create(base);
+          note = ` The model has no thinking option "${input.thinking}", so it uses yours.`;
+        }
+        return `Started agent ${handle.id} on ${key}.${note} Call wait_agent with agent_id "${handle.id}" to get its result.`;
+      },
+    }),
+    tool({
+      name: "wait_agent",
+      description: "Wait for an agent that start_agent started, and get its last reply. Call it again while the agent works.",
+      input: WaitAgentInput,
+      allowed: (grant) => grant.canStart,
+      async run(input, grant) {
+        const id = input.agent_id;
+        const handle = paseo().agents.ref(id);
+        const snapshot = (await handle.refresh().catch(() => null))?.agent;
+        if (snapshot?.labels?.[AGENT_LABELS.startedBy] !== grant.id) {
+          throw new Error(`Agent ${id} was not started by your start_agent calls.`);
+        }
+        const result = await handle.waitForFinish(input.timeout_seconds * 1000);
+        if (result.status === "timeout") return `Agent ${id} is still working. Call wait_agent again.`;
+        if (result.status === "permission") return `Agent ${id} waits for the user to answer a permission request in Paseo.`;
+        if (result.status === "error") return `Agent ${id} stopped with an error: ${result.error ?? "unknown error"}`;
+        const reply = result.lastMessage ?? (await lastReply(handle));
+        return `Agent ${id} finished.\n\nIts last reply:\n${reply || "(no reply)"}`;
+      },
+    }),
+  ];
+}
+
+type Minted = z.infer<typeof agentToolsRpc.output>;
+type Mint = (scope: ToolScope, canStart: boolean) => Promise<Minted>;
+
+export function registerAgentTools(server: PluginServerContext, deps: AgentToolsDependencies) {
+  const file = createJsonFile(path.join(deps.dataDirectory, "agent-tools.json"), FileSchema, () => ({
+    port: null,
+    grants: [],
+  }));
+  // The SDK hands Paseo to handlers and hooks only. The subprocess has one, so keep the latest.
+  let api: Paseo | null = null;
+  const remember = (_event: unknown, context: { paseo: Paseo }) => {
+    api = context.paseo;
+  };
+  server.on("agent.turn_started", remember);
+  server.on("agent.turn_ended", remember);
+  server.on("agent.created", remember);
+  const paseo = () => {
+    if (!api) throw new Error("Paseo is not ready yet. Try again in a few seconds.");
+    return api;
+  };
+
+  let listening: Promise<number> | null = null;
+  const ensureListening = () => {
+    listening ??= file
+      .read()
+      .then((current) => listenLocal(http, current.port))
+      .then(async (port) => {
+        await file.update((current) => ({ next: { ...current, port }, result: null }));
+        return port;
+      });
+    return listening;
+  };
+  const mint: Mint = async (scope, canStart) => {
+    const port = await ensureListening();
+    const token = randomBytes(32).toString("base64url");
+    const grant: Grant = {
+      id: randomBytes(8).toString("hex"),
+      hash: hashOf(token),
+      scope,
+      canStart,
+      createdAt: new Date().toISOString(),
+    };
+    await file.update((current) => ({ next: { ...current, grants: [...current.grants, grant].slice(-MAX_GRANTS) }, result: null }));
+    return {
+      grantId: grant.id,
+      server: { type: "http", url: `http://127.0.0.1:${port}/mcp`, headers: { Authorization: `Bearer ${token}` } },
+      toolPolicy: toolPolicy(canStart ? [...LINEAR_TOOLS, ...AGENT_TOOLS] : [...LINEAR_TOOLS]),
+    };
+  };
+  const http = createMcpServer<Grant>({
+    name: "paseo-linear",
+    version: "1.0.0",
+    tools: linearTools(deps, paseo, mint),
+    async authorize(token) {
+      const hash = hashOf(token);
+      return (await file.read()).grants.find((grant) => grant.hash === hash) ?? null;
+    },
+  });
+
+  server.handle(agentToolsRpc, async (scope, context) => {
+    api = context.paseo;
+    return mint(scope, true);
+  });
+  // Agents from before a restart call the same port, so listen again when grants exist.
+  void file
+    .read()
+    .then((current) => (current.grants.length > 0 ? ensureListening() : null))
+    .catch((error: unknown) => console.error("Linear MCP could not start", error));
+
+  return () =>
+    new Promise<void>((resolve) => {
+      http.closeAllConnections();
+      http.close(() => resolve());
+    });
+}

package/server/init.ts

@@ -47,6 +47,7 @@ export function registerInit(server: PluginServerContext, dependencies: InitDepe
         workspace: await paseo.workspaces.open(rootPath),
         cwd: rootPath,
         provider: settings?.live.exploreProvider || settings?.launch.provider || "",
+        effort: settings?.live.exploreProvider ? settings.live.exploreEffort : "",
         title: `Set up Linear prompts for ${project.projectDisplayName}`,
         prompt: initPrompt(rootPath),
         labels: { [AGENT_LABELS.init]: projectId },

package/server/live.ts

@@ -11,10 +11,13 @@ import {
   type Job,
   type LaunchInput,
   launchAfterExploreRpc,
+  clearMapRpc,
   linksRpc,
   listFilesRpc,
+  subagentLogsRpc,
   liveMapRpc,
   MAX_DIR_ENTRIES,
+  MAX_EXPLORE_FILES,
 } from "../shared/live";
 import { AGENT_LABELS, issueSnapshot } from "../shared/prompts";
 import { type LinearSettings, projectEnabled } from "../shared/settings";
@@ -27,6 +30,7 @@ import {
 } from "./agent-runs";
 import type { LinearAccess } from "./handlers";
 import { fileLinks } from "./links";
+import { subagentLogs } from "./subagent-logs";
 import type { LaunchQueue, MapStore } from "./stores";
 
 const EXPLORE_TIMEOUT_MS = 20 * 60_000;
@@ -41,6 +45,8 @@ export interface AgentInfo {
   /** Paseo project of the agent's workspace, when the workspace is known. */
   projectId: string | null;
   provider: string;
+  /** The provider's session, such as Claude's session id. */
+  sessionId: string | null;
   labels: Record<string, string>;
 }
 
@@ -62,6 +68,7 @@ export async function agentInfo(paseo: Paseo, agentId: string): Promise<AgentInf
     workspaceId,
     projectId: workspace?.projectId ?? null,
     provider: agent.provider,
+    sessionId: agent.runtimeInfo?.sessionId ?? null,
     labels: agent.labels ?? {},
   };
 }
@@ -100,7 +107,7 @@ export function explorePrompt(issue: IssueDetail): string {
     issueSnapshot(issue, { includeComments: false }),
     "",
     "List the files an engineer will most likely read or change for this issue and each sub-issue.",
-    "Include files that will probably be created, at their expected path. List at most 40 files.",
+    `Include files that will probably be created, at their expected path. List at most ${MAX_EXPLORE_FILES} files.`,
     `Set "issue" to the sub-issue key the file belongs to, or ${issue.identifier} for the whole issue.`,
     `Valid keys: ${keys.join(", ")}.`,
     "Reply with only a JSON object in a ```json block, with repo-relative paths:",
@@ -223,6 +230,21 @@ export function registerLive(server: PluginServerContext, dependencies: LiveDepe
     return { links: await fileLinks(agent.cwd, files) };
   });
 
+  server.handle(clearMapRpc, async ({ agentId }, { paseo }) => {
+    const agent = await agentInfo(paseo, agentId);
+    const identifier = agent.labels[AGENT_LABELS.issue];
+    if (!identifier) throw new Error("This agent is not linked to a Linear issue");
+    if (jobs.get(identifier)?.job.status === "running") throw new Error("The explore agent is still mapping this issue");
+    await maps.delete(identifier);
+    jobs.forget(identifier);
+    return { cleared: true };
+  });
+  server.handle(subagentLogsRpc, async ({ agentId }, { paseo }) => {
+    const agent = await agentInfo(paseo, agentId);
+    // Only Claude keeps subagent transcripts this plugin can read.
+    if (agent.provider.split("/")[0] !== "claude" || !agent.sessionId) return { runs: [] };
+    return { runs: await subagentLogs(agent.sessionId, agent.cwd) };
+  });
   server.handle(liveMapRpc, async ({ identifier }, { paseo }) => {
     const map = await maps.get(identifier);
     let job = jobs.get(identifier)?.job ?? null;
@@ -249,6 +271,7 @@ export function registerLive(server: PluginServerContext, dependencies: LiveDepe
     /** Opened only when a new run starts. */
     workspace: () => Promise<WorkspaceHandle>;
     provider: string;
+    effort: string;
     force: boolean;
   }
 
@@ -275,6 +298,7 @@ export function registerLive(server: PluginServerContext, dependencies: LiveDepe
         workspace: await target.workspace(),
         cwd: target.cwd,
         provider: target.provider,
+        effort: target.effort,
         title: `Explore ${identifier}`,
         prompt: explorePrompt(issue),
         labels,
@@ -306,6 +330,7 @@ export function registerLive(server: PluginServerContext, dependencies: LiveDepe
       workspace: async () =>
         workspaceId ? paseo.workspaces.ref(workspaceId) : paseo.workspaces.open(cwd),
       provider: settings?.live.exploreProvider || agent.provider,
+      effort: settings?.live.exploreEffort ?? "",
       force,
     });
     return { job };
@@ -322,6 +347,7 @@ export function registerLive(server: PluginServerContext, dependencies: LiveDepe
       cwd: info.workspaceDirectory ?? info.projectRootPath,
       workspace: async () => workspace,
       provider: settings?.live.exploreProvider || input.agent.config.provider,
+      effort: settings?.live.exploreEffort ?? "",
       force: false,
     });
     // A failed or timed-out explore run still starts the agent; the map falls back to ticket text.

package/server/mcp-http.ts

@@ -0,0 +1,152 @@
+import { createServer, type IncomingMessage, type Server, type ServerResponse } from "node:http";
+import type { AddressInfo } from "node:net";
+import { type ZodType, z } from "zod";
+
+// A small MCP server over HTTP for agents on this host. It sends plain JSON responses, which the
+// streamable HTTP transport allows, so it needs no sessions and no event streams.
+
+export interface McpTool<C> {
+  name: string;
+  description: string;
+  input: ZodType;
+  /** Callers that may list and call the tool; all callers when absent. */
+  allowed?(caller: C): boolean;
+  run(input: unknown, caller: C): Promise<string>;
+}
+
+/** A tool whose run gets its parsed input. */
+export function tool<S extends ZodType, C>(
+  definition: Omit<McpTool<C>, "input" | "run"> & { input: S; run(input: z.output<S>, caller: C): Promise<string> },
+): McpTool<C> {
+  return definition as unknown as McpTool<C>;
+}
+
+export interface McpOptions<C> {
+  name: string;
+  version: string;
+  tools: readonly McpTool<C>[];
+  /** The caller for a bearer token, or null to refuse the request. */
+  authorize(token: string): Promise<C | null>;
+}
+
+const VERSIONS = ["2025-06-18", "2025-03-26", "2024-11-05"];
+const MAX_BODY = 1_000_000;
+
+type Message = { jsonrpc?: unknown; id?: unknown; method?: unknown; params?: unknown };
+
+const failure = (id: unknown, code: number, message: string) => ({ jsonrpc: "2.0", id: id ?? null, error: { code, message } });
+const success = (id: unknown, result: unknown) => ({ jsonrpc: "2.0", id, result });
+const text = (value: string, isError = false) => ({ content: [{ type: "text", text: value }], ...(isError ? { isError } : {}) });
+
+function errorText(error: unknown): string {
+  if (error instanceof z.ZodError) return error.issues.map((issue) => `${issue.path.join(".") || "input"}: ${issue.message}`).join("; ");
+  return error instanceof Error ? error.message : String(error);
+}
+
+/** The answer to one JSON-RPC message, or null for a notification. */
+export async function answer<C>(options: McpOptions<C>, message: Message, caller: C): Promise<object | null> {
+  if (typeof message !== "object" || message === null || message.jsonrpc !== "2.0" || typeof message.method !== "string") {
+    return failure(message?.id, -32600, "Invalid request");
+  }
+  if (message.id === undefined || message.id === null) return null;
+  const params = (typeof message.params === "object" && message.params !== null ? message.params : {}) as Record<string, unknown>;
+  const tools = options.tools.filter((tool) => tool.allowed?.(caller) ?? true);
+  switch (message.method) {
+    case "initialize": {
+      const asked = typeof params.protocolVersion === "string" ? params.protocolVersion : "";
+      return success(message.id, {
+        protocolVersion: VERSIONS.includes(asked) ? asked : VERSIONS[0],
+        capabilities: { tools: { listChanged: false } },
+        serverInfo: { name: options.name, version: options.version },
+      });
+    }
+    case "ping":
+      return success(message.id, {});
+    case "tools/list":
+      return success(message.id, {
+        tools: tools.map((tool) => ({
+          name: tool.name,
+          description: tool.description,
+          inputSchema: z.toJSONSchema(tool.input, { io: "input" }),
+        })),
+      });
+    case "tools/call": {
+      const tool = tools.find((entry) => entry.name === params.name);
+      if (!tool) return failure(message.id, -32602, `Unknown tool: ${String(params.name)}`);
+      try {
+        return success(message.id, text(await tool.run(tool.input.parse(params.arguments ?? {}), caller)));
+      } catch (error) {
+        return success(message.id, text(errorText(error), true));
+      }
+    }
+    default:
+      return failure(message.id, -32601, `Unknown method: ${message.method}`);
+  }
+}
+
+function readBody(request: IncomingMessage): Promise<string | null> {
+  return new Promise((resolve, reject) => {
+    const chunks: Buffer[] = [];
+    let size = 0;
+    request.on("data", (chunk: Buffer) => {
+      size += chunk.length;
+      if (size > MAX_BODY) {
+        resolve(null);
+        request.destroy();
+      } else chunks.push(chunk);
+    });
+    request.on("end", () => resolve(Buffer.concat(chunks).toString("utf8")));
+    request.on("error", reject);
+  });
+}
+
+function send(response: ServerResponse, status: number, body?: unknown) {
+  response.writeHead(status, body === undefined ? {} : { "content-type": "application/json" });
+  response.end(body === undefined ? undefined : JSON.stringify(body));
+}
+
+// Browsers send an Origin header and agents do not, so a web page can never reach the tools.
+export function createMcpServer<C>(options: McpOptions<C>): Server {
+  return createServer(async (request, response) => {
+    try {
+      if (new URL(request.url ?? "/", "http://localhost").pathname !== "/mcp") return send(response, 404);
+      if (request.headers.origin) return send(response, 403);
+      if (request.method !== "POST") {
+        response.setHeader("allow", "POST");
+        return send(response, 405);
+      }
+      const token = /^Bearer (\S+)$/.exec(request.headers.authorization ?? "")?.[1];
+      const caller = token ? await options.authorize(token) : null;
+      if (caller === null) return send(response, 401, failure(null, -32001, "Unknown token"));
+      const raw = await readBody(request);
+      if (raw === null) return send(response, 413);
+      let parsed: unknown;
+      try {
+        parsed = JSON.parse(raw);
+      } catch {
+        return send(response, 400, failure(null, -32700, "Parse error"));
+      }
+      const messages = (Array.isArray(parsed) ? parsed : [parsed]) as Message[];
+      const answers = (await Promise.all(messages.map((message) => answer(options, message, caller)))).filter(Boolean);
+      if (answers.length === 0) return send(response, 202);
+      send(response, 200, Array.isArray(parsed) ? answers : answers[0]);
+    } catch (error) {
+      console.error("Linear MCP request failed", error);
+      if (!response.headersSent) send(response, 500);
+    }
+  });
+}
+
+/** Listens on 127.0.0.1, on the preferred port when it is free. Returns the port. */
+export function listenLocal(server: Server, preferred: number | null): Promise<number> {
+  const attempt = (port: number) =>
+    new Promise<number>((resolve, reject) => {
+      const fail = (error: Error) => reject(error);
+      server.once("error", fail);
+      server.listen(port, "127.0.0.1", () => {
+        server.off("error", fail);
+        resolve((server.address() as AddressInfo).port);
+      });
+    });
+  return preferred ? attempt(preferred).catch(() => attempt(0)) : attempt(0);
+}

package/server/stores.ts

@@ -13,7 +13,7 @@ interface JsonFile<T> {
   update<R>(change: (current: T) => { next: T; result: R }): Promise<R>;
 }
 
-function createJsonFile<T>(file: string, schema: ZodType<T>, empty: () => T): JsonFile<T> {
+export function createJsonFile<T>(file: string, schema: ZodType<T>, empty: () => T): JsonFile<T> {
   let value: T | null = null;
   let queue: Promise<unknown> = Promise.resolve();
   async function load(): Promise<T> {
@@ -51,6 +51,7 @@ function createJsonFile<T>(file: string, schema: ZodType<T>, empty: () => T): Js
 export interface MapStore {
   get(identifier: string): Promise<IssueMap | null>;
   set(map: IssueMap): Promise<void>;
+  delete(identifier: string): Promise<void>;
 }
 
 /** Explore maps survive daemon restarts, so a finished explore run is never paid for twice. */
@@ -72,6 +73,12 @@ export function createMapStore(file: string): MapStore {
         return { next: Object.fromEntries(kept.map((entry) => [entry.identifier, entry])), result: undefined };
       });
     },
+    delete(identifier) {
+      return store.update((current) => {
+        const { [identifier]: _removed, ...rest } = current;
+        return { next: rest, result: undefined };
+      });
+    },
   };
 }