@a-t-h-i/bot-lobby 0.6.48 → 0.6.50

package/src/state/persistence.ts

@@ -104,7 +104,7 @@ export function saveTask(root: string, configDir: string, task: Task): void {
   rememberTiming(task);
 }
 
-/** Explicit user waivers and resolved approvals must survive an in-flight worker's snapshot. */
+/** Explicit user waivers, skipped steps 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;
@@ -117,6 +117,9 @@ function preserveUserInterventions(task: Task, latest: Task): void {
     const resolved = latest.approvals.find((entry) => entry.id === approval.id && entry.status !== "pending");
     if (approval.status === "pending" && resolved) Object.assign(approval, resolved);
   }
+  const skipped = new Set((task.skippedSteps ?? []).map((entry) => entry.text));
+  const newSkips = (latest.skippedSteps ?? []).filter((entry) => !skipped.has(entry.text));
+  if (newSkips.length > 0) task.skippedSteps = [...(task.skippedSteps ?? []), ...newSkips];
   const keys = new Set(task.decisions.map((entry) => JSON.stringify(entry)));
   task.decisions.push(...latest.decisions.filter((entry) => !keys.has(JSON.stringify(entry))));
 }

package/src/webui/api/index.ts

@@ -15,13 +15,15 @@ import { lobbyAbort, lobbyHistory, lobbySend, lobbySnapshot } from "./lobby.ts";
 import { promptsAnswer, promptsDismiss, promptsList } from "./prompts.ts";
 import { plannerAnswer, plannerCommentLine, plannerGet, plannerNew, plannerRetry, plannerSend, plannerEditMessage, plannerToggleSeat, plannerSave, plannerPrevious, plannerPreviousArchive, plannerPreviousDelete, plannerPreviousGet, plannerPreviousOpen } from "./planner.ts";
 import { quickfixCancel, quickfixList, quickfixMovedToTask, quickfixRunAnyway, quickfixSubmit } from "./quickfix.ts";
-import { tasksArchive, tasksArchived, tasksAuto, tasksComment, tasksComments, tasksDelete, tasksEditComment, tasksGet, tasksList, tasksMessage, tasksRestore, tasksOpen, tasksResume, tasksDeliveryReview, tasksDeliveryDefer, tasksDeliver, tasksAccept, tasksForceClose, tasksResolveApproval } from "./tasks.ts";
+import { tasksArchive, tasksArchived, tasksAuto, tasksComment, tasksComments, tasksDelete, tasksEditComment, tasksGet, tasksList, tasksMessage, tasksRestore, tasksOpen, tasksResume, tasksDeliveryReview, tasksDeliveryDefer, tasksDeliver, tasksAccept, tasksSkipStep, tasksForceClose, tasksResolveApproval } from "./tasks.ts";
 import { knowledgeAdd, knowledgeAsk, knowledgeComment, knowledgeEdit, knowledgeFiles, knowledgeOpen, knowledgeRemove, knowledgeReplaceFile, knowledgeUnnote } from "./knowledge.ts";
 import { plansDiscard, plansGet, plansStart } from "./plans.ts";
 import { gitCancelReview, gitJev, gitPull, gitPulls, gitReview } from "./git.ts";
 import { issuesCreate, issuesGet, issuesList } from "./issues.ts";
-import { sessionsAnswer, sessionsChat, sessionsList, sessionsMessage, sessionsStart, sessionsStop, sessionsSwitch } from "./sessions.ts";
+import { sessionsAnswer, sessionsArchive, sessionsChat, sessionsList, sessionsMessage, sessionsRename, sessionsStart, sessionsStop, sessionsSwitch } from "./sessions.ts";
 import { settingsGet, settingsLinters, settingsSet } from "./settings.ts";
+import { terminalClose, terminalInput, terminalList, terminalOpen, terminalResize } from "./terminal.ts";
+import { MAX_INPUT_CHARS } from "../terminal.ts";
 import { themesChoose, themesGet, themesRemove, themesRename, themesSave } from "./themes.ts";
 import { noticeText, pushNotice } from "../notices.ts";
 
@@ -134,6 +136,10 @@ function buildRoutes(): Record<string, Route> {
     schema: Type.Object({ taskId: TaskId }, { additionalProperties: false }),
     run: (body, ctx) => tasksAccept(body as { taskId: string }, ctx),
   };
+  routes["tasks.skipStep"] = {
+    schema: Type.Object({ taskId: TaskId, step: Type.Integer({ minimum: 0, maximum: 49 }), text: Type.String({ minLength: 1, maxLength: 20_000 }), reason: Type.String({ minLength: 1, maxLength: 1000 }) }, { additionalProperties: false }),
+    run: (body, ctx) => tasksSkipStep(body as Parameters<typeof tasksSkipStep>[0], ctx),
+  };
   routes["tasks.forceClose"] = {
     schema: Type.Object({ taskId: TaskId, title: Type.String({ maxLength: 20_000 }) }, { additionalProperties: false }),
     run: (body, ctx) => tasksForceClose(body as { taskId: string; title: string }, ctx),
@@ -219,6 +225,34 @@ function buildRoutes(): Record<string, Route> {
     schema: Type.Object({ key: Type.Optional(TaskId), sessionId: Type.Optional(TaskId), claimTaskId: Type.Optional(TaskId) }, { additionalProperties: false }),
     run: (body, ctx) => sessionsSwitch(body as { key?: string; sessionId?: string; claimTaskId?: string }, ctx),
   };
+  const TerminalId = Type.String({ minLength: 1, maxLength: 40 });
+  const Cols = Type.Integer({ minimum: 2, maximum: 500 });
+  const Rows = Type.Integer({ minimum: 2, maximum: 300 });
+  routes["terminal.list"] = { schema: Empty, run: () => terminalList() };
+  routes["terminal.open"] = {
+    schema: Type.Object({ cols: Cols, rows: Rows }, { additionalProperties: false }),
+    run: (body, ctx) => terminalOpen(body as { cols: number; rows: number }, ctx),
+  };
+  routes["terminal.input"] = {
+    schema: Type.Object({ id: TerminalId, data: Type.String({ minLength: 1, maxLength: MAX_INPUT_CHARS }) }, { additionalProperties: false }),
+    run: (body) => terminalInput(body as { id: string; data: string }),
+  };
+  routes["terminal.resize"] = {
+    schema: Type.Object({ id: TerminalId, cols: Cols, rows: Rows }, { additionalProperties: false }),
+    run: (body) => terminalResize(body as { id: string; cols: number; rows: number }),
+  };
+  routes["terminal.close"] = {
+    schema: Type.Object({ id: TerminalId }, { additionalProperties: false }),
+    run: (body) => terminalClose(body as { id: string }),
+  };
+  routes["sessions.rename"] = {
+    schema: Type.Object({ key: Type.Optional(TaskId), name: Type.String({ minLength: 1, maxLength: 500 }) }, { additionalProperties: false }),
+    run: (body, ctx) => sessionsRename(body as { key?: string; name: string }, ctx),
+  };
+  routes["sessions.archive"] = {
+    schema: Type.Object({ key: TaskId, archived: Type.Optional(Type.Boolean()) }, { additionalProperties: false }),
+    run: (body, ctx) => sessionsArchive(body as { key: string; archived?: boolean }, ctx),
+  };
   routes["sessions.answer"] = {
     schema: Type.Object({ key: TaskId, dialogId: TaskId, answer: DialogAnswer }, { additionalProperties: false }),
     run: (body, ctx) => sessionsAnswer(body as { key: string; dialogId: string; answer: { value: string } | { confirmed: boolean } | { cancelled: true } }, ctx),

package/src/webui/api/lobby.ts

@@ -22,7 +22,7 @@ function planFacts(task: Task, work: WorkProjection | undefined): Pick<SnapshotT
   const active = steps.filter((step) => step.active);
   const current = steps.find((step) => step.status === "current");
   return {
-    progress: { done: steps.filter((step) => step.status === "done").length, total: steps.length },
+    progress: { done: steps.filter((step) => step.status === "done" || step.status === "skipped").length, total: steps.length },
     ...(current ? { currentStep: current.text } : {}),
     ...(active.length > 0 ? { activeSteps: active.map((step) => ({ text: step.text, workedMs: step.workedMs, activeAgentCount: step.activeAgentCount, runIds: step.runIds })) } : {}),
     ...clock,

package/src/webui/api/plan-facts.ts

@@ -4,7 +4,7 @@
  * right now and the work time. Kept here (not via `persistedRuns`) so the
  * server never loads the TUI.
  */
