@a-t-h-i/bot-lobby 0.6.44 → 0.6.46

package/README.md

@@ -33,14 +33,25 @@ files the task changed, after the project's linter and a QA pass sized to the ch
 - **Plan**: plan with a panel of agents. **View plan** (`V`) opens the draft in a slide-out, where
   any line takes a comment.
 - **Tasks**: every task across sessions as a list or a board, with its steps, timings and **Resume**.
-- **Issues** and **Git**: plan from an open issue, or have an agent review a pull request read-only.
-  Both read GitHub through `gh` and post nothing.
+- **Git**: use the **Pull requests / Issues** switch to review pull requests or browse open issues
+  through `gh`. Issues retain descriptions, existing comments, **File issue** and **Plan it**;
+  pull-request reviews remain read-only and post nothing.
 - **Knowledge**: what each agent has learned about the project, which you can edit, annotate or ask
   about.
 
 The rail on the left holds settings, the key list, the theme and sounds. The project switcher
-(`P`) sits in the message box and opens any folder on the machine running bot-lobby. A task running
-in a background session opens its conversation from **Tasks**.
+(`P`) opens any folder on the machine running bot-lobby. Background sessions still run tasks;
+follow their progress and use **Resume** in **Tasks**, without a separate Sessions conversation page.
+
+Git opens pull requests at `#/git` and `#/git/<number>`, and issues at `#/git/issues` and
+`#/git/issues/<number>`. Old `#/issues` bookmarks redirect to Git. Former Sessions and Excalidraw
+addresses fall back to Lobby; Excalidraw integration is removed without deleting saved room links
+or external boards.
+
+The composer appears only on **Lobby**, **Tasks**, **Plan**, **Quick fix** and **Knowledge**, including
+supported detail routes and Knowledge's Docs/Chat views. On Git, Metrics and Settings it stays mounted
+but hidden and inert, preserving drafts and attachments (including uploads that finish while hidden)
+without taking space. Phone navigation remains available.
 
 | Agent | Does |
 | --- | --- |

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@a-t-h-i/bot-lobby",
-  "version": "0.6.44",
+  "version": "0.6.46",
   "description": "Structured multi-agent software engineering orchestrator for Pi",
   "type": "module",
   "license": "Apache-2.0",
@@ -72,16 +72,11 @@
     "react-dom": "19.3.0",
     "react-markdown": "10.1.0",
     "remark-gfm": "4.0.1",
-    "socket.io": "4.8.4",
     "tailwind-merge": "3.7.0",
     "tailwindcss": "4.3.3",
     "tw-animate-css": "1.4.0",
     "typebox": "1.3.27",
     "typescript": "^5.7.0",
     "vite": "8.3.2"
-  },
-  "dependencies": {
-    "https-proxy-agent": "^9.1.0",
-    "socket.io-client": "4.8.4"
   }
 }

package/src/execution/agent-runner.ts

@@ -11,7 +11,6 @@ import { ASK_ENV } from "../ask/relay.ts";
 import { STEP_LIMIT_MS } from "../state/step-limits.ts";
 import type { EffortRouter, RunProfileLike } from "../classifier/effort.ts";
 import { ASK_TOOL } from "../ask/types.ts";
-import { agentOfRun, grantOption } from "../excalidraw/sessions.ts";
 
 export interface AgentContext {
   task: string;
@@ -289,7 +288,6 @@ async function runAgentOnce(request: AgentRequest, run: ProcessRunner, attempt:
       } : {}),
       signal,
       ...(request.onAsk ? { onAsk: request.onAsk } : {}),
-      ...grantOption(agentOfRun(request.domain, request.role)),
       env: request.onAsk ? { ...request.env, [ASK_ENV]: "1" } : request.env,
       stallTimeoutMs: request.stallTimeoutMs,
       toolStallTimeoutMs: request.toolStallTimeoutMs,

package/src/execution/delegation.ts

@@ -1,4 +1,3 @@
-import { toolsOf } from "../excalidraw/sessions.ts";
 import { appendMetrics, metricFromRun } from "../state/metrics.ts";
 import { randomUUID } from "node:crypto";
 import { mkdirSync, writeFileSync } from "node:fs";
@@ -73,7 +72,7 @@ export async function delegationHost(options: PiRunOptions, run: ProcessRunner)
   const agent = options.agent ?? { runId: id, taskId: id, domain: "backend" as const, role: editable ? "worker" as const : "reviewer" as const };
   const depth = agent.depth ?? 1;
   const quota = options.delegationQuota ?? { used: 0 };
