@agent-native/core 0.122.3 → 0.123.0

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

@@ -388,11 +388,15 @@ export type ContinuationReason = (typeof CONTINUATION_REASONS)[number];
 
 /**
  * True when an `agent_runs.terminal_reason` marks a CHUNK boundary rather than
- * the end of the turn. Both writers (`terminalReasonForRun` in run-manager and
- * `markBackgroundContinuationChunkTerminal` in production-agent) record
- * status='completed' with one of these while a chained successor run carries the
- * turn on, so such a row must never be reported to a client as a plain `done`.
- * Mirrored client-side by `BACKGROUND_CONTINUATION_TERMINAL_REASONS`.
+ * the end of the turn — i.e. the run was TRUNCATED at a budget/timeout/loop/
+ * no-progress boundary and did not finish what it was asked to do.
+ *
+ * This is the single predicate for "the reason says this run did not finish".
+ * `setRunTerminalReason` (run-store) uses it to record `status='truncated'`
+ * instead of `'completed'`, so consumers should read the status rather than
+ * re-deriving truncation from the reason. It stays exported for legacy
+ * `status='completed'` rows written before the `truncated` status existed,
+ * which linger for one retention window.
  */
 export function isContinuationTerminalReason(reason: unknown): boolean {
   return (
@@ -406,4 +410,17 @@ export interface RunEvent {
   event: AgentChatEvent;
 }
 
-export type RunStatus = "running" | "completed" | "errored" | "aborted";
+/**
+ * `agent_runs.status`. `completed` means the turn actually finished (terminal
+ * reason `done`); `truncated` means it stopped at a budget/timeout/loop/
+ * no-progress boundary with work still outstanding. Truncations were previously
+ * filed as `completed`, which made them invisible to every success-rate query
+ * and — because retention keys off status — deleted them a week before the
+ * genuine failures they belong with.
+ */
+export type RunStatus =
+  | "running"
+  | "completed"
+  | "truncated"
+  | "errored"
+  | "aborted";

package/corpus/core/src/application-state/script-helpers.ts

@@ -12,7 +12,10 @@
  * context) should fall through to the env var.
  */
 
-import { getRequestRunContext } from "../server/request-context.js";
+import {
+  getAmbientUserEmail,
+  getRequestRunContext,
+} from "../server/request-context.js";
 import {
   appStateGet,
   appStatePut,
@@ -42,7 +45,7 @@ async function resolveSessionId(): Promise<string> {
     // request-context not available — fall through to env var
   }
 
-  const email = process.env.AGENT_USER_EMAIL;
+  const email = getAmbientUserEmail();
   if (email) return email;
 
   throw new Error(

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

@@ -1,8 +1,17 @@
-import { discoverAgents } from "../server/agent-discovery.js";
+import {
+  formatCapabilityDetail,
+  formatCapabilitySummary,
+  loadAllCapabilities,
+  loadCapabilities,
+  MAX_APPS,
+} from "../server/agent-capabilities.js";
+import { discoverAgents, findAgent } from "../server/agent-discovery.js";
 
 export interface ParsedAgentsArgs {
   command: "list" | "help";
   selfAppId?: string;
+  app?: string;
+  capabilities: boolean;
   json: boolean;
   errors: string[];
 }
@@ -15,6 +24,7 @@ export interface AgentsCliIo {
 export function parseAgentsArgs(args: string[]): ParsedAgentsArgs {
   const parsed: ParsedAgentsArgs = {
     command: "list",
+    capabilities: false,
     json: false,
     errors: [],
   };
@@ -39,6 +49,24 @@ export function parseAgentsArgs(args: string[]): ParsedAgentsArgs {
       parsed.json = true;
       continue;
     }
+    if (name === "capabilities" || name === "what-can-they-do") {
+      parsed.capabilities = true;
+      continue;
+    }
+    if (name === "app") {
+      const value =
+        inlineValue ??
+        (args[i + 1] !== undefined && !args[i + 1].startsWith("--")
+          ? args[++i]
+          : undefined);
+      if (!value) {
+        parsed.errors.push(`Missing value for --${name}`);
+      } else {
+        parsed.app = value;
+        parsed.capabilities = true;
+      }
+      continue;
+    }
     if (name === "self" || name === "self-app-id") {
       const value =
         inlineValue ??
@@ -82,7 +110,47 @@ export async function runAgents(
     return 1;
   }
 
+  if (parsed.app) {
+    const agent = await findAgent(parsed.app, parsed.selfAppId);
+    if (!agent) {
+      const available = (await discoverAgents(parsed.selfAppId))
+        .map((peer) => peer.id)
+        .join(", ");
+      stderr(
+        `No connected agent "${parsed.app}". Available: ${available || "(none)"}`,
+      );
+      return 1;
+    }
+    const peer = await loadCapabilities(agent);
+    stdout(
+      parsed.json
+        ? JSON.stringify(toCapabilityJson(peer), null, 2)
+        : formatCapabilityDetail(peer, callHint),
+    );
+    return 0;
+  }
+
   const agents = await discoverAgents(parsed.selfAppId);
+
+  if (parsed.capabilities) {
+    if (agents.length === 0) {
+      stdout("No connected agents found.");
+      return 0;
+    }
+    const shown = agents.slice(0, MAX_APPS);
+    const peers = await loadAllCapabilities(shown);
+    stdout(
+      parsed.json
+        ? JSON.stringify({ agents: peers.map(toCapabilityJson) }, null, 2)
+        : formatCapabilitySummary(
+            peers,
+            agents.length - shown.length,
+            (appId) => `run agent-native agents list --app ${appId}`,
+          ),
+    );
+    return 0;
+  }
+
   if (parsed.json) {
     stdout(JSON.stringify({ agents }, null, 2));
     return 0;

package/corpus/core/src/cli/app-skill.ts

@@ -681,7 +681,7 @@ export function exportedSkillContentHash(
     `mcp:${mcpServerNames(manifest).join(",")}:${manifest.hosted.mcpUrl}`,
   );
   return createHash("sha256")
-    .update(parts.join("\n\n"))
+    .update(parts.join("\n\u0000\n"))
     .digest("hex")
     .slice(0, 12);
 }

package/corpus/core/src/cli/code-agent-executor.ts

@@ -50,7 +50,11 @@ import {
   readAgentsBundleFromFs,
   generateDevelopmentSkillsPromptBlock,
 } from "../server/agents-bundle.js";
-import { runWithRequestContext } from "../server/request-context.js";
+import {
+  getAmbientOrgId,
+  getAmbientUserEmail,
+  runWithRequestContext,
+} from "../server/request-context.js";
 import {
   isReasoningEffort,
   type ReasoningEffort,
@@ -1157,8 +1161,8 @@ function runWithOptionalCodeAgentRequestContext<T>(
   const userEmail =
     metadataString(run, "ownerEmail") ??
     metadataString(run, "userEmail") ??
-    process.env.AGENT_USER_EMAIL;
-  const orgId = metadataString(run, "orgId") ?? process.env.AGENT_ORG_ID;
+    getAmbientUserEmail();
+  const orgId = metadataString(run, "orgId") ?? getAmbientOrgId();
   if (!userEmail && !orgId) return fn();
   return runWithRequestContext({ userEmail, orgId }, fn);
 }

package/corpus/core/src/cli/design-connect.ts

@@ -1108,6 +1108,27 @@ function resolvePreviewSnapshotUrl(
   return parsed.toString();
 }
 
+/**
+ * Remove a literal `previewToken` query pair via raw string splitting instead
+ * of `URLSearchParams`. `URLSearchParams` re-serializes the ENTIRE query
+ * string on mutation, turning a valueless pair like `?url` into `?url=` even
+ * when `previewToken` was never present — which silently changes which
+ * codepath Vite's dev server routes the request to (e.g. `?url` vs `?url=`
+ * resolve to different response bodies). Returns `search` untouched whenever
+ * `previewToken` is absent, so every other proxied query string reaches the
+ * dev server byte-for-byte.
+ */
+function stripPreviewTokenQueryParam(search: string): string {
+  if (!search.includes("previewToken")) return search;
+  const raw = search.startsWith("?") ? search.slice(1) : search;
+  const kept = raw
+    .split("&")
+    .filter(
+      (pair) => pair !== "previewToken" && !pair.startsWith("previewToken="),
+    );
+  return kept.length > 0 ? `?${kept.join("&")}` : "";
+}
+
 function resolvePreviewProxyUrl(
   devServerUrl: string,
   requestUrl: string | undefined,
@@ -2227,7 +2248,23 @@ export async function startDesignConnectBridge(
 
       // ── Read-only preview routes (preview token required) ────────────────
 
-      if (pathname === "/" || pathname === "/manifest.json") {
+      // The injected <base href> re-points the proxied app's own
+      // <link rel="manifest" href="/manifest.json"> at the bridge, which
+      // would otherwise collide with the bridge's own control-plane manifest
+      // below. Browsers tag that fetch with Sec-Fetch-Dest: manifest (a
+      // request-metadata header Node's fetch never sends), so existing
+      // control-plane callers — the Design app and `fetchRunningBridgeManifest`
+      // (used by `design connect --json` / daemon self-detection) — keep
+      // hitting the bridge manifest unchanged, while the app's own manifest
+      // request falls through to the ordinary authenticated proxy below.
+      const isProxiedAppManifestRequest =
+        (req.method === "GET" || req.method === "HEAD") &&
+        pathname === "/manifest.json" &&
+        readHeader(req, "sec-fetch-dest") === "manifest";
+      if (
+        !isProxiedAppManifestRequest &&
+        (pathname === "/" || pathname === "/manifest.json")
+      ) {
         if (rejectInvalidPreviewToken()) return;
         sendJson(res, 200, manifest as unknown as Record<string, unknown>);
         return;
@@ -2676,7 +2713,13 @@ export async function startDesignConnectBridge(
         req.method &&
         ["GET", "HEAD", "POST", "PUT", "PATCH", "DELETE"].includes(req.method)
       ) {
-        if (!previewTokenValid) {
+        // The browser's own manifest-link fetch algorithm omits credentials
+        // and custom headers by spec default, so it structurally cannot carry
+        // a previewToken. That is consistent with the proxied dev server,
+        // which already serves this exact path with no auth of its own — so
+        // this narrow, unspoofable (Sec-Fetch-Dest is a forbidden header,
+        // unsettable from page JS) case is exempted from the token gate.
+        if (!previewTokenValid && !isProxiedAppManifestRequest) {
           sendJson(res, 401, {
             ok: false,
             error: "invalid or missing preview token",
@@ -2686,10 +2729,9 @@ export async function startDesignConnectBridge(
         void (async () => {
           try {
             const proxyRequestUrl = new URL(req.url ?? "/", manifest.bridgeUrl);
-            proxyRequestUrl.searchParams.delete("previewToken");
             const targetUrl = resolvePreviewProxyUrl(
               manifest.devServerUrl,
-              `${proxyRequestUrl.pathname}${proxyRequestUrl.search}`,
+              `${proxyRequestUrl.pathname}${stripPreviewTokenQueryParam(proxyRequestUrl.search)}`,
             );
             const method = req.method ?? "GET";
             const requestBody =
@@ -2775,13 +2817,12 @@ export async function startDesignConnectBridge(
       );
       return;
     }
-    requestUrl.searchParams.delete("previewToken");
     let targetUrl: URL;
     try {
       targetUrl = new URL(
         resolvePreviewProxyUrl(
           manifest.devServerUrl,
-          `${requestUrl.pathname}${requestUrl.search}`,
+          `${requestUrl.pathname}${stripPreviewTokenQueryParam(requestUrl.search)}`,
         ),
       );
     } catch {
@@ -3088,27 +3129,60 @@ async function startDetachedDesignBridge(
   }
 
   const invocation = resolveCurrentCliInvocation(argv);
+  // A detached bridge that dies — port already taken, crash on boot, killed
+  // with its process group — used to do so with stdio "ignore", so the failure
+  // left no trace anywhere and Design silently fell back to non-editable
+  // iframes. Keep its output on disk so the death is diagnosable.
+  const logPath = await createDaemonLogPath(manifest.rootPath);
+  const logFd = await fs.open(logPath, "a");
   const child = spawn(invocation.command, invocation.args, {
     cwd: process.cwd(),
     detached: true,
     env: process.env,
-    stdio: "ignore",
+    stdio: ["ignore", logFd.fd, logFd.fd],
     shell: process.platform === "win32",
   });
   child.unref();
 
   if (await waitForBridgeHealth(manifest.bridgeUrl)) {
+    await logFd.close();
     console.error(`Design localhost bridge running at ${manifest.bridgeUrl}`);
+    console.error(`Bridge log: ${logPath}`);
     console.log(JSON.stringify(manifest, null, 2));
     return 0;
   }
 
+  const tail = await readDaemonLogTail(logPath);
+  await logFd.close();
   console.error(
-    `Timed out waiting for detached Design bridge at ${manifest.bridgeUrl}`,
+    [
+      `Timed out waiting for detached Design bridge at ${manifest.bridgeUrl}`,
+      `Bridge log: ${logPath}`,
+      tail ? `Last output:\n${tail}` : "The bridge produced no output.",
+    ].join("\n"),
   );
   return 1;
 }
 
+async function createDaemonLogPath(rootPath: string): Promise<string> {
+  const dir = path.join(rootPath, ".agent-native");
+  await fs.mkdir(dir, { recursive: true });
+  return path.join(dir, "design-connect.log");
+}
+
+async function readDaemonLogTail(
+  logPath: string,
+  maxBytes = 4000,
+): Promise<string> {
+  try {
+    const contents = await fs.readFile(logPath, "utf8");
+    return contents.slice(-maxBytes).trim();
+  } catch {
+    // An unreadable log must not mask the timeout the caller is reporting.
+    return "";
+  }
+}
+
 export async function runDesign(argv: string[]) {
   const subcommand = argv[0];
   if (subcommand !== "connect") {

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

@@ -9,6 +9,7 @@ import { fileURLToPath } from "url";
 import * as Sentry from "@sentry/node";
 
 import { resolveDeployPostBuildInvocation } from "./deploy-build.js";
+import { shouldTrackCliRun } from "./telemetry-routing.js";
 import { createCliTelemetry } from "./telemetry.js";
 
 // Resolve version once at module scope — used by both --version and --help
@@ -604,7 +605,7 @@ function runBuildStep(
   });
 }
 
-trackCli("cli.run");
+if (shouldTrackCliRun(command, args)) trackCli("cli.run");
 
 switch (command) {
   case "dev": {

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

@@ -92,6 +92,15 @@ export interface ScreenMemoryStoreResolutionOptions {
   homeDir?: string;
 }
 
+function existingScreenMemoryStore(candidate: string): string | undefined {
+  const resolved = path.resolve(candidate);
+  try {
+    return fs.statSync(resolved).isDirectory() ? resolved : undefined;
+  } catch {
+    return undefined;
+  }
+}
+
 /**
  * Resolve the active Clips store without asking people to find an app-data
  * path. Environment overrides remain the unambiguous escape hatch; otherwise
@@ -100,11 +109,12 @@ export interface ScreenMemoryStoreResolutionOptions {
 export function resolveScreenMemoryStoreDir(
   options: ScreenMemoryStoreResolutionOptions = {},
 ): string | undefined {
-  if (options.explicitDir) return path.resolve(options.explicitDir);
+  if (options.explicitDir)
+    return existingScreenMemoryStore(options.explicitDir);
   const env = options.env ?? process.env;
   const override =
     env.CLIPS_SCREEN_MEMORY_DIR || env.AGENT_NATIVE_SCREEN_MEMORY_DIR;
-  if (override) return path.resolve(override);
+  if (override) return existingScreenMemoryStore(override);
 
   const platform = options.platform ?? process.platform;
   const home = options.homeDir ?? os.homedir();
@@ -116,7 +126,7 @@ export function resolveScreenMemoryStoreDir(
         : env.XDG_DATA_HOME || path.join(home, ".local", "share");
   return ["com.clips.tray", "com.clips.tray.alpha"]
     .map((bundleId) => path.join(appDataRoot, bundleId, "screen-memory"))
-    .filter((candidate) => fs.existsSync(candidate))
+    .filter((candidate) => existingScreenMemoryStore(candidate))
     .map((candidate) => ({
       candidate,
       modifiedAt: Math.max(