-import { planChecklist, planSteps, stepWork, type PlanStep } from "../../pi/plan-checklist.ts";
+import { planChecklist, planSteps, skippedIndexes, stepWork, type PlanStep } from "../../pi/plan-checklist.ts";
 import type { AgentRun } from "../../schemas/findings.ts";
 import type { Task } from "../../schemas/task.ts";
 import type { WorkProjection } from "../../state/work-time.ts";
@@ -44,6 +44,8 @@ export interface StepView {
   agents: StepAgent[];
   /** Worker time on the step, in ms. */
   workedMs: number;
+  /** The user skipped it: why, and when. */
+  skip?: { reason: string; at: string };
 }
 
 export interface StepAgent {
@@ -62,8 +64,10 @@ export interface StepAgent {
 export function stepViews(task: Task, work: WorkProjection | undefined, now = Date.now()): StepView[] {
   if (!task.plan) return [];
   const runs = [...persistedTaskRuns(task), ...activeRuns(task, work)];
-  const checklist = planChecklist(task.plan, runs);
-  const times = stepWork(planSteps(task.plan), runs, now);
+  const texts = planSteps(task.plan);
+  const checklist = planChecklist(task.plan, runs, task.skippedSteps);
+  const times = stepWork(texts, runs, now, skippedIndexes(texts, task.skippedSteps));
+  const skipOf = (text: string) => task.skippedSteps?.find((entry) => skippedIndexes([text], [entry]).size > 0);
   const byId = new Map(runs.map((run) => [run.runId, run]));
   return checklist.map((step, index) => {
     const time = times[index] ?? { ms: 0, active: false, activeAgentCount: 0, runIds: [] };
@@ -71,6 +75,7 @@ export function stepViews(task: Task, work: WorkProjection | undefined, now = Da
       const run = byId.get(runId);
       return run ? [{ runId, ...(run.parentRunId ? { parentRunId: run.parentRunId } : {}), domain: run.domain, instruction: (run.instruction ?? "").split("\n")[0]!.trim(), startedAt: run.startedAt }] : [];
     });
-    return { text: step.text, status: time.active ? "current" : step.status, active: time.active, activeAgentCount: time.activeAgentCount, runIds: time.runIds, agents, workedMs: Math.round(time.ms) };
+    const skip = step.status === "skipped" ? skipOf(step.text) : undefined;
+    return { text: step.text, status: time.active && !skip ? "current" : step.status, active: time.active && !skip, activeAgentCount: time.activeAgentCount, runIds: time.runIds, agents, workedMs: Math.round(time.ms), ...(skip ? { skip: { reason: skip.reason, at: skip.at } } : {}) };
   });
 }

package/src/webui/api/sessions.ts

@@ -114,3 +114,24 @@ export function sessionsAnswer(body: { key: string; dialogId: string; answer: Di
   session!.answer(body.dialogId, body.answer);
   return { notice: "answer sent" };
 }
+
+/** Rename this window's session (no key) or a background one. */
+export function sessionsRename(body: { key?: string; name: string }, ctx: ApiContext): { notice: string } {
+  if (!ctx.service.renameSession) fail(501, "unsupported", "this lobby cannot rename sessions");
+  try {
+    return { notice: ctx.service.renameSession!(body.key, body.name) };
+  } catch (error) {
+    fail(/^no session/.test((error as Error).message) ? 404 : 400, /^no session/.test((error as Error).message) ? "not_found" : "bad_request", (error as Error).message);
+  }
+}
+
+/** Put an ended background session away from the list (`archived` true, the default), or bring it back. */
+export function sessionsArchive(body: { key: string; archived?: boolean }, ctx: ApiContext): { notice: string } {
+  if (!ctx.service.archiveSession) fail(501, "unsupported", "this lobby cannot archive sessions");
+  try {
+    return { notice: ctx.service.archiveSession!(body.key, body.archived ?? true) };
+  } catch (error) {
+    const message = (error as Error).message;
+    fail(/^no /.test(message) ? 404 : 409, /^no /.test(message) ? "not_found" : "conflict", message);
+  }
+}

package/src/webui/api/tasks.ts

@@ -70,7 +70,7 @@ function checkOf(task: Task): TaskRow["check"] {
 function progressOf(task: Task, work: WorkProjection | undefined, now: number): TaskRow["progress"] {
   const steps = stepViews(task, work, now);
   if (steps.length === 0) return undefined;
-  return { done: steps.filter((step) => step.status === "done").length, total: steps.length };
+  return { done: steps.filter((step) => step.status === "done" || step.status === "skipped").length, total: steps.length };
 }
 
 /** The work clock as the page shows it; a finished task's no longer counts. */
@@ -302,6 +302,15 @@ export async function tasksAccept(body: { taskId: string }, ctx: ApiContext): Pr
   return ctx.service.acceptTask(body.taskId);
 }
 
+/** Skip a plan step with the user's reason; refused once the plan changed under the page. */
+export async function tasksSkipStep(body: { taskId: string; step: number; text: string; reason: string }, ctx: ApiContext): Promise<{ notice: string }> {
+  const task = interventionTask(body.taskId, ctx);
+  if (!task.plan) fail(400, "bad_request", "this task has no plan yet");
+  if (!body.reason.trim()) fail(400, "bad_request", "say why you are skipping this step");
+  if (!ctx.service.skipTaskStep) fail(400, "bad_request", "skipping steps is unavailable");
+  return ctx.service.skipTaskStep(body.taskId, body.step, body.text, body.reason);
+}
+
 export async function tasksForceClose(body: { taskId: string; title: string }, ctx: ApiContext): Promise<{ notice: string }> {
   const task = interventionTask(body.taskId, ctx);
   if (body.title !== task.title) fail(400, "bad_request", "the title must match exactly");
@@ -337,6 +346,7 @@ export function tasksGet(body: { taskId: string }, ctx: ApiContext): TaskDetail
   const details = found.plan ? planDetails(found.plan) : undefined;
   return {
     canAccept: Boolean(active && ctx.service.acceptTask) && acceptable(found),
+    canSkip: Boolean(active && ctx.service.skipTaskStep && found.plan) && !TERMINAL_STATES.includes(found.state),
     canForceClose: Boolean(active && ctx.service.forceCloseTask) && !TERMINAL_STATES.includes(found.state) && (ctx.service.canForceCloseTask?.(found.id) ?? true),
     timing: projectPhaseTiming(found, new Date(now).toISOString()),
     ...(clock ? { work: clock } : {}),
@@ -348,6 +358,7 @@ export function tasksGet(body: { taskId: string }, ctx: ApiContext): TaskDetail
     steps: stepViews(found, work, now).map((step) => ({
       text: step.text,
       status: step.status === "pending" ? "open" : step.status,
+      ...(step.skip ? { skip: step.skip } : {}),
       ...(step.active ? { active: true, workedMs: step.workedMs, activeAgentCount: step.activeAgentCount, agents: step.agents } : {}),
     })),
     amendments: [...found.amendments],

package/src/webui/api/terminal.ts

@@ -0,0 +1,42 @@
+/** `terminal.*`: shells in the project's folder for the page's terminal drawer (see `../terminal.ts`). */
+import { fail, type ApiContext } from "./index.ts";
+import { terminalBackend, terminals, TerminalError } from "../terminal.ts";
+import type { TerminalInfo } from "../protocol.ts";
+
+function guard<T>(run: () => T): T {
+  try {
+    return run();
+  } catch (error) {
+    if (error instanceof TerminalError) fail(error.missing ? 404 : 409, error.missing ? "not_found" : "conflict", error.message);
+    throw error;
+  }
+}
+
+export async function terminalList(): Promise<{ available: boolean; reason?: string; terminals: TerminalInfo[] }> {
+  const backend = await terminalBackend();
+  return { available: backend.kind !== "none", ...(backend.kind === "none" ? { reason: backend.reason } : {}), terminals: terminals.list() };
+}
+
+export async function terminalOpen(body: { cols: number; rows: number }, ctx: ApiContext): Promise<TerminalInfo> {
+  try {
+    return await terminals.open(ctx.service.projectRoot?.() ?? process.cwd(), body.cols, body.rows);
+  } catch (error) {
+    if (error instanceof TerminalError) fail(409, "conflict", error.message);
+    throw error;
+  }
+}
+
+export function terminalInput(body: { id: string; data: string }): Record<string, never> {
+  guard(() => terminals.input(body.id, body.data));
+  return {};
+}
+
+export function terminalResize(body: { id: string; cols: number; rows: number }): Record<string, never> {
+  guard(() => terminals.resize(body.id, body.cols, body.rows));
+  return {};
+}
+
+export function terminalClose(body: { id: string }): Record<string, never> {
+  guard(() => terminals.close(body.id));
+  return {};
+}

package/src/webui/dev/fake-service.ts

@@ -9,6 +9,7 @@ import { LobbyFeed } from "../../lobby/feed.ts";
 import { promptHub } from "../../lobby/prompt-hub.ts";
 import { lobbyTopics } from "../../lobby/topics.ts";
 import type { BackgroundSession, DialogAnswer, SessionDialog } from "../../lobby/sessions.ts";
+import { cleanSessionName } from "../../lobby/sessions.ts";
 import type { PlanComment } from "../../state/comments.ts";
 import type { LobbyService } from "../../lobby/host.ts";
 import { loadScenario, type ScenarioFixture } from "./fixtures.ts";
@@ -280,11 +281,16 @@ function fakeBackground(entry: NonNullable<ScenarioFixture["backgroundSessions"]
     stop() {
       status = "exited";
       dialogs.length = 0;
+      lobbyTopics.bump("sessions");
     },
     answer(id: string, _answer: DialogAnswer) {
       const index = dialogs.findIndex((dialog) => dialog.id === id);
       if (index >= 0) dialogs.splice(index, 1);
     },
+    rename(name: string) {
+      session.name = name;
+      lobbyTopics.bump("sessions");
+    },
   };
   return session as unknown as BackgroundSession;
 }
@@ -335,6 +341,8 @@ export function createFixtureService(name: string, feed = new LobbyFeed()): Lobb
   const auto = new Set(fixture.autoTasks ?? []);
   const comments = new Map<string, Array<Record<string, unknown>>>(Object.entries(fixture.taskComments ?? {}));
   const backgrounds = (fixture.backgroundSessions ?? []).map(fakeBackground);
+  const archivedBackgrounds: BackgroundSession[] = [];
+  let sessionName = fixture.status.sessionName;
   let planning = fakePlanner(fixture.mockPlanner ?? defaultPlanner());
   let config: BotLobbyConfig = resolveConfig(fixture.settings?.config ?? {});
   const models = fixture.settings?.models ?? DEFAULT_MODELS;
@@ -391,7 +399,7 @@ export function createFixtureService(name: string, feed = new LobbyFeed()): Lobb
   let commentSeq = 0;
   const service = {
     sessionId: () => fixture.status.sessionId,
-    sessionName: () => fixture.status.sessionName,
+    sessionName: () => sessionName,
     masterBusy: () => fixture.status.busy,
     config: () => config,
     linters: () => fixture.settings?.linters ?? [{ tool: "ESLint", folder: "", installed: true }, { tool: "Ruff", folder: "services/api", installed: false }],
@@ -481,6 +489,15 @@ export function createFixtureService(name: string, feed = new LobbyFeed()): Lobb
     },
     sendToTask: (taskId: string, _text: string) => (tasks.some((task) => (task as { id: string }).id === taskId) ? `sent — the session driving ${taskId} passes it to its oracle` : `no task ${taskId}`),
     sendToSession: (_sessionId: string, _text: string) => "sent — that session passes it to its oracle within a few seconds",
+    skipTaskStep: async (taskId: string, step: number, text: string, reason: string) => {
+      const task = tasks.find((entry) => (entry as { id: string }).id === taskId) as { id: string; skippedSteps?: Array<{ text: string; reason: string; at: string }>; decisions?: Array<{ domain: string; text: string; createdAt: string }> } | undefined;
+      if (!task) throw new Error(`no task ${taskId}`);
+      const at = new Date().toISOString();
+      task.skippedSteps = [...(task.skippedSteps ?? []), { text, reason: reason.trim(), at }];
+      task.decisions = [...(task.decisions ?? []), { domain: "master", text: `The user skipped step ${step + 1} ("${text}") from the Tasks screen. Reason: ${reason.trim()}`, createdAt: at }];
+      lobbyTopics.bump("tasks");
+      return { notice: `step ${step + 1} skipped; the oracle has been told` };
+    },
     resumeTask: async (taskId: string) => {
       const task = tasks.find((entry) => (entry as { id: string }).id === taskId) as { id: string; title: string; paused?: boolean; ownerSessionId?: string } | undefined;
       if (!task) return { notice: `no task ${taskId}` };
@@ -500,6 +517,30 @@ export function createFixtureService(name: string, feed = new LobbyFeed()): Lobb
       return { notice: `resumed ${taskId} in a background session`, key: session.key };
     },
     sessions: () => [...backgrounds],
+    renameSession: (key: string | undefined, name: string) => {
+      const clean = cleanSessionName(name);
+      if (!key) {
+        sessionName = clean;
+        lobbyTopics.bump("status");
+        lobbyTopics.bump("sessions");
+        return `renamed this window to ${clean}`;
+      }
+      const session = backgrounds.find((entry) => entry.key === key);
+      if (!session) throw new Error(`no session ${key}`);
+      session.rename(clean);
+      return `renamed ${key} to ${clean}`;
+    },
+    archiveSession: (key: string, archived: boolean) => {
+      const from = archived ? backgrounds : archivedBackgrounds;
+      const index = from.findIndex((entry) => entry.key === key);
+      if (index < 0) throw new Error(archived ? `no session ${key} to archive` : `no archived session ${key}`);
+      const session = from[index]!;
+      if (session.alive) throw new Error(`${session.name} is still running: stop it before archiving it`);
+      from.splice(index, 1);
+      (archived ? archivedBackgrounds : backgrounds).push(session);
+      lobbyTopics.bump("sessions");
+      return archived ? `archived ${session.name}` : `brought back ${session.name}`;
+    },
     startSession: (start: { request?: string; plan?: { id: string; title: string }; auto?: boolean }) => {
       const key = `S${backgrounds.length + 1}`;
       const session = fakeBackground({ key, name: start.plan?.title ?? start.request?.trim().slice(0, 40) ?? "mock session", status: "starting", ...(start.plan ? { planId: start.plan.id } : {}) });