@h-rig/cli 0.0.6-alpha.82 → 0.0.6-alpha.84

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

@@ -0,0 +1,186 @@
+// @bun
+var __require = import.meta.require;
+
+// packages/cli/src/app-opentui/adapters/common.ts
+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.");
+}
+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 });
+}
+async function captureConsole(fn) {
+  const output = [];
+  const original = {
+    log: console.log,
+    info: console.info,
+    warn: console.warn,
+    error: console.error
+  };
+  const capture = (...parts) => {
+    output.push(parts.map((part) => typeof part === "string" ? part : JSON.stringify(part)).join(" "));
+  };
+  console.log = capture;
+  console.info = capture;
+  console.warn = capture;
+  console.error = capture;
+  try {
+    const result = await fn();
+    return { result, output };
+  } finally {
+    console.log = original.log;
+    console.info = original.info;
+    console.warn = original.warn;
+    console.error = original.error;
+  }
+}
+
+// packages/cli/src/app-opentui/adapters/repo.ts
+function repoActionRequest(ctx) {
+  const intent = ctx.getState().intent;
+  const payload = intent?.action?.payload;
+  if (!payload)
+    return { kind: "none" };
+  if (payload.repoReset === true)
+    return { kind: "reset" };
+  const alias = payload.repoSync;
+  if (typeof alias === "string" && alias.trim())
+    return { kind: "sync", alias: alias.trim() };
+  return { kind: "none" };
+}
+function readRepoGitStatus(projectRoot, checkoutRoot, pinnedCommit, runCapture, existsSync, joinPath) {
+  const unavailable = { available: false, clean: false, dirtyCount: 0, head: "", branch: "", ahead: 0, behind: 0 };
+  if (!checkoutRoot || !existsSync(joinPath(checkoutRoot, ".git")))
+    return unavailable;
+  const porcelain = runCapture(["git", "-C", checkoutRoot, "status", "--porcelain"], projectRoot);
+  if (porcelain.exitCode !== 0)
+    return unavailable;
+  const dirtyLines = porcelain.stdout.split(/\r?\n/).filter((row) => row.trim().length > 0);
+  const head = runCapture(["git", "-C", checkoutRoot, "rev-parse", "--short", "HEAD"], projectRoot).stdout.trim();
+  const branchRaw = runCapture(["git", "-C", checkoutRoot, "rev-parse", "--abbrev-ref", "HEAD"], projectRoot).stdout.trim();
+  let ahead = 0;
+  let behind = 0;
+  if (pinnedCommit) {
+    const counts = runCapture(["git", "-C", checkoutRoot, "rev-list", "--left-right", "--count", `${pinnedCommit}...HEAD`], projectRoot);
+    if (counts.exitCode === 0) {
+      const [behindStr = "0", aheadStr = "0"] = counts.stdout.trim().split(/\s+/);
+      behind = Number.parseInt(behindStr, 10) || 0;
+      ahead = Number.parseInt(aheadStr, 10) || 0;
+    }
+  }
+  return {
+    available: true,
+    clean: dirtyLines.length === 0,
+    dirtyCount: dirtyLines.length,
+    head,
+    branch: branchRaw && branchRaw !== "HEAD" ? branchRaw : "(detached)",
+    ahead,
+    behind
+  };
+}
+async function refreshRepo(ctx) {
+  const request = repoActionRequest(ctx);
+  const label = request.kind === "sync" ? `Syncing ${request.alias}` : request.kind === "reset" ? "Resetting repo baseline" : "Loading repo state";
+  emitStarted(ctx, label);
+  try {
+    const projectRoot = projectRootOf(ctx);
+    const [
+      { repoBaseline, resetBaseline },
+      { currentTaskId },
+      { listManagedRepoEntries, resolveManagedRepoIdByAlias },
+      { syncManagedRepo, resolveManagedRepoLayoutByAlias },
+      { runCapture },
+      { existsSync },
+      pathMod
+    ] = await Promise.all([
+      import("@rig/runtime/control-plane/native/repo-ops"),
+      import("@rig/runtime/control-plane/native/task-state"),
+      import("@rig/runtime/control-plane/repos/registry"),
+      import("@rig/runtime/control-plane/repos"),
+      import("@rig/runtime/control-plane/native/utils"),
+      import("fs"),
+      import("path")
+    ]);
+    const joinPath = (...parts) => pathMod.resolve(...parts);
+    if (request.kind === "sync") {
+      const repoId = resolveManagedRepoIdByAlias(request.alias);
+      if (!repoId)
+        throw new Error(`No managed repo registered for alias ${request.alias}.`);
+      emitProgress(ctx, label, `re-syncing ${request.alias} from its remote default branch`);
+      await captureConsole(() => syncManagedRepo(projectRoot, repoId));
+    } else if (request.kind === "reset") {
+      emitProgress(ctx, label, "resetting baseline to origin/main and refreshing pins");
+      await captureConsole(() => resetBaseline(projectRoot, false));
+    }
+    emitProgress(ctx, label, "reading baseline pins and managed repos");
+    const { result } = await captureConsole(() => ({
+      pins: repoBaseline(projectRoot, false),
+      taskId: currentTaskId(projectRoot),
+      managed: listManagedRepoEntries()
+    }));
+    const baselinePins = Object.entries(result.pins).map(([alias, commit]) => ({ alias, commit: String(commit) }));
+    const pinByAlias = new Map(baselinePins.map((pin) => [pin.alias, pin.commit]));
+    const managedRepos = result.managed.map((entry) => {
+      const layout = resolveManagedRepoLayoutByAlias(projectRoot, entry.alias);
+      const git = layout ? readRepoGitStatus(projectRoot, layout.checkoutRoot, pinByAlias.get(entry.alias), runCapture, existsSync, joinPath) : undefined;
+      return {
+        id: entry.id,
+        alias: entry.alias,
+        defaultBranch: entry.defaultBranch,
+        defaultRemoteUrl: entry.defaultRemoteUrl,
+        ...git ? { git } : {}
+      };
+    });
+    const snapshot = {
+      activeTaskId: result.taskId.trim() ? result.taskId.trim() : null,
+      baselinePins,
+      managedRepos,
+      flatLayout: managedRepos.length === 0,
+      refreshedAt: Date.now()
+    };
+    patchData(ctx, { repo: snapshot, lastRefreshError: undefined });
+    patchFooter(ctx, { message: snapshot.flatLayout ? "flat layout \xB7 no managed repos" : `${managedRepos.length} managed repos \xB7 ${baselinePins.length} pins` });
+    emitCompleted(ctx, label, { managed: managedRepos.length, pins: baselinePins.length, task: snapshot.activeTaskId });
+    return snapshot;
+  } catch (error) {
+    emitFailed(ctx, label, error);
+    throw error;
+  }
+}
+export {
+  refreshRepo
+};

