@saadnvd1/agent-os 0.3.524 → 0.3.527

package/lib/doctor/checks.ts

@@ -0,0 +1,222 @@
+/**
+ * Is this machine ready to run AgentOS? Node, git, tmux, ripgrep, lsof and at
+ * least one agent CLI, each with what to do when it is not. Read-only: it runs
+ * each tool's version and nothing else.
+ */
+
+import { execFile } from "child_process";
+import { promisify } from "util";
+import { probeAgents, type AgentProbe } from "../agents/probe";
+import { getAllProviderDefinitions } from "../providers/registry";
+
+// The oldest Node major AgentOS runs on; scripts/lib/prerequisites.sh must agree
+// (lib/doctor/drift.test.ts fails when they don't).
+export const MIN_NODE_MAJOR = 20;
+
+const TOOL_MS = 5_000;
+const CACHE_MS = 60 * 1000;
+
+export type CheckStatus = "ok" | "warn" | "fail";
+
+export interface DoctorCheck {
+  id: string;
+  label: string;
+  status: CheckStatus;
+  detail: string;
+  // The line to run, or what to do, when the check is not ok.
+  fix?: string;
+}
+
+export type ExecFn = (
+  file: string,
+  args: string[],
+  options: { timeout: number }
+) => Promise<{ stdout: string; stderr: string }>;
+
+export interface DoctorDeps {
+  exec: ExecFn;
+  probe: (fresh: boolean) => Promise<Record<string, AgentProbe>>;
+  nodeVersion: string;
+}
+
+const defaultDeps: DoctorDeps = {
+  exec: promisify(execFile) as ExecFn,
+  probe: probeAgents,
+  nodeVersion: process.versions.node,
+};
+
+const INSTALL = {
+  mac: "brew install",
+  linux: "sudo apt-get install -y",
+};
+const installLine = (pkg: string) =>
+  process.platform === "darwin"
+    ? `${INSTALL.mac} ${pkg}`
+    : `${INSTALL.linux} ${pkg}`;
+
+interface Tool {
+  id: string;
+  label: string;
+  bin: string;
+  args: string[];
+  pkg: string;
+  // Missing is a fail for what AgentOS cannot run without, a warn otherwise.
+  required: boolean;
+  why: string;
+}
+
+const TOOLS: Tool[] = [
+  {
+    id: "git",
+    label: "git",
+    bin: "git",
+    args: ["--version"],
+    pkg: "git",
+    required: true,
+    why: "Sessions work in git worktrees.",
+  },
+  {
+    id: "tmux",
+    label: "tmux",
+    bin: "tmux",
+    args: ["-V"],
+    pkg: "tmux",
+    required: true,
+    why: "Terminal sessions run inside tmux.",
+  },
+  {
+    id: "ripgrep",
+    label: "ripgrep",
+    bin: "rg",
+    args: ["--version"],
+    pkg: "ripgrep",
+    required: false,
+    why: "File search is slower without it.",
+  },
+  {
+    id: "lsof",
+    label: "lsof",
+    bin: "lsof",
+    args: ["-v"],
+    pkg: "lsof",
+    required: false,
+    why: "Finding what holds a port needs it.",
+  },
+];
+
+const firstLine = (s: string) =>
+  s
+    .split("\n")
+    .find((l) => l.trim())
+    ?.trim();
+
+export function checkNode(version: string): DoctorCheck {
+  const major = Number.parseInt(version.split(".")[0], 10);
+  const ok = major >= MIN_NODE_MAJOR;
+  return {
+    id: "node",
+    label: "Node.js",
+    status: ok ? "ok" : "fail",
+    detail: ok
+      ? `v${version}`
+      : `v${version}; AgentOS needs ${MIN_NODE_MAJOR} or newer`,
+    ...(ok
+      ? {}
+      : { fix: `Install Node.js ${MIN_NODE_MAJOR}+ from nodejs.org` }),
+  };
+}
+
+async function checkTool(tool: Tool, exec: ExecFn): Promise<DoctorCheck> {
+  const base = { id: tool.id, label: tool.label };
+  try {
+    const { stdout, stderr } = await exec(tool.bin, tool.args, {
+      timeout: TOOL_MS,
+    });
+    return {
+      ...base,
+      status: "ok",
+      detail: firstLine(`${stdout}\n${stderr}`) ?? "installed",
+    };
+  } catch (error) {
+    const timedOut = (error as { killed?: boolean }).killed;
+    // lsof -v exits non-zero on some builds while printing its version; a
+    // tool that ran is installed, only one that could not start is missing.
+    const e = error as { code?: unknown; stdout?: string; stderr?: string };
+    const ran = typeof e.code === "number" && !timedOut;
+    if (tool.id === "lsof" && ran)
+      return { ...base, status: "ok", detail: "installed" };
+    return {
+      ...base,
+      status: tool.required ? "fail" : "warn",
+      detail: timedOut
+        ? `${tool.bin} did not answer`
+        : `Not found. ${tool.why}`,
+      fix: installLine(tool.pkg),
+    };
+  }
+}
+
+export function checkAgents(probes: Record<string, AgentProbe>): DoctorCheck {
+  const clis = getAllProviderDefinitions().filter((d) => d.cli);
+  const names = new Map(clis.map((d) => [d.id, d.name]));
+  // Providers without a CLI (a plain terminal) are always "installed".
+  const found = Object.entries(probes).filter(
+    ([id, p]) => names.has(id as never) && p.installed
+  );
+  const ready = found.filter(([, p]) => p.auth !== "needs-login");
+  const list = (rows: typeof found) =>
+    rows.map(([id]) => names.get(id as never) ?? id).join(", ");
+  if (ready.length > 0)
+    return {
+      id: "agents",
+      label: "Agent CLI",
+      status: "ok",
+      detail: `${list(ready)} ready`,
+    };
+  if (found.length > 0)
+    return {
+      id: "agents",
+      label: "Agent CLI",
+      status: "warn",
+      detail: `${list(found)} installed but needs sign-in`,
+      fix: "Sign in below",
+    };
+  return {
+    id: "agents",
+    label: "Agent CLI",
+    status: "fail",
+    detail: "No agent CLI installed",
+    fix: "Install one below",
+  };
+}
+
+let cache: { at: number; checks: Promise<DoctorCheck[]> } | null = null;
+
+/** Every check, in parallel, cached for a minute. `fresh` runs them again. */
+export function runDoctor(
+  fresh = false,
+  deps: Partial<DoctorDeps> = {}
+): Promise<DoctorCheck[]> {
+  const custom = Object.keys(deps).length > 0;
+  if (!custom && !fresh && cache && Date.now() - cache.at < CACHE_MS)
+    return cache.checks;
+  const d = { ...defaultDeps, ...deps };
+  const checks = Promise.all([
+    Promise.resolve(checkNode(d.nodeVersion)),
+    ...TOOLS.map((t) => checkTool(t, d.exec)),
+    d
+      .probe(fresh)
+      .then(checkAgents)
+      .catch(
+        (): DoctorCheck => ({
+          id: "agents",
+          label: "Agent CLI",
+          status: "warn",
+          detail: "Couldn't check the agent CLIs",
+          fix: "Check again",
+        })
+      ),
+  ]);
+  if (!custom) cache = { at: Date.now(), checks };
+  return checks;
+}