-  const tools = [...new Set([...baseTools, ...(options.excalidraw ? toolsOf(options.excalidraw) : []), "codemode", "tool_search", ...(canDelegate(agent, quota.used) ? [DELEGATE_TOOL] : [])])];
+  const tools = [...new Set([...baseTools, "codemode", "tool_search", ...(canDelegate(agent, quota.used) ? [DELEGATE_TOOL] : [])])];
   const mcpTools = options.mcpTools ?? agentProfile(config, agent.domain, agent.role).mcpTools ?? [];
   const policy: AgentPolicy = { tools, mcpTools, readOnly: !editable, depth };
   if (depth > 1) return { tools, env: { ...options.env, [AGENT_ENV]: JSON.stringify(policy), [DELEGATION_ENV]: "" }, note: "You are a child agent. Finish only your assigned brief and report evidence to your parent; you cannot delegate further.", close: async () => {}, onStart: options.onStart, children: [] as AgentRun[] };

package/src/execution/pi-runner.ts

@@ -10,7 +10,6 @@ import { activityWord } from "../pi/activity.ts";
 import { shortDuration } from "../text.ts";
 import { readRelayRequest } from "../ask/relay.ts";
 import type { AskQuestion, AskResult } from "../ask/types.ts";
-import { grantEnv, grantNote, type Grant } from "../excalidraw/sessions.ts";
 import type { EffortRouter, RunProfileLike } from "../classifier/effort.ts";
 
 /** Live control over one running subagent: queue a steering message for its next turn. */
@@ -57,8 +56,6 @@ export interface PiRunOptions {
   time?: TimeLimit;
   /** Answers the agent's relayed questions; without it they are cancelled like any other dialog. */
   onAsk?: RelayAsk;
-  /** The Excalidraw sessions assigned to this agent: its tools, the room links in its environment, and a note on them in its task. */
-  excalidraw?: Grant;
 }
 
 /**
@@ -771,7 +768,6 @@ function writePromptFile(prompt: string): { file: string; cleanup: () => void }
 export async function runPiAgent(options: PiRunOptions, run: ProcessRunner = spawnPiProcess): Promise<PiRunResult> {
   const host = await delegationHost(options, run);
   let prompt: ReturnType<typeof writePromptFile> | undefined;
-  const grant = options.excalidraw;
   try {
     prompt = writePromptFile([options.systemPrompt, host.note].filter(Boolean).join("\n\n"));
     if (options.signal?.aborted) return { status: "cancelled", output: "", usage: { input: 0, output: 0, cost: 0, turns: 0 } };
@@ -780,8 +776,8 @@ export async function runPiAgent(options: PiRunOptions, run: ProcessRunner = spa
       cwd: options.cwd,
       signal: options.signal,
       timeoutMs: options.timeoutMs,
-      prompt: `Task: ${options.task}${grant ? `\n\n${grantNote(grant)}` : ""}`,
-      env: grant ? { ...host.env, ...grantEnv(grant) } : host.env,
+      prompt: `Task: ${options.task}`,
+      env: host.env,
       stallTimeoutMs: options.stallTimeoutMs,
       toolStallTimeoutMs: options.toolStallTimeoutMs,
       wrapUpAtMs: options.wrapUpAtMs,

package/src/execution/task-cancellation.ts

@@ -0,0 +1,27 @@
+import { resolve } from "node:path";
+
+const executions = new Map<string, Set<AbortController>>();
+const key = (root: string, configDir: string, taskId: string) => JSON.stringify([resolve(root), configDir, taskId]);
+
+/** Scope an orchestration action and its workers/children to one project task. */
+export function taskExecution(root: string, configDir: string, taskId: string, parent?: AbortSignal) {
+  const id = key(root, configDir, taskId);
+  const controller = new AbortController();
+  const running = executions.get(id) ?? new Set<AbortController>();
+  running.add(controller);
+  executions.set(id, running);
+  return {
+    signal: parent ? AbortSignal.any([parent, controller.signal]) : controller.signal,
+    release: () => {
+      running.delete(controller);
+      if (!running.size) executions.delete(id);
+    },
+  };
+}
+
+/** Abort only this task's orchestration and the subprocesses inheriting its signal. */
+export function cancelTaskExecutions(root: string, configDir: string, taskId: string): void {
+  for (const controller of executions.get(key(root, configDir, taskId)) ?? []) {
+    controller.abort(new Error("Task abandoned by the user"));
+  }
+}

