@agent-native/core 0.131.4 → 0.131.6

package/corpus/core/src/agent/run-loop-with-resume.ts

@@ -26,11 +26,13 @@ import {
   runAgentLoop,
   appendAgentLoopContinuation,
   isResumableEngineError,
+  isTransientProviderRateLimitError,
   continuationReasonForResumableError,
   lastUnfinishedPreparingActionToolFromEvents,
   resolveFinalResponseGuardRequestText,
   SELF_CHAIN_MIN_CONTINUATION_BUDGET_MS,
   type AgentLoopContinuationReason,
+  type AgentLoopOutcome,
 } from "./production-agent.js";
 import { resolveRunSoftTimeoutMs } from "./run-manager.js";
 import type { ResolveRunSoftTimeoutOptions } from "./run-manager.js";
@@ -112,7 +114,7 @@ function appendToolCallJournalNote(
 
 async function appendContinuationAndJournal(
   messages: EngineMessage[],
-  reason: AgentLoopContinuationReason,
+  reason: AgentLoopContinuationReason | "rate_limited",
   threadId: string | undefined,
   localEvents: readonly AgentChatEvent[] = [],
 ): Promise<void> {
@@ -185,6 +187,47 @@ function internalContinuationReasonForAttempt(
  */
 export const MAX_RUN_LOOP_CONTINUATIONS = 6;
 
+/**
+ * A delegated turn that is proven to be running inside a durable background
+ * function has the same 15-minute host budget as main chat, but this wrapper
+ * historically kept the foreground-sized six-continuation cap. A healthy
+ * child A2A call can consume several minutes and the receiving model may then
+ * need more than six recovery/model-stream boundaries to finish its own tool
+ * work. Keep a hard cap, but give the proven background path the same bounded
+ * continuation allowance as the durable main-chat runner. The cumulative
+ * soft-timeout below still prevents these rounds from exceeding the one real
+ * background-function wall-clock budget.
+ */
+export const MAX_BACKGROUND_RUN_LOOP_CONTINUATIONS = 20;
+
+/**
+ * The engine already performs its own short provider retries. After those are
+ * exhausted, a proven durable background A2A/MCP run gets one cooled-down
+ * continuation for a transient 429/529. One extra round is enough to bridge a
+ * short provider bucket without multiplying a sustained rate limit into a
+ * request storm across the larger background continuation allowance.
+ */
+export const MAX_BACKGROUND_RATE_LIMIT_CONTINUATIONS = 1;
+export const BACKGROUND_RATE_LIMIT_CONTINUATION_DELAY_MS = 20_000;
+
+function waitForBackgroundRateLimitCooldown(
+  signal: AbortSignal,
+): Promise<void> {
+  if (signal.aborted) return Promise.resolve();
+  return new Promise((resolve) => {
+    const finish = () => {
+      clearTimeout(timer);
+      signal.removeEventListener("abort", finish);
+      resolve();
+    };
+    const timer = setTimeout(
+      finish,
+      BACKGROUND_RATE_LIMIT_CONTINUATION_DELAY_MS,
+    );
+    signal.addEventListener("abort", finish, { once: true });
+  });
+}
+
 /** Machine-readable code carried on the give-up terminal `error` event so the
  * client renders a loud "stopped before finishing" terminal instead of an
  * ambiguous silent stall. Deliberately NOT in the client's auto-recoverable
@@ -222,7 +265,73 @@ export async function runAgentLoopDirectWithSoftTimeout(
     resolveFinalResponseGuardRequestText(opts.messages);
   const stableOpts = { ...opts, finalResponseGuardRequestText };
   const timeoutMs = resolveRunSoftTimeoutMs(softTimeoutMs, timeoutOptions);
-  if (timeoutMs <= 0) return runAgentLoop(stableOpts);
+  let finalOutcomeReported = false;
+  const reportFinalOutcome = (outcome: AgentLoopOutcome) => {
+    if (finalOutcomeReported) return;
+    finalOutcomeReported = true;
+    try {
+      opts.onOutcome?.(outcome);
+    } catch {
+      // Outcome observers cannot alter recovery or completion.
+    }
+  };
+
+  // Disabling continuation recovery must not disable terminal classification.
+  // Keep the same outcome boundary around a direct loop so A2A/MCP callers
+  // never infer success from a rejected or canceled run.
+  if (timeoutMs <= 0) {
+    const directEvents: AgentChatEvent[] = [];
+    let directOutcome: AgentLoopOutcome | undefined;
+    try {
+      const result = await runAgentLoop({
+        ...stableOpts,
+        send: (event) => {
+          directEvents.push(event);
+          stableOpts.send(event);
+        },
+        onOutcome: (outcome) => {
+          directOutcome = outcome;
+        },
+      });
+      const unfinishedReason =
+        internalContinuationReasonForAttempt(directEvents);
+      if (opts.signal.aborted) {
+        reportFinalOutcome({
+          state: "canceled",
+          message: "Agent run was aborted.",
+        });
+      } else if (unfinishedReason) {
+        reportFinalOutcome({
+          state: "failed",
+          code: unfinishedReason,
+          retryable: false,
+          message: `Agent stopped before finishing (${unfinishedReason}).`,
+        });
+      } else {
+        reportFinalOutcome(directOutcome ?? { state: "completed" });
+      }
+      return result;
+    } catch (err) {
+      const candidate = err as { errorCode?: unknown; message?: unknown };
+      reportFinalOutcome(
+        opts.signal.aborted
+          ? { state: "canceled", message: "Agent run was aborted." }
+          : {
+              state: "failed",
+              code:
+                typeof candidate?.errorCode === "string" && candidate.errorCode
+                  ? candidate.errorCode
+                  : "internal_error",
+              retryable: isResumableEngineError(err),
+              message:
+                typeof candidate?.message === "string"
+                  ? candidate.message
+                  : String(err),
+            },
+      );
+      throw err;
+    }
+  }
 
   const upstreamSignal = opts.signal;
   const usage: Awaited<ReturnType<typeof runAgentLoop>> = {
@@ -260,6 +369,11 @@ export async function runAgentLoopDirectWithSoftTimeout(
   // pattern, already proven for the analogous foreground self-chain case).
   // The first round is unaffected — it always gets the full `timeoutMs`.
   const loopEntryAt = Date.now();
+  const maxRunLoopContinuations =
+    timeoutOptions?.backgroundFunction === true
+      ? MAX_BACKGROUND_RUN_LOOP_CONTINUATIONS
+      : MAX_RUN_LOOP_CONTINUATIONS;
+  let backgroundRateLimitContinuations = 0;
   // Tracks whether the most recent attempt ended by scheduling another
   // continuation (soft-timeout or resumable error → `continue`) rather than
   // returning a finished turn. When the loop then exits because the budget is
@@ -267,7 +381,7 @@ export async function runAgentLoopDirectWithSoftTimeout(
   // this is the silent give-up case: emit a loud terminal so the user sees an
   // unambiguous "stopped before finishing" instead of a bare done/"…".
   let lastAttemptWasUnfinishedContinuation = false;
-  while (!upstreamSignal.aborted && attempts < MAX_RUN_LOOP_CONTINUATIONS) {
+  while (!upstreamSignal.aborted && attempts < maxRunLoopContinuations) {
     const roundTimeoutMs =
       attempts === 0 ? timeoutMs : timeoutMs - (Date.now() - loopEntryAt);
     if (
@@ -307,10 +421,14 @@ export async function runAgentLoopDirectWithSoftTimeout(
     };
 
     try {
+      let attemptOutcome: AgentLoopOutcome | undefined;
       const nextUsage = await runAgentLoop({
         ...stableOpts,
         send,
         signal: controller.signal,
+        onOutcome: (outcome) => {
+          attemptOutcome = outcome;
+        },
       });
       addUsage(nextUsage);
       const attemptEvents = localTurnEvents.slice(attemptStartIndex);
@@ -345,6 +463,11 @@ export async function runAgentLoopDirectWithSoftTimeout(
         );
         continue;
       }
+      reportFinalOutcome(
+        upstreamSignal.aborted
+          ? { state: "canceled", message: "Agent run was aborted." }
+          : (attemptOutcome ?? { state: "completed" }),
+      );
       return usage;
     } catch (err) {
       if (softTimedOut && !upstreamSignal.aborted) {
@@ -367,6 +490,39 @@ export async function runAgentLoopDirectWithSoftTimeout(
         );
         continue;
       }
+      const transientRateLimit = isTransientProviderRateLimitError(err);
+      const rateLimitRetryFitsBudget =
+        timeoutOptions?.backgroundFunction === true &&
+        backgroundRateLimitContinuations <
+          MAX_BACKGROUND_RATE_LIMIT_CONTINUATIONS &&
+        timeoutMs -
+          (Date.now() - loopEntryAt) -
+          BACKGROUND_RATE_LIMIT_CONTINUATION_DELAY_MS >=
+          SELF_CHAIN_MIN_CONTINUATION_BUDGET_MS;
+      if (
+        !upstreamSignal.aborted &&
+        transientRateLimit &&
+        rateLimitRetryFitsBudget
+      ) {
+        lastAttemptWasUnfinishedContinuation = true;
+        backgroundRateLimitContinuations++;
+        if (
+          !(await hasCompletedSideEffectToolCallInCurrentTurn(
+            opts.threadId,
+            localTurnEvents,
+          ))
+        ) {
+          opts.send({ type: "clear" });
+        }
+        await appendContinuationAndJournal(
+          opts.messages,
+          "rate_limited",
+          opts.threadId,
+          localTurnEvents,
+        );
+        await waitForBackgroundRateLimitCooldown(upstreamSignal);
+        continue;
+      }
       // Resumable transport / gateway interruptions: the LLM call was cut off
       // mid-stream (gateway 45s timeout, socket hang up, function-level
       // timeout that didn't trip our soft timer first). Treat it the same way
@@ -398,6 +554,26 @@ export async function runAgentLoopDirectWithSoftTimeout(
         );
         continue;
       }
+      if (upstreamSignal.aborted) {
+        reportFinalOutcome({
+          state: "canceled",
+          message: "Agent run was aborted.",
+        });
+        throw err;
+      }
+      const candidate = err as { errorCode?: unknown; message?: unknown };
+      reportFinalOutcome({
+        state: "failed",
+        code:
+          typeof candidate?.errorCode === "string" && candidate.errorCode
+            ? candidate.errorCode
+            : "internal_error",
+        retryable: false,
+        message:
+          typeof candidate?.message === "string"
+            ? candidate.message
+            : String(err),
+      });
       throw err;
     } finally {
       clearTimeout(timer);
@@ -431,6 +607,17 @@ export async function runAgentLoopDirectWithSoftTimeout(
       errorCode: RUN_BUDGET_EXHAUSTED_ERROR_CODE,
       recoverable: true,
     });
+    reportFinalOutcome({
+      state: "failed",
+      code: RUN_BUDGET_EXHAUSTED_ERROR_CODE,
+      retryable: false,
+      message: RUN_BUDGET_EXHAUSTED_MESSAGE,
+    });
+  } else if (upstreamSignal.aborted) {
+    reportFinalOutcome({
+      state: "canceled",
+      message: "Agent run was aborted.",
+    });
   }
 
   return usage;

package/corpus/core/src/agent/run-manager.ts

@@ -136,17 +136,6 @@ export const BACKGROUND_SOFT_TIMEOUT_CEILING_MS = 13 * 60_000; // 780_000
 export const DEFAULT_BACKGROUND_RUN_SOFT_TIMEOUT_MS =
   BACKGROUND_SOFT_TIMEOUT_CEILING_MS;
 
-/**
- * Default no-progress window for a run executing inside a proven durable
- * background function. Keep this below the 13-minute soft timeout so a truly
- * wedged background turn can still checkpoint, persist, and continue before
- * the function budget expires, but far above the foreground 150s window so
- * large Design/Plan/Assets generations are not chopped up while the model is
- * legitimately planning a big tool payload.
- */
-export const DEFAULT_BACKGROUND_NO_PROGRESS_TIMEOUT_MS =
-  BACKGROUND_SOFT_TIMEOUT_CEILING_MS - 60_000;
-
 /**
  * AUTHORITATIVE no-progress backstop for a run, enforced by the run manager
  * itself (timer-driven, independent of any layer below).
@@ -176,6 +165,17 @@ export const DEFAULT_BACKGROUND_NO_PROGRESS_TIMEOUT_MS =
  */
 export const RUN_NO_PROGRESS_HARD_TIMEOUT_MS = 150_000;
 
+/**
+ * Default no-progress window for a run executing inside a proven durable
+ * background function. A background worker that is heartbeating but has no
+ * real progress and no tool/A2A work in flight is still wedged; letting that
+ * state outlive the client's follow budget only turns a recoverable stall into
+ * a terminal timeout. In-flight work suspends this backstop, so use the same
+ * server-owned 150s bound as the long foreground regime.
+ */
+export const DEFAULT_BACKGROUND_NO_PROGRESS_TIMEOUT_MS =
+  RUN_NO_PROGRESS_HARD_TIMEOUT_MS;
+
 /**
  * Fraction of the soft timeout a foreground no-progress backstop may consume.
  * The hosted foreground path rides a synchronous serverless function whose
@@ -291,6 +291,15 @@ export const SQL_SUBSCRIPTION_ACTIVE_GRACE_MS = 2_000;
 /** Keep terminal/status probes at the historical cadence to bound DB work. */
 export const SQL_SUBSCRIPTION_STATUS_POLL_MS = 500;
 
+/** Initial retry delay after a transient cross-isolate SQL polling failure. */
+export const SQL_SUBSCRIPTION_RETRY_BASE_MS = 250;
+
+/** Bound consecutive SQL polling failures so a dead subscription fails loud. */
+export const SQL_SUBSCRIPTION_MAX_CONSECUTIVE_FAILURES = 4;
+
+/** Cap retry delay even if the failure bound changes independently. */
+export const SQL_SUBSCRIPTION_RETRY_MAX_MS = 2_000;
+
 export function resolveSqlSubscriptionPollMs(
   now: number,
   activePollUntil: number,
@@ -300,7 +309,18 @@ export function resolveSqlSubscriptionPollMs(
     : SQL_SUBSCRIPTION_IDLE_POLL_MS;
 }
 
+export function resolveSqlSubscriptionRetryMs(
+  consecutiveFailures: number,
+): number {
+  const retryIndex = Math.max(0, Math.floor(consecutiveFailures) - 1);
+  return Math.min(
+    SQL_SUBSCRIPTION_RETRY_MAX_MS,
+    SQL_SUBSCRIPTION_RETRY_BASE_MS * 2 ** retryIndex,
+  );
+}
+
 const PROVIDER_RATE_LIMITED_ERROR_CODE = "provider_rate_limited";
+const PROVIDER_NETWORK_ERROR_CODE = "provider_network_error";
 
 function isPreparingActionActivityEvent(event: AgentChatEvent): boolean {
   if (event.type !== "activity") return false;
@@ -321,9 +341,22 @@ function getRunErrorMessage(err: unknown): string {
   return "Unknown error";
 }
 
-function getEngineRunErrorCode(err: EngineError): string | undefined {
-  if (err.errorCode) return err.errorCode;
-  if (err.statusCode === 429) return PROVIDER_RATE_LIMITED_ERROR_CODE;
+function isProviderConnectionErrorMessage(message: string): boolean {
+  const normalized = message.trim().toLowerCase();
+  return (
+    normalized === "connection error." ||
+    normalized.includes("cannot connect to api:")
+  );
+}
+
+function getRunErrorCode(err: unknown): string | undefined {
+  if (err instanceof EngineError) {
+    if (err.errorCode) return err.errorCode;
+    if (err.statusCode === 429) return PROVIDER_RATE_LIMITED_ERROR_CODE;
+  }
+  if (err instanceof Error && isProviderConnectionErrorMessage(err.message)) {
+    return PROVIDER_NETWORK_ERROR_CODE;
+  }
   return undefined;
 }
 
@@ -333,17 +366,23 @@ function getEngineRunErrorDetails(err: EngineError): string | undefined {
 }
 
 function shouldCaptureRunError(err: unknown): boolean {
-  if (!(err instanceof EngineError)) return true;
-  const errorCode = getEngineRunErrorCode(err);
+  const errorCode = getRunErrorCode(err);
   if (isLlmCredentialError(err, errorCode)) return false;
-  if (err.statusCode === 401 || err.statusCode === 403) return false;
+  if (
+    err instanceof EngineError &&
+    (err.statusCode === 401 || err.statusCode === 403)
+  ) {
+    return false;
+  }
+  if (!(err instanceof Error)) return true;
   if (/^40[13] status code\b/i.test(err.message)) return false;
-  if (err.message.trim().toLowerCase() === "connection error.") return false;
+  if (isProviderConnectionErrorMessage(err.message)) return false;
   if (!errorCode) return true;
   const normalizedCode = errorCode.toLowerCase();
   return (
     !normalizedCode.startsWith("credits-limit") &&
     normalizedCode !== "builder_gateway_network_error" &&
+    normalizedCode !== PROVIDER_NETWORK_ERROR_CODE &&
     normalizedCode !== "provider_rate_limited" &&
     normalizedCode !== "rate_limit_exceeded"
   );
@@ -1042,8 +1081,7 @@ export function startRun(
   let pendingTerminalEvent: RunEvent | null = null;
 
   const captureRunError = (error: unknown, phase: "run" | "completion") => {
-    const errorCode =
-      error instanceof EngineError ? getEngineRunErrorCode(error) : undefined;
+    const errorCode = getRunErrorCode(error);
     captureError(error, {
       route: "/_agent-native/agent-chat",
       tags: {
@@ -1162,8 +1200,7 @@ export function startRun(
         captureRunError(err, "run");
       }
       const errorMessage = getRunErrorMessage(err);
-      const errorCode =
-        err instanceof EngineError ? getEngineRunErrorCode(err) : undefined;
+      const errorCode = getRunErrorCode(err);
       const details =
         err instanceof EngineError ? getEngineRunErrorDetails(err) : undefined;
       send({
@@ -1587,6 +1624,7 @@ function subscribeFromSQL(
       let lastSeq = fromSeq;
       let activePollUntil = 0;
       let lastStatusCheckAt = 0;
+      let consecutivePollFailures = 0;
       const ping = () => {
         try {
           controller.enqueue(encoder.encode(`: ping ${Date.now()}\n\n`));
@@ -1598,6 +1636,49 @@ function subscribeFromSQL(
       ping();
       pingTimer = setInterval(ping, 10_000);
 
+      const closeStream = () => {
+        cancelled = true;
+        if (pollTimer) clearTimeout(pollTimer);
+        if (pingTimer) clearInterval(pingTimer);
+        try {
+          controller.close();
+        } catch {}
+      };
+
+      const failSubscription = (error: unknown) => {
+        const event: AgentChatEvent = {
+          type: "error",
+          error:
+            "The live agent connection could not load persisted run progress.",
+          errorCode: "run_subscription_poll_failed",
+          details:
+            "The agent may still be running. Reconnect to resume from the last persisted event.",
+          recoverable: true,
+        };
+        captureError(error, {
+          route: "/_agent-native/agent-chat/runs/:id/events",
+          tags: {
+            source: "agent-run-manager",
+            phase: "sql-subscription-poll",
+            consecutiveFailures: String(consecutivePollFailures),
+          },
+          extra: {
+            runId,
+            fromSeq,
+            lastSeq,
+            error: getRunErrorMessage(error),
+          },
+        });
+        try {
+          controller.enqueue(
+            encoder.encode(
+              `data: ${JSON.stringify({ ...event, seq: lastSeq })}\n\n`,
+            ),
+          );
+        } catch {}
+        closeStream();
+      };
+
       const poll = async () => {
         if (cancelled) return;
         try {
@@ -1642,6 +1723,7 @@ function subscribeFromSQL(
             const now = Date.now();
             if (now - lastStatusCheckAt < SQL_SUBSCRIPTION_STATUS_POLL_MS) {
               if (!cancelled) {
+                consecutivePollFailures = 0;
                 const pollMs = resolveSqlSubscriptionPollMs(
                   now,
                   activePollUntil,
@@ -1786,34 +1868,28 @@ function subscribeFromSQL(
 
           // Schedule next poll
           if (!cancelled) {
+            consecutivePollFailures = 0;
             const pollMs = resolveSqlSubscriptionPollMs(
               Date.now(),
               activePollUntil,
             );
             pollTimer = setTimeout(poll, pollMs);
           }
-        } catch {
-          // SQL error — close stream
-          try {
-            if (pingTimer) clearInterval(pingTimer);
-            controller.close();
-          } catch {}
+        } catch (error) {
+          consecutivePollFailures += 1;
+          if (
+            consecutivePollFailures >= SQL_SUBSCRIPTION_MAX_CONSECUTIVE_FAILURES
+          ) {
+            failSubscription(error);
+            return;
+          }
+          pollTimer = setTimeout(
+            poll,
+            resolveSqlSubscriptionRetryMs(consecutivePollFailures),
+          );
         }
       };
 
-      // Verify run exists before starting poll
-      try {
-        const run = await getRunById(runId);
-        if (!run) {
-          if (pingTimer) clearInterval(pingTimer);
-          controller.close();
-          return;
-        }
-      } catch {
-        controller.close();
-        return;
-      }
-
       await poll();
     },
     cancel() {

package/corpus/core/src/agent/thread-debug-history.ts

@@ -0,0 +1,86 @@
+import { createHash } from "node:crypto";
+
+export const MAX_THREAD_DEBUG_RUNS = 50;
+
+type UnknownRecord = Record<string, unknown>;
+
+function isRecord(value: unknown): value is UnknownRecord {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+export function hashThreadDebugPrompt(prompt: string): string {
+  return `sha256:${createHash("sha256").update(prompt).digest("hex")}`;
+}
+
+function compactDebugEntry(
+  value: unknown,
+  prompts: Map<string, string>,
+): UnknownRecord | null {
+  if (!isRecord(value)) return null;
+
+  const entry = { ...value };
+  if (typeof entry.systemPrompt === "string") {
+    const promptHash = hashThreadDebugPrompt(entry.systemPrompt);
+    prompts.set(promptHash, entry.systemPrompt);
+    entry.systemPromptHash = promptHash;
+    delete entry.systemPrompt;
+  }
+  return entry;
+}
+
+/**
+ * Append one run's diagnostics while keeping repeated system prompts out of
+ * every history entry. Existing full-prompt history is migrated on write.
+ */
+export function appendThreadDebugHistory(
+  threadData: UnknownRecord,
+  currentDebug: UnknownRecord,
+): UnknownRecord {
+  const promptCandidates = new Map<string, string>();
+  if (isRecord(threadData._debugPrompts)) {
+    for (const [hash, prompt] of Object.entries(threadData._debugPrompts)) {
+      if (typeof prompt === "string") promptCandidates.set(hash, prompt);
+    }
+  }
+
+  const previousRuns = Array.isArray(threadData._debugRuns)
+    ? threadData._debugRuns
+        .map((entry) => compactDebugEntry(entry, promptCandidates))
+        .filter((entry): entry is UnknownRecord => entry !== null)
+    : [];
+  const compactCurrent = compactDebugEntry(currentDebug, promptCandidates) ?? {
+    ...currentDebug,
+  };
+  const debugRuns = [...previousRuns, compactCurrent].slice(
+    -MAX_THREAD_DEBUG_RUNS,
+  );
+
+  const referencedHashes = new Set<string>();
+  for (const entry of debugRuns) {
+    if (typeof entry.systemPromptHash === "string") {
+      referencedHashes.add(entry.systemPromptHash);
+    }
+  }
+  if (typeof compactCurrent.systemPromptHash === "string") {
+    referencedHashes.add(compactCurrent.systemPromptHash);
+  }
+
+  const debugPrompts = Object.fromEntries(
+    [...referencedHashes].sort().flatMap((hash) => {
+      const prompt = promptCandidates.get(hash);
+      return prompt === undefined ? [] : [[hash, prompt]];
+    }),
+  );
+
+  const result: UnknownRecord = {
+    ...threadData,
+    _debug: compactCurrent,
+    _debugRuns: debugRuns,
+  };
+  if (Object.keys(debugPrompts).length > 0) {
+    result._debugPrompts = debugPrompts;
+  } else {
+    delete result._debugPrompts;
+  }
+  return result;
+}

package/corpus/core/src/agent/types.ts

@@ -276,8 +276,10 @@ export type AgentChatEvent =
   | {
       type: "agent_call";
       agent: string;
-      status: "start" | "done" | "error";
+      status: "start" | "done" | "pending" | "error";
       agentCallId?: string;
+      /** Remote task to resume when status is pending/input-required. */
+      taskId?: string;
       durationMs?: number;
     }
   | {

package/corpus/core/src/cli/create.ts

@@ -708,6 +708,14 @@ export async function addAppToWorkspace(
   }
 
   const hasDispatch = installed.includes("dispatch");
+  const availableTemplates = coreTemplates().filter(
+    (template) => !installed.includes(template.name),
+  );
+  if (availableTemplates.length === 0) {
+    clack.cancel("All available apps are already installed.");
+    process.exit(0);
+  }
+
   const templates = await promptTemplatePicker(preselected, clack, {
     excludeNames: installed,
     message: "Which apps do you want to add?",
@@ -716,7 +724,9 @@ export async function addAppToWorkspace(
     recommendedNames: hasDispatch ? [] : ["dispatch"],
   });
   if (templates.length === 0) {
-    clack.cancel("No apps selected. Cancelled.");
+    clack.cancel(
+      "No apps selected. Press space to select an app, then press enter to continue.",
+    );
     process.exit(0);
   }
 

package/corpus/core/src/cli/templates-meta.ts

@@ -99,7 +99,7 @@ export const TEMPLATES: TemplateMeta[] = [
     devPort: 8086,
     prodUrl: "https://slides.agent-native.com",
     defaultMode: "prod",
-    requiredPackages: ["pinpoint", "creative-context"],
+    requiredPackages: ["creative-context"],
     core: true,
   },
   {
@@ -199,7 +199,7 @@ export const TEMPLATES: TemplateMeta[] = [
     devPort: 8099,
     prodUrl: "https://design.agent-native.com",
     defaultMode: "prod",
-    requiredPackages: ["pinpoint", "embedding", "creative-context"],
+    requiredPackages: ["embedding", "creative-context"],
     core: true,
   },
   {