package/lib/orchestrator/ask-view.ts

@@ -30,10 +30,23 @@ export interface AskView {
   createdAt: string;
 }
 
+// A question the orchestrator put to Saad in chat, open until answered.
+export interface QuestionView {
+  id: number;
+  text: string;
+  // The task it is about, when it names one.
+  task: string | null;
+  taskName: string | null;
+  createdAt: string;
+}
+
 export interface OrchestratorOverview {
   workspaceId: string;
   sessionId: string | null;
   paused: boolean;
   inReview: number;
   asks: AskView[];
+  questions: QuestionView[];
+  // Keys (ask:<id>, question:<id>) he hid from the Needs-you strip.
+  dismissed: string[];
 }

package/lib/orchestrator/brief.ts

@@ -84,7 +84,9 @@ When one of these comes up, park it with \`ask_saad\` (kind: the hard line it cr
 
 Saad answers an ask on his list, and the answer reaches you as an event: \`ask "<title>": approved\`, \`declined\`, or \`reply: <text>\`. Act on it. An approval covers that one item only, never standing permission: the next item like it is a new ask. Approving a held task lets \`sign_off\` merge it once, at the commit he approved; approving a brake lets one start through, once.
 
-Saad can pause you. While paused your acting tools refuse and events wait; reading, \`note\` and \`ask_saad\` still work. When he resumes, what queued arrives as one message.
+Anything you need from Saad in chat (a question, a choice, a confirmation) goes through \`question\` in the same turn you ask it, and you still write the question plainly in your reply. It stays pinned on his Needs-you strip until it is resolved: when he answers (in chat, or with the strip's Reply) or it stops mattering, call \`resolve_question\`. Don't leave one open once he has answered. \`ask_saad\` is for hard lines and calls that need Approve or Decline; \`question\` is for everything conversational. Don't open a question for something that is already an ask. Updates AgentOS sends you fold into one-line rows in his chat, so a question buried in a long reply to an event is easy to miss: that is what \`question\` is for.
+
+Saad can pause you. While paused your acting tools refuse and events wait; reading, \`note\`, \`question\` and \`ask_saad\` still work. When he resumes, what queued arrives as one message.
 
 A message starting \`[Scheduled message "<name>" ...]\` is a standing prompt saved in Schedules, posted on its timer. Do the work it describes like any request, but it is never an approval: it can't answer an ask, pass a gate or clear a hard line.
 
@@ -127,6 +129,8 @@ Acting:
 - \`${TOOL_NAMES.arm}\` (task): merge a task's PR by itself the moment every gate passes; one event when it merges or a gate fails.
 - \`${TOOL_NAMES.disarm}\` (task): stop an armed task merging by itself.
 - \`${TOOL_NAMES.ask_saad}\` (title, detail, link?, kind, task?, sha?): park an item on Saad's asks list and carry on; it never waits.
+- \`${TOOL_NAMES.question}\` (text, task?): mark a question you asked Saad in chat as open, pinned on his Needs-you strip.
+- \`${TOOL_NAMES.resolve_question}\` (id): clear an open question once he has answered it or it no longer matters.
 
 The MCP servers this workspace allows (Settings → Workspaces) are yours to use through their own tools, for reading and for additive, reversible changes. Anything outbound through them (sending a message, an email, a post) is a hard line: park it with \`ask_saad\`.
 

package/lib/orchestrator/deliver.ts

@@ -10,6 +10,7 @@ import {
   logSuppressed,
   markDelivered,
   pendingEvents,
+  subjectNames,
   suppressedSince,
   unlogDeliveries,
 } from "./events";
@@ -130,9 +131,11 @@ export async function deliverEvents(opts: {
   const text = lines.join("\n");
   // Saad's answers to asks, shown in chat as his decisions.
   const decided = [...new Set(pending.filter(isAnswer).map((e) => e.line))];
+  const subjects = subjectNames(pending.map((e) => e.subject));
   const origin: ChatOrigin = {
     kind: "event",
     label: "AgentOS",
+    ...(subjects.length ? { subjects } : {}),
     ...(decided.length ? { decided } : {}),
     ...(pending.every((e) => isAwayEvent(e)) ? { away: true as const } : {}),
   };

package/lib/orchestrator/events.ts

@@ -299,3 +299,22 @@ export function deliveriesSince(
       .get(workspaceId, subject, iso(since)) as { n: number }
   ).n;
 }
+
+// The sessions an event batch is about, by name, for chat to say what each
+// update was.
+export function subjectNames(
+  subjects: (string | null)[]
+): { id: string; name: string }[] {
+  const ids = [...new Set(subjects.filter((s): s is string => !!s))];
+  if (!ids.length) return [];
+  const rows = db
+    .prepare(
+      `SELECT id, name FROM sessions WHERE id IN (${ids.map(() => "?").join(",")})`
+    )
+    .all(...ids) as { id: string; name: string }[];
+  const byId = new Map(rows.map((r) => [r.id, r.name]));
+  return ids.flatMap((id) => {
+    const name = byId.get(id);
+    return name ? [{ id, name }] : [];
+  });
+}

package/lib/orchestrator/needs-you-items.ts

@@ -0,0 +1,104 @@
+// What the Needs-you strip lists: everything waiting on Saad, newest first.
+// Client-safe and pure, so the strip and its tests share one rule.
+
+import { NEED_LABEL, type SessionNeed } from "../sidebar/shelves";
+import type { AskView, QuestionView } from "./ask-view";
+
+export type NeedsYouItem =
+  | {
+      key: string;
+      kind: "ask";
+      title: string;
+      sub: string;
+      at: number;
+      ask: AskView;
+    }
+  | {
+      key: string;
+      kind: "question";
+      title: string;
+      sub: string;
+      at: number;
+      question: QuestionView;
+    }
+  // The orchestrator's own chat waiting on an approval or an answer.
+  | { key: string; kind: "chat"; title: string; sub: string; at: number }
+  | {
+      key: string;
+      kind: "task";
+      title: string;
+      sub: string;
+      at: number;
+      sessionId: string;
+    };
+
+export interface TaskNeed {
+  sessionId: string;
+  name: string;
+  need: SessionNeed;
+}
+
+// SQLite datetime('now') is UTC without a zone marker.
+export const sqliteMs = (t: string) =>
+  Date.parse(`${t.replace(" ", "T")}Z`) || 0;
+
+// Those he can act on from the strip. A failed or unsent task isn't a
+// question to him.
+const TASK_NEEDS: readonly SessionNeed[] = [
+  "approve",
+  "answer",
+  "signin",
+  "input",
+];
+
+export function needsYouItems(input: {
+  asks: AskView[];
+  questions: QuestionView[];
+  dismissed: readonly string[];
+  tasks?: TaskNeed[];
+  chatWaiting?: boolean;
+  chatKey?: string;
+}): NeedsYouItem[] {
+  const hidden = new Set(input.dismissed);
+  const items: NeedsYouItem[] = [
+    ...input.asks.map(
+      (ask): NeedsYouItem => ({
+        key: `ask:${ask.id}`,
+        kind: "ask",
+        title: ask.title,
+        sub: ask.kind,
+        at: sqliteMs(ask.createdAt),
+        ask,
+      })
+    ),
+    ...input.questions.map(
+      (question): NeedsYouItem => ({
+        key: `question:${question.id}`,
+        kind: "question",
+        title: question.text,
+        sub: question.taskName ?? "Question",
+        at: sqliteMs(question.createdAt),
+        question,
+      })
+    ),
+  ];
+  if (input.chatWaiting)
+    items.push({
+      key: input.chatKey ?? "approval:chat",
+      kind: "chat",
+      title: "Waiting for your answer in chat",
+      sub: "Answer",
+      at: Date.now(),
+    });
+  for (const t of input.tasks ?? [])
+    if (TASK_NEEDS.includes(t.need))
+      items.push({
+        key: `task:${t.sessionId}`,
+        kind: "task",
+        title: t.name,
+        sub: NEED_LABEL[t.need],
+        at: 0,
+        sessionId: t.sessionId,
+      });
+  return items.filter((i) => !hidden.has(i.key)).sort((a, b) => b.at - a.at);
+}

package/lib/orchestrator/overview.ts

@@ -11,6 +11,7 @@ import { askBinding, openAsks, PRESENCE_KINDS } from "./asks";
 import type { OrchestratorOverview } from "./ask-view";
 import { getOrchestrator } from "./home";
 import { resolveStaleAsks } from "./ask-settle";
+import { dismissedKeys, openQuestions } from "./questions";
 
 export type { AskView, OrchestratorOverview } from "./ask-view";
 
@@ -57,6 +58,8 @@ export function orchestratorOverview(): OrchestratorOverview[] {
           createdAt: a.created_at,
         };
       }),
+      questions: openQuestions(w.id),
+      dismissed: dismissedKeys(w.id),
     };
   });
 }

package/lib/orchestrator/questions.ts

@@ -0,0 +1,120 @@
+/**
+ * Questions the orchestrator puts to Saad in chat. Marking one open pins it
+ * on his Needs-you strip until he answers it (the strip's Reply) or the
+ * orchestrator clears it. Unlike an ask it has no Approve or Decline: it is
+ * just words that need an answer. Dismissing an item from the strip only
+ * hides it, for asks and questions alike.
+ */
+
+import { db } from "../db";
+import type { QuestionView } from "./ask-view";
+import { workspaceTask } from "./targets";
+
+export const MAX_OPEN_QUESTIONS = 10;
+
+interface QuestionRow {
+  id: number;
+  text: string;
+  task: string | null;
+  task_name: string | null;
+  created_at: string;
+}
+
+export function openQuestions(workspaceId: string): QuestionView[] {
+  settleQuestions(workspaceId);
+  return (
+    db
+      .prepare(
+        `SELECT q.id, q.text, q.task, s.name AS task_name, q.created_at
+         FROM orchestrator_questions q LEFT JOIN sessions s ON s.id = q.task
+         WHERE q.workspace_id = ? AND q.status = 'open'
+         ORDER BY q.id DESC`
+      )
+      .all(workspaceId) as QuestionRow[]
+  ).map((r) => ({
+    id: r.id,
+    text: r.text,
+    task: r.task,
+    taskName: r.task_name,
+    createdAt: r.created_at,
+  }));
+}
+
+// A question about work that has finished no longer needs an answer.
+function settleQuestions(workspaceId: string): void {
+  db.prepare(
+    `UPDATE orchestrator_questions
+     SET status = 'cleared', resolved_by = 'orchestrator', resolved_at = datetime('now')
+     WHERE workspace_id = ? AND status = 'open' AND task IN (
+       SELECT id FROM sessions WHERE task_status IN ('merged', 'dropped', 'done'))`
+  ).run(workspaceId);
+}
+
+// The same words while open are the same question.
+export function askQuestion(
+  workspaceId: string,
+  text: string,
+  taskRef?: string
+): string {
+  const task = taskRef ? workspaceTask(workspaceId, taskRef).id : null;
+  const open = db
+    .prepare(
+      `SELECT id FROM orchestrator_questions
+       WHERE workspace_id = ? AND status = 'open' AND text = ?`
+    )
+    .get(workspaceId, text) as { id: number } | undefined;
+  if (open) return `Question ${open.id} is already open; left as it is.`;
+  const count = (
+    db
+      .prepare(
+        `SELECT COUNT(*) AS n FROM orchestrator_questions
+         WHERE workspace_id = ? AND status = 'open'`
+      )
+      .get(workspaceId) as { n: number }
+  ).n;
+  if (count >= MAX_OPEN_QUESTIONS)
+    return `Not opened: ${count} questions are already open. Clear the ones that no longer matter with resolve_question first.`;
+  const { lastInsertRowid } = db
+    .prepare(
+      `INSERT INTO orchestrator_questions (workspace_id, text, task) VALUES (?, ?, ?)`
+    )
+    .run(workspaceId, text, task);
+  return `Question ${lastInsertRowid} is open on Saad's Needs-you strip. Call resolve_question ${lastInsertRowid} once he has answered or it no longer matters.`;
+}
+
+export function resolveQuestion(
+  workspaceId: string,
+  id: number,
+  by: "saad" | "orchestrator"
+): boolean {
+  return (
+    db
+      .prepare(
+        `UPDATE orchestrator_questions
+         SET status = ?, resolved_by = ?, resolved_at = datetime('now')
+         WHERE id = ? AND workspace_id = ? AND status = 'open'`
+      )
+      .run(by === "saad" ? "answered" : "cleared", by, id, workspaceId)
+      .changes > 0
+  );
+}
+
+export function dismissItem(workspaceId: string, key: string): void {
+  db.prepare(
+    `INSERT OR IGNORE INTO needs_you_dismissed (workspace_id, key) VALUES (?, ?)`
+  ).run(workspaceId, key);
+}
+
+export function undismissItem(workspaceId: string, key: string): void {
+  db.prepare(
+    `DELETE FROM needs_you_dismissed WHERE workspace_id = ? AND key = ?`
+  ).run(workspaceId, key);
+}
+
+export function dismissedKeys(workspaceId: string): string[] {
+  return (
+    db
+      .prepare(`SELECT key FROM needs_you_dismissed WHERE workspace_id = ?`)
+      .all(workspaceId) as { key: string }[]
+  ).map((r) => r.key);
+}

