@h-rig/cli 0.0.6-alpha.81 → 0.0.6-alpha.83

package/dist/src/app-opentui/adapters/tasks.js

@@ -15,6 +15,89 @@ var __export = (target, all) => {
 };
 var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
 
+// packages/cli/src/app-opentui/adapters/common.ts
+function adapterContextFromRuntime(runtime, renderer) {
+  return {
+    projectRoot: runtime.getState().projectRoot,
+    renderer,
+    ensureRuntime: () => runtime.getRunnerContext(),
+    emit: (event) => runtime.emit(event),
+    getState: () => runtime.getState()
+  };
+}
+function projectRootOf(ctx) {
+  const root = ctx.rig?.projectRoot ?? ctx.projectRoot ?? ctx.getState().projectRoot;
+  if (typeof root === "string" && root.trim())
+    return root;
+  throw new Error("App adapter requires a projectRoot.");
+}
+async function runtimeOf(ctx) {
+  if (ctx.rig && "runId" in ctx.rig && ctx.ensureRuntime === undefined) {
+    return ctx.rig;
+  }
+  if (ctx.ensureRuntime)
+    return ctx.ensureRuntime();
+  throw new Error("App adapter requires ensureRuntime() before this action can run.");
+}
+function normalizeAppError(error) {
+  const message = error instanceof Error ? error.message : String(error);
+  const rawHint = error instanceof Error ? error.hint : undefined;
+  return {
+    message,
+    ...typeof rawHint === "string" && rawHint.trim() ? { hint: rawHint.trim() } : {}
+  };
+}
+function emitStarted(ctx, label, optimistic) {
+  ctx.emit({ type: "action.started", label, ...optimistic ? { optimistic } : {} });
+}
+function emitProgress(ctx, label, detail, data) {
+  ctx.emit({ type: "action.progress", label, ...detail ? { detail } : {}, ...data ? { data } : {} });
+}
+function emitCompleted(ctx, label, data) {
+  ctx.emit({ type: "action.completed", label, ...data ? { data } : {} });
+}
+function emitFailed(ctx, label, error, data) {
+  if (data)
+    patchData(ctx, data);
+  const normalized = normalizeAppError(error);
+  ctx.emit({
+    type: "action.failed",
+    label,
+    message: normalized.message,
+    ...normalized.hint ? { hint: normalized.hint } : {},
+    cause: error
+  });
+}
+function patchData(ctx, data) {
+  ctx.emit({ type: "data.patch", data });
+}
+function patchFooter(ctx, footer) {
+  ctx.emit({ type: "footer.patch", footer });
+}
+function stringField(record, keys, fallback = "") {
+  for (const key of keys) {
+    const value = record[key];
+    if (typeof value === "string" && value.trim())
+      return value.trim();
+    if (typeof value === "number" && Number.isFinite(value))
+      return String(value);
+  }
+  return fallback;
+}
+function compactRecord(record, keys) {
+  const out = {};
+  for (const key of keys) {
+    const value = record[key];
+    if (value !== undefined && value !== null && value !== "")
+      out[key] = value;
+  }
+  return out;
+}
+function payloadString(intent, key) {
+  const value = intent.action.payload?.[key];
+  return typeof value === "string" && value.trim() ? value.trim() : undefined;
+}
+
 // packages/cli/src/runner.ts
 import { EventBus } from "@rig/runtime/control-plane/runtime/events";
 import { CliError as RuntimeCliError } from "@rig/runtime/control-plane/errors";
@@ -237,17 +320,21 @@ function setGitHubBearerTokenForCurrentProcess(token, projectRoot) {
   const scopedKey = resolve2(projectRoot ?? process.cwd());
   scopedGitHubBearerTokens.set(scopedKey, cleanToken(token ?? undefined));
 }
