@saadnvd1/agent-os 0.3.535 → 0.3.538

package/README.md

@@ -134,7 +134,8 @@ Pi,
 [Kilo Code CLI](https://kilo.ai/docs/cli),
 [Gemini CLI](https://github.com/google-gemini/gemini-cli),
 [Aider](https://aider.chat/), [Cursor CLI](https://cursor.com/cli), Amp or
-[GitHub Copilot CLI](https://github.com/github/copilot-cli).
+[GitHub Copilot CLI](https://github.com/github/copilot-cli) or
+[Kiro CLI](https://kiro.dev/docs/cli/).
 
 ```bash
 npm install -g @saadnvd1/agent-os
@@ -250,10 +251,21 @@ CLI) with the fix for anything missing (`/api/doctor`).
 | Amp            | ❌   | ✅     | ❌   | `--dangerously-allow-all`                    |
 | Oh My Pi       | ❌   | ❌     | ❌   | N/A                                          |
 | GitHub Copilot | ✅   | ✅     | ❌   | `--allow-all`                                |
+| Kiro CLI       | ❌   | ❌     | ❌   | `--trust-all-tools`                          |
+| Amazon Q (old) | ❌   | ❌     | ❌   | `--trust-all-tools`                          |
 
 Agents without chat run in the terminal. The new-session picker says when an
 agent isn't installed or needs a sign-in first, and what to run.
 
+Kiro CLI (and the older Amazon Q CLI, `q`, shown only where it is installed)
+signs in on its own: a session first checks `whoami`, and if you're signed out
+runs `login --use-device-flow`. AgentOS reads the link and one-time code off
+the screen and shows them in a card above the terminal, with a push when it's
+waiting, so you can finish on your phone. No credential passes through
+AgentOS. Identity Center sign-in (including Microsoft or Okta federation) works
+this way; a login through an external identity provider doesn't support the
+device flow, so sign in once on the machine itself, or set `KIRO_API_KEY`.
+
 ### CLI
 
 ```bash
@@ -1578,8 +1590,11 @@ approved`). An approval covers that one item only: a held task's approval
   pass, by giving `ask_saad` the task and its head sha: the ask is pinned to
   that commit, opens with what AgentOS knows about it (files changed,
   sensitive files, the review's verdict) and links the PR, and your approval
-  lets `sign_off` merge it once, at that commit, with a code review of it in
-  the PR body. It never rewrites an ask the gates raised.
+  lets `sign_off` merge it once, at that commit. It never rewrites an ask the
+  gates raised. An approved merge (either kind, and an armed task's) needs no
+  review or other gate of that commit: only an AI-attributed PR body, failing
+  CI (running CI waits), a head that moved off the commit, and on the
+  orchestrator's own ask a stack parent not merged yet, still stop it.
   An ask closes itself when its task is merged or dropped, or the brakes
   lift. At most 10 are open per workspace, titles that say the same thing
   fold into one, a declined subject isn't asked again for 6 hours, and a

package/app/page.tsx

@@ -302,7 +302,7 @@ function HomeContent() {
         isLocal && provider.id === "claude"
           ? ` --append-system-prompt-file "$HOME/.agent-os/bus-brief.md" ${CLAUDE_STATUS_SETTINGS_FLAG}`
           : "";
-      const agentCmd = `${provider.command} ${flagsStr}${busBrief}`;
+      const agentCmd = `${provider.preamble}${provider.command} ${flagsStr}${busBrief}`;
       // The init script is a file on this machine, so remote sessions run the
       // agent directly and drop to a shell when it exits.
       const command =

package/components/Pane/index.tsx

@@ -2,6 +2,8 @@
 
 import { useTaskLogQuery } from "@/data/session-logs";
 import { SetupCard } from "@/components/Chat/SetupCard";
+import { SignInCard } from "@/components/Terminal/SignInCard";
+import { getProviderDefinition } from "@/lib/providers/registry";
 import type { TabData } from "@/lib/panes";
 import { useRef, useCallback, useEffect, memo, useMemo } from "react";
 import dynamic from "next/dynamic";
@@ -322,28 +324,34 @@ export const Pane = memo(function Pane({
         </div>
       );
     const savedState = sessionRegistry.getTerminalState(paneId, tab.id);
+    const signInAgent = own ? getProviderDefinition(own.agent_type) : undefined;
     return (
-      <Terminal
-        ref={getTerminalRef(tab.id)}
-        onConnected={getTerminalConnectedHandler(tab)}
-        onBeforeUnmount={(scrollState) => {
-          sessionRegistry.saveTerminalState(paneId, tab.id, {
-            scrollTop: scrollState.scrollTop,
-            scrollHeight: 0,
-            lastActivity: Date.now(),
-            cursorY: scrollState.cursorY,
-          });
-        }}
-        initialScrollState={
-          savedState
-            ? {
-                scrollTop: savedState.scrollTop,
-                cursorY: savedState.cursorY,
-                baseY: 0,
-              }
-            : undefined
-        }
-      />
+      <div className="relative h-full w-full">
+        {signInAgent?.signIn && own && (
+          <SignInCard sessionId={own.id} agent={signInAgent.name} />
+        )}
+        <Terminal
+          ref={getTerminalRef(tab.id)}
+          onConnected={getTerminalConnectedHandler(tab)}
+          onBeforeUnmount={(scrollState) => {
+            sessionRegistry.saveTerminalState(paneId, tab.id, {
+              scrollTop: scrollState.scrollTop,
+              scrollHeight: 0,
+              lastActivity: Date.now(),
+              cursorY: scrollState.cursorY,
+            });
+          }}
+          initialScrollState={
+            savedState
+              ? {
+                  scrollTop: savedState.scrollTop,
+                  cursorY: savedState.cursorY,
+                  baseY: 0,
+                }
+              : undefined
+          }
+        />
+      </div>
     );
   };
 

package/components/Terminal/SignInCard.tsx

@@ -0,0 +1,84 @@
+"use client";
+
+import { useState } from "react";
+import { ExternalLink, X } from "lucide-react";
+import { useSignIn } from "@/data/statuses/useSignIn";
+import { trustedSignInUrl } from "@/lib/agents/signin-screen";
+import { CopyButton } from "@/components/Chat/CopyButton";
+
+// Finishing an agent's sign-in from this device: the link to open and the
+// code to type there. The text is the CLI's own, so a link is only opened
+// when it points at a sign-in page; anything else stays text to copy.
+export function SignInCard({
+  sessionId,
+  agent,
+}: {
+  sessionId: string;
+  agent: string;
+}) {
+  const signIn = useSignIn(sessionId);
+  // Hidden until the sign-in shows something new.
+  const [hidden, setHidden] = useState("");
+  if (!signIn) return null;
+  const { url, code } = signIn;
+  const key = `${url}|${code}`;
+  if (hidden === key) return null;
+  return (
+    <div
+      role="status"
+      className="bg-card hairline absolute inset-x-2 top-2 z-10 flex flex-col gap-3 rounded-lg p-3 shadow-lg"
+    >
+      <div>
+        <div className="flex items-center justify-between gap-2">
+          <p className="text-sm font-medium">Sign in to {agent}</p>
+          <button
+            type="button"
+            aria-label="Dismiss"
+            onClick={() => setHidden(key)}
+            className="text-muted-foreground hover:text-foreground -m-2 flex h-11 w-11 items-center justify-center"
+          >
+            <X className="size-4" />
+          </button>
+        </div>
+        <p className="text-muted-foreground text-xs">
+          Finish signing in on any device; the session carries on by itself.
+        </p>
+      </div>
+      {code && (
+        <div className="flex items-center justify-between gap-2">
+          <span className="font-mono text-2xl tracking-widest select-all">
+            {code}
+          </span>
+          <CopyButton
+            text={code}
+            label="Copy code"
+            className="h-11 w-11 md:h-11 md:w-11"
+          />
+        </div>
+      )}
+      {url &&
+        (trustedSignInUrl(url) ? (
+          <a
+            href={url}
+            target="_blank"
+            rel="noopener noreferrer"
+            className="bg-primary text-primary-foreground flex h-11 items-center justify-center gap-2 rounded-lg text-sm font-medium"
+          >
+            Open sign-in page
+            <ExternalLink className="size-4" />
+          </a>
+        ) : (
+          <div className="flex items-center gap-2">
+            <span className="text-muted-foreground min-w-0 flex-1 text-xs break-all select-all">
+              {url}
+            </span>
+            <CopyButton
+              text={url}
+              label="Copy link"
+              className="h-11 w-11 md:h-11 md:w-11"
+            />
+          </div>
+        ))}
+    </div>
+  );
+}

package/components/Welcome/AgentList.tsx

@@ -23,7 +23,9 @@ export function AgentList() {
 
   useEffect(() => mutate(), [mutate]);
 
-  const providers = getAllProviderDefinitions().filter((p) => p.cli);
+  const providers = getAllProviderDefinitions().filter(
+    (p) => p.cli && (!p.legacy || agents?.[p.id]?.installed)
+  );
   const shown = providers.filter((p) => all || FEATURED_AGENTS.includes(p.id));
   const hidden = providers.length - shown.length;
 

package/components/views/types.ts

@@ -20,6 +20,8 @@ export interface SessionStatus {
   claudeSessionId?: string | null;
   // From a program's OSC 7501 report: untrusted, rendered as plain text.
   detail?: string | null;
+  // The link and code a CLI's sign-in is waiting on (untrusted text).
+  signIn?: { url: string | null; code: string | null } | null;
   progress?: number | null;
 }
 

package/data/statuses/useSignIn.ts

@@ -0,0 +1,16 @@
+import { useQuery } from "@tanstack/react-query";
+import type { SessionStatus } from "@/components/views/types";
+import { statusKeys } from "../sessions/keys";
+import { fetchStatuses } from "./queries";
+
+// The sign-in a session's CLI is waiting on, read from the statuses the
+// sidebar already keeps; asks for nothing of its own.
+export function useSignIn(sessionId: string): SessionStatus["signIn"] {
+  const { data } = useQuery({
+    queryKey: statusKeys.all,
+    queryFn: fetchStatuses,
+    staleTime: 2000,
+    select: (d) => d.statuses[sessionId]?.signIn ?? null,
+  });
+  return data;
+}

package/lib/__fixtures__/screens/kiro-device-login.txt

@@ -0,0 +1,10 @@
+Logging in to Kiro
+
+Confirm the code in your browser:
+
+    ABCD-EFGH
+
+Open this URL to continue:
+https://view.awsapps.com/start/#/device?user_code=ABCD-EFGH
+
+Waiting for authorization...

package/lib/agent-options.ts

@@ -13,6 +13,8 @@ export const AGENT_OPTIONS: { value: AgentType; label: string }[] = [
   { value: "pi", label: "Pi" },
   { value: "omp", label: "Oh My Pi" },
   { value: "copilot", label: "GitHub Copilot" },
+  { value: "kiro", label: "Kiro CLI" },
+  { value: "amazonq", label: "Amazon Q CLI (legacy)" },
 ];
 
 export const agentLabel = (agent: AgentType) =>

package/lib/agents/probe.ts

@@ -87,6 +87,31 @@ function claudeAuth(env: NodeJS.ProcessEnv): AgentAuth {
   return hasJsonKeys(config) ? "needs-login" : "unknown";
 }
 
+// Signed in when `cli args` exits 0. Timing out or failing to start tells
+// nothing; any other exit code is the CLI saying it isn't signed in.
+async function exitAuth(
+  cli: string,
+  env: NodeJS.ProcessEnv,
+  args: string[],
+  signedOut: (code: unknown) => boolean
+): Promise<AgentAuth> {
+  try {
+    await run(cli, args, { timeout: PROBE_MS, env });
+    return "ready";
+  } catch (error) {
+    return signedOut((error as { code?: unknown }).code)
+      ? "needs-login"
+      : "unknown";
+  }
+}
+
+// Kiro's `whoami` is never read, only its exit code: its output names the
+// account.
+const kiroAuth: AuthCheck = (cli, env) =>
+  anyEnv(env, ["KIRO_API_KEY"])
+    ? "ready"
+    : exitAuth(cli, env, ["whoami"], (c) => typeof c === "number" && c !== 0);
+
 const AUTH: Partial<Record<ProviderId, { check: AuthCheck; hint: string }>> = {
   claude: {
     check: (_cli, env) => claudeAuth(env),
@@ -94,16 +119,8 @@ const AUTH: Partial<Record<ProviderId, { check: AuthCheck; hint: string }>> = {
   },
   codex: {
     // Exits 0 signed in, 1 not.
-    check: async (cli, env) => {
-      try {
-        await run(cli, ["login", "status"], { timeout: PROBE_MS, env });
-        return "ready";
-      } catch (error) {
-        return (error as { code?: unknown }).code === 1
-          ? "needs-login"
-          : "unknown";
-      }
-    },
+    check: (cli, env) =>
+      exitAuth(cli, env, ["login", "status"], (c) => c === 1),
     hint: "Run `codex login` in a terminal",
   },
   // OpenCode's own free models need no sign-in.
@@ -153,6 +170,15 @@ const AUTH: Partial<Record<ProviderId, { check: AuthCheck; hint: string }>> = {
         : "needs-login",
     hint: "Run `cursor-agent login` in a terminal",
   },
+  kiro: {
+    check: kiroAuth,
+    hint: "Run `kiro-cli login --use-device-flow` in a terminal, or set KIRO_API_KEY",
+  },
+  amazonq: {
+    check: (cli, env) =>
+      exitAuth(cli, env, ["whoami"], (c) => typeof c === "number" && c !== 0),
+    hint: "Run `q login --use-device-flow` in a terminal",
+  },
   amp: {
     check: (_cli, env) =>
       hasJsonKeys(home(".local", "share", "amp", "secrets.json")) ||

package/lib/agents/setup-commands.ts

@@ -34,6 +34,15 @@ export const SETUP_COMMANDS: Partial<Record<ProviderId, SetupCommands>> = {
     install: "npm install -g @github/copilot",
     signIn: "copilot login",
   },
+  kiro: {
+    install: "curl -fsSL https://cli.kiro.dev/install | bash",
+    signIn: "kiro-cli login --use-device-flow",
+    docs: "https://kiro.dev/docs/cli/",
+  },
+  amazonq: {
+    signIn: "q login --use-device-flow",
+    docs: "https://kiro.dev/docs/cli/",
+  },
   // No installer line we can vouch for from here; its own site has it.
   opencode: { docs: "https://opencode.ai/docs" },
 };

package/lib/agents/signin-screen.ts

@@ -0,0 +1,109 @@
+/**
+ * The sign-in a CLI is waiting on, read from its screen: the link to open
+ * and the one-time code to type there (a device flow), so a device can
+ * finish it. Only the stretch of screen between the two lines a session
+ * prints around its login is read, so the agent's own output (links and the
+ * word "code" are everywhere in it) is never taken for a sign-in. What's
+ * there is the CLI's own output, so nothing is trusted: a link is only
+ * offered to open when its host is a sign-in page.
+ */
+
+// Printed by the session before the login and after it, whatever it did.
+export const SIGN_IN_START = "AgentOS: signing in";
+export const SIGN_IN_END = "AgentOS: sign-in finished";
+
+export interface SignInScreen {
+  url: string | null;
+  code: string | null;
+}
+
+const CUE = /verif|authori[sz]|one.?time|confirm|enter|code|open/i;
+const DONE = /logged in|signed in|success/i;
+const URL_LINE = /https:\/\/\S+/;
+const CODE_IN_URL = /user_code=([A-Z0-9-]{6,12})/;
+const CODE_LINE = /\b([A-Z0-9]{4}-[A-Z0-9]{4})\b/;
+const BARE_CODE = /^[A-Z0-9]{4}-[A-Z0-9]{4}$/;
+const URL_PIECE = /^[\w\-./?=&%#:+~@]+$/;
+// A URL cut by the pane's width: the piece before the cut ran this long.
+const WRAPPED_AT = 30;
+const LOOKBACK = 30;
+const NEAR = 3;
+
+// Where a device flow sends you: AWS's device-authorization page, the
+// Builder ID and Identity Center portals, and Kiro's own login. Not every
+// AWS host: S3 buckets and API gateways are anyone's.
+const TRUSTED_HOSTS = [
+  /^device\.sso\.[a-z0-9-]+\.amazonaws\.com$/,
+  /^view\.awsapps\.com$/,
+  /^d-[a-z0-9]+\.awsapps\.com$/,
+  /^([a-z0-9-]+\.)?kiro\.dev$/,
+];
+
+export function trustedSignInUrl(url: string): boolean {
+  try {
+    const u = new URL(url);
+    return (
+      u.protocol === "https:" &&
+      !u.username &&
+      !u.password &&
+      TRUSTED_HOSTS.some((h) => h.test(u.hostname))
+    );
+  } catch {
+    return false;
+  }
+}
+
+// Lines of the screen, with a URL the pane cut across lines put back.
+function joined(lines: string[]): string[] {
+  const out: string[] = [];
+  for (let i = 0; i < lines.length; i++) {
+    let line = lines[i].trim();
+    const at = line.search(URL_LINE);
+    if (at >= 0 && !/\s/.test(line.slice(at))) {
+      let last = line.slice(at);
+      for (;;) {
+        const next = lines[i + 1]?.trim() ?? "";
+        if (
+          last.length < WRAPPED_AT ||
+          !URL_PIECE.test(next) ||
+          BARE_CODE.test(next)
+        )
+          break;
+        line += next;
+        last = next;
+        i++;
+      }
+    }
+    out.push(line);
+  }
+  return out;
+}
+
+export function findSignIn(text: string): SignInScreen | null {
+  const all = text.split("\n");
+  const start = all.findLastIndex((l) => l.includes(SIGN_IN_START));
+  if (start < 0) return null;
+  const during = all.slice(start + 1);
+  if (during.some((l) => l.includes(SIGN_IN_END))) return null;
+  const lines = joined(during.slice(-LOOKBACK));
+  let found: { at: number; url: string } | null = null;
+  lines.forEach((line, at) => {
+    const url = line.match(URL_LINE)?.[0].replace(/[).,;]+$/, "");
+    if (!url) return;
+    const near = lines.slice(Math.max(0, at - NEAR), at + NEAR + 1);
+    if (near.some((l) => CUE.test(l))) found = { at, url };
+  });
+  if (!found) return null;
+  const { at, url } = found as { at: number; url: string };
+  if (lines.slice(at + 1).some((l) => DONE.test(l))) return null;
+  let code = url.match(CODE_IN_URL)?.[1] ?? null;
+  if (!code)
+    for (const l of lines.slice(Math.max(0, at - NEAR), at + NEAR + 1)) {
+      const m = l.match(CODE_LINE);
+      if (m && l !== url) {
+        code = m[1];
+        break;
+      }
+    }
+  return { url, code };
+}

package/lib/banner.ts

@@ -8,7 +8,10 @@ import * as path from "path";
 /**
  * Generate an init script that shows the AgentOS banner and configures tmux
  */
-function generateInitScript(agentCommand: string): string {
+export function generateInitScript(
+  agentCommand: string,
+  preamble = ""
+): string {
   return `#!/bin/bash
 # AgentOS Session Init Script
 # Auto-generated - do not edit manually
@@ -47,15 +50,15 @@ printf "\\n"
 sleep 0.8
 
 # Start the agent
-exec ${agentCommand}
+${preamble}exec ${agentCommand}
 `;
 }
 
 /**
  * Write init script to temp file and return the command to run it
  */
-export function wrapWithBanner(agentCommand: string): string {
-  const scriptContent = generateInitScript(agentCommand);
+export function wrapWithBanner(agentCommand: string, preamble = ""): string {
+  const scriptContent = generateInitScript(agentCommand, preamble);
   const scriptPath = path.join(os.tmpdir(), `agent-os-init-${Date.now()}.sh`);
 
   fs.writeFileSync(scriptPath, scriptContent, { mode: 0o755 });

package/lib/orchestration.ts

@@ -168,7 +168,7 @@ export async function spawnWorker(
 
   // Create tmux session with the agent and banner
   const agentCmd = `${provider.command} ${flagsStr}`;
-  const newSessionCmd = wrapWithBanner(agentCmd);
+  const newSessionCmd = wrapWithBanner(agentCmd, provider.preamble);
   try {
     await tmux(["set", "-g", "mouse", "on"]).catch(() => {});
     // The last argument is the agent's command line, which tmux runs.

package/lib/orchestrator/armed.ts

@@ -8,7 +8,8 @@
  * The orchestrator hears one event: merged, or a failure. A failure is
  * counted against the task once per head, as sign_off would count it, and
  * reported once; the task stays armed for its fix. One that goes to Saad
- * disarms it, since only he merges it from then on. The flag is in the
+ * disarms it, since only he merges it from then on, or approves its head
+ * for it to merge on that approval. The flag is in the
  * database, so it survives a restart.
  */
 
@@ -85,17 +86,19 @@ export function arm(workspaceId: string, ref: string): string {
 }
 
 // Arms a task, or says why it can't be: only a running task, in a
-// workspace whose orchestrator hears how it went, that isn't with Saad.
+// workspace whose orchestrator hears how it went, that isn't with Saad
+// (or that he approved a commit of: it merges on that, at that commit only).
 export function armTask(task: Session): void {
   if (task.task_status !== "running")
     throw new Error(`${task.name} is already ${task.task_status}`);
-  const held = holdingEscalations(task.id);
+  const w = armingWorkspace(task);
+  const approved = !!w && !!latestApproval(w, workSubject(task.id))?.sha;
+  const held = approved ? [] : holdingEscalations(task.id);
   if (held.length)
     throw new Error(
       `${task.name} is with Saad (${held.map((h) => h.gate).join(", ")}); only he merges it`
     );
-  const w = armingWorkspace(task);
-  if (w && openBySubject(w, workSubject(task.id)))
+  if (w && !approved && openBySubject(w, workSubject(task.id)))
     throw new Error(
       `${task.name} has an open ask with Saad; it merges on his answer`
     );
@@ -209,9 +212,16 @@ async function mergeOne(
     return;
   }
   // With Saad, on a gate or on a question about it: he decides, so it
-  // doesn't merge by itself meanwhile.
-  const held = holdingEscalations(task.id).map((h) => h.gate);
-  if (!held.length && openBySubject(workspaceId, workSubject(task.id)))
+  // doesn't merge by itself meanwhile, unless he approved this head.
+  const approved =
+    !!pr.head &&
+    latestApproval(workspaceId, workSubject(task.id))?.sha === pr.head;
+  const held = approved ? [] : holdingEscalations(task.id).map((h) => h.gate);
+  if (
+    !approved &&
+    !held.length &&
+    openBySubject(workspaceId, workSubject(task.id))
+  )
     held.push("an open ask");
   if (held.length) {
     setArmed(task.id, false);

package/lib/orchestrator/ask-tool.ts

@@ -122,7 +122,7 @@ export async function askSaad(
   }
   const { ask, created } = raised;
   const once = merge
-    ? ` If he approves, sign_off merges it once, at ${merge.sha.slice(0, 7)} only.`
+    ? ` If he approves, sign_off merges it once, at ${merge.sha.slice(0, 7)} only, without waiting on a review.`
     : "";
   if (!created)
     return `Already on Saad's list as ask ${ask.id}; updated it.${once} Carry on with everything else.`;

package/lib/orchestrator/brief.ts

@@ -86,11 +86,11 @@ ${brakesEnabled() ? BRAKES_ON : BRAKES_OFF}
 - Credentials and account security.
 - Choosing what gets built when it's a product call he hasn't made.
 
-When one of these comes up, park it with \`ask_saad\` (kind: the hard line it crosses) and carry on with everything else. Use it too for a decision that's his (kind: decision). Escalated gates and brakes become asks on their own; don't ask again for those. To ask whether to merge a PR the gates won't pass, give \`ask_saad\` the task and the PR's head sha: if he approves, \`sign_off\` merges it once, at that commit only.
+When one of these comes up, park it with \`ask_saad\` (kind: the hard line it crosses) and carry on with everything else. Use it too for a decision that's his (kind: decision). Escalated gates and brakes become asks on their own; don't ask again for those. To ask whether to merge a PR the gates won't pass, give \`ask_saad\` the task and the PR's head sha: if he approves, \`sign_off\` merges it once, at that commit only, without the review gates.
 
 ## Asks and pause
 
-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 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 merge (a held task's or your own ask's) lets \`sign_off\`, or an armed task, merge it once at the commit he approved, with no review, scope or other gate in the way: only an AI-attributed PR body, failing CI (running CI is a wait), an unmerged stack parent on your own ask, or a head that moved off that commit still stop it; approving a brake lets one start through, once.
 
 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.
 

package/lib/orchestrator/external-gates.ts

@@ -19,6 +19,7 @@ import { resolveAsks } from "./asks";
 import { clearStaleRunning, getCheck } from "./checks";
 import { gateTarget, type ExternalPR } from "./external-pr";
 import { holdingEscalations } from "./gates";
+import { reviewWanted } from "./held-review";
 import { addNote } from "./notes";
 import { commitTime } from "./repo";
 import { review, reviewAt, type ReviewOpts } from "./review";
@@ -154,7 +155,10 @@ export async function reviewExternal(
 ): Promise<string> {
   clearStaleRunning();
   const held = holdingEscalations(ext.id);
-  if (held.length)
+  if (
+    held.length &&
+    !(ext.pr.head && reviewWanted(workspaceId, ext.id, ext.pr.head))
+  )
     return `${ext.name} is with Saad (${held.map((h) => h.gate).join(", ")}); no review needed from you.`;
   if (!ext.pr.head) throw new Error(`${ext.name}'s head commit is unknown`);
   return reviewAt(

package/lib/orchestrator/gates.ts

@@ -65,7 +65,18 @@ export interface GateInput {
 
 const short = (sha: string) => sha.slice(0, 7);
 
-function ciGate(i: GateInput): GateOutcome {
+export function ciGate(
+  i: Pick<
+    GateInput,
+    | "sha"
+    | "checks"
+    | "failing"
+    | "settleIn"
+    | "mergeable"
+    | "baseName"
+    | "repoCI"
+  >
+): GateOutcome {
   const gate = "ci";
   const at = short(i.sha);
   if (i.checks === "pending")
@@ -88,7 +99,7 @@ function ciGate(i: GateInput): GateOutcome {
 
 // A head with no checks. Only a repository with no CI at all has nothing to
 // gate on; in one with CI the head is not yet, whatever the reason.
-function noChecks(i: GateInput, at: string): GateOutcome {
+function noChecks(i: Parameters<typeof ciGate>[0], at: string): GateOutcome {
   const gate = "ci";
   const wait = (reason: string): GateOutcome => ({
     gate,

package/lib/orchestrator/held-review.ts

@@ -0,0 +1,18 @@
+// A held task is with Saad, so `review` normally has nothing to do. Except
+// when the orchestrator has asked him to merge a commit: sign_off needs a
+// finished review of exactly that commit before an approval of it merges,
+// and a held task would otherwise never get one.
+
+import { latestApproval } from "./ask-approvals";
+import { openBySubject, workSubject } from "./asks";
+
+export function reviewWanted(
+  workspaceId: string,
+  id: string,
+  head: string
+): boolean {
+  const subject = workSubject(id);
+  if (latestApproval(workspaceId, subject)?.sha === head) return true;
+  const open = openBySubject(workspaceId, subject);
+  return open?.raised_by === "orchestrator" && open.sha === head;
+}

package/lib/orchestrator/held.ts

@@ -1,5 +1,5 @@
 // A task that's with Saad merges only on his approval of its exact head
-// commit, once. A new commit since he approved goes back to him.
+// commit, once (signoff.ts). A new commit since he approved goes back to him.
 
 import { AskRefused, raiseAsk, workSubject } from "./asks";
 import { latestApproval } from "./ask-approvals";
@@ -17,10 +17,8 @@ export function heldVerdict(
   pr: number,
   moved?: string
 ): Verdict {
-  // One the orchestrator raised was judged before this (signoff.ts).
+  // An approval of this head was judged before this (signoff.ts).
   const approval = latestApproval(workspaceId, workSubject(task.id));
-  if (approval?.sha === sha)
-    return { ok: true, sha, pr, approval: approval.id };
   if (approval) {
     const why = `Saad approved ${approval.sha ? short(approval.sha) : "an earlier commit"}, but PR #${pr}'s head is now ${short(sha)}${moved ? ` and ${moved}` : ""}`;
     try {

package/lib/orchestrator/review.ts

@@ -24,6 +24,7 @@ import { changedFiles, fullDiff } from "./diff";
 import { diffParts } from "./diff-parts";
 import { countFailure, escalate } from "./escalate";
 import { checkGate, holdingEscalations } from "./gates";
+import { reviewWanted } from "./held-review";
 import { mergeApprovalsOn } from "./merge-approvals";
 import {
   baseReviewSkill,
@@ -210,6 +211,8 @@ function countVerdicts(
   target: ReviewTarget,
   sha: string
 ): string {
+  // Held already: the verdict is only stored, for sign_off to read.
+  if (holdingEscalations(target.id).length) return "";
   const escalated: string[] = [];
   for (const gate of ["review", "scope"] as const) {
     if (gate === "scope" && !target.task?.lh_card_id) continue;
@@ -308,11 +311,12 @@ export async function review(
   if (task.task_status !== "running")
     throw new Error(`${task.name} is already ${task.task_status}`);
   const held = holdingEscalations(task.id);
-  if (held.length)
+  const pr = held.length ? await prFor(task, true) : null;
+  if (held.length && !(pr?.head && reviewWanted(workspaceId, task.id, pr.head)))
     return `${task.name} is with Saad (${held.map((h) => h.gate).join(", ")}); no review needed from you.`;
-  const pr = await prFor(task, true);
-  if (!pr?.head) throw new Error(`${task.name} has no PR to review yet`);
-  return reviewAt(workspaceId, taskReviewTarget(task, pr), pr.head, opts);
+  const there = pr ?? (await prFor(task, true));
+  if (!there?.head) throw new Error(`${task.name} has no PR to review yet`);
+  return reviewAt(workspaceId, taskReviewTarget(task, there), there.head, opts);
 }
 
 export function taskReviewTarget(task: Session, pr: TaskPR): ReviewTarget {

package/lib/orchestrator/signoff.ts

@@ -25,7 +25,12 @@ import {
   sensitiveFiles,
 } from "./diff";
 import { countFailure, escalate } from "./escalate";
-import { evaluateGates, holdingEscalations, type GateInput } from "./gates";
+import {
+  ciGate,
+  evaluateGates,
+  holdingEscalations,
+  type GateInput,
+} from "./gates";
 import { addNote } from "./notes";
 import { latestApproval, refundApproval, spendApproval } from "./ask-approvals";
 import { workSubject } from "./asks";
@@ -96,7 +101,11 @@ export async function judge(
         restackedOf(task)?.to === sha
       )
     : null;
-  if (quick?.wait)
+  // Saad's approval of this head stands in for that review (gateVerdict).
+  if (
+    quick?.wait &&
+    latestApproval(workspaceId, workSubject(task.id))?.sha !== sha
+  )
     return {
       ok: false,
       wait: true,
@@ -164,13 +173,12 @@ export async function gateVerdict(
   });
   const { pr, sha, repo } = work;
   const held = holdingEscalations(work.id);
-  // Saad approved merging this exact commit. On an ask the orchestrator
-  // raised (ask_saad with its task and sha), held or not, it merges once
-  // whatever the gates say, but only once an independent review of that
-  // commit finished (its findings are his to override, not that it ran) and
-  // its stack parent merged: the orchestrator wrote that ask, and no answer
-  // to it stands in for those. An approval of the gates' own ask on a held
-  // task merges as it always has (heldVerdict).
+  // Saad approved merging this exact commit: held or not, it merges once,
+  // without a review or any other gate approval stands in for. Approval
+  // doesn't cover what's left: an AI-attributed body, failing CI (running
+  // CI is a wait), and, on an ask the orchestrator raised or a task the
+  // gates don't hold, a stack parent not merged yet. On a held task, an
+  // approval of an earlier commit goes back to him (heldVerdict).
   let approval = latestApproval(workspaceId, workSubject(work.id));
   // The head moved since he approved: his approval follows it when the PR's
   // own patch is unchanged (a rebase), else the re-ask says what changed.
@@ -185,19 +193,19 @@ export async function gateVerdict(
     if (carried.approval) approval = carried.approval;
     else moved = carried.note;
   }
-  if (
-    approval?.sha === sha &&
-    (approval.raised_by === "orchestrator" || !held.length)
-  ) {
+  if (approval?.sha === sha) {
     const i = await inputs();
-    const refusal =
-      i.codeReview.refusal ??
-      (i.codeReview.ran ? null : i.codeReview.wait) ??
-      i.stackRefusal;
-    if (refusal)
-      return no(
-        `${work.name} (PR #${pr.number} at ${short(sha)}): Saad approved this commit, but ${refusal}`
-      );
+    const approved = `${work.name} (PR #${pr.number} at ${short(sha)}): Saad approved this commit, but`;
+    const stack =
+      approval.raised_by === "orchestrator" || !held.length
+        ? i.stackRefusal
+        : null;
+    const refusal = i.codeReview.refusal ?? stack;
+    if (refusal) return no(`${approved} ${refusal}`);
+    const ci = ciGate({ sha, ...i, repoCI: await repoCIFor(repo, work, i) });
+    if (ci.state === "fail") return no(`${approved} ${ci.reason}`);
+    if (ci.state === "wait") return no(`${approved} ${ci.reason}`, true);
+    // "escalate" is a repository with no CI: Saad is who that goes to.
     return { ok: true, sha, pr: pr.number, approval: approval.id };
   }
   if (held.length)
@@ -223,14 +231,7 @@ export async function gateVerdict(
 
   const ruled = ruleBreaks(files, await addedLines(repo, base, sha));
   const live = await inputs();
-  // Asked only when it can change the answer: a head with no checks that
-  // isn't settling or conflicting.
-  const repoCI =
-    live.checks === "none" &&
-    live.settleIn === 0 &&
-    live.mergeable !== "CONFLICTING"
-      ? await repoHasCI(repo, base)
-      : undefined;
+  const repoCI = await repoCIFor(repo, base, live);
   const outcomes = evaluateGates({ sha, ruleBreaks: ruled, ...live, repoCI });
   const head = `${work.name} (PR #${pr.number} at ${short(sha)}) can't merge:`;
   const toSaad = outcomes.find((o) => o.state === "escalate");
@@ -253,6 +254,25 @@ export async function gateVerdict(
   return no(`${head}\n${lines.join("\n")}`, !failed.length);
 }
 
+// Asked only when it can change the answer: a head with no checks that
+// isn't settling or conflicting.
+async function repoCIFor(
+  repo: string,
+  base: string | GateWork,
+  i: Pick<GateInput, "checks" | "settleIn" | "mergeable">
+) {
+  if (i.checks !== "none" || i.settleIn !== 0 || i.mergeable === "CONFLICTING")
+    return undefined;
+  if (typeof base !== "string") {
+    try {
+      base = await fetchRefs(repo, base.refs);
+    } catch {
+      return undefined;
+    }
+  }
+  return repoHasCI(repo, base);
+}
+
 export async function signOff(
   workspaceId: string,
   ref: string

package/lib/orchestrator/tools.ts

@@ -116,7 +116,7 @@ const DESCRIPTIONS: Record<ToolName, string> = {
   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.",
+    "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, without a review (an AI-attributed body or failing CI still refuses).",
 };
 
 export function orchestratorTools(

package/lib/providers/registry.ts

@@ -16,6 +16,8 @@ export const PROVIDER_IDS = [
   "pi",
   "omp",
   "copilot",
+  "kiro",
+  "amazonq",
   "shell",
 ] as const;
 
@@ -53,6 +55,17 @@ export interface ProviderDefinition {
 
   // Default arguments
   defaultArgs?: string[]; // Always passed to CLI
+
+  // A subcommand that comes before every other argument (`kiro-cli chat`).
+  subcommand?: string[];
+
+  // How to sign in from a terminal: `check` exits 0 when signed in, `login`
+  // prints a link and a code to finish on another device. A session runs
+  // them first, so it never waits on a prompt nobody can see.
+  signIn?: { check: string[]; login: string[] };
+
+  // A superseded CLI, offered only where it is installed.
+  legacy?: boolean;
 }
 
 // The model value that means "whatever the agent itself defaults to".
@@ -63,6 +76,34 @@ export const AGENT_DEFAULT_MODEL = "default";
 export const isAgentModelName = (v: unknown): v is string =>
   typeof v === "string" && /^[A-Za-z0-9][A-Za-z0-9._:/@+-]{0,99}$/.test(v);
 
+const KIRO: ProviderDefinition = {
+  id: "kiro",
+  name: "Kiro CLI",
+  description: "AWS's Kiro CLI (formerly Amazon Q Developer CLI)",
+  cli: "kiro-cli",
+  configDir: "~/.kiro",
+  subcommand: ["chat"],
+  autoApproveFlag: "--trust-all-tools",
+  // `--resume-id` exists, but where Kiro keeps its sessions isn't something
+  // we read yet (lib/providers/resume-ids.ts), so no id ever reaches it.
+  supportsResume: false,
+  supportsFork: false,
+  modelFlag: "--model",
+  initialPromptFlag: "", // Positional argument
+  signIn: { check: ["whoami"], login: ["login", "--use-device-flow"] },
+};
+
+// The same CLI under its old name, with fewer flags.
+const AMAZON_Q: ProviderDefinition = {
+  ...KIRO,
+  id: "amazonq",
+  name: "Amazon Q CLI (legacy)",
+  description: "Amazon Q Developer CLI, replaced by Kiro CLI",
+  cli: "q",
+  configDir: "~/.aws/amazonq",
+  legacy: true,
+};
+
 /**
  * Provider Registry
  * All supported agent providers with their configurations
@@ -211,6 +252,8 @@ export const PROVIDERS: ProviderDefinition[] = [
     modelFlag: "--model",
     initialPromptFlag: "-i",
   },
+  KIRO,
+  AMAZON_Q,
   {
     id: "shell",
     name: "Terminal",

package/lib/providers.ts

@@ -6,6 +6,7 @@
  * into a command line.
  */
 
+import { SIGN_IN_END, SIGN_IN_START } from "./agents/signin-screen";
 import {
   AGENT_DEFAULT_MODEL,
   type ProviderDefinition,
@@ -25,6 +26,8 @@ export interface AgentProvider {
   supportsResume: boolean;
   supportsFork: boolean;
   configDir: string;
+  // Shell that signs in first when the CLI isn't, or "".
+  preamble: string;
   // The CLI's arguments, each already quoted for the shell.
   buildFlags(options: BuildFlagsOptions): string[];
 }
@@ -44,7 +47,7 @@ export function buildArgs(
   def: ProviderDefinition,
   options: BuildFlagsOptions
 ): string[] {
-  const args: string[] = [];
+  const args: string[] = [...(def.subcommand ?? [])];
   if (options.sessionId && def.resumeArgs) {
     args.push(...def.resumeArgs(options.sessionId));
   } else if (options.parentSessionId && def.forkArgs) {
@@ -69,6 +72,20 @@ const SAFE_ARG = /^[\w@%+=:,./-]+$/;
 const quoteArg = (arg: string) =>
   SAFE_ARG.test(arg) ? arg : `'${arg.replace(/'/g, `'\\''`)}'`;
 
+// Signs in when the CLI isn't, between two marker lines the screen reader
+// looks for (lib/agents/signin-screen.ts), and stops if that fails, so the
+// pane shows why instead of a CLI that waits.
+function signInPreamble(def: ProviderDefinition): string {
+  if (!def.signIn) return "";
+  const cli = quoteArg(def.cli);
+  const run = (args: string[]) => [cli, ...args.map(quoteArg)].join(" ");
+  return (
+    `{ ${run(def.signIn.check)} >/dev/null 2>&1 || ` +
+    `{ echo '${SIGN_IN_START}'; ${run(def.signIn.login)}; s=$?; ` +
+    `echo '${SIGN_IN_END}'; [ $s -eq 0 ]; }; } && `
+  );
+}
+
 function toProvider(def: ProviderDefinition): AgentProvider {
   return {
     id: def.id,
@@ -78,6 +95,7 @@ function toProvider(def: ProviderDefinition): AgentProvider {
     supportsResume: def.supportsResume,
     supportsFork: def.supportsFork,
     configDir: def.configDir,
+    preamble: signInPreamble(def),
     buildFlags: (options) => buildArgs(def, options).map(quoteArg),
   };
 }

package/lib/start-options.ts

@@ -6,6 +6,7 @@
  */
 
 import { AGENT_OPTIONS } from "./agent-options";
+import { getProviderDefinition } from "./providers/registry";
 import { probeAgents } from "./agents/probe";
 import { gitCheck } from "./git";
 import { listHosts } from "./hosts";
@@ -64,7 +65,10 @@ export async function startOptions(
           hostId: project.host_id || "local",
         }
       : null,
-    agents: AGENT_OPTIONS.map((a) => ({
+    agents: AGENT_OPTIONS.filter(
+      (a) =>
+        !getProviderDefinition(a.value)?.legacy || probes?.[a.value]?.installed
+    ).map((a) => ({
       value: a.value,
       label: a.label,
       installed: probes?.[a.value]?.installed ?? null,

package/lib/status/collect.ts

@@ -9,6 +9,7 @@ import {
   findQuestion,
   plainText,
   readInputBox,
+  screenText,
   statusDetector,
   sessionKey,
   type SessionStatus,
@@ -16,9 +17,12 @@ import {
 import type { AgentType } from "../providers";
 import {
   getManagedSessionPattern,
+  getProviderDefinition,
   getProviderIdFromSessionName,
   getSessionIdFromName,
 } from "../providers/registry";
+import { findSignIn } from "../agents/signin-screen";
+import { noteWaiting } from "../notify/push/waiting";
 import { getDb } from "../db";
 import { beginPass, chatMemo } from "./incremental";
 import { chatCompacting, chatState } from "../chat/runner";
@@ -72,6 +76,8 @@ export interface SessionStatusResponse {
   prStage?: PrStage;
   // A program's own message (OSC 7501): untrusted, plain text only.
   detail?: string | null;
+  // The link and code a sign-in is waiting on (lib/agents/signin-screen).
+  signIn?: { url: string | null; code: string | null } | null;
   progress?: number | null;
 }
 
@@ -244,6 +250,9 @@ function getAgentTypeFromSessionName(sessionName: string): AgentType {
   return getProviderIdFromSessionName(sessionName) || "claude";
 }
 
+// Sessions whose sign-in has started the wait for you, until it is over.
+const signingIn = new Set<string>();
+
 async function collect(full = false): Promise<StatusSnapshot> {
   const sessions = await getTmuxSessions();
 
@@ -308,6 +317,10 @@ async function collect(full = false): Promise<StatusSnapshot> {
           hostId,
         });
     const id = pane.id;
+    // A CLI that signs in with a link and a code shows them while it works.
+    const signIn = getProviderDefinition(agentType)?.signIn
+      ? findSignIn(screenText(screen))
+      : null;
 
     return {
       sessionName,
@@ -316,6 +329,7 @@ async function collect(full = false): Promise<StatusSnapshot> {
       status,
       program,
       screenNeed,
+      signIn,
       claudeSessionId,
       lastLine: lastLineOf(screen),
       agentType,
@@ -323,6 +337,13 @@ async function collect(full = false): Promise<StatusSnapshot> {
   });
 
   const results = await Promise.all(sessionPromises);
+  // A session killed mid-login can't clear its own wait.
+  const alive = new Set(results.map((r) => r.id));
+  for (const id of signingIn)
+    if (!alive.has(id)) {
+      signingIn.delete(id);
+      noteWaiting(id, false);
+    }
   heuristicBusy = results.some((r) => r.status === "running");
 
   for (const {
@@ -332,6 +353,7 @@ async function collect(full = false): Promise<StatusSnapshot> {
     status,
     program,
     screenNeed,
+    signIn,
     claudeSessionId,
     lastLine,
     agentType,
@@ -344,6 +366,20 @@ async function collect(full = false): Promise<StatusSnapshot> {
       agentType,
       title: statusDetector.titleFor(sessionName, hostId),
     };
+    // Waiting on a sign-in is waiting on you, buzzed after the usual minute.
+    if (signIn) {
+      if (!signingIn.has(id)) noteWaiting(id, true);
+      signingIn.add(id);
+      statusMap[id] = {
+        ...shared,
+        status: "waiting",
+        need: "signin",
+        unread: false,
+        signIn: { url: signIn.url, code: signIn.code },
+      };
+      continue;
+    }
+    if (signingIn.delete(id)) noteWaiting(id, false);
     // A question on screen, or a message typed and never sent: it needs you
     // whether or not you've seen it, like a blocked program.
     const needKey = screenNeed ? `${screenNeed.need}:${screenNeed.detail}` : "";

package/package.json

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

package/scripts/setup.sh

@@ -29,7 +29,7 @@ echo "tmux: $(tmux -V)"
 
 # Check AI coding CLI
 AI_CLI_FOUND=""
-for cli in claude codex opencode kilo gemini aider cursor-agent amp pi omp copilot; do
+for cli in claude codex opencode kilo gemini aider cursor-agent amp pi omp copilot kiro-cli q; do
     if command -v "$cli" &> /dev/null; then
         AI_CLI_FOUND="$AI_CLI_FOUND $cli"
     fi
@@ -37,7 +37,7 @@ done
 
 if [ -z "$AI_CLI_FOUND" ]; then
     echo "Error: no supported AI coding CLI is installed"
-    echo "Install one of: Claude Code, Codex, OpenCode, Kilo Code CLI, Gemini CLI, Aider, Cursor CLI, Amp, Pi, or Oh My Pi"
+    echo "Install one of: Claude Code, Codex, OpenCode, Kilo Code CLI, Gemini CLI, Aider, Cursor CLI, Amp, Pi, Oh My Pi, or Kiro CLI"
     exit 1
 fi
 echo "AI CLI(s):$AI_CLI_FOUND"