package/lib/orchestrator/serve.ts

@@ -23,6 +23,7 @@ import { addNote } from "./notes";
 import { addProject } from "./add-project";
 import { addRule, removeRule } from "./rules";
 import { askSaad } from "./ask-tool";
+import { askQuestion, resolveQuestion } from "./questions";
 import { listOrchestratorPeers, messageOrchestrator } from "./cross";
 import { PAUSED_REFUSAL } from "./pause";
 import { readSession } from "./read";
@@ -211,5 +212,15 @@ export async function runTool(
       return disarm(w, p(tool, raw).task);
     case "ask_saad":
       return askSaad(w, p(tool, raw));
+    case "question": {
+      const a = p(tool, raw);
+      return askQuestion(w, a.text, a.task);
+    }
+    case "resolve_question": {
+      const id = p(tool, raw).id;
+      return resolveQuestion(w, id, "orchestrator")
+        ? `Question ${id} cleared.`
+        : `No open question ${id}.`;
+    }
   }
 }

package/lib/orchestrator/tool-names.ts

@@ -29,6 +29,8 @@ export const TOOL_NAMES = {
   done: name("done"),
   add_project: name("add_project"),
   note: name("note"),
+  question: name("question"),
+  resolve_question: name("resolve_question"),
   rule_add: name("rule_add"),
   rule_remove: name("rule_remove"),
   review: name("review"),

package/lib/orchestrator/tool-schemas.ts

@@ -239,6 +239,18 @@ export const TOOL_SHAPES = {
       .describe("A new project's name (default: the folder's)"),
   },
   note: { text: z.string().trim().min(1).max(2000) },
+  question: {
+    text: z
+      .string()
+      .trim()
+      .min(1)
+      .max(300)
+      .describe("The question as you asked it in chat, one or two sentences"),
+    task: ref("The task it is about, when it names one").optional(),
+  },
+  resolve_question: {
+    id: z.number().int().positive().describe("The question's id"),
+  },
   rule_add: {
     text: z
       .string()

package/lib/orchestrator/tools.ts

@@ -101,6 +101,10 @@ const DESCRIPTIONS: Record<ToolName, string> = {
   arm: "Arm a task's PR to merge: AgentOS merges it, through the same gates as sign_off, the moment they all pass at its head, and tells you with one event. A gate failure comes as one event and it stays armed for the fix; one that goes to Saad disarms it. Survives restarts. Use it instead of calling sign_off until it passes.",
   disarm:
     "Disarm a task armed to merge: it merges only through sign_off again.",
+  question:
+    "Mark a question you asked Saad in chat as open: it stays pinned on his Needs-you strip until he answers or you clear it. Use it for anything you need from him that isn't an ask_saad item. The same text while open is the same question.",
+  resolve_question:
+    "Clear an open question once Saad has answered it in chat, or it no longer matters.",
   ask_saad:
     "Park an item on Saad's asks list (a decision, or anything crossing a hard line) and carry on; it never waits. One open ask per title. His answer reaches you as an event. To ask whether to merge a PR the gates refuse, give task and sha (its head): his approval lets sign_off merge it once, at that commit.",
 };

package/lib/welcome-url.ts

@@ -3,7 +3,12 @@
 
 export const WELCOME_PARAM = "welcome";
 
-export const WELCOME_STEPS = ["agents", "project", "finish"] as const;
+export const WELCOME_STEPS = [
+  "agents",
+  "project",
+  "devices",
+  "finish",
+] as const;
 
 export type WelcomeStep = (typeof WELCOME_STEPS)[number];
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@saadnvd1/agent-os",
-  "version": "0.3.524",
+  "version": "0.3.527",
   "description": "Self-hosted web UI for managing Claude Code sessions",
   "bin": {
     "agent-os": "scripts/agent-os"

package/stores/needsYouFocus.ts

@@ -0,0 +1,13 @@
+import { proxy } from "valtio";
+
+// "Show this ask", raised by the Needs-you strip and handled by the asks list
+// above the chat, which opens itself and scrolls the card into view.
+export const needsYouFocus = proxy<{
+  ask: { id: number; at: number } | null;
+}>({ ask: null });
+
+export const needsYouFocusActions = {
+  ask: (id: number) => {
+    needsYouFocus.ask = { id, at: Date.now() };
+  },
+};

package/stores/welcomeUi.test.ts

@@ -0,0 +1,15 @@
+import { beforeEach, describe, expect, it } from "vitest";
+import { welcomeUi, welcomeUiActions } from "./welcomeUi";
+
+describe("choosing a project in the welcome", () => {
+  beforeEach(() => {
+    welcomeUiActions.go("project");
+    welcomeUiActions.setProject(null);
+  });
+
+  it("remembers it and lands on the devices step, not the finish", () => {
+    welcomeUiActions.chooseProject("p1");
+    expect(welcomeUi.projectId).toBe("p1");
+    expect(welcomeUi.step).toBe("devices");
+  });
+});