@saadnvd1/agent-os 0.3.519 → 0.3.521

package/components/Welcome/WelcomeDialog.tsx

@@ -0,0 +1,153 @@
+"use client";
+
+import { memo } from "react";
+import { useSnapshot } from "valtio";
+import { Check } from "lucide-react";
+import {
+  Dialog,
+  DialogContent,
+  DialogDescription,
+  DialogTitle,
+} from "@/components/ui/dialog";
+import { Button } from "@/components/ui/button";
+import { useProjectsQuery } from "@/data/projects/queries";
+import { useEndWelcome, useWelcomeUrl } from "@/hooks/useWelcome";
+import { cn } from "@/lib/utils";
+import { WELCOME_STEPS, type WelcomeStep } from "@/lib/welcome-url";
+import { welcomeUi, welcomeUiActions } from "@/stores/welcomeUi";
+import { AgentList } from "./AgentList";
+import { ProjectStep } from "./ProjectStep";
+
+const STEPS: Record<
+  WelcomeStep,
+  { label: string; title: string; hint: string }
+> = {
+  agents: {
+    label: "Agents",
+    title: "Connect your agents",
+    hint: "Install and sign in the coding agents you want to use. You need one.",
+  },
+  project: {
+    label: "Project",
+    title: "Add your first project",
+    hint: "A folder or repo for the first session to work in.",
+  },
+  finish: {
+    label: "Start",
+    title: "You're set",
+    hint: "Open a session in your project and give it a task.",
+  },
+};
+
+function FinishStep() {
+  const { projectId } = useSnapshot(welcomeUi);
+  const { data: projects = [] } = useProjectsQuery();
+  const project = projects.find((p) => p.id === projectId);
+  return (
+    <p className="text-muted-foreground bg-muted/40 rounded-lg px-3 py-3 text-sm">
+      {project ? (
+        <>
+          First session opens in{" "}
+          <span className="text-foreground font-medium">{project.name}</span>.
+        </>
+      ) : (
+        "No project yet. Add one from the sidebar whenever you are ready."
+      )}
+    </p>
+  );
+}
+
+/**
+ * First-run setup: agents, then a first project, then a session. It stays
+ * open until finished or skipped, and every step after the first can be skipped.
+ */
+export const WelcomeDialog = memo(function WelcomeDialog() {
+  useWelcomeUrl();
+  const { open, step, projectId } = useSnapshot(welcomeUi);
+  const end = useEndWelcome();
+  const at = WELCOME_STEPS.indexOf(step);
+  const info = STEPS[step];
+  const last = at === WELCOME_STEPS.length - 1;
+
+  return (
+    <Dialog open={open}>
+      <DialogContent
+        showCloseButton={false}
+        onInteractOutside={(e) => e.preventDefault()}
+        onEscapeKeyDown={(e) => e.preventDefault()}
+        className="max-h-[100dvh] overflow-y-auto max-sm:h-[100dvh] max-sm:max-w-full max-sm:rounded-none sm:max-h-[90dvh] sm:max-w-xl"
+      >
+        <nav aria-label="Setup steps" className="flex items-center gap-1">
+          {WELCOME_STEPS.map((s, i) => (
+            <button
+              key={s}
+              type="button"
+              disabled={i === at}
+              onClick={() => welcomeUiActions.go(s)}
+              aria-current={i === at ? "step" : undefined}
+              className={cn(
+                "flex min-h-11 flex-1 items-center justify-center gap-1.5 rounded-lg px-2 text-xs font-medium sm:min-h-8",
+                i === at
+                  ? "bg-foreground/[0.08] text-foreground"
+                  : "text-muted-foreground hover:bg-foreground/[0.06]"
+              )}
+            >
+              {i < at && <Check className="size-3" />}
+              {STEPS[s].label}
+            </button>
+          ))}
+          <Button
+            variant="ghost"
+            size="sm"
+            className="min-h-11 sm:min-h-8"
+            onClick={() => end()}
+          >
+            Skip setup
+          </Button>
+        </nav>
+        <div className="flex flex-col gap-1">
+          <DialogTitle>{info.title}</DialogTitle>
+          <DialogDescription>{info.hint}</DialogDescription>
+        </div>
+        {step === "agents" && <AgentList />}
+        {step === "project" && <ProjectStep />}
+        {step === "finish" && <FinishStep />}
+        <div className="flex items-center justify-between gap-2">
+          <Button
+            variant="ghost"
+            className="min-h-11 sm:min-h-9"
+            disabled={at === 0}
+            onClick={() => welcomeUiActions.go(WELCOME_STEPS[at - 1])}
+          >
+            Back
+          </Button>
+          <div className="flex items-center gap-2">
+            {step === "project" && (
+              <Button
+                variant="ghost"
+                className="min-h-11 sm:min-h-9"
+                onClick={() => welcomeUiActions.go("finish")}
+              >
+                Skip
+              </Button>
+            )}
+            <Button
+              className="min-h-11 sm:min-h-9"
+              onClick={() =>
+                last ? end(true) : welcomeUiActions.go(WELCOME_STEPS[at + 1])
+              }
+            >
+              {last
+                ? projectId
+                  ? "Start your first session"
+                  : "Go to AgentOS"
+                : step === "agents"
+                  ? "Continue"
+                  : "Next"}
+            </Button>
+          </div>
+        </div>
+      </DialogContent>
+    </Dialog>
+  );
+});