package/src/index.ts

@@ -19,7 +19,6 @@ import { registerClassifierTools } from "./classifier/tools.ts";
 import { registerFreshContext } from "./pi/fresh-context.ts";
 import { registerAskTool } from "./ask/tool.ts";
 import { registerWebTools } from "./web/tools.ts";
-import { registerExcalidrawTools } from "./excalidraw/tools.ts";
 import { registerToolBudget } from "./pi/tool-budget.ts";
 
 export default function (pi: ExtensionAPI): void {
@@ -49,8 +48,6 @@ export default function (pi: ExtensionAPI): void {
   registerAskTool(pi, undefined, CONFIG_DIR_NAME);
   // The web tools, for the researcher and for pi without a task (the oracle leaves them to the researcher).
   registerWebTools(pi);
-  // The shared Excalidraw sessions the user assigned to agents: the oracle here, every other agent through its own grant.
-  registerExcalidrawTools(pi, CONFIG_DIR_NAME);
   // Parallel workers share files through the master's file desk.
   if (isSubagentProcess()) registerDeskClient(pi);
   // Subagents look files up with the classifier (the engine allows the tool only while file hints are on).

package/src/lobby/host.ts

@@ -18,18 +18,11 @@ import type { IssuesState } from "./issues.ts";
 import type { PullsState } from "./pulls.ts";
 import type { PullReviews } from "./pr-review.ts";
 import type { KnowledgeBook } from "./knowledge.ts";
-import type { ExcalidrawBook, ExcalidrawSession } from "../excalidraw/sessions.ts";
 import type { WorkspaceInfo } from "../execution/workspace.ts";
 
 export { TAB_IDS, TAB_LABELS, visibleTabs } from "./prompts.ts";
 export type { TabId } from "./prompts.ts";
 
-/** What a checked Excalidraw session reported. */
-export interface SessionCheck {
-  ok: boolean;
-  text: string;
-}
-
 /**
  * Which session the Lobby tab shows and talks to: this window, one it started
  * in the background, one running in another terminal, or a task whose
@@ -147,10 +140,6 @@ export interface LobbyService {
   reviews: PullReviews;
   /** Every agent's knowledge files: read, edited, commented on. */
   knowledge: KnowledgeBook;
-  /** The shared Excalidraw sessions (five at most) and which agents each is assigned to. */
-  excalidraw: ExcalidrawBook;
-  /** Join a session's room for a moment and report what is there. */
-  checkExcalidraw(session: ExcalidrawSession): Promise<SessionCheck>;
   /** The effective config, never a secret; the web settings page reads it. */
   config?(): BotLobbyConfig;
   /** Save a whole config, the way the settings menu does; the web settings page writes it. */
@@ -163,7 +152,7 @@ export interface LobbyService {
   classifierModels?(): Array<{ id: string; label: string }>;
   /** The model this window's session runs on (`provider/id`), when it has one. */
   sessionModel?(): string | undefined;
-  /** The Issues tab is switched on (`lobby.issues`). */
+  /** Git's Issues view is switched on (`lobby.issues`). */
   issuesEnabled(): boolean;
   /** What this window carried on from one that stopped unexpectedly, when it did. */
   recovered?(): { at: number; text: string } | undefined;
@@ -184,6 +173,10 @@ export interface LobbyService {
    * background session. A notice, and the background session's key.
    */
   resumeTask?(taskId: string): Promise<{ notice: string; key?: string }>;
+  acceptTask?(taskId: string): Promise<{ notice: string }>;
+  forceCloseTask?(taskId: string, title: string): Promise<{ notice: string }>;
+  canForceCloseTask?(taskId: string): boolean;
+  resolveTaskApproval?(taskId: string, approvalId: string, decision: "approved" | "rejected", note?: string): Promise<{ notice: string }>;
   /** Leave a message for a session running in another terminal; it delivers it within seconds. Returns a notice. */
   sendToSession(sessionId: string, text: string): string;
   /** Sessions running in this project, other than this window's, from their heartbeats. */

package/src/lobby/planner.ts

@@ -22,7 +22,6 @@ import { randomUUID } from "node:crypto";
 import { loadPrompt } from "../prompts/loader.ts";
 import { compilePrompt } from "../prompts/compiler.ts";
 import { runPiAgent, spawnPiProcess, type PiStreamEvent, type ProcessRunner } from "../execution/pi-runner.ts";
-import { grantOption, type Grant } from "../excalidraw/sessions.ts";
 import { describeToolCall } from "../pi/activity.ts";
 import { appendMetrics, type MetricRecord } from "../state/metrics.ts";
 import { savePlannedTask, type IssueRef, type PlannedTask } from "../state/backlog.ts";
@@ -904,7 +903,6 @@ export class PlanningSession {
         task: splitRequest({ title, plan, steps, ...(feedback ? { revision: feedback } : {}), ...(rejected.length > 0 ? { rejected } : {}) }),
         systemPrompt: splitPrompt(profile.instructions),
         tools: this.tools(PLANNER_TOOLS),
-        ...grantOption("planner"),
       }, signal, (step) => (this.step = step));
       if (signal.aborted) throw new Error("stopped");
       if (lead.status !== "success") return lead.error ?? lead.status;
@@ -997,7 +995,7 @@ export class PlanningSession {
     this.deps.onChange?.();
   }
 
-  private async run(label: string, kind: "planner" | "panel", profile: QuickFixProfile, request: { task: string; systemPrompt: string; tools: readonly string[]; excalidraw?: Grant }, signal: AbortSignal, setStep: (step: string) => void, routedFrom?: string): Promise<RunOutcome> {
+  private async run(label: string, kind: "planner" | "panel", profile: QuickFixProfile, request: { task: string; systemPrompt: string; tools: readonly string[] }, signal: AbortSignal, setStep: (step: string) => void, routedFrom?: string): Promise<RunOutcome> {
     const startedAt = Date.now();
     const runId = randomUUID();
     let outcome: RunOutcome;
@@ -1069,8 +1067,6 @@ export class PlanningSession {
       task: `${transcript}\n\nYou are ${label} on the planning panel${roundNote(this.turns, this.limit)}: ask your seat's open questions, or declare READY.`,
       systemPrompt: memberPrompt(member, profile.instructions),
       tools: this.tools(member === "researcher" ? RESEARCH_PANEL_TOOLS : PLANNER_TOOLS),
-      // A panel seat is the agent of its own kind: DEV is Backend, DESIGN the Designer.
-      ...grantOption(member),
     };
     const route = effort ? this.deps.effort?.plan(effort, { ...(profile.model ? { model: profile.model } : {}), thinking: profile.thinking }) : undefined;
     let outcome = await this.run(label, "panel", route ? { ...profile, model: route.model, thinking: route.thinking } : profile, request, signal, (step) => (state.step = step), route ? profileLabel(route.from) : undefined);
@@ -1128,7 +1124,6 @@ export class PlanningSession {
         task: `${transcript}\n\n${panelSection(outcomes)}\n\n${oracleClosing(mode, this.turns, limit)}`,
         systemPrompt: plannerPrompt(profile.instructions),
         tools: this.tools(PLANNER_TOOLS),
-        ...grantOption("planner"),
       }, controller.signal, (step) => (this.step = step));
       if (controller.signal.aborted) throw new Error("stopped");
       this.finishRound(outcomes, lead, mode);

package/src/lobby/prompts.ts

@@ -4,7 +4,7 @@
  * `node:*`): the web page imports this file directly.
  */
 
-export const TAB_IDS = ["lobby", "tasks", "plan", "quickfix", "issues", "excalidraw", "git", "knowledge", "metrics"] as const;
+export const TAB_IDS = ["lobby", "tasks", "plan", "quickfix", "git", "knowledge"] as const;
 export type TabId = (typeof TAB_IDS)[number];
 
 export const TAB_LABELS: Record<TabId, string> = {
@@ -12,16 +12,13 @@ export const TAB_LABELS: Record<TabId, string> = {
   tasks: "Tasks",
   plan: "Plan",
   quickfix: "Quick fix",
-  issues: "Issues",
-  metrics: "Metrics",
   git: "Git",
   knowledge: "Knowledge",
-  excalidraw: "Excalidraw",
 };
 
-/** The tabs on show: Issues only while `lobby.issues` switches it on. */
-export function visibleTabs(issues: boolean): TabId[] {
-  return TAB_IDS.filter((tab) => issues || tab !== "issues");
+/** The tabs on show; issues are available inside Git. */
+export function visibleTabs(_issues: boolean): TabId[] {
+  return [...TAB_IDS];
 }
 
 /** A question answered in another window of the page (or put away) before this one's answer arrived. */

package/src/lobby/quickfix.ts

@@ -9,7 +9,6 @@ import type { AgentRun } from "../schemas/findings.ts";
 import { loadPrompt } from "../prompts/loader.ts";
 import { runPiAgent, spawnPiProcess, type PiStreamEvent, type ProcessRunner } from "../execution/pi-runner.ts";
 import { MAX_CHILDREN } from "../execution/delegation.ts";
-import { grantOption } from "../excalidraw/sessions.ts";
 import { describeToolCall } from "../pi/activity.ts";
 import { appendMetrics, type MetricRecord } from "../state/metrics.ts";
 import { appendChange, EditLog } from "../state/changes.ts";
@@ -338,7 +337,6 @@ export class QuickFixQueue {
           task: [job.prompt, job.interrupted ? INTERRUPTED_NOTE : "", likely, scripts ? `## Scripts\n\n${scripts}` : ""].filter(Boolean).join("\n\n"),
           systemPrompt: quickFixPrompt(profile.instructions),
           tools: [...QUICK_FIX_TOOLS, ...(this.deps.hints?.tools() ?? [])],
-          ...grantOption("quickfix"),
           model,
           thinking,
           mcpTools: profile.mcpTools,

package/src/lobby/runtime.ts

@@ -26,7 +26,6 @@ import { execCommand, IssuesState } from "./issues.ts";
 import { PullsState } from "./pulls.ts";
 import { PullReviews } from "./pr-review.ts";
 import { KnowledgeBook } from "./knowledge.ts";
-import { ExcalidrawBook } from "../excalidraw/sessions.ts";
 import type { LobbyService } from "./host.ts";
 import { backgroundSessions, createLobbyService, lobbyNotify, lobbyProfile, plannerDeps, resumeSession, reviewProfile, seatProfile, setServiceState, savePlan as serviceSavePlan, answerPanel as serviceAnswerPanel } from "./service.ts";
 import { lobbyTopics } from "./topics.ts";
@@ -49,7 +48,6 @@ export interface Runtime {
   pulls: PullsState;
   reviews: PullReviews;
   knowledge: KnowledgeBook;
-  excalidraw: ExcalidrawBook;
   unsubscribeFeed?: () => void;
   /** Puts the panel's questions to the user: the web page's questionnaire unless a test sets another. */
   asker?: Asker;
@@ -163,7 +161,6 @@ export function startLobbyService(pi: ExtensionAPI, ctx: ExtensionContext, confi
       backups: () => loadConfig().knowledge.backupCount,
       sessionId: () => ctx.sessionManager.getSessionId(),
     }),
-    excalidraw: new ExcalidrawBook({ root }),
   };
   state.reviews = new PullReviews({
     cwd: ctx.cwd,
@@ -204,8 +201,7 @@ export function startLobbyService(pi: ExtensionAPI, ctx: ExtensionContext, confi
   // changes and the web page rereads it. lobbyFeed (lobby), run updates (tasks),
   // quick fix (quickfix), planner (planner), background sessions (sessions),
   // metrics (metrics), pulls/reviews (git), issues (issues), the prompt hub
-  // (prompts), owner/notify events (notices), busy/workspace (status), link
-  // checks (excalidraw).
+  // (prompts), owner/notify events (notices), busy/workspace (status).
   setQuickFixHandoff((request, builder, reason) => (runtime === state ? handToQuickFix(state, request, builder, reason) : undefined));
   lobbyFeed.clear();
   // Only the newest messages are kept; the feed learns whether earlier ones exist, and loads them when scrolled to.

package/src/lobby/service.ts

@@ -9,6 +9,8 @@ import { updateBlockingRequest } from "../state/blocking-requests.ts";
 import { randomUUID } from "node:crypto";
 import { loadTask, ownedTask, peekOwnedTask, peekTasks, saveTask } from "../state/persistence.ts";
 import { taskWork } from "../state/work-time.ts";
+import { transition } from "../state/task-state.ts";
+import { cancelTaskExecutions } from "../execution/task-cancellation.ts";
 import { refreshReview, deferReview } from "../delivery/review.ts";
 import { deliver, type DeliveryRequest } from "../delivery/operations.ts";
 import { deliveryStore, deliveryTask } from "../delivery/store.ts";
@@ -18,7 +20,7 @@ import { loadConfig, readDataRoots, saveConfig as writeConfig } from "../state/p
 import { knowledgeQuestion } from "./knowledge.ts";
 import { addPlanComment, editComment, readPlanComments, type PlanComment } from "../state/comments.ts";
 import { isAutoMode } from "../state/auto.ts";
-import { sendToInbox, sendToSession as leaveForSession } from "../state/inbox.ts";
+import { markInboxDelivered, sendToInbox, sendToSession as leaveForSession } from "../state/inbox.ts";
 import { livePresence } from "../state/presence.ts";
 import { archiveTask as archiveTaskOnDisk, deleteTask as deleteTaskOnDisk, listArchivedTasks, restoreTask as restoreTaskOnDisk } from "../state/archive.ts";
 import { discardPlannedTask, listPlannedTasks, type PlannedTask } from "../state/backlog.ts";
@@ -45,12 +47,14 @@ import { carryOnMessage, resumeRoute, RESUMED_DECISION, type Drivers } from "./r
 import { archivePlan as archivePlanOnDisk, deletePlan as deletePlanOnDisk, isPlanId, previousPlans, readPlan, type PlanRecord, type PlanSummary } from "../state/plan-history.ts";
 import { applyMasterModel } from "../pi/model-settings.ts";
 import { lobbyTopics } from "./topics.ts";
-import { checkSession } from "../excalidraw/check.ts";
 import type { LobbyAgentKind, PanelMember } from "../schemas/configuration.ts";
 import type { LiveSession, LobbyService, SwitchTarget } from "./host.ts";
 import { pushNotice, type NoticeLevel } from "../webui/notices.ts";
 import type { Runtime } from "./runtime.ts";
 import { findLinters } from "../execution/lint.ts";
+import { handleResolveApproval, lastQaAsks, waiveLint, waiveQa } from "../workflow/workflow.ts";
+import { recordDecision } from "../master/decisions.ts";
+import { fail } from "../webui/api/index.ts";
 
 /** The state background callbacks report to; set while the lobby service runs. */
 let serviceState: Runtime | undefined;
@@ -385,6 +389,73 @@ async function resumeTask(state: Runtime, taskId: string): Promise<{ notice: str
   }
 }
 
+function mutableTask(state: Runtime, taskId: string): Task {
+  if (!/^[A-Za-z0-9][A-Za-z0-9_.-]{0,199}$/.test(taskId)) fail(400, "bad_request", "invalid task ID");
+  const task = loadTask(state.root, state.configDir, taskId);
+  if (!task) fail(404, "not_found", "task not found in this project");
+  if (TERMINAL_STATES.includes(task.state)) fail(400, "bad_request", "task is terminal");
+  return task;
+}
+
+async function wakeTask(state: Runtime, task: Task, message: string): Promise<string> {
+  const inbox = sendToInbox(state.root, state.configDir, task.id, message, state.ctx.sessionManager.getSessionId());
+  const route = resumeRoute(task, taskDrivers(state));
+  if (route.kind === "stopped" || route.kind === "paused") return (await resumeTask(state, task.id)).notice;
+  if (task.ownerSessionId === state.ctx.sessionManager.getSessionId()) {
+    state.pi.sendUserMessage(message, state.ctx.isIdle() ? undefined : { deliverAs: "followUp" });
+    markInboxDelivered(state.root, state.configDir, task.id, [inbox.id]);
+  } else {
+    const session = backgroundSessions().find((entry) => entry.alive && entry.projectRoot === state.root && entry.sessionId === task.ownerSessionId);
+    if (session) {
+      session.send(message);
+      markInboxDelivered(state.root, state.configDir, task.id, [inbox.id]);
+    }
+  }
+  return "the owning oracle has been notified";
+}
+
+function canForceCloseTask(state: Runtime, taskId: string): boolean {
+  const task = loadTask(state.root, state.configDir, taskId);
+  return Boolean(task && !TERMINAL_STATES.includes(task.state) && (!task.ownerSessionId || task.ownerSessionId === state.ctx.sessionManager.getSessionId()));
+}
+
+async function forceCloseTask(state: Runtime, taskId: string, title: string): Promise<{ notice: string }> {
+  const task = mutableTask(state, taskId);
+  if (title !== task.title) fail(400, "bad_request", "the title must match exactly");
+  if (!canForceCloseTask(state, taskId)) fail(400, "bad_request", "cancel this task in its owning session; remote cancellation is unavailable");
+  recordDecision(task, "The user force-closed the task from the Tasks screen; work abandoned, code and worktree retained.");
+  transition(task, "abandoned");
+  saveTask(state.root, state.configDir, task);
+  cancelTaskExecutions(state.root, state.configDir, task.id);
+  if (task.ownerSessionId === state.ctx.sessionManager.getSessionId()) state.ctx.abort();
+  lobbyTopics.bump("tasks");
+  return { notice: `${task.id} abandoned; code, worktree and history retained` };
+}
+
+async function acceptTask(state: Runtime, taskId: string): Promise<{ notice: string }> {
+  const task = mutableTask(state, taskId);
+  if (!["implementing", "reviewing", "blocked"].includes(task.state)) fail(400, "bad_request", "there is no work to accept yet");
+  const asks = lastQaAsks(task);
+  if (task.qaVerdict !== "pass" && !task.qaWaiver) waiveQa(task, asks, "from the Tasks screen");
+  if (task.lint?.state === "failing") waiveLint(task, "from the Tasks screen");
+  recordDecision(task, "The user accepted the work as it is from the Tasks screen; the oracle was asked to complete it.");
+  saveTask(state.root, state.configDir, task);
+  lobbyTopics.bump("tasks");
+  const wake = await wakeTask(state, task, `The user accepted ${task.id}'s work as it is. Call orchestrate action=complete now with a short summary naming outstanding QA/lint asks: ${asks.join("; ") || "none recorded"}. Read the persisted gate waivers first. Do not merge automatically.`);
+  return { notice: `${task.id} accepted as it is; ${wake}` };
+}
+
+async function resolveTaskApproval(state: Runtime, taskId: string, approvalId: string, decision: "approved" | "rejected", note?: string): Promise<{ notice: string }> {
+  const task = mutableTask(state, taskId);
+  if (!task.approvals.some((entry) => entry.id === approvalId && entry.status === "pending")) fail(409, "conflict", "approval is no longer pending");
+  let message: string;
+  try { message = handleResolveApproval(task, { action: "resolve_approval", approvalId, decision, note }); }
+  catch (error) { return fail(400, "bad_request", (error as Error).message); }
+  saveTask(state.root, state.configDir, task);
+  lobbyTopics.bump("tasks");
+  return { notice: `${message}; ${await wakeTask(state, task, message)}` };
+}
+
 /** Leave a message for a task another terminal's session drives; its owner passes it to the oracle. */
 function sendToTask(state: Runtime, taskId: string, text: string): string {
   const task = loadTask(state.root, state.configDir, taskId);
@@ -814,11 +885,6 @@ export function createLobbyService(state: Runtime): LobbyService {
     pulls: state.pulls,
     reviews: state.reviews,
     knowledge: state.knowledge,
-    excalidraw: state.excalidraw,
-    checkExcalidraw: (session) => {
-      lobbyTopics.bump("excalidraw");
-      return checkSession(session.link, session.name);
-    },
     profileLabel: (kind) => {
       const profile = lobbyProfile(state, kind);
       return `${profile.model ?? "session model"} · ${profile.thinking}`;
@@ -832,6 +898,10 @@ export function createLobbyService(state: Runtime): LobbyService {
     setAuto: (taskId, on) => switchAuto(state, taskId, on),
     sendToTask: (taskId, text) => sendToTask(state, taskId, text),
     resumeTask: (taskId) => resumeTask(state, taskId),
+    acceptTask: (taskId) => acceptTask(state, taskId),
+    forceCloseTask: (taskId, title) => forceCloseTask(state, taskId, title),
+    canForceCloseTask: (taskId) => canForceCloseTask(state, taskId),
+    resolveTaskApproval: (taskId, approvalId, decision, note) => resolveTaskApproval(state, taskId, approvalId, decision, note),
     sendToSession: (sessionId, text) => sendToSession(state, sessionId, text),
     liveSessions: () => liveSessions(state),
     switchTo: (target) => switchTo(state, target),

package/src/lobby/topics.ts

@@ -16,7 +16,6 @@ export const LOBBY_TOPICS = [
   "git",
   "issues",
   "knowledge",
-  "excalidraw",
   "prompts",
   "notices",
   "status",

package/src/pi/tools.ts

@@ -62,7 +62,7 @@ const OrchestrateSchema = Type.Object({
   text: Type.Optional(Type.String({ description: "decide/complete/knowledge/script: the decision, completion summary, knowledge text, or the script itself" })),
   message: Type.Optional(Type.String({ description: "complete: the commit message for the agents' changes, which the engine commits (only their files): a first line of 72 characters or fewer saying what changed, at most three short lines below it" })),
   file: Type.Optional(Type.String({ description: "compact: the knowledge file to rewrite, e.g. knowledge.md; script: a script a worker drafted, to save instead of text" })),
-  name: Type.Optional(Type.String({ description: "whiteboard: name for the new Excalidraw session; script: the file name, what it does in snake_case with its language's extension (seed_public_holidays.py, run_changed_tests.sh)" })),
+  name: Type.Optional(Type.String({ description: "script: the file name, what it does in snake_case with its language's extension (seed_public_holidays.py, run_changed_tests.sh)" })),
   purpose: Type.Optional(Type.String({ description: "script: one line on what the script does" })),
   usage: Type.Optional(Type.String({ description: "script: the command that runs it, with its arguments" })),
   kind: Type.Optional(
@@ -79,7 +79,7 @@ const DESCRIPTION = [
   "dependency), propose (record the proposal and request approval), plan (record the internal",
   "plan, or amend it later with the full revised plan), implement (delegate a step to a domain worker, or several domains in parallel with assignments), qa (final quality gate and the only",
   "review), knowledge (record approved project knowledge or a decision; works without a task),",
-  "compact (replace a knowledge file with a rewritten version, archiving the old one; works without a task; disperse domain-relevant facts to action=knowledge (domain=designer|backend|qa) first), script (save a script to the shared scripts library, or replace one, for a job that comes back; works without a task), whiteboard (create your own Excalidraw session and assign it to yourself),",
+  "compact (replace a knowledge file with a rewritten version, archiving the old one; works without a task; disperse domain-relevant facts to action=knowledge (domain=designer|backend|qa) first), script (save a script to the shared scripts library, or replace one, for a job that comes back; works without a task),",
   "resolve_approval (approve or reject a request), complete (declare the task done after the gates",
   "pass, then ask the user to confirm merging and pushing main and removing its worktree), block/resume (escalate or continue), budget (under a time budget: where it stands, or ask the",
   "user for more minutes with a reason), track (the task's path and who takes part: show it, or correct it with",

package/src/state/persistence.ts

@@ -89,13 +89,38 @@ export function readTaskArtifact(
 
 export function saveTask(root: string, configDir: string, task: Task): void {
   const latest = loadTask(root, configDir, task.id);
-  if (latest) mergePhaseTiming(task, timingBaselines.get(task), latest);
+  // Abandonment is final: an in-flight action must not overwrite its audit or resurrect it.
+  if (latest?.state === "abandoned") {
+    Object.assign(task, latest);
+    return;
+  }
+  if (latest) {
+    preserveUserInterventions(task, latest);
+    mergePhaseTiming(task, timingBaselines.get(task), latest);
+  }
   const path = join(taskDir(dataRoot(root, configDir), task.id), "state.json");
   forgetCached(path);
   writeFileEnsured(path, JSON.stringify(task, null, 2));
   rememberTiming(task);
 }
 
+/** Explicit user waivers and resolved approvals must survive an in-flight worker's snapshot. */
+function preserveUserInterventions(task: Task, latest: Task): void {
+  const newlyWaived = !task.qaWaiver && latest.qaWaiver;
+  task.qaWaiver ??= latest.qaWaiver;
+  task.lintWaiver ??= latest.lintWaiver;
+  if (newlyWaived && !TERMINAL_STATES.includes(task.state)) {
+    task.blockers = [];
+    if (["implementing", "blocked"].includes(task.state)) task.state = "reviewing";
+  }
+  for (const approval of task.approvals) {
+    const resolved = latest.approvals.find((entry) => entry.id === approval.id && entry.status !== "pending");
+    if (approval.status === "pending" && resolved) Object.assign(approval, resolved);
+  }
+  const keys = new Set(task.decisions.map((entry) => JSON.stringify(entry)));
+  task.decisions.push(...latest.decisions.filter((entry) => !keys.has(JSON.stringify(entry))));
+}
+
 /** Read a task state: the bot-lobby copy wins, else the newest pre-rename copy. */
 export function loadTask(root: string, configDir: string, taskId: string): Task | undefined {
   for (const dr of readDataRoots(root, configDir)) {