-function readPrivateRemoteSessionToken(projectRoot) {
+function readRemoteAuthState(projectRoot) {
   const path = resolve2(projectRoot, ".rig", "state", "github-auth.json");
   if (!existsSync2(path))
     return null;
   try {
     const parsed = JSON.parse(readFileSync2(path, "utf8"));
-    return cleanToken(typeof parsed.apiSessionToken === "string" ? parsed.apiSessionToken : typeof parsed.sessionToken === "string" ? parsed.sessionToken : undefined);
+    return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : null;
   } catch {
     return null;
   }
 }
+function readPrivateRemoteSessionToken(projectRoot) {
+  const parsed = readRemoteAuthState(projectRoot);
+  return parsed ? cleanToken(typeof parsed.apiSessionToken === "string" ? parsed.apiSessionToken : typeof parsed.sessionToken === "string" ? parsed.sessionToken : undefined) : null;
+}
 function readGitHubBearerTokenForRemote(projectRoot) {
   const scopedKey = resolve2(projectRoot);
   if (scopedGitHubBearerTokens.has(scopedKey))
@@ -258,15 +345,25 @@ function readGitHubBearerTokenForRemote(projectRoot) {
   return cleanToken(process.env.RIG_SERVER_AUTH_TOKEN) ?? cleanToken(process.env.RIG_REMOTE_AUTH_TOKEN);
 }
 function readStoredGitHubAuthToken(projectRoot) {
-  const path = resolve2(projectRoot, ".rig", "state", "github-auth.json");
-  if (!existsSync2(path))
+  const parsed = readRemoteAuthState(projectRoot);
+  return parsed ? cleanToken(typeof parsed.token === "string" ? parsed.token : undefined) : null;
+}
+function inferRemoteServerProjectRootFromAuthState(projectRoot) {
+  const repo = readRepoConnection(projectRoot);
+  const slug = repo?.project?.trim();
+  if (!slug || !/^[^/]+\/[^/]+$/.test(slug))
     return null;
-  try {
-    const parsed = JSON.parse(readFileSync2(path, "utf8"));
-    return cleanToken(typeof parsed.token === "string" ? parsed.token : undefined);
-  } catch {
+  const auth = readRemoteAuthState(projectRoot);
+  const authUpdatedAt = typeof auth?.updatedAt === "string" ? Date.parse(auth.updatedAt) : Number.NaN;
+  const repoLinkedAt = typeof repo?.linkedAt === "string" ? Date.parse(repo.linkedAt) : Number.NaN;
+  if (Number.isFinite(authUpdatedAt) && Number.isFinite(repoLinkedAt) && authUpdatedAt + 1000 < repoLinkedAt)
     return null;
-  }
+  const checkoutBaseDir = typeof auth?.checkoutBaseDir === "string" && auth.checkoutBaseDir.trim() ? auth.checkoutBaseDir.trim() : null;
+  if (!checkoutBaseDir)
+    return null;
+  const inferred = `${checkoutBaseDir.replace(/\/+$/, "")}/${slug}`;
+  writeRepoServerProjectRoot(projectRoot, inferred);
+  return inferred;
 }
 function readLocalConnectionFallbackToken(projectRoot) {
   return readGitHubBearerTokenForRemote(projectRoot) ?? cleanToken(process.env.RIG_GITHUB_TOKEN) ?? readStoredGitHubAuthToken(projectRoot);
@@ -277,7 +374,7 @@ async function ensureServerForCli(projectRoot) {
     if (selected?.connection.kind === "remote") {
       reportServerPhase(`Connecting to ${selected.alias}\u2026`);
       const authToken = readGitHubBearerTokenForRemote(projectRoot);
-      const serverProjectRoot = selected.serverProjectRoot ?? await backfillRemoteServerProjectRoot(projectRoot, selected.connection.baseUrl, authToken);
+      const serverProjectRoot = selected.serverProjectRoot ?? inferRemoteServerProjectRootFromAuthState(projectRoot) ?? await backfillRemoteServerProjectRoot(projectRoot, selected.connection.baseUrl, authToken);
       return {
         baseUrl: selected.connection.baseUrl,
         authToken,
@@ -306,7 +403,10 @@ async function backfillRemoteServerProjectRoot(projectRoot, baseUrl, authToken)
   if (!slug)
     return null;
   try {
-    const response = await fetch(`${baseUrl}/api/projects/${encodeURIComponent(slug)}`, {
+    const url = new URL(`${baseUrl}/api/projects/${encodeURIComponent(slug)}`);
+    if (authToken && queryAuthFallbackEnabled())
+      url.searchParams.set("rt", authToken);
+    const response = await fetch(url, {
       headers: mergeHeaders(undefined, authToken)
     });
     if (!response.ok)
@@ -333,10 +433,23 @@ function appendTaskFilterParams(url, filters) {
   if (filters.limit !== undefined)
     url.searchParams.set("limit", String(filters.limit));
 }
+function mergeCookie(existing, name, value) {
+  const encoded = `${name}=${encodeURIComponent(value)}`;
+  if (!existing?.trim())
+    return encoded;
+  const parts = existing.split(";").map((part) => part.trim()).filter((part) => part && !part.startsWith(`${name}=`));
+  return [...parts, encoded].join("; ");
+}
+function queryAuthFallbackEnabled(env = process.env) {
+  return env.RIG_ENABLE_QUERY_AUTH_FALLBACK === "1" || env.RIG_QUERY_AUTH_FALLBACK === "1";
+}
 function mergeHeaders(headers, authToken) {
   const merged = new Headers(headers);
   if (authToken) {
-    merged.set("authorization", `Bearer ${authToken}`);
+    const bearer = `Bearer ${authToken}`;
+    merged.set("authorization", bearer);
+    merged.set("x-auth", bearer);
+    merged.set("cookie", mergeCookie(merged.get("cookie"), "rig_auth", authToken));
   }
   return merged;
 }
@@ -396,15 +509,34 @@ async function buildServerFailureContext(projectRoot, server) {
     hint: "Check the selected server with `rig server status`, or switch with `rig server use <alias|local>`."
   };
 }
+function isLoopbackRemoteBaseUrl(baseUrl) {
+  try {
+    const host = new URL(baseUrl).hostname.toLowerCase();
+    return host === "localhost" || host === "127.0.0.1" || host === "::1" || host === "[::1]";
+  } catch {
+    return false;
+  }
+}
+function canUseRemoteWithoutProjectRoot(pathname) {
+  return pathname === "/health" || pathname === "/api/health" || pathname === "/api/server/status" || pathname === "/api/server/project-root" || pathname.startsWith("/api/github/auth/") || pathname === "/api/projects" || pathname.startsWith("/api/projects/");
+}
 async function requestServerJson(context, pathname, init = {}) {
   const server = await ensureServerForCli(context.projectRoot);
+  const requestUrl = new URL(`${server.baseUrl}${pathname}`);
+  if (server.connectionKind === "remote" && !server.serverProjectRoot && !canUseRemoteWithoutProjectRoot(requestUrl.pathname) && (server.authToken || !isLoopbackRemoteBaseUrl(server.baseUrl))) {
+    const repo = readRepoConnection(context.projectRoot);
+    throw new CliError(`Remote server is selected for ${repo?.project ?? "this repo"}, but this checkout has no server-host project root link.`, 1, { hint: "Run `rig init --repair` or `rig init --yes --repo owner/repo --server remote` to repair the remote project link before task/run commands." });
+  }
   const headers = mergeHeaders(init.headers, server.authToken);
   if (server.serverProjectRoot)
     headers.set("x-rig-project-root", server.serverProjectRoot);
+  if (server.connectionKind === "remote" && server.authToken && queryAuthFallbackEnabled()) {
+    requestUrl.searchParams.set("rt", server.authToken);
+  }
   reportServerPhase(`${(init.method ?? "GET").toUpperCase()} ${pathname.split("?")[0]}\u2026`);
   let response;
   try {
-    response = await fetch(`${server.baseUrl}${pathname}`, {
+    response = await fetch(requestUrl, {
       ...init,
       headers
     });
@@ -466,11 +598,26 @@ async function getGitHubAuthStatusViaServer(context) {
   return payload && typeof payload === "object" && !Array.isArray(payload) ? payload : {};
 }
 async function postGitHubTokenViaServer(context, token, options = {}) {
-  const payload = await requestServerJson(context, "/api/github/auth/token", {
-    method: "POST",
-    headers: { "content-type": "application/json" },
-    body: JSON.stringify({ token, selectedRepo: options.selectedRepo, projectRoot: options.projectRoot })
-  });
+  const server = await ensureServerForCli(context.projectRoot);
+  const requestUrl = new URL(`${server.baseUrl}/api/github/auth/token`);
+  reportServerPhase("POST /api/github/auth/token\u2026");
+  let response;
+  try {
+    response = await fetch(requestUrl, {
+      method: "POST",
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify({ token, selectedRepo: options.selectedRepo, projectRoot: options.projectRoot ?? server.serverProjectRoot ?? undefined })
+    });
+  } catch (error) {
+    const failure = await buildServerFailureContext(context.projectRoot, server);
+    throw new CliError(`Rig server auth bootstrap failed: ${error instanceof Error ? error.message : String(error)}
+${failure.contextLine}`, 1, { hint: failure.hint });
+  }
+  const payload = await response.json().catch(() => null);
+  if (!response.ok) {
+    const detail = payload && typeof payload === "object" && !Array.isArray(payload) ? String(payload.error ?? JSON.stringify(payload)) : `HTTP ${response.status}`;
+    throw new CliError(`Rig server auth bootstrap failed (${response.status}): ${detail}`, 1, { hint: "Re-run `rig github auth import-gh`, or check the selected server with `rig server status`." });
+  }
   return payload && typeof payload === "object" && !Array.isArray(payload) ? payload : {};
 }
 async function prepareRemoteCheckoutViaServer(context, input) {
@@ -1107,7 +1254,8 @@ async function runFastTaskRunPreflight(context, options = {}) {
     }
   }
   const repo = readRepoConnection(context.projectRoot);
-  checks.push(repo ? preflightCheck("project-link", "project linked to Rig server", repo.project ? "pass" : "warn", `${repo.selected}${repo.project ? ` -> ${repo.project}` : ""}`, "Run `rig init --yes --repo owner/repo` to record the GitHub repo slug.") : preflightCheck("project-link", "project linked to Rig server", legacyServerCompatibility ? "warn" : "fail", "missing .rig/state/connection.json", "Run `rig init` or `rig server use <alias|local>`."));
+  const remoteWithoutProjectLink = selectedServer?.connectionKind === "remote" && !repo?.project;
+  checks.push(repo ? preflightCheck("project-link", "project linked to selected server", repo.project ? "pass" : remoteWithoutProjectLink ? "fail" : "warn", `${repo.selected}${repo.project ? ` -> ${repo.project}` : " (missing project link)"}`, remoteWithoutProjectLink ? "Run `rig init --repair` or `rig init --yes --repo owner/repo --server remote` to restore the remote project link." : "Run `rig init --yes --repo owner/repo` to record the GitHub repo slug.") : preflightCheck("project-link", "project linked to selected server", legacyServerCompatibility ? "warn" : "fail", "missing .rig/state/connection.json", "Run `rig init` or `rig server use <alias|local>`."));
   try {
     const auth = await request("/api/github/auth/status");
     checks.push(isAuthenticated(auth) ? preflightCheck("github-auth", "GitHub auth valid", "pass") : preflightCheck("github-auth", "GitHub auth valid", legacyServerCompatibility ? "warn" : "fail", "not authenticated", "Run `rig github auth import-gh` or `rig github auth token --token <token>`."));
@@ -1682,6 +1830,7 @@ async function attachRunBundledPiFrontend(context, input) {
   let detached = false;
   try {
     await runPiMain([
+      "--offline",
       "--no-extensions",
       "--no-skills",
       "--no-prompt-templates",
@@ -2990,93 +3139,536 @@ var init_task = __esm(() => {
   init__connection_state();
 });
 
-// packages/cli/src/app-opentui/adapters/tasks.ts
-import { randomUUID } from "crypto";
-
-// packages/cli/src/app-opentui/adapters/common.ts
-function adapterContextFromRuntime(runtime, renderer) {
+// packages/cli/src/app-opentui/pi-pty-host.ts
+import { fileURLToPath } from "url";
+import { basename } from "path";
+import { RGBA, StyledText, TextAttributes } from "@opentui/core";
+import { Terminal as XtermTerminal } from "@xterm/headless";
+function clampCols(cols) {
+  return Math.max(MIN_COLS, Math.trunc(cols || 100));
+}
+function clampRows(rows) {
+  return Math.max(MIN_ROWS, Math.min(MAX_ROWS, Math.trunc(rows || 35)));
+}
+function rgbaFromXtermColor(mode, value) {
+  if (mode === 1 || mode === 2 || mode === XTERM_COLOR_MODE_INDEXED_16 || mode === XTERM_COLOR_MODE_INDEXED_256) {
+    return RGBA.fromIndex(value);
+  }
+  if (mode === 3 || mode === XTERM_COLOR_MODE_RGB) {
+    return RGBA.fromInts(value >> 16 & 255, value >> 8 & 255, value & 255);
+  }
+  return;
+}
+function textAttributesFromCell(cell) {
+  let attributes = TextAttributes.NONE;
+  if (cell.isBold())
+    attributes |= TextAttributes.BOLD;
+  if (cell.isDim())
+    attributes |= TextAttributes.DIM;
+  if (cell.isItalic())
+    attributes |= TextAttributes.ITALIC;
+  if (cell.isUnderline())
+    attributes |= TextAttributes.UNDERLINE;
+  if (cell.isBlink())
+    attributes |= TextAttributes.BLINK;
+  if (cell.isInverse())
+    attributes |= TextAttributes.INVERSE;
+  if (cell.isInvisible())
+    attributes |= TextAttributes.HIDDEN;
+  if (cell.isStrikethrough())
+    attributes |= TextAttributes.STRIKETHROUGH;
+  return attributes;
+}
+function sameRgba(a, b) {
+  if (!a && !b)
+    return true;
+  return Boolean(a && b && a.equals(b));
+}
+function sameStyle(a, b) {
+  return sameRgba(a.fg, b.fg) && sameRgba(a.bg, b.bg) && (a.attributes ?? 0) === (b.attributes ?? 0);
+}
+function styleFromCell(cell) {
   return {
-    projectRoot: runtime.getState().projectRoot,
-    renderer,
-    ensureRuntime: () => runtime.getRunnerContext(),
-    emit: (event) => runtime.emit(event),
-    getState: () => runtime.getState()
+    fg: rgbaFromXtermColor(cell.getFgColorMode(), cell.getFgColor()),
+    bg: rgbaFromXtermColor(cell.getBgColorMode(), cell.getBgColor()),
+    attributes: textAttributesFromCell(cell)
   };
 }
-function projectRootOf(ctx) {
-  const root = ctx.rig?.projectRoot ?? ctx.projectRoot ?? ctx.getState().projectRoot;
-  if (typeof root === "string" && root.trim())
-    return root;
-  throw new Error("Rig app adapter requires a projectRoot.");
-}
-async function runtimeOf(ctx) {
-  if (ctx.rig && "runId" in ctx.rig && ctx.ensureRuntime === undefined) {
-    return ctx.rig;
+function lineToStyledText(line, cols) {
+  if (!line)
+    return new StyledText([{ __isChunk: true, text: "" }]);
+  const chunks = [];
+  let run = "";
+  let runStyle = null;
+  const flush = () => {
+    if (!run)
+      return;
+    chunks.push({
+      __isChunk: true,
+      text: run,
+      ...runStyle?.fg ? { fg: runStyle.fg } : {},
+      ...runStyle?.bg ? { bg: runStyle.bg } : {},
+      ...(runStyle?.attributes ?? 0) !== 0 ? { attributes: runStyle.attributes } : {}
+    });
+    run = "";
+  };
+  for (let index = 0;index < cols; index += 1) {
+    const cell = line.getCell(index);
+    if (!cell) {
+      if (runStyle !== null)
+        flush();
+      runStyle = null;
+      run += " ";
+      continue;
+    }
+    if (cell.getWidth() === 0)
+      continue;
+    const style = styleFromCell(cell);
+    if (!runStyle || !sameStyle(runStyle, style)) {
+      flush();
+      runStyle = style;
+    }
+    run += cell.getChars() || " ";
   }
-  if (ctx.ensureRuntime)
-    return ctx.ensureRuntime();
-  throw new Error("Rig app adapter requires ensureRuntime() before this action can run.");
+  flush();
+  return new StyledText(chunks.length > 0 ? chunks : [{ __isChunk: true, text: "" }]);
+}
+function childCommandPrefix() {
+  const execName = basename(process.execPath).toLowerCase();
+  const currentEntry = process.argv[1];
+  if (execName === "bun" || execName === "bun.exe") {
+    return currentEntry ? [process.execPath, currentEntry, "__opentui-pi-host"] : [process.execPath, fallbackChildScriptPath];
+  }
+  return [process.execPath, "__opentui-pi-host"];
 }
-function normalizeAppError(error) {
-  const message = error instanceof Error ? error.message : String(error);
-  const rawHint = error instanceof Error ? error.hint : undefined;
+function withEnv(base) {
+  const env = {};
+  for (const [key, value] of Object.entries(base ?? process.env)) {
+    if (key === "RIG_PLAIN" || key === "RIG_CLI_PLAIN_HELP" || key === "NO_COLOR")
+      continue;
+    if (typeof value === "string")
+      env[key] = value;
+  }
   return {
-    message,
-    ...typeof rawHint === "string" && rawHint.trim() ? { hint: rawHint.trim() } : {}
+    ...env,
+    TERM: "xterm-256color",
+    COLORTERM: "truecolor",
+    FORCE_COLOR: env.FORCE_COLOR ?? "1",
+    RIG_OPENTUI_PI_HOST: "1"
   };
 }
-function emitStarted(ctx, label, optimistic) {
-  ctx.emit({ type: "action.started", label, ...optimistic ? { optimistic } : {} });
-}
-function emitProgress(ctx, label, detail, data) {
-  ctx.emit({ type: "action.progress", label, ...detail ? { detail } : {}, ...data ? { data } : {} });
+async function startPiPtyHost(options) {
+  activeHost?.dispose("replace");
+  const host = new PiPtyHost(options);
+  activeHost = host;
+  await host.start();
+  return host;
 }
-function emitCompleted(ctx, label, data) {
-  ctx.emit({ type: "action.completed", label, ...data ? { data } : {} });
+
+class PiPtyHost {
+  runId;
+  projectRoot;
+  onSnapshot;
+  onExit;
+  onError;
+  terminal;
+  disposables = [];
+  decoder = new TextDecoder("utf-8");
+  proc = null;
+  pty = null;
+  status = "starting";
+  cols;
+  rows;
+  message = "starting bundled Pi";
+  exitCode;
+  signal;
+  notifyTimer = null;
+  _disposed = false;
+  constructor(options) {
+    this.runId = options.runId;
+    this.projectRoot = options.projectRoot;
+    this.cols = clampCols(options.cols);
+    this.rows = clampRows(options.rows);
+    this.onSnapshot = options.onSnapshot;
+    this.onExit = options.onExit;
+    this.onError = options.onError;
+    this.terminal = new XtermTerminal({
+      allowProposedApi: true,
+      cols: this.cols,
+      rows: this.rows,
+      scrollback: 1000
+    });
+    this.registerTerminalResponders();
+  }
+  get disposed() {
+    return this._disposed;
+  }
+  get snapshot() {
+    return this.createSnapshot();
+  }
+  async start() {
+    if (this._disposed)
+      throw new Error("Pi PTY host is disposed.");
+    if (typeof Bun.Terminal !== "function") {
+      throw new Error("Bun native PTY is unavailable in this runtime. Pi host requires Bun.Terminal.");
+    }
+    const spawnOptions = {
+      cwd: this.projectRoot,
+      env: withEnv(process.env),
+      terminal: {
+        cols: this.cols,
+        rows: this.rows,
+        name: "xterm-256color",
+        data: (_terminal, data) => this.handlePtyData(data)
+      }
+    };
+    const proc = Bun.spawn([
+      ...childCommandPrefix(),
+      "--run-id",
+      this.runId,
+      "--project-root",
+      this.projectRoot
+    ], spawnOptions);
+    if (!proc.terminal)
+      throw new Error("Bun did not attach a terminal to the bundled Pi child process.");
+    this.proc = proc;
+    this.pty = proc.terminal;
+    this.status = "running";
+    this.message = "bundled Pi running inside this app";
+    this.emitSnapshotSoon(0);
+    proc.exited.then((exitCode) => {
+      if (this._disposed)
+        return;
+      this.status = exitCode === 0 ? "exited" : "failed";
+      this.exitCode = exitCode;
+      this.signal = null;
+      this.message = exitCode === 0 ? "bundled Pi exited" : `bundled Pi exited with code ${exitCode}`;
+      const snapshot = this.createSnapshot();
+      this.onSnapshot?.(snapshot);
+      this.onExit?.(snapshot);
+      if (activeHost === this)
+        activeHost = null;
+      this.dispose("exit", { kill: false, notify: false });
+    }).catch((error) => {
+      if (this._disposed)
+        return;
+      this.status = "failed";
+      this.message = error instanceof Error ? error.message : String(error);
+      const snapshot = this.createSnapshot();
+      this.onSnapshot?.(snapshot);
+      this.onError?.(error, snapshot);
+      if (activeHost === this)
+        activeHost = null;
+      this.dispose("error", { kill: false, notify: false });
+    });
+  }
+  write(data) {
+    if (this._disposed || !this.pty)
+      return;
+    try {
+      this.pty.write(data);
+    } catch (error) {
+      this.status = "failed";
+      this.message = error instanceof Error ? error.message : String(error);
+      const snapshot = this.createSnapshot();
+      this.onSnapshot?.(snapshot);
+      this.onError?.(error, snapshot);
+    }
+  }
+  resize(cols, rows) {
+    const nextCols = clampCols(cols);
+    const nextRows = clampRows(rows);
+    if (nextCols === this.cols && nextRows === this.rows)
+      return;
+    this.cols = nextCols;
+    this.rows = nextRows;
+    this.terminal.resize(nextCols, nextRows);
+    try {
+      this.pty?.resize(nextCols, nextRows);
+    } catch {}
+    this.emitSnapshotSoon(0);
+  }
+  detach() {
+    this.dispose("detach");
+    return this.createSnapshot("detached from bundled Pi");
+  }
+  dispose(reason = "dispose", options = {}) {
+    if (this._disposed)
+      return;
+    this._disposed = true;
+    if (this.notifyTimer)
+      clearTimeout(this.notifyTimer);
+    this.notifyTimer = null;
+    for (const disposable of this.disposables.splice(0)) {
+      try {
+        disposable.dispose();
+      } catch {}
+    }
+    if (options.kill !== false) {
+      try {
+        this.proc?.kill("SIGTERM");
+      } catch {}
+    }
+    try {
+      this.pty?.close();
+    } catch {}
+    try {
+      this.terminal.dispose();
+    } catch {}
+    if (activeHost === this)
+      activeHost = null;
+    if (options.notify) {
+      this.message = reason;
+      this.onSnapshot?.(this.createSnapshot(reason));
+    }
+  }
+  handlePtyData(data) {
+    if (this._disposed)
+      return;
+    const text = this.decoder.decode(data, { stream: true });
+    this.respondToRawTerminalQueries(text);
+    this.terminal.write(data, () => this.emitSnapshotSoon());
+  }
+  emitSnapshotSoon(delayMs = SNAPSHOT_DELAY_MS) {
+    if (this._disposed || this.notifyTimer)
+      return;
+    this.notifyTimer = setTimeout(() => {
+      this.notifyTimer = null;
+      if (this._disposed)
+        return;
+      this.onSnapshot?.(this.createSnapshot());
+    }, delayMs);
+  }
+  createSnapshot(message2 = this.message) {
+    const buffer = this.terminal.buffer.active;
+    const end = buffer.length;
+    const start = Math.max(0, end - MAX_SNAPSHOT_LINES);
+    const styledStart = Math.max(start, end - this.rows - STYLED_SNAPSHOT_MARGIN);
+    const lines = [];
+    const styledLines = [];
+    for (let row = start;row < end; row += 1) {
+      const line = buffer.getLine(row);
+      lines.push((line?.translateToString(false) ?? "").slice(0, this.cols));
+      if (row >= styledStart)
+        styledLines[lines.length - 1] = lineToStyledText(line, this.cols);
+    }
+    while (lines.length < this.rows) {
+      lines.push("");
+      styledLines[lines.length - 1] = new StyledText([{ __isChunk: true, text: "" }]);
+    }
+    return {
+      runId: this.runId,
+      status: this.status,
+      cols: this.cols,
+      rows: this.rows,
+      lines,
+      styledLines,
+      message: message2,
+      ...this.exitCode !== undefined ? { exitCode: this.exitCode } : {},
+      ...this.signal !== undefined ? { signal: this.signal } : {}
+    };
+  }
+  registerTerminalResponders() {
+    this.disposables.push(this.terminal.parser.registerCsiHandler({ final: "c" }, (params) => {
+      if (params.length === 0 || params[0] === 0)
+        this.write("\x1B[?62;22c");
+      return false;
+    }));
+    this.disposables.push(this.terminal.parser.registerCsiHandler({ prefix: ">", final: "c" }, (params) => {
+      if (params.length === 0 || params[0] === 0)
+        this.write("\x1B[>0;0;0c");
+      return false;
+    }));
+    this.disposables.push(this.terminal.parser.registerCsiHandler({ final: "n" }, (params) => {
+      if (params[0] === 5) {
+        this.write("\x1B[0n");
+      } else if (params[0] === 6) {
+        const row = this.terminal.buffer.active.cursorY + 1;
+        const col = this.terminal.buffer.active.cursorX + 1;
+        this.write(`\x1B[${row};${col}R`);
+      }
+      return false;
+    }));
+  }
+  respondToRawTerminalQueries(text) {
+    if (!text)
+      return;
+    const decrqm = /\x1b\[\?(\d+)\$p/g;
+    let match;
+    while ((match = decrqm.exec(text)) !== null) {
+      this.write(`\x1B[?${match[1]};2$y`);
+    }
+  }
 }
-function emitFailed(ctx, label, error, data) {
-  if (data)
-    patchData(ctx, data);
-  const normalized = normalizeAppError(error);
-  ctx.emit({
-    type: "action.failed",
-    label,
-    message: normalized.message,
-    ...normalized.hint ? { hint: normalized.hint } : {},
-    cause: error
-  });
+var MIN_COLS = 40, MIN_ROWS = 12, MAX_ROWS = 300, MAX_SNAPSHOT_LINES = 360, STYLED_SNAPSHOT_MARGIN = 6, SNAPSHOT_DELAY_MS = 120, fallbackChildScriptPath, activeHost = null, XTERM_COLOR_MODE_INDEXED_16 = 16777216, XTERM_COLOR_MODE_INDEXED_256 = 33554432, XTERM_COLOR_MODE_RGB = 50331648;
+var init_pi_pty_host = __esm(() => {
+  fallbackChildScriptPath = fileURLToPath(new URL("./pi-host-child.ts", import.meta.url));
+});
+
+// packages/cli/src/app-opentui/adapters/fleet.ts
+function normalizeRunRecord(record) {
+  const runId = stringField(record, ["runId", "id"]);
+  if (!runId)
+    return null;
+  const title = stringField(record, ["title", "taskTitle", "taskId"], "untitled run");
+  const taskId3 = stringField(record, ["taskId"]);
+  const updatedAt = stringField(record, ["updatedAt", "createdAt"]);
+  return {
+    runId,
+    status: stringField(record, ["status", "state"], "unknown"),
+    title,
+    raw: record,
+    ...taskId3 ? { taskId: taskId3 } : {},
+    ...updatedAt ? { updatedAt } : {}
+  };
 }
-function patchData(ctx, data) {
-  ctx.emit({ type: "data.patch", data });
+async function refreshFleet(ctx, options = {}) {
+  const label = "Refreshing fleet";
+  emitStarted(ctx, label);
+  try {
+    const { listRunsViaServer: listRunsViaServer2, resolveServerConnectionLabel: resolveServerConnectionLabel2 } = await Promise.resolve().then(() => (init__server_client(), exports__server_client));
+    const projectRoot = projectRootOf(ctx);
+    emitProgress(ctx, label, "contacting selected server");
+    const [runs, serverLabel] = await Promise.all([
+      listRunsViaServer2({ projectRoot }, { limit: options.limit ?? 50 }),
+      resolveServerConnectionLabel2(projectRoot)
+    ]);
+    const normalized = runs.flatMap((run) => {
+      const entry = normalizeRunRecord(run);
+      return entry ? [entry] : [];
+    });
+    patchData(ctx, { fleet: { runs: normalized, refreshedAt: new Date().toISOString() } });
+    patchFooter(ctx, { server: serverLabel, runs: String(normalized.length) });
+    emitCompleted(ctx, label, { count: normalized.length });
+    return normalized;
+  } catch (error) {
+    emitFailed(ctx, label, error);
+    throw error;
+  }
 }
-function patchFooter(ctx, footer) {
-  ctx.emit({ type: "footer.patch", footer });
+var init_fleet = () => {};
+
+// packages/cli/src/app-opentui/adapters/pi-attach.ts
+var exports_pi_attach = {};
+__export(exports_pi_attach, {
+  preparePiAttachHandoff: () => preparePiAttachHandoff,
+  createPiAttachAdapter: () => createPiAttachAdapter,
+  attachRunWithBundledPi: () => attachRunWithBundledPi
+});
+function createPiAttachAdapter(renderer) {
+  return {
+    id: "pi-attach",
+    async handleIntent(runtime, intent) {
+      if (intent.scene !== "handoff" && intent.action.kind !== "run-attach")
+        return false;
+      const ctx = adapterContextFromRuntime(runtime, renderer);
+      const runId = payloadString(intent, "runId") ?? runtime.getState().data.selectedRunId;
+      if (intent.action.kind === "run-attach" && runId) {
+        await attachRunWithBundledPi(ctx, runId);
+        return true;
+      }
+      if (runId) {
+        await preparePiAttachHandoff(ctx, runId);
+        return true;
+      }
+      return false;
+    }
+  };
 }
-function stringField(record, keys, fallback = "") {
-  for (const key of keys) {
-    const value = record[key];
-    if (typeof value === "string" && value.trim())
-      return value.trim();
-    if (typeof value === "number" && Number.isFinite(value))
-      return String(value);
+async function preparePiAttachHandoff(ctx, runId) {
+  const cleanRunId = runId.trim();
+  const label = `Preparing Pi ${cleanRunId.slice(0, 8)}`;
+  emitStarted(ctx, label, { piAttach: { runId: cleanRunId, status: "preparing" } });
+  try {
+    const { getRunDetailsViaServer: getRunDetailsViaServer2, getRunPiStatusViaServer: getRunPiStatusViaServer2, resolveServerConnectionLabel: resolveServerConnectionLabel2 } = await Promise.resolve().then(() => (init__server_client(), exports__server_client));
+    const projectRoot = projectRootOf(ctx);
+    emitProgress(ctx, label, "checking run and Pi session readiness");
+    const [run, piStatus, server] = await Promise.all([
+      getRunDetailsViaServer2({ projectRoot }, cleanRunId).catch((error) => ({ error: error instanceof Error ? error.message : String(error) })),
+      getRunPiStatusViaServer2({ projectRoot }, cleanRunId).catch((error) => ({ error: error instanceof Error ? error.message : String(error) })),
+      resolveServerConnectionLabel2(projectRoot)
+    ]);
+    const state = {
+      runId: cleanRunId,
+      status: "preparing",
+      message: "ready to enter worker Pi",
+      result: { run, piStatus, server },
+      ready: true
+    };
+    patchData(ctx, { piAttach: state });
+    emitCompleted(ctx, label, { runId: cleanRunId, server });
+    return state;
+  } catch (error) {
+    const state = { runId: cleanRunId, status: "failed", message: error instanceof Error ? error.message : String(error) };
+    patchData(ctx, { piAttach: state });
+    emitFailed(ctx, label, error, { runId: cleanRunId });
+    throw error;
   }
-  return fallback;
 }
-function compactRecord(record, keys) {
-  const out = {};
-  for (const key of keys) {
-    const value = record[key];
-    if (value !== undefined && value !== null && value !== "")
-      out[key] = value;
+async function attachRunWithBundledPi(ctx, runId) {
+  const cleanRunId = runId.trim();
+  const label = `Entering Pi ${cleanRunId.slice(0, 8)}`;
+  if (!cleanRunId) {
+    const error = new Error("Attach requires a run id.");
+    emitFailed(ctx, label, error);
+    throw error;
+  }
+  emitStarted(ctx, label, { piAttach: { runId: cleanRunId, status: "entering-pi" } });
+  patchData(ctx, { piAttach: { runId: cleanRunId, status: "entering-pi", message: "starting bundled Pi" } });
+  try {
+    await preparePiAttachHandoff(ctx, cleanRunId).catch(() => null);
+    emitProgress(ctx, label, "starting Bun PTY host for bundled Pi");
+    const projectRoot = projectRootOf(ctx);
+    const cols = typeof process.stdout.columns === "number" ? process.stdout.columns : 100;
+    const rows = Math.max(1, (typeof process.stdout.rows === "number" ? process.stdout.rows : 35) - 1);
+    const patchTerminal = (snapshot) => {
+      patchData(ctx, {
+        piTerminal: snapshot,
+        piAttach: {
+          runId: cleanRunId,
+          status: snapshot.status === "failed" ? "failed" : snapshot.status === "exited" ? "returned" : "entering-pi",
+          message: snapshot.message ?? "bundled Pi running",
+          result: { runId: cleanRunId, status: snapshot.status, exitCode: snapshot.exitCode }
+        }
+      });
+    };
+    await startPiPtyHost({
+      runId: cleanRunId,
+      projectRoot,
+      cols,
+      rows,
+      onSnapshot: patchTerminal,
+      onExit: (snapshot) => {
+        patchTerminal(snapshot);
+        emitCompleted(ctx, label, { runId: cleanRunId, result: { status: snapshot.status, exitCode: snapshot.exitCode } });
+        ctx.emit({ type: "scene.change", scene: "fleet", intent: { scene: "fleet", argv: ["runs"], action: { kind: "refresh", label: "Opening runs" } } });
+        refreshFleet(ctx).catch((error) => emitFailed(ctx, "Refresh runs", error));
+      },
+      onError: (error, snapshot) => {
+        patchTerminal(snapshot);
+        emitFailed(ctx, label, error, { runId: cleanRunId });
+      }
+    });
+    const record = {
+      runId: cleanRunId,
+      status: "running",
+      rendered: "bundled Pi embedded via Bun.Terminal + @xterm/headless"
+    };
+    emitProgress(ctx, label, "bundled Pi is running", { piAttach: { runId: cleanRunId, status: "entering-pi", message: "bundled Pi running", result: record } });
+    return record;
+  } catch (error) {
+    patchData(ctx, { piAttach: { runId: cleanRunId, status: "failed", message: error instanceof Error ? error.message : String(error) } });
+    emitFailed(ctx, label, error, { runId: cleanRunId });
+    throw error;
   }
-  return out;
-}
-function payloadString(intent, key) {
-  const value = intent.action.payload?.[key];
-  return typeof value === "string" && value.trim() ? value.trim() : undefined;
 }
+var init_pi_attach = __esm(() => {
+  init_pi_pty_host();
+  init_fleet();
+});
 
 // packages/cli/src/app-opentui/adapters/tasks.ts
+import { randomUUID } from "crypto";
 function createTasksAdapter() {
   return {
     id: "tasks",
@@ -3084,12 +3676,13 @@ function createTasksAdapter() {
       if (intent.scene !== "tasks" && intent.action.kind !== "task-run-next" && intent.action.kind !== "task-run-id")
         return false;
       const ctx = adapterContextFromRuntime(runtime);
+      const detach = intent.action.payload?.detach === true;
       if (intent.action.kind === "task-run-next") {
-        await submitNextTaskRun(ctx);
+        await submitNextTaskRun(ctx, {}, { detach });
         return true;
       }
       if (intent.action.kind === "task-run-id") {
-        await submitTaskRun(ctx, { taskId: payloadString(intent, "task") });
+        await submitTaskRun(ctx, { taskId: payloadString(intent, "task"), detach });
         return true;
       }
       if (intent.action.kind === "refresh" || intent.action.kind === "navigate") {
@@ -3150,6 +3743,30 @@ function labelsFor(record) {
 function assigneesFor(record) {
   return stringList(rawRecord(record, "assignees"));
 }
+function activeRunForRecord(record) {
+  const value = rawRecord(record, "activeRun");
+  if (!value || typeof value !== "object" || Array.isArray(value))
+    return;
+  const activeRun = value;
+  const runId = optionalString(activeRun, ["runId", "id"]);
+  if (!runId)
+    return;
+  const status = optionalString(activeRun, ["status", "state"]);
+  const stage = optionalString(activeRun, ["stage", "phase"]);
+  return {
+    runId,
+    ...status ? { status } : {},
+    ...stage ? { stage } : {}
+  };
+}
+function activeRunIdFromTaskLike(task) {
+  return activeRunForRecord(task)?.runId;
+}
+function activeRunIdFromTaskRunError(error) {
+  const message2 = error instanceof Error ? error.message : String(error);
+  const match = message2.match(/already has an active (?:Rig )?run:\s*([^\s"'}]+)/i);
+  return match?.[1]?.replace(/[),.;]+$/g, "") ?? null;
+}
 function normalizeTaskRecord(record) {
   const id = stringField(record, ["id", "taskId", "number"]);
   if (!id)
@@ -3157,6 +3774,7 @@ function normalizeTaskRecord(record) {
   const priority = optionalNumber(record, ["priority", "rank", "score"]);
   const updatedAt = optionalString(record, ["updatedAt", "updated_at", "modifiedAt"]);
   const createdAt = optionalString(record, ["createdAt", "created_at"]);
+  const activeRun = activeRunForRecord(record);
   return {
     id,
     status: stringField(record, ["status", "state"], "unknown"),
@@ -3166,6 +3784,7 @@ function normalizeTaskRecord(record) {
     ...createdAt ? { createdAt } : {},
     labels: labelsFor(record),
     assignees: assigneesFor(record),
+    ...activeRun ? { activeRun } : {},
     raw: record
   };
 }
@@ -3393,7 +4012,7 @@ async function submitTaskRun(ctx, input = {}) {
   try {
     const { submitTaskRunViaServer: submitTaskRunViaServer2 } = await Promise.resolve().then(() => (init__server_client(), exports__server_client));
     const defaults = await loadRunDefaults(projectRoot);
-    emitProgress(ctx, label, "submitting run to selected Rig server", { runId, taskId: taskId3 ?? null });
+    emitProgress(ctx, label, "submitting run to selected server", { runId, taskId: taskId3 ?? null });
     const submitted = await submitTaskRunViaServer2({ projectRoot }, {
       runId,
       taskId: taskId3 || undefined,
@@ -3413,14 +4032,41 @@ async function submitTaskRun(ctx, input = {}) {
       latestSubmittedRun: { runId: submitted.runId, taskId: taskId3 ?? null },
       runDetail: { runId: submitted.runId, status: "submitted", title: optimisticTitle, run: submitted, logs: [], timeline: [], timelineCursor: null }
     });
-    patchFooter(ctx, { run: `${submitted.runId.slice(0, 8)} submitted` });
+    patchFooter(ctx, { run: `${submitted.runId.slice(0, 8)} ${input.detach ? "submitted" : "attaching"}` });
+    if (!input.detach) {
+      ctx.emit({
+        type: "scene.change",
+        scene: "handoff",
+        intent: { scene: "handoff", argv: ["attach", submitted.runId], action: { kind: "run-attach", payload: { runId: submitted.runId }, label: `Attach Pi ${submitted.runId.slice(0, 8)}` } }
+      });
+      const { attachRunWithBundledPi: attachRunWithBundledPi2 } = await Promise.resolve().then(() => (init_pi_attach(), exports_pi_attach));
+      await attachRunWithBundledPi2(ctx, submitted.runId);
+    }
     return submitted;
   } catch (error) {
+    const activeRunId = activeRunIdFromTaskRunError(error);
+    if (activeRunId) {
+      emitProgress(ctx, label, `task already has active run ${activeRunId.slice(0, 8)}; attaching Pi`, {
+        selectedRunId: activeRunId,
+        dispatchingRun: null,
+        latestSubmittedRun: { runId: activeRunId, taskId: taskId3 ?? null }
+      });
+      patchData(ctx, { selectedRunId: activeRunId, dispatchingRun: null });
+      patchFooter(ctx, { run: `${activeRunId.slice(0, 8)} active` });
+      ctx.emit({
+        type: "scene.change",
+        scene: "handoff",
+        intent: { scene: "handoff", argv: ["attach", activeRunId], action: { kind: "run-attach", payload: { runId: activeRunId }, label: `Attach Pi ${activeRunId.slice(0, 8)}` } }
+      });
+      const { attachRunWithBundledPi: attachRunWithBundledPi2 } = await Promise.resolve().then(() => (init_pi_attach(), exports_pi_attach));
+      await attachRunWithBundledPi2(ctx, activeRunId);
+      return { runId: activeRunId };
+    }
     emitFailed(ctx, label, error, { runId, taskId: taskId3 ?? null, revert: { dispatchingRun: null } });
     throw error;
   }
 }
-async function submitNextTaskRun(ctx, filters = {}) {
+async function submitNextTaskRun(ctx, filters = {}, options = {}) {
   const label = "Selecting next task";
   emitStarted(ctx, label, { dispatch: { status: "selecting-next" } });
   try {
@@ -3436,7 +4082,7 @@ async function submitNextTaskRun(ctx, filters = {}) {
       throw error;
     }
     emitCompleted(ctx, label, { taskId: task.id, count: selected.count });
-    const submitted = await submitTaskRun(ctx, { taskId: task.id, title: task.title });
+    const submitted = await submitTaskRun(ctx, { taskId: task.id, title: task.title, detach: options.detach });
     return { ...submitted, task };
   } catch (error) {
     emitFailed(ctx, label, error);
@@ -3468,5 +4114,7 @@ export {
   normalizeTaskRecord,
   loadTaskPreview,
   ensureTaskRuntime,
-  createTasksAdapter
+  createTasksAdapter,
+  activeRunIdFromTaskRunError,
+  activeRunIdFromTaskLike
 };