package/data/agents/index.ts

@@ -1,4 +1,4 @@
-import { useQuery } from "@tanstack/react-query";
+import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
 import type { AgentProbe } from "@/lib/agents/probe";
 
 export const agentKeys = {
@@ -20,3 +20,18 @@ export function useAgentStatusQuery() {
     refetchOnMount: "always",
   });
 }
+
+// Asks the server to probe again now, not from its minute-old answer, and
+// puts the result where the status query reads it.
+export function useRecheckAgents() {
+  const client = useQueryClient();
+  return useMutation({
+    mutationFn: async () => {
+      const res = await fetch("/api/agents/status?fresh");
+      if (!res.ok) throw new Error("Couldn't check the agents");
+      return ((await res.json()) as { agents: Record<string, AgentProbe> })
+        .agents;
+    },
+    onSuccess: (agents) => client.setQueryData(agentKeys.status(), agents),
+  });
+}

package/data/tasks/index.ts

@@ -85,6 +85,18 @@ export function useDropTask() {
   );
 }
 
+export function useApprovePlan() {
+  return useTaskMutation(async (input: { id: string; message?: string }) =>
+    json(
+      await fetch(`/api/tasks/${input.id}/approve-plan`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ message: input.message }),
+      })
+    )
+  );
+}
+
 export function useResumeTask() {
   return useTaskMutation(async (input: { id: string; force?: boolean }) =>
     json(

package/data/welcome/index.ts

@@ -0,0 +1,36 @@
+import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
+import type { WelcomeGate } from "@/lib/welcome";
+
+export const welcomeKeys = {
+  all: ["welcome"] as const,
+};
+
+export function useWelcomeQuery() {
+  return useQuery({
+    queryKey: welcomeKeys.all,
+    queryFn: async () => {
+      const res = await fetch("/api/welcome");
+      if (!res.ok) throw new Error("Couldn't check first-run setup");
+      return (await res.json()) as WelcomeGate;
+    },
+    // Asked once per load: it only flips when setup is done here.
+    staleTime: Infinity,
+    retry: false,
+  });
+}
+
+export function useCompleteWelcome() {
+  const client = useQueryClient();
+  return useMutation({
+    mutationFn: async () => {
+      const res = await fetch("/api/welcome", {
+        method: "POST",
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify({ action: "complete" }),
+      });
+      if (!res.ok) throw new Error("Couldn't save setup");
+      return (await res.json()) as WelcomeGate;
+    },
+    onSuccess: (gate) => client.setQueryData(welcomeKeys.all, gate),
+  });
+}

package/hooks/useWelcome.ts

@@ -0,0 +1,70 @@
+"use client";
+
+import { useEffect, useRef } from "react";
+import { subscribe } from "valtio";
+import { useCompleteWelcome, useWelcomeQuery } from "@/data/welcome";
+import { hrefWithWelcome, welcomeFromHref } from "@/lib/welcome-url";
+import { newDraft } from "@/stores/drafts";
+import { welcomeUi, welcomeUiActions } from "@/stores/welcomeUi";
+
+function fromAddress() {
+  const at = welcomeFromHref(window.location.href);
+  if (at.open) welcomeUiActions.open(at.step);
+  else if (welcomeUi.open) welcomeUiActions.close();
+}
+
+/**
+ * `?welcome=<step>` opens the first-run welcome at that step, on load and on
+ * back/forward; the address follows it. Moving between steps adds a history
+ * entry, so Back goes to the step before. A fresh install with setup still to
+ * do opens it by itself, once.
+ */
+export function useWelcomeUrl() {
+  const { data: gate } = useWelcomeQuery();
+  const asked = useRef(false);
+
+  useEffect(() => {
+    fromAddress();
+    let was = { open: welcomeUi.open, step: welcomeUi.step };
+    const unsubscribe = subscribe(welcomeUi, () => {
+      const href = window.location.href;
+      const next = hrefWithWelcome(href, {
+        open: welcomeUi.open,
+        step: welcomeUi.step,
+      });
+      const url = new URL(href);
+      if (next !== url.pathname + url.search + url.hash) {
+        const move = was.open && welcomeUi.open && was.step !== welcomeUi.step;
+        window.history[move ? "pushState" : "replaceState"](
+          window.history.state,
+          "",
+          next
+        );
+      }
+      was = { open: welcomeUi.open, step: welcomeUi.step };
+    });
+    window.addEventListener("popstate", fromAddress);
+    return () => {
+      unsubscribe();
+      window.removeEventListener("popstate", fromAddress);
+    };
+  }, []);
+
+  useEffect(() => {
+    if (!gate?.show || asked.current || welcomeUi.open) return;
+    asked.current = true;
+    welcomeUiActions.open("agents");
+  }, [gate?.show]);
+}
+
+/** Setup is over, finished or skipped: remember it and close. */
+export function useEndWelcome() {
+  const { mutate } = useCompleteWelcome();
+  return (start?: boolean) => {
+    const projectId = welcomeUi.projectId;
+    mutate();
+    welcomeUiActions.close();
+    welcomeUiActions.setProject(null);
+    if (start && projectId) newDraft({ kind: "project", projectId });
+  };
+}

package/lib/agents/probe.ts

@@ -64,7 +64,34 @@ type AuthCheck = (
   env: NodeJS.ProcessEnv
 ) => Promise<AgentAuth> | AgentAuth;
 
+// Claude Code keeps who is signed in under `oauthAccount` in its config, at
+// $CLAUDE_CONFIG_DIR/.claude.json, or ~/.claude.json without that variable.
+function claudeAuth(env: NodeJS.ProcessEnv): AgentAuth {
+  const dir = env.CLAUDE_CONFIG_DIR?.trim();
+  const configDir = dir || home(".claude");
+  const config = dir ? path.join(dir, ".claude.json") : home(".claude.json");
+  if (
+    anyEnv(env, [
+      "ANTHROPIC_API_KEY",
+      "ANTHROPIC_AUTH_TOKEN",
+      "CLAUDE_CODE_OAUTH_TOKEN",
+      "CLAUDE_CODE_USE_BEDROCK",
+      "CLAUDE_CODE_USE_VERTEX",
+    ]) ||
+    hasJsonKeys(path.join(configDir, "settings.json"), "apiKeyHelper")
+  )
+    return "ready";
+  if (hasJsonKeys(config, "oauthAccount")) return "ready";
+  // A config without an account is a CLI that has never signed in; no config
+  // at all tells nothing.
+  return hasJsonKeys(config) ? "needs-login" : "unknown";
+}
+
 const AUTH: Partial<Record<ProviderId, { check: AuthCheck; hint: string }>> = {
+  claude: {
+    check: (_cli, env) => claudeAuth(env),
+    hint: "Run `claude auth login` in a terminal",
+  },
   codex: {
     // Exits 0 signed in, 1 not.
     check: async (cli, env) => {

package/lib/agents/setup-commands.ts

@@ -0,0 +1,54 @@
+/**
+ * The official commands the welcome runs in its terminal to install an agent
+ * CLI or sign it in. Typed into the user's own shell, never run by the
+ * server, so they are the same lines the install script (scripts/lib/ai-clis.sh)
+ * uses.
+ */
+
+import type { ProviderId } from "../providers/registry";
+
+export interface SetupCommands {
+  install?: string;
+  signIn?: string;
+  docs?: string;
+}
+
+export const SETUP_COMMANDS: Partial<Record<ProviderId, SetupCommands>> = {
+  claude: {
+    install: "curl -fsSL https://claude.ai/install.sh | bash",
+    signIn: "claude auth login",
+  },
+  codex: {
+    install: "npm install -g @openai/codex",
+    signIn: "codex login",
+  },
+  gemini: {
+    install: "npm install -g @google/gemini-cli",
+    signIn: "gemini",
+  },
+  kilocode: { install: "npm install -g @kilocode/cli", signIn: "kilo" },
+  cursor: { signIn: "cursor-agent login", docs: "https://cursor.com/cli" },
+  amp: { signIn: "amp login", docs: "https://ampcode.com" },
+  pi: { signIn: "pi" },
+  // No installer line we can vouch for from here; its own site has it.
+  opencode: { docs: "https://opencode.ai/docs" },
+};
+
+// The ones the welcome shows up front; the rest wait behind "Show all".
+export const FEATURED_AGENTS: ProviderId[] = [
+  "claude",
+  "codex",
+  "gemini",
+  "opencode",
+];
+
+export type AgentState = "missing" | "needs-login" | "ready" | "installed";
+
+export function agentState(p: {
+  installed: boolean;
+  auth: "ready" | "needs-login" | "unknown";
+}): AgentState {
+  if (!p.installed) return "missing";
+  if (p.auth === "needs-login") return "needs-login";
+  return p.auth === "ready" ? "ready" : "installed";
+}

package/lib/db/migrations.ts

@@ -1739,6 +1739,35 @@ const migrations: Migration[] = [
       );
     },
   },
+  {
+    id: 75,
+    name: "plan_only_tasks",
+    up: (db) => {
+      // plan_only: 1 for a task that stops after its plan and waits for
+      // approval (plan_phase 'awaiting'); queued tasks keep it until they start.
+      const has = (table: string) =>
+        (
+          db.prepare(`PRAGMA table_info(${table})`).all() as { name: string }[]
+        ).some((c) => c.name === "plan_only");
+      for (const table of ["sessions", "task_queue"])
+        if (!has(table))
+          db.exec(`ALTER TABLE ${table} ADD COLUMN plan_only INTEGER`);
+    },
+  },
+  {
+    id: 76,
+    name: "welcome_backfill",
+    up: (db) => {
+      // An install that already has a session or a project of its own has
+      // been set up; mark it so the first-run welcome never shows there.
+      db.exec(
+        `INSERT OR IGNORE INTO settings (key, value)
+         SELECT 'welcome.completed_at', 'existing-install'
+         WHERE EXISTS (SELECT 1 FROM sessions)
+            OR EXISTS (SELECT 1 FROM projects WHERE is_uncategorized = 0)`
+      );
+    },
+  },
 ];
 
 // `upTo`: stop after this id (tests that start from an older database).

package/lib/db/types.ts

@@ -19,7 +19,9 @@ export interface Session {
   // A task's own models: "provider/model", or JSON of role to one.
   model_overrides?: string | null;
   // A task's plan step: planning on the planning model, then implementing.
-  plan_phase?: "planning" | "implementing" | null;
+  // 'awaiting': a plan-only task's plan is written; it waits for approval.
+  plan_phase?: "planning" | "awaiting" | "implementing" | null;
+  plan_only?: number | null;
   // The orchestrator session that started this one; null for a person.
   started_by?: string | null;
   // 1 planned, 0 no plan, null not stated; why, in the starter's words.

package/lib/lumifyhub/lists.ts

@@ -26,6 +26,7 @@ export function cardTargetFor(state: TaskState | "queued"): CardTarget {
       return "todo";
     case "working":
     case "needs-input":
+    case "plan-ready":
     case "blocked":
     case "moving":
       return "in_progress";

package/lib/models/plan-step.ts

@@ -19,20 +19,28 @@ import {
 } from "./resolve";
 import { ANTHROPIC } from "./roles";
 import { queueEvent } from "../orchestrator/events";
+import { addNote } from "../orchestrator/notes";
+import { amendBrief, amendmentsOf } from "../orchestrator/amendments";
 
 export const PLAN_FILE = ".agentos/plan.md";
 
-export function planPrompt(task: string): string {
+export function planPrompt(task: string, only = false): string {
+  const after = only
+    ? "it waits for approval before anything is implemented, so don't ask for it"
+    : "the implementation model takes over this conversation next and follows it";
   return `${task}
 
 ---
-Plan first. This turn, only read and plan: write the implementation plan for the task above to \`${PLAN_FILE}\` in this worktree (what to change, file by file; the tests; how you'll verify it; anything ambiguous and the call you'd make). Change no other file, and don't commit, push or open a PR. End the turn once the plan is written: the implementation model takes over this conversation next and follows it.`;
+Plan first. This turn, only read and plan: write the implementation plan for the task above to \`${PLAN_FILE}\` in this worktree (what to change, file by file; the tests; how you'll verify it; anything ambiguous and the call you'd make). Change no other file, and don't commit, push or open a PR. End the turn once the plan is written: ${after}.`;
 }
 
-export function implementPrompt(planned: boolean): string {
-  return planned
+export function implementPrompt(planned: boolean, amendment?: string): string {
+  const base = planned
     ? `The plan is in \`${PLAN_FILE}\`. Implement it now, finishing the task as its instructions above say. Where the plan turns out wrong, do what's right and say so.`
     : `No plan was written to \`${PLAN_FILE}\`. Plan briefly, then implement the task, finishing it as its instructions above say.`;
+  return amendment
+    ? `${base}\n\nThe plan was approved with this change, which is now part of the task's scope:\n${amendment}`
+    : base;
 }
 
 // The worktree's plan folder, kept out of git by its own .gitignore.
@@ -72,7 +80,7 @@ export function planSummary(text: string, max = 5): string[] {
 }
 
 // Tells the orchestrator that started a task its plan is written, once.
-function announcePlan(s: Session, ref: string): void {
+function announcePlan(s: Session, ref: string | null): void {
   if (!s.started_by && !s.held_by_device) return;
   const workspaceId = sessionWorkspace(s);
   // A task held for another machine's orchestrator can't reach it: the line
@@ -80,10 +88,13 @@ function announcePlan(s: Session, ref: string): void {
   if (!s.held_by_device && !workspaceId) return;
   if (!s.worktree_path) return;
   const file = path.join(s.worktree_path, PLAN_FILE);
-  let head = `Task "${s.name}": no plan file was written; implementing on ${ref} anyway.`;
+  const next = ref
+    ? `implementing on ${ref}`
+    : "waiting for approval, not implementing (approve_plan to go ahead, drop to reject)";
+  let head = `Task "${s.name}": no plan file was written; ${next}${ref ? " anyway" : ""}.`;
   try {
     const summary = planSummary(fs.readFileSync(file, "utf8"));
-    head = `Task "${s.name}": plan written to ${file}; implementing on ${ref}.`;
+    head = `Task "${s.name}": plan written to ${file}; ${next}.`;
     if (summary.length) head += `\n${summary.map((l) => `- ${l}`).join("\n")}`;
   } catch {
     // No plan file: the line says so.
@@ -101,56 +112,129 @@ function announcePlan(s: Session, ref: string): void {
 export const implementMessageId = (sessionId: string) =>
   `implement-${sessionId}`;
 
-// Called when a chat goes idle. A task whose plan turn has ended (it has a
-// recorded plan turn) moves to implementing, once, and the implementation
-// message is queued under a fixed id, which a restart sends rather than
-// repeats.
-export async function handoffAfterPlan(
-  sessionId: string,
-  send: (sessionId: string, id: string) => Promise<void>
-): Promise<boolean> {
-  const planned = db
-    .prepare(
-      `SELECT 1 FROM chat_turns WHERE session_id = ? AND role = 'plan' LIMIT 1`
-    )
-    .get(sessionId);
-  if (!planned) return false;
-  const s = db.prepare(`SELECT * FROM sessions WHERE id = ?`).get(sessionId) as
+type Send = (sessionId: string, id: string) => Promise<void>;
+
+function getSession(sessionId: string): Session | undefined {
+  return db.prepare(`SELECT * FROM sessions WHERE id = ?`).get(sessionId) as
     | Session
     | undefined;
-  if (s?.plan_phase !== "planning" || !s.worktree_path) return false;
+}
+
+// Planning (or, once approved, awaiting) becomes implementing, once: the
+// phase, the model and the message in one go, so a restart part-way finds
+// either none of them or all, and sends the message on the new model. The
+// message goes under a fixed id, which a restart sends rather than repeats.
+async function startImplementing(
+  s: Session,
+  from: "planning" | "awaiting",
+  send: Send,
+  amendment?: string
+): Promise<string | null> {
+  const sessionId = s.id;
   const routed = resolveRole("implement", {
     workspaceId: sessionWorkspace(s),
     override: taskOverride(s),
   });
   const id = implementMessageId(sessionId);
-  // The phase, the model and the message in one go: a restart part-way
-  // finds either none of them or all, and sends the message on the new model.
   const claimed = db.transaction(() => {
     const changed = db
       .prepare(
         `UPDATE sessions SET plan_phase = 'implementing'
-         WHERE id = ? AND plan_phase = 'planning' AND task_status = 'running'`
+         WHERE id = ? AND plan_phase = ? AND task_status = 'running'`
       )
-      .run(sessionId).changes;
+      .run(sessionId, from).changes;
     if (!changed) return false;
     setSessionModel(sessionId, routed);
     enqueue(sessionId, {
       id,
       text: implementPrompt(
-        fs.existsSync(path.join(s.worktree_path!, PLAN_FILE))
+        fs.existsSync(path.join(s.worktree_path!, PLAN_FILE)),
+        amendment
       ),
       origin: { kind: "decision", label: "Plan step" },
     });
     return true;
   })();
-  if (!claimed) return false;
+  if (!claimed) return null;
+  if (from === "planning") {
+    try {
+      announcePlan(s, routed.ref);
+    } catch (e) {
+      console.error("plan-done event failed:", e);
+    }
+  }
+  await applySessionModel(sessionId, s.model_provider ?? ANTHROPIC, routed);
+  await send(sessionId, id);
+  return routed.ref;
+}
+
+// Called when a chat goes idle. A task whose plan turn has ended (it has a
+// recorded plan turn) moves to implementing, once; a plan-only task instead
+// waits for approval (approvePlan), holding no agent process.
+export async function handoffAfterPlan(
+  sessionId: string,
+  send: Send
+): Promise<boolean> {
+  const planned = db
+    .prepare(
+      `SELECT 1 FROM chat_turns WHERE session_id = ? AND role = 'plan' LIMIT 1`
+    )
+    .get(sessionId);
+  if (!planned) return false;
+  const s = getSession(sessionId);
+  if (s?.plan_phase !== "planning" || !s.worktree_path) return false;
+  if (!s.plan_only)
+    return (await startImplementing(s, "planning", send)) !== null;
+  const waiting = db
+    .prepare(
+      `UPDATE sessions SET plan_phase = 'awaiting'
+       WHERE id = ? AND plan_phase = 'planning' AND task_status = 'running'`
+    )
+    .run(sessionId).changes;
+  if (!waiting) return false;
   try {
-    announcePlan(s, routed.ref);
+    announcePlan(s, null);
   } catch (e) {
     console.error("plan-done event failed:", e);
   }
-  await applySessionModel(sessionId, s.model_provider ?? ANTHROPIC, routed);
-  await send(sessionId, id);
+  // The worker has nothing left to do: it ends at this turn boundary, and
+  // the next message (an approval, or a revision) starts one that resumes.
+  try {
+    await (await import("../chat/runner")).retireChat(sessionId);
+  } catch (e) {
+    console.error(`Releasing the worker of ${sessionId} failed:`, e);
+  }
   return true;
 }
+
+// approvePlan, sending through the chat runner (imported when needed: it
+// imports this file).
+export async function approvePlanNow(sessionId: string, message?: string) {
+  const { sendQueuedNow } = await import("../chat/runner");
+  return approvePlan(sessionId, message, (id, m) => sendQueuedNow(id, m));
+}
+
+// Approves a waiting plan-only task: implementation starts on the
+// implementation model, once. A message amends the plan and is recorded on
+// the task's brief as a scope change, before implementing, so its review
+// judges against it.
+export async function approvePlan(
+  sessionId: string,
+  message: string | undefined,
+  send: Send
+): Promise<{ ref: string; amendments: number }> {
+  const s = getSession(sessionId);
+  if (!s || s.plan_phase !== "awaiting" || s.task_status !== "running")
+    throw new Error(
+      `${s?.name ?? "That task"} isn't waiting for plan approval`
+    );
+  const text = message?.trim() || undefined;
+  const workspaceId = sessionWorkspace(s);
+  if (text && workspaceId) {
+    amendBrief(workspaceId, s.id, text);
+    addNote(workspaceId, `Plan approved with a change for ${s.name}: ${text}`);
+  }
+  const ref = await startImplementing(s, "awaiting", send, text);
+  if (!ref) throw new Error(`${s.name} isn't waiting for plan approval`);
+  return { ref, amendments: amendmentsOf(s.id).length };
+}

package/lib/models/roles.ts

@@ -97,5 +97,7 @@ export function sessionRole(session: {
   // Work an orchestrator started is implementation, not a person's session.
   if (!session.task_status)
     return session.started_by ? "implement" : "interactive";
-  return session.plan_phase === "planning" ? "plan" : "implement";
+  return session.plan_phase === "planning" || session.plan_phase === "awaiting"
+    ? "plan"
+    : "implement";
 }