package/dist/src/app-opentui/adapters/run-detail.d.ts

@@ -1,6 +1,4 @@
-import type { AppAdapter } from "../types";
 import { type AppAdapterContext } from "./common";
-export declare function createRunDetailAdapter(): AppAdapter;
 export type AppRunSnapshot = {
     readonly runId: string;
     readonly status: string;
@@ -9,10 +7,19 @@ export type AppRunSnapshot = {
     readonly logs: Record<string, unknown>[];
     readonly timeline: Record<string, unknown>[];
     readonly timelineCursor: string | null;
+    /** Server-reported totals (when available) so the scene can show "N of M" and
+     * decide whether a "load more" affordance is warranted (#2). */
+    readonly logsTotal?: number;
+    readonly timelineTotal?: number;
 };
 export declare function loadRunDetail(ctx: AppAdapterContext, runId: string, options?: {
     readonly timelineCursor?: string | null;
 }): Promise<AppRunSnapshot>;
+/** "Load more" for the timeline (#2): fetch the NEXT page using the stored
+ * `timelineCursor` and APPEND it to the existing snapshot, advancing the cursor.
+ * The previously-loaded rows stay; nothing is re-fetched. No cursor ⇒ nothing
+ * more to load (the scene only offers the affordance while a cursor exists). */
+export declare function loadMoreRunTimeline(ctx: AppAdapterContext, runId: string): Promise<AppRunSnapshot | null>;
 export declare function steerRunFromApp(ctx: AppAdapterContext, input: {
     readonly runId: string;
     readonly message: string;

package/dist/src/app-opentui/adapters/run-detail.js

@@ -192,17 +192,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))
@@ -213,15 +217,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);
@@ -232,7 +246,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,
@@ -261,7 +275,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)
@@ -288,10 +305,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;
 }
@@ -351,15 +381,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
     });
@@ -421,11 +470,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) {
@@ -703,20 +767,11 @@ var init__server_client = __esm(() => {
 });
 
 // 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("Rig app adapter requires a projectRoot.");
+  throw new Error("App adapter requires a projectRoot.");
 }
 function normalizeAppError(error) {
   const message = error instanceof Error ? error.message : String(error);
@@ -774,33 +829,17 @@ function stringField(record, keys, fallback = "") {
   }
   return fallback;
 }
-function payloadString(intent, key) {
-  const value = intent.action.payload?.[key];
-  return typeof value === "string" && value.trim() ? value.trim() : undefined;
-}
 
 // packages/cli/src/app-opentui/adapters/run-detail.ts
-function createRunDetailAdapter() {
-  return {
-    id: "run-detail",
-    async handleIntent(runtime, intent) {
-      if (intent.scene !== "run-detail" && intent.action.kind !== "run-steer")
-        return false;
-      const ctx = adapterContextFromRuntime(runtime);
-      const runId = payloadString(intent, "runId") ?? runtime.getState().data.selectedRunId;
-      if (intent.action.kind === "run-steer") {
-        const message = payloadString(intent, "message") ?? intent.raw;
-        if (runId && message)
-          await steerRunFromApp(ctx, { runId, message });
-        return true;
-      }
-      if (runId) {
-        await loadRunDetail(ctx, runId);
-        return true;
-      }
-      return false;
-    }
-  };
+var LOG_PAGE = 100;
+var TIMELINE_PAGE = 200;
+function payloadTotal(payload) {
+  for (const key of ["total", "totalCount", "count"]) {
+    const value = payload[key];
+    if (typeof value === "number" && Number.isFinite(value))
+      return value;
+  }
+  return;
 }
 function unwrapRun(payload) {
   return payload.run && typeof payload.run === "object" && !Array.isArray(payload.run) ? payload.run : payload;
@@ -809,8 +848,24 @@ function nextCursor(payload) {
   const cursor = payload.nextCursor ?? payload.cursor;
   return typeof cursor === "string" && cursor.trim() ? cursor : null;
 }
+function loadMoreRequest(ctx, runId) {
+  const value = ctx.getState().data?.runDetailLoadMore;
+  if (!value || typeof value !== "object" || Array.isArray(value))
+    return null;
+  const record = value;
+  if (record.runId !== runId || typeof record.cursor !== "string" || !record.cursor.trim())
+    return null;
+  return { runId, cursor: record.cursor };
+}
 async function loadRunDetail(ctx, runId, options = {}) {
   const cleanRunId = runId.trim();
+  const more = loadMoreRequest(ctx, cleanRunId);
+  if (more) {
+    patchData(ctx, { runDetailLoadMore: undefined });
+    const appended = await loadMoreRunTimeline(ctx, cleanRunId).catch(() => null);
+    if (appended)
+      return appended;
+  }
   const label = `Loading run ${cleanRunId.slice(0, 8)}`;
   if (!cleanRunId) {
     const error = new Error("Run detail requires a run id.");
@@ -824,10 +879,12 @@ async function loadRunDetail(ctx, runId, options = {}) {
     emitProgress(ctx, label, "loading run, logs, and timeline");
     const [runPayload, logsPayload, timelinePayload] = await Promise.all([
       getRunDetailsViaServer2(context, cleanRunId),
-      getRunLogsViaServer2(context, cleanRunId, { limit: 100 }),
-      getRunTimelineViaServer2(context, cleanRunId, { limit: 200, ...options.timelineCursor ? { cursor: options.timelineCursor } : {} })
+      getRunLogsViaServer2(context, cleanRunId, { limit: LOG_PAGE }),
+      getRunTimelineViaServer2(context, cleanRunId, { limit: TIMELINE_PAGE, ...options.timelineCursor ? { cursor: options.timelineCursor } : {} })
     ]);
     const run = unwrapRun(runPayload);
+    const logsTotal = payloadTotal(logsPayload);
+    const timelineTotal = payloadTotal(timelinePayload);
     const snapshot = {
       runId: cleanRunId,
       status: stringField(run, ["status", "state"], "unknown"),
@@ -835,9 +892,12 @@ async function loadRunDetail(ctx, runId, options = {}) {
       run,
       logs: arrayFromPayload(logsPayload),
       timeline: arrayFromPayload(timelinePayload),
-      timelineCursor: nextCursor(timelinePayload)
+      timelineCursor: nextCursor(timelinePayload),
+      ...logsTotal !== undefined ? { logsTotal } : {},
+      ...timelineTotal !== undefined ? { timelineTotal } : {}
     };
-    patchData(ctx, { selectedRunId: cleanRunId, runDetail: snapshot });
+    const clearSettledSteer = settledSteerForRun(ctx, cleanRunId) ? { pendingRunMessage: undefined } : {};
+    patchData(ctx, { selectedRunId: cleanRunId, runDetail: snapshot, lastRefreshError: undefined, ...clearSettledSteer });
     patchFooter(ctx, { run: `${cleanRunId.slice(0, 8)} ${snapshot.status}` });
     emitCompleted(ctx, label, { runId: cleanRunId, status: snapshot.status, logs: snapshot.logs.length, timeline: snapshot.timeline.length });
     return snapshot;
@@ -846,6 +906,56 @@ async function loadRunDetail(ctx, runId, options = {}) {
     throw error;
   }
 }
+function settledSteerForRun(ctx, runId) {
+  const value = ctx.getState().data?.pendingRunMessage;
+  if (!value || typeof value !== "object" || Array.isArray(value))
+    return false;
+  const record = value;
+  if (record.runId !== runId)
+    return false;
+  return record.status === "sent" || record.status === "delivered" || record.status === "failed";
+}
+function currentSnapshot(ctx) {
+  const value = ctx.getState().data?.runDetail;
+  return value && typeof value === "object" && !Array.isArray(value) ? value : null;
+}
+async function loadMoreRunTimeline(ctx, runId) {
+  const cleanRunId = runId.trim();
+  const snapshot = currentSnapshot(ctx);
+  if (!snapshot || snapshot.runId !== cleanRunId || !snapshot.timelineCursor)
+    return snapshot;
+  const label = `More timeline ${cleanRunId.slice(0, 8)}`;
+  emitStarted(ctx, label);
+  try {
+    const { getRunTimelineViaServer: getRunTimelineViaServer2 } = await Promise.resolve().then(() => (init__server_client(), exports__server_client));
+    const context = { projectRoot: projectRootOf(ctx) };
+    const page = await getRunTimelineViaServer2(context, cleanRunId, { limit: TIMELINE_PAGE, cursor: snapshot.timelineCursor });
+    const more = arrayFromPayload(page);
+    const timelineTotal = payloadTotal(page) ?? snapshot.timelineTotal;
+    const next = {
+      ...snapshot,
+      timeline: [...snapshot.timeline, ...more],
+      timelineCursor: nextCursor(page),
+      ...timelineTotal !== undefined ? { timelineTotal } : {}
+    };
+    patchData(ctx, { runDetail: next, lastRefreshError: undefined });
+    emitCompleted(ctx, label, { runId: cleanRunId, added: more.length, timeline: next.timeline.length });
+    return next;
+  } catch (error) {
+    emitFailed(ctx, label, error, { runId: cleanRunId });
+    throw error;
+  }
+}
+function steerResultSummary(result) {
+  for (const key of ["status", "state", "message", "detail"]) {
+    const value = result[key];
+    if (typeof value === "string" && value.trim())
+      return value.trim();
+  }
+  if (result.ok === true || result.queued === true || result.delivered === true)
+    return "accepted by run";
+  return "delivered";
+}
 async function steerRunFromApp(ctx, input) {
   const label = `Steering ${input.runId.slice(0, 8)}`;
   const message = input.message.trim();
@@ -854,17 +964,21 @@ async function steerRunFromApp(ctx, input) {
     emitFailed(ctx, label, error, { runId: input.runId });
     throw error;
   }
-  emitStarted(ctx, label, { runMessage: { runId: input.runId, text: message, status: "queued" } });
-  patchData(ctx, { pendingRunMessage: { runId: input.runId, text: message, status: "queued" } });
+  const pending = { runId: input.runId, text: message, status: "queued" };
+  emitStarted(ctx, label, { pendingRunMessage: pending });
+  patchData(ctx, { pendingRunMessage: pending });
   try {
     const { sendRunPiPromptViaServer: sendRunPiPromptViaServer2, steerRunViaServer: steerRunViaServer2 } = await Promise.resolve().then(() => (init__server_client(), exports__server_client));
     const context = { projectRoot: projectRootOf(ctx) };
     const result = await sendRunPiPromptViaServer2(context, input.runId, message, "steer").catch(() => steerRunViaServer2(context, input.runId, message));
+    const summary = steerResultSummary(result);
+    patchData(ctx, { pendingRunMessage: { runId: input.runId, text: message, status: "sent", result: summary } });
     emitCompleted(ctx, label, { runId: input.runId, result });
-    patchData(ctx, { pendingRunMessage: null });
     return result;
   } catch (error) {
-    emitFailed(ctx, label, error, { runId: input.runId, revert: { pendingRunMessage: null } });
+    const message2 = normalizeAppError(error).message;
+    emitFailed(ctx, label, error, { runId: input.runId });
+    patchData(ctx, { pendingRunMessage: { runId: input.runId, text: message, status: "failed", result: message2 } });
     throw error;
   }
 }
@@ -878,7 +992,10 @@ async function stopRunFromDetail(ctx, runId) {
     const { stopRunViaServer: stopRunViaServer2 } = await Promise.resolve().then(() => (init__server_client(), exports__server_client));
     const result = await stopRunViaServer2({ projectRoot: projectRootOf(ctx) }, cleanRunId);
     emitCompleted(ctx, label, { runId: cleanRunId, result });
-    await loadRunDetail(ctx, cleanRunId).catch(() => null);
+    await loadRunDetail(ctx, cleanRunId).catch((error) => {
+      patchData(ctx, { lastRefreshError: normalizeAppError(error).message });
+      return null;
+    });
     return result;
   } catch (error) {
     emitFailed(ctx, label, error, { runId: cleanRunId, revert: { status: "unknown" } });
@@ -889,5 +1006,5 @@ export {
   stopRunFromDetail,
   steerRunFromApp,
   loadRunDetail,
-  createRunDetailAdapter
+  loadMoreRunTimeline
 };

package/dist/src/app-opentui/adapters/server.d.ts

@@ -1,6 +1,4 @@
-import type { AppAdapter } from "../types";
 import { type AppAdapterContext } from "./common";
-export declare function createServerAdapter(): AppAdapter;
 export type AppServerState = {
     readonly label: string;
     readonly baseUrl?: string;
@@ -11,4 +9,14 @@ export type AppServerState = {
     readonly auth?: Record<string, unknown>;
     readonly error?: string;
 };
+/** Start the local Rig server DETACHED and return to the server scene (bug #3).
+ *
+ * `rig server start` is a blocking long-running process; running it through the
+ * foreground command PTY traps the operator (kitty-mode even swallows ctrl-c).
+ * Instead we: (a) switch this repo's connection to local, (b) spawn the server
+ * detached + wait for ready via ensureLocalRigServerConnection (it writes the
+ * published server state and unrefs the child), then (c) re-probe. The operator
+ * is never blocked: this returns once the detached server answers.
+ */
+export declare function startLocalServerFromApp(ctx: AppAdapterContext): Promise<AppServerState>;
 export declare function refreshServerStatus(ctx: AppAdapterContext): Promise<AppServerState>;