@saadnvd1/agent-os 0.3.464 → 0.3.466

package/README.md

@@ -311,6 +311,19 @@ mode and starts it, **Keep planning** goes back to the composer.
 The ring in the tab bar (in the composer on a phone) is how full the
 conversation's context is, measured against the room before auto-compact:
 amber past 60%, red past 85%. Tap it for the breakdown and **Compact now**.
+
+A message to a chat idle past its prompt cache (5 minutes or an hour, read
+from the agent's own usage) re-reads the whole conversation at the
+cache-write price. When the context is also above a threshold (150k tokens by
+default, Settings → Workspaces → Compact idle chats; off sets it to never), a
+chip above the composer says "Idle 47m · 412k context · Compact first?": Send
+compacts and then sends, **Send as-is** skips it for that one message.
+Messages nobody is typing (the orchestrator's `send`, AgentOS events and
+wakes, `aos send`, schedules) compact first on their own, only between turns,
+and the chat shows one quiet line with the context before and after. An
+orchestrator isn't compacted (a summary would lose the fence around what it
+read from tasks and CI): it starts a fresh conversation from its brief and
+the current state instead, as at its fresh-start threshold.
 On a desktop browser the screen button attaches a screenshot of a screen or
 window you pick; on a phone, attach a screenshot as a photo.
 
@@ -1245,6 +1258,13 @@ One Node process serves every terminal, chat stream and request, so a route
 handler in `app/api/` may not call a `*Sync` child_process or fs function:
 ESLint refuses it. Use the async form with a timeout.
 
+Every git process starts in `lib/git-exec.ts`: `git()`, `gitResult()`,
+`gitOk()` and named operations (`revParse`, `worktreeAdd`, `gitPush`, …). It
+sets one timeout, kills a hung git, never lets git prompt, keeps the server's
+tmux out of hooks and rejects with a `GitError` carrying the exit code and
+stderr. ESLint refuses git spawned anywhere else in `lib/`, `app/` or
+`server.ts`.
+
 `scripts/redeploy` (and `scripts/autodeploy`, which calls it) builds into
 `.next-build` while the live server keeps serving `.next`. The build is swapped
 in by rename only once it finished with a `BUILD_ID`, right before the restart.

package/app/api/fresh-start/route.ts

@@ -2,15 +2,17 @@ import { NextRequest, NextResponse } from "next/server";
 import { refreshSettings, setRefreshSettings } from "@/lib/chat/refresh";
 
 // When a chat's conversation starts over (lib/chat/refresh): context
-// tokens for orchestrators and for tasks, 0 for never.
+// tokens for orchestrators and for tasks, and above which a stale chat is
+// compacted before a message (lib/chat/stale); 0 for never.
 export async function GET() {
   return NextResponse.json(refreshSettings());
 }
 
 export async function PUT(request: NextRequest) {
   try {
-    const { orchestratorTokens, taskTokens } = await request.json();
-    setRefreshSettings({ orchestratorTokens, taskTokens });
+    const { orchestratorTokens, taskTokens, staleCompactTokens } =
+      await request.json();
+    setRefreshSettings({ orchestratorTokens, taskTokens, staleCompactTokens });
     return NextResponse.json(refreshSettings());
   } catch (error) {
     const message = error instanceof Error ? error.message : String(error);

package/app/api/git/commit/route.ts

@@ -45,7 +45,8 @@ export async function POST(request: NextRequest) {
 
     if (
       branchName &&
-      (typeof branchName !== "string" || !isValidBranchName(path, branchName))
+      (typeof branchName !== "string" ||
+        !(await isValidBranchName(path, branchName)))
     ) {
       return NextResponse.json(
         { error: "Invalid branch name" },
@@ -64,8 +65,8 @@ export async function POST(request: NextRequest) {
 
     // Create new branch if on main/master and branch name provided
     let newBranch = false;
-    if (branchName && isMainBranch(path)) {
-      createBranch(path, branchName);
+    if (branchName && (await isMainBranch(path))) {
+      await createBranch(path, branchName);
       newBranch = true;
     }
 

package/app/api/git/file-content/route.ts

@@ -1,10 +1,7 @@
 import { NextRequest, NextResponse } from "next/server";
-import { execFile } from "child_process";
-import { promisify } from "util";
+import { git } from "@/lib/git-exec";
 import { expandPath } from "@/lib/git-status";
 
-const execFileAsync = promisify(execFile);
-
 /**
  * GET /api/git/file-content?path=...&file=...
  * Get file content from git HEAD (original version before changes)
@@ -33,17 +30,9 @@ export async function GET(request: NextRequest) {
 
     try {
       // Get file content from HEAD
-      const { stdout: content } = await execFileAsync(
-        "git",
-        ["show", `HEAD:${file}`],
-        {
-          cwd: expandedPath,
-          encoding: "utf-8",
-          maxBuffer: 10 * 1024 * 1024, // 10MB
-          timeout: 30_000,
-          killSignal: "SIGKILL",
-        }
-      );
+      const content = await git(expandedPath, ["show", `HEAD:${file}`], {
+        timeout: 30_000,
+      });
 
       return NextResponse.json({ content });
     } catch (gitError: unknown) {

package/app/api/git/history/[hash]/diff/route.ts

@@ -31,7 +31,7 @@ export async function GET(request: NextRequest, { params }: RouteParams) {
       );
     }
 
-    const diff = getCommitFileDiff(path, hash, file);
+    const diff = await getCommitFileDiff(path, hash, file);
     return NextResponse.json({ diff });
   } catch (error) {
     console.error("Error getting commit file diff:", error);

package/app/api/git/history/[hash]/route.ts

@@ -23,7 +23,7 @@ export async function GET(request: NextRequest, { params }: RouteParams) {
       );
     }
 
-    const commit = getCommitDetail(path, hash);
+    const commit = await getCommitDetail(path, hash);
     if (!commit) {
       return NextResponse.json({ error: "Commit not found" }, { status: 404 });
     }

package/app/api/git/history/route.ts

@@ -15,7 +15,7 @@ export async function GET(request: NextRequest) {
       );
     }
 
-    const commits = getCommitHistory(path, limit);
+    const commits = await getCommitHistory(path, limit);
     return NextResponse.json({ commits });
   } catch (error) {
     console.error("Error getting commit history:", error);

package/app/api/git/push/route.ts

@@ -28,7 +28,7 @@ export async function POST(request: NextRequest) {
     }
 
     // Check if remote exists
-    const remoteUrl = getRemoteUrl(path);
+    const remoteUrl = await getRemoteUrl(path);
     if (!remoteUrl) {
       return NextResponse.json(
         { error: "No remote origin configured" },
@@ -48,7 +48,7 @@ export async function POST(request: NextRequest) {
     }
 
     // Push (set upstream if needed)
-    const needsUpstream = !hasUpstream(path);
+    const needsUpstream = !(await hasUpstream(path));
     const output = await push(path, needsUpstream);
 
     forgetGitStatus(path);

package/app/api/sessions/[id]/pr/route.ts

@@ -2,6 +2,7 @@ import { NextRequest, NextResponse } from "next/server";
 import { execFile } from "child_process";
 import { promisify } from "util";
 import { getDb, queries, type Session } from "@/lib/db";
+import { gitPush } from "@/lib/git-exec";
 
 const execFileAsync = promisify(execFile);
 
@@ -69,8 +70,7 @@ async function createPR(
 ): Promise<PRInfo> {
   // First push the branch if not already pushed
   try {
-    await execFileAsync("git", ["push", "-u", "origin", "--", branchName], {
-      cwd: projectPath,
+    await gitPush(projectPath, ["-u", "origin", "--", branchName], {
       timeout: 30000,
     });
   } catch {

package/components/Chat/ChatPanel.tsx

@@ -26,6 +26,9 @@ import { SubagentCard } from "./Subagent";
 import { UndoDialog, UndoneBlock } from "./Undo";
 import { Composer } from "./Composer";
 import { Queue } from "./Queue";
+import { StaleChip } from "./StaleChip";
+import { composerCompacts } from "@/lib/chat/stale";
+import { useFreshStartQuery } from "@/data/fresh-start";
 import { QuoteButton } from "./QuoteButton";
 import { ToolBodies, ToolGroup } from "./Tools";
 import { RowState, RowStore } from "./rowState";
@@ -282,6 +285,12 @@ export function ChatPanel({
     toEnd();
     send(text);
   };
+  // A stale chat compacts before the next message unless the reader picks
+  // "Send as-is", for that send only.
+  const staleCompactTokens = useFreshStartQuery().data?.staleCompactTokens ?? 0;
+  const [asIsFor, setAsIsFor] = useState<string | null>(null);
+  const asIs = asIsFor === sessionId;
+  const setAsIs = (on: boolean) => setAsIsFor(on ? sessionId : null);
 
   // Shift+Tab switches plan mode from the composer, as in the terminal.
   const shiftTab = useRef(togglePlan);
@@ -517,6 +526,13 @@ export function ChatPanel({
             )
           }
         />
+        <StaleChip
+          context={context}
+          state={state}
+          thresholdTokens={staleCompactTokens}
+          asIs={asIs}
+          onAsIs={setAsIs}
+        />
         <Composer
           draftKey={sessionId}
           suggestion={shownSuggestion}
@@ -529,7 +545,13 @@ export function ChatPanel({
           placeholder={connected ? `Message ${sessionName}` : "Reconnecting…"}
           onSend={(text, images) => {
             toEnd();
-            send(text, images.length ? images : undefined);
+            const compact = composerCompacts(text, context, {
+              state,
+              thresholdTokens: staleCompactTokens,
+              asIs,
+            });
+            setAsIs(false);
+            send(text, images.length ? images : undefined, compact);
           }}
           onStop={interrupt}
           commands={commands}

package/components/Chat/Messages.tsx

@@ -4,6 +4,7 @@ import { Check, ChevronRight, Circle, CircleDot, Sparkles } from "lucide-react";
 import type { ChatItem } from "@/lib/chat/events";
 import { cn } from "@/lib/utils";
 import { leadingCommand } from "@/lib/chat/commands";
+import { compactedLine } from "@/lib/chat/stale";
 import { CopyButton } from "./CopyButton";
 import { ImageThumb } from "./ImageThumb";
 import { Markdown } from "./Markdown";
@@ -184,9 +185,7 @@ export function Compacted({ item }: { item: Of<"compacted"> }) {
   return (
     <div className="text-muted-foreground/60 flex items-center gap-3 font-mono text-[11px]">
       <span className="bg-foreground/[0.06] h-px flex-1" />
-      {item.trigger === "auto"
-        ? "Context compacted automatically"
-        : "Context compacted"}
+      {compactedLine(item)}
       <span className="bg-foreground/[0.06] h-px flex-1" />
     </div>
   );

package/components/Chat/StaleChip.tsx

@@ -0,0 +1,55 @@
+"use client";
+
+import { Minimize2 } from "lucide-react";
+import type { ChatContext, ChatState } from "@/lib/chat/events";
+import { staleLabel, staleness } from "@/lib/chat/stale";
+import { cn } from "@/lib/utils";
+import { useNow } from "./useNow";
+
+// Above the composer while the chat is stale (lib/chat/stale): its prompt
+// cache has expired and its context is long, so the next message would
+// re-read all of it at full price. Send compacts first unless the reader
+// picks "Send as-is", for that one send only.
+export function StaleChip({
+  context,
+  state,
+  thresholdTokens,
+  asIs,
+  onAsIs,
+}: {
+  context: ChatContext | null;
+  state: ChatState;
+  thresholdTokens: number;
+  asIs: boolean;
+  onAsIs: (asIs: boolean) => void;
+}) {
+  const watching = !!context?.cacheTtlMs && thresholdTokens > 0;
+  const now = useNow(watching);
+  const stale = staleness(context, { state, thresholdTokens, now });
+  if (!stale) return null;
+  return (
+    <div
+      role="status"
+      className="bg-card popover-surface mb-2 flex items-center gap-2 rounded-2xl py-1 pr-1 pl-3 text-xs"
+    >
+      <Minimize2 className="text-muted-foreground h-3.5 w-3.5 shrink-0" />
+      <span className="text-muted-foreground min-w-0 flex-1 truncate">
+        {staleLabel(stale)} ·{" "}
+        <span className="text-foreground">
+          {asIs ? "Sending as-is" : "Compact first?"}
+        </span>
+      </span>
+      <button
+        type="button"
+        aria-pressed={asIs}
+        onClick={() => onAsIs(!asIs)}
+        className={cn(
+          "hover:bg-foreground/[0.06] min-h-11 shrink-0 rounded-xl px-3 font-medium md:min-h-8",
+          asIs && "text-primary"
+        )}
+      >
+        {asIs ? "Compact first" : "Send as-is"}
+      </button>
+    </div>
+  );
+}

package/components/Workspaces/FreshStartForm.tsx

@@ -18,7 +18,10 @@ export function FreshStartForm() {
   if (isError)
     return <p className="text-destructive text-sm">{error.message}</p>;
   return (
-    <Form key={`${data.orchestratorTokens}:${data.taskTokens}`} saved={data} />
+    <Form
+      key={`${data.orchestratorTokens}:${data.taskTokens}:${data.staleCompactTokens}`}
+      saved={data}
+    />
   );
 }
 
@@ -26,11 +29,13 @@ function Form({ saved }: { saved: RefreshSettings }) {
   const update = useUpdateFreshStart();
   const orchestrator = useThreshold(saved.orchestratorTokens, 200);
   const task = useThreshold(saved.taskTokens, 200);
-  const error = orchestrator.error ?? task.error;
+  const stale = useThreshold(saved.staleCompactTokens, 150);
+  const error = orchestrator.error ?? task.error ?? stale.error;
   const dirty =
     !error &&
     (orchestrator.tokens !== saved.orchestratorTokens ||
-      task.tokens !== saved.taskTokens);
+      task.tokens !== saved.taskTokens ||
+      stale.tokens !== saved.staleCompactTokens);
 
   return (
     <form
@@ -38,9 +43,13 @@ function Form({ saved }: { saved: RefreshSettings }) {
         e.preventDefault();
         if (error) return;
         update.mutate(
-          { orchestratorTokens: orchestrator.tokens, taskTokens: task.tokens },
           {
-            onSuccess: () => toast.success("Fresh starts saved"),
+            orchestratorTokens: orchestrator.tokens,
+            taskTokens: task.tokens,
+            staleCompactTokens: stale.tokens,
+          },
+          {
+            onSuccess: () => toast.success("Context settings saved"),
             onError: (err) => toast.error(err.message),
           }
         );
@@ -56,6 +65,18 @@ function Form({ saved }: { saved: RefreshSettings }) {
       </p>
       <ThresholdRow label="Orchestrators" field={orchestrator} />
       <ThresholdRow label="Tasks" field={task} />
+      <h3 className="pt-2 text-sm font-medium">Compact idle chats</h3>
+      <p className="text-muted-foreground text-sm">
+        A message to a chat idle past its prompt cache re-reads the whole
+        conversation at full price. Above this size, messages from the
+        orchestrator, events and schedules compact it first; the composer offers
+        to.
+      </p>
+      <ThresholdRow
+        label="Idle chats"
+        field={stale}
+        switchLabel="Compact idle chats before a message"
+      />
       {error && <p className="text-destructive text-xs">{error}</p>}
       <div className="flex justify-end">
         <Button
@@ -90,9 +111,11 @@ function useThreshold(tokens: number, fallbackK: number) {
 function ThresholdRow({
   label,
   field,
+  switchLabel,
 }: {
   label: string;
   field: ReturnType<typeof useThreshold>;
+  switchLabel?: string;
 }) {
   return (
     <div className="space-y-2">
@@ -101,7 +124,7 @@ function ThresholdRow({
         <Switch
           checked={field.on}
           onCheckedChange={field.setOn}
-          aria-label={`Fresh starts for ${label.toLowerCase()}`}
+          aria-label={switchLabel ?? `Fresh starts for ${label.toLowerCase()}`}
         />
       </label>
       {field.on && (

package/data/chat/useChat.ts

@@ -298,10 +298,18 @@ export function useChat(
 
   const queryClient = useQueryClient();
   const send = useCallback(
-    (text: string, images?: ChatImage[]) => {
+    // `compact`: the reader let a stale chat compact first (lib/chat/stale).
+    (text: string, images?: ChatImage[], compact?: boolean) => {
       const ws = wsRef.current;
       if (!ws) return;
-      ws.send(JSON.stringify({ type: "send", text, images }));
+      ws.send(
+        JSON.stringify({
+          type: "send",
+          text,
+          images,
+          ...(compact && { compact: true }),
+        })
+      );
       if (ws.readyState === WebSocket.OPEN) markRunning(queryClient, sessionId);
     },
     [queryClient, sessionId]

package/lib/away/deploy.ts

@@ -9,7 +9,7 @@
 
 import fs from "fs";
 import type { ProjectConfig } from "../project-config";
-import { run } from "../tasks/gh";
+import { gitFetch, isAncestor } from "../git-exec";
 import { expandHome } from "../tasks/session";
 import { selfUrl } from "../agents/self-env";
 import { commitTime } from "../orchestrator/repo";
@@ -61,15 +61,11 @@ async function contains(
   sha: string
 ): Promise<boolean> {
   if (tip === sha) return true;
-  const ancestor = () =>
-    run("git", ["merge-base", "--is-ancestor", sha, tip], repo).then(
-      () => true,
-      () => false
-    );
+  const ancestor = () => isAncestor(repo, sha, tip);
   if (await ancestor()) return true;
   // The deployed commit may be newer than this checkout knows. A fetch that
   // fails throws, so stale refs never read as "not deployed".
-  await run("git", ["fetch", "--quiet", "origin"], repo);
+  await gitFetch(repo, ["--quiet", "origin"]);
   return ancestor();
 }
 

package/lib/away/run.ts

@@ -23,6 +23,7 @@ import { notifyPhone } from "../notify";
 import { getProject } from "../projects";
 import { loadProjectConfig } from "../project-config";
 import { run } from "../tasks/gh";
+import { git } from "../git-exec";
 import { expandHome } from "../tasks/session";
 import { auditId, auditsRoot, writeAtomic } from "../session-audit/store";
 import {
@@ -199,11 +200,11 @@ async function dirtySessions(ids: string[]): Promise<Set<string>> {
         // A linked machine's worktree isn't on this disk.
         if (!s || (s.host_id && s.host_id !== "local")) return;
         const dir = expandHome(s.worktree_path || s.working_directory);
-        const out = await run(
-          "git",
-          ["status", "--porcelain", "--untracked-files=normal"],
-          dir
-        ).catch(() => "");
+        const out = await git(dir, [
+          "status",
+          "--porcelain",
+          "--untracked-files=normal",
+        ]).catch(() => "");
         if (out.trim()) dirty.add(id);
       })
     );

package/lib/build.ts

@@ -3,20 +3,16 @@
 // A worker whose build isn't the server's is running code from before a
 // redeploy.
 
-import { execFileSync } from "child_process";
 import fs from "fs";
 import path from "path";
 import type { ChatState } from "./chat/events";
+import { gitSync } from "./git-exec";
 
 export function buildId(): string {
   if (process.env.AGENTOS_BUILD) return process.env.AGENTOS_BUILD;
   let id = "";
   try {
-    id = execFileSync("git", ["rev-parse", "HEAD"], {
-      cwd: process.cwd(),
-      encoding: "utf8",
-      stdio: ["ignore", "pipe", "ignore"],
-    }).trim();
+    id = gitSync(process.cwd(), ["rev-parse", "HEAD"]).trim();
   } catch {}
   if (!id) {
     try {

package/lib/bus/index.ts

@@ -163,6 +163,9 @@ async function deliver(
         from: from.name,
         peer: from.peer,
         origin: from.origin,
+        // Nobody is at the composer to choose: a stale chat is compacted
+        // first (lib/chat/stale).
+        compact: "auto",
       });
       return { state };
     } catch (error) {

package/lib/chat/client-send.ts

@@ -1,14 +1,22 @@
 import type { ChatImage } from "./events";
+import type { CompactFirst } from "./stale";
 
-// What a browser's send may carry: its text and images. Who a message is
-// from (`from`, `peer`, `origin`) is set by the server alone, never by a client.
+// What a browser's send may carry: its text and images, and whether the
+// reader chose to compact a stale chat first. Who a message is from (`from`,
+// `peer`, `origin`) is set by the server alone, never by a client.
 export function clientSend(msg: unknown): {
   text: string;
   images?: ChatImage[];
+  compact?: CompactFirst;
 } {
-  const m = (msg ?? {}) as { text?: unknown; images?: unknown };
+  const m = (msg ?? {}) as {
+    text?: unknown;
+    images?: unknown;
+    compact?: unknown;
+  };
   return {
     text: typeof m.text === "string" ? m.text : "",
     images: Array.isArray(m.images) ? (m.images as ChatImage[]) : undefined,
+    ...(m.compact === true && { compact: "yes" as const }),
   };
 }

package/lib/chat/drivers/claude-mapper.ts

@@ -31,6 +31,10 @@ export type ClaudeMessage = {
       input_tokens?: number;
       output_tokens?: number;
       cache_creation_input_tokens?: number;
+      cache_creation?: {
+        ephemeral_5m_input_tokens?: number;
+        ephemeral_1h_input_tokens?: number;
+      } | null;
     };
   };
   event?: {
@@ -49,7 +53,11 @@ export type ClaudeMessage = {
   content?: string;
   terminal_slash_commands?: string[];
   commands?: SdkCommand[];
-  compact_metadata?: { trigger?: "manual" | "auto" };
+  compact_metadata?: {
+    trigger?: "manual" | "auto";
+    pre_tokens?: number;
+    post_tokens?: number;
+  };
   // Background tasks (task_started, task_progress, task_notification).
   task_id?: string;
   tool_use_id?: string;
@@ -223,6 +231,8 @@ export class ClaudeMapper {
               id: randomUUID(),
               kind: "compacted",
               trigger: m.compact_metadata?.trigger,
+              before: m.compact_metadata?.pre_tokens,
+              after: m.compact_metadata?.post_tokens,
               createdAt: now(),
             },
           },

package/lib/chat/drivers/claude.ts

@@ -10,6 +10,7 @@ import type { DriverEvent, FileSuggestion, McpServerView } from "../events";
 import { InputQueue } from "../queue";
 import { Approvals, isPlanFile, sdkMode } from "./claude-approvals";
 import { toChatContext, usageTotals } from "../context";
+import { cacheTtlMs } from "../stale";
 import { ClaudeMapper, toCommand, type ClaudeMessage } from "./claude-mapper";
 import { SuggestionTrace } from "./suggestion-trace";
 import { redact } from "../../orchestrator/untrusted";
@@ -224,6 +225,8 @@ export const claudeDriver: ChatDriver = {
       () => plan
     );
     let sessionId = options.resumeId ?? null;
+    // The prompt-cache lifetime its turns write with (lib/chat/stale).
+    let cacheTtl: number | undefined;
 
     // What the agent restored on starting: a resumed conversation's totals
     // when its last process saved them, nothing otherwise. Each turn's cost
@@ -248,13 +251,18 @@ export const claudeDriver: ChatDriver = {
           planFile = writtenPlanFile(m) ?? planFile;
           trace.message(m);
           for (const e of mapper.map(m)) out.push(e);
+          if (m.type === "assistant" && !m.parent_tool_use_id)
+            cacheTtl = cacheTtlMs(m.message?.usage?.cache_creation) ?? cacheTtl;
           // How full the window is now, for the meter, without holding up
           // the conversation.
           if (m.type === "result")
             void q
               .getContextUsage({ detail: "summary" })
               .then((u) =>
-                out.push({ type: "context", context: toChatContext(u) })
+                out.push({
+                  type: "context",
+                  context: { ...toChatContext(u), cacheTtlMs: cacheTtl },
+                })
               )
               .catch(() => {});
         }

package/lib/chat/events.ts

@@ -106,7 +106,11 @@ export interface ChatContext {
   percentage: number;
   categories: { name: string; tokens: number }[];
   model?: string;
+  // When it was measured: the end of the last turn.
   at: number;
+  // The prompt-cache lifetime the conversation writes with (lib/chat/stale),
+  // once a turn has said.
+  cacheTtlMs?: number;
 }
 
 // Running totals the agent reports at the end of each turn.
@@ -174,7 +178,16 @@ export type ChatItem =
   | (Base & { kind: "command_output"; text: string })
   // The conversation's MCP servers, as /mcp reports them.
   | (Base & { kind: "mcp"; servers: McpServerView[] })
-  | (Base & { kind: "compacted"; trigger?: "manual" | "auto" })
+  | (Base & {
+      kind: "compacted";
+      trigger?: "manual" | "auto";
+      // Context tokens before and after, when the agent reports them.
+      before?: number;
+      after?: number;
+      // Compacted ahead of a message to a stale chat (lib/chat/stale): how
+      // long it had been idle.
+      idleMs?: number;
+    })
   // A plan the agent proposed from plan mode, and whether it was carried out.
   | (Base & { kind: "plan"; plan: string; carried?: boolean })
   | (Base & { kind: "error"; message: string })