@agent-native/core 0.148.0 → 0.149.0

package/dist/agent/engine/registry.js

@@ -401,20 +401,26 @@ function shouldTraceEngineDetection() {
  * `/builder/status` resolves them via the same request org context, and the
  * chat engine picker must not disagree with that card.
  */
-export async function detectEngineFromUserSecrets() {
+export async function detectEngineFromUserSecrets(identity) {
     const traceLookup = shouldTraceEngineDetection();
-    let email;
-    let orgId;
+    let email = identity?.userEmail?.trim() || undefined;
+    let orgId = identity?.orgId;
     try {
         const { getRequestUserEmail, getRequestOrgId } = await import("../../server/request-context.js");
-        email = getRequestUserEmail();
-        orgId = getRequestOrgId();
+        email ??= getRequestUserEmail();
+        if (orgId === undefined)
+            orgId = getRequestOrgId();
     }
     catch {
+        if (!email) {
+            if (traceLookup) {
+                console.log(`[engine-detect] result=null reason=no-request-context email=(unknown) orgId=(unknown)`);
+            }
+            return null;
+        }
         if (traceLookup) {
-            console.log(`[engine-detect] result=null reason=no-request-context email=(unknown) orgId=(unknown)`);
+            console.log(`[engine-detect] request context unavailable; using explicit identity email=${email} orgId=${orgId ?? "(none)"}`);
         }
-        return null;
     }
     if (!email) {
         if (traceLookup) {
@@ -427,8 +433,9 @@ export async function detectEngineFromUserSecrets() {
             return false;
         if (entry.requiredEnvVars.length === 0)
             return false;
-        if (entry.name === "builder")
-            return hasUsableBuilderConnection();
+        if (entry.name === "builder") {
+            return hasUsableBuilderConnection(identity);
+        }
         for (const key of entry.requiredEnvVars) {
             // A throw here means the credential store could not be read. Let it
             // propagate: swallowing it reports "no provider connected" to a user
@@ -520,8 +527,8 @@ async function resolveProviderBaseUrl(envVar) {
  * keeps that distinction instead of reporting "connect a provider" to a user
  * whose org-shared keys exist but were unreadable.
  */
-async function hasUsableBuilderConnection() {
-    const creds = await resolveBuilderCredentialsDetailed();
+async function hasUsableBuilderConnection(identity) {
+    const creds = await resolveBuilderCredentialsDetailed(identity);
     assertCredentialStoreReadable(creds);
     return Boolean(creds.privateKey && creds.publicKey);
 }
@@ -567,7 +574,7 @@ async function apiKeyBelongsToDifferentProvider(apiKey, selectedEntry) {
     }
     return false;
 }
-async function engineCreateConfigForEntry(entry, apiKey, extra, preferResolvedCredential = false, apiKeyEnvVar) {
+async function engineCreateConfigForEntry(entry, apiKey, extra, preferResolvedCredential = false, apiKeyEnvVar, credentialIdentity) {
     const safeExtra = { ...(extra ?? {}) };
     let matchingApiKey = apiKey;
     // A declared provenance settles the question without inspecting values: a
@@ -632,6 +639,25 @@ async function engineCreateConfigForEntry(entry, apiKey, extra, preferResolvedCr
                 safeExtra.baseUrl = baseUrl;
         }
     }
+    if (entry.name === "builder" &&
+        (credentialIdentity !== undefined || safeExtra.credentials == null)) {
+        // Builder authentication is a private/public key pair, not the single
+        // provider key carried by ResolveEngineConfig. Capture the scoped pair
+        // while the verified request identity is available so a later stream or
+        // detached run cannot resolve credentials from the wrong ambient context.
+        const creds = await resolveBuilderCredentialsDetailed(credentialIdentity);
+        assertCredentialStoreReadable(creds);
+        if (credentialIdentity !== undefined ||
+            creds.source !== null ||
+            creds.lookupFailed) {
+            safeExtra.credentials = {
+                privateKey: creds.privateKey,
+                publicKey: creds.publicKey,
+                userId: creds.userId,
+                orgName: creds.orgName,
+            };
+        }
+    }
     return engineCreateConfig(entry, matchingApiKey, safeExtra);
 }
 /**
@@ -661,15 +687,16 @@ export function isStoredEngineUsable(stored, entry) {
  * deploy env vars; this async helper is what request-time routes should use
  * when deciding whether a stored engine can actually run for the current user.
  */
-export async function isStoredEngineUsableForRequest(stored, entry) {
+export async function isStoredEngineUsableForRequest(stored, entry, options = {}) {
     if (!isAgentEnginePackageInstalled(entry))
         return false;
     if (isAgentEngineSettingConfigured(stored))
         return true;
     if (entry.requiredEnvVars.length === 0)
         return true;
-    if (entry.name === "builder")
-        return hasUsableBuilderConnection();
+    if (entry.name === "builder") {
+        return hasUsableBuilderConnection(options.credentialIdentity);
+    }
     for (const key of entry.requiredEnvVars) {
         if (!(await resolveUsableProviderSecret(key)))
             return false;
@@ -692,8 +719,9 @@ export async function isResolvedEngineUsableForRequest(engine, options = {}) {
         return false;
     if (entry.requiredEnvVars.length === 0)
         return true;
-    if (entry.name === "builder")
-        return hasUsableBuilderConnection();
+    if (entry.name === "builder") {
+        return hasUsableBuilderConnection(options.credentialIdentity);
+    }
     if (options.apiKey?.trim()) {
         const key = entry.requiredEnvVars[0];
         if (!key)
@@ -776,7 +804,7 @@ export async function getConfiguredEngineNameForRequest(options = {}) {
  * 7. Default "anthropic" (requires ANTHROPIC_API_KEY)
  */
 export async function resolveEngine(config) {
-    const { engineOption, apiKey, apiKeyEnvVar, model: _model, appId } = config;
+    const { engineOption, apiKey, apiKeyEnvVar, model: _model, appId, credentialIdentity, } = config;
     // 1. Explicit instance passed directly
     if (engineOption &&
         typeof engineOption === "object" &&
@@ -792,7 +820,7 @@ export async function resolveEngine(config) {
         if (!entry)
             throw new Error(`[agent-engine] Unknown engine: "${name}". Registered: ${[..._registry.keys()].join(", ")}`);
         assertAgentEnginePackageInstalled(entry);
-        return entry.create(await engineCreateConfigForEntry(entry, apiKey, engineConfig, false, apiKeyEnvVar));
+        return entry.create(await engineCreateConfigForEntry(entry, apiKey, engineConfig, false, apiKeyEnvVar, credentialIdentity));
     }
     // 3. Explicit string name from options
     if (typeof engineOption === "string") {
@@ -800,7 +828,7 @@ export async function resolveEngine(config) {
         if (!entry)
             throw new Error(`[agent-engine] Unknown engine: "${engineOption}". Registered: ${[..._registry.keys()].join(", ")}`);
         assertAgentEnginePackageInstalled(entry);
-        return entry.create(await engineCreateConfigForEntry(entry, apiKey, undefined, false, apiKeyEnvVar));
+        return entry.create(await engineCreateConfigForEntry(entry, apiKey, undefined, false, apiKeyEnvVar, credentialIdentity));
     }
     // 4. Env var — explicit engine name override
     const envEngine = process.env.AGENT_ENGINE;
@@ -808,14 +836,17 @@ export async function resolveEngine(config) {
         const entry = _registry.get(envEngine);
         if (entry) {
             assertAgentEnginePackageInstalled(entry);
-            return entry.create(await engineCreateConfigForEntry(entry, apiKey, undefined, true, apiKeyEnvVar));
+            return entry.create(await engineCreateConfigForEntry(entry, apiKey, undefined, true, apiKeyEnvVar, credentialIdentity));
         }
     }
     const appDefault = await getAgentAppModelDefaultForCurrentRequest(appId);
     if (appDefault?.engine) {
         const entry = _registry.get(appDefault.engine);
-        if (entry && (await isStoredEngineUsableForRequest(appDefault, entry))) {
-            return entry.create(await engineCreateConfigForEntry(entry, apiKey, undefined, true, apiKeyEnvVar));
+        if (entry &&
+            (await isStoredEngineUsableForRequest(appDefault, entry, {
+                credentialIdentity,
+            }))) {
+            return entry.create(await engineCreateConfigForEntry(entry, apiKey, undefined, true, apiKeyEnvVar, credentialIdentity));
         }
     }
     let stored = null;
@@ -829,7 +860,7 @@ export async function resolveEngine(config) {
     // (Builder OAuth callback + "paste your own key" settings flow write here,
     // not env). Stored/app defaults are checked first so an explicit provider
     // selection can override a connected Builder account.
-    const detectedFromUser = await detectEngineFromUserSecrets();
+    const detectedFromUser = await detectEngineFromUserSecrets(credentialIdentity);
     // 6. Settings store — only when the stored row's API key is reachable.
     // This explicit selection beats automatic Builder detection so users can
     // switch away from Builder credits by saving/applying their own provider key.
@@ -838,26 +869,29 @@ export async function resolveEngine(config) {
     const storedConfig = storedRaw?.config;
     if (storedRaw && typeof storedEngine === "string") {
         const entry = _registry.get(storedEngine);
-        if (entry && (await isStoredEngineUsableForRequest(storedRaw, entry))) {
-            return entry.create(await engineCreateConfigForEntry(entry, apiKey, stripInlineApiKeyConfig(storedConfig), true, apiKeyEnvVar));
+        if (entry &&
+            (await isStoredEngineUsableForRequest(storedRaw, entry, {
+                credentialIdentity,
+            }))) {
+            return entry.create(await engineCreateConfigForEntry(entry, apiKey, stripInlineApiKeyConfig(storedConfig), true, apiKeyEnvVar, credentialIdentity));
         }
     }
     if (detectedFromUser) {
-        return detectedFromUser.create(await engineCreateConfigForEntry(detectedFromUser, apiKey, undefined, true, apiKeyEnvVar));
+        return detectedFromUser.create(await engineCreateConfigForEntry(detectedFromUser, apiKey, undefined, true, apiKeyEnvVar, credentialIdentity));
     }
     // 8. Auto-detect from any provider env var — so just dropping a key in
     // .env works without also setting AGENT_ENGINE. Skip keys with active
     // auth-failure markers so a rejected deploy key cannot permanently win.
     const detected = await detectEngineFromEnvForRequest();
     if (detected) {
-        return detected.create(await engineCreateConfigForEntry(detected, apiKey, undefined, true, apiKeyEnvVar));
+        return detected.create(await engineCreateConfigForEntry(detected, apiKey, undefined, true, apiKeyEnvVar, credentialIdentity));
     }
     // 9. Default: anthropic
     const anthropicEntry = _registry.get("anthropic");
     if (!anthropicEntry) {
         throw new Error("[agent-engine] Default Anthropic engine is not registered. Did builtin.ts fail to load?");
     }
-    return anthropicEntry.create(await engineCreateConfigForEntry(anthropicEntry, apiKey, undefined, true, apiKeyEnvVar));
+    return anthropicEntry.create(await engineCreateConfigForEntry(anthropicEntry, apiKey, undefined, true, apiKeyEnvVar, credentialIdentity));
 }
 /**
  * Read the user-selected model for an engine from the `agent-engine` setting.

package/dist/agent/production-agent.js

@@ -5978,6 +5978,10 @@ export function createProductionAgentHandler(options) {
         // DIAGNOSTIC-ONLY: bracket engine resolution (Builder credential / app-default
         // settings reads inside resolveEngine).
         workerStep("engine_start");
+        const credentialIdentity = {
+            userEmail: ownerEmail,
+            orgId: getRequestOrgId(),
+        };
         let engine;
         try {
             engine = await resolveEngine({
@@ -5986,6 +5990,7 @@ export function createProductionAgentHandler(options) {
                 apiKeyEnvVar: effectiveApiKeyEnvVar,
                 model: configuredModel,
                 appId: options.appId,
+                credentialIdentity,
             });
         }
         catch {
@@ -5993,6 +5998,7 @@ export function createProductionAgentHandler(options) {
                 apiKey: effectiveApiKey,
                 apiKeyEnvVar: effectiveApiKeyEnvVar,
                 appId: options.appId,
+                credentialIdentity,
             });
         }
         // DIAGNOSTIC-ONLY: engine resolution finished.
@@ -6056,6 +6062,7 @@ export function createProductionAgentHandler(options) {
         console.log(`[agent-chat] resolved engine=${engine.name} model=${effectiveModel} requestModel=${requestModel ?? "(none)"} requestEngine=${requestEngine ?? "(none)"} modelSource=${modelSelectionSource} turnId=${requestTurnId ?? "(none)"}`);
         if (!(await isResolvedEngineUsableForRequest(engine, {
             apiKey: effectiveApiKey,
+            credentialIdentity,
         }))) {
             setResponseHeader(event, "Content-Type", "text/event-stream");
             setResponseHeader(event, "Cache-Control", "no-cache");

package/dist/agent/run-manager.d.ts

@@ -164,10 +164,11 @@ export declare const DEFAULT_COMPLETED_RUN_RETENTION_MS: number;
  */
 export declare const DEFAULT_ERRORED_RUN_RETENTION_MS: number;
 /**
- * How recently a terminal run must have started for `/runs/active` to surface
- * it. Reconnect after this window won't replay the run — typical real-world
- * disconnects resolve in seconds, so 10 minutes is generous while keeping us
- * from resurrecting ancient turns when the user reopens an old thread.
+ * How recently a terminal run must have completed for `/runs/active` to surface
+ * it. This must outlast the durable browser watchdog (13 minutes) and the
+ * in-flight reader watchdog (15 minutes) so a quiet event stream can detach
+ * and still replay a run that completed while the browser was waiting.
+ * Reconnect after this window won't replay the run.
  */
 export declare const TERMINAL_RUN_RECONNECT_WINDOW_MS: number;
 /** Fast poll cadence while a SQL-backed SSE subscription is actively receiving rows. */

package/dist/agent/run-manager.js

@@ -180,12 +180,13 @@ export const DEFAULT_COMPLETED_RUN_RETENTION_MS = 24 * 60 * 60 * 1000;
  */
 export const DEFAULT_ERRORED_RUN_RETENTION_MS = 7 * 24 * 60 * 60 * 1000;
 /**
- * How recently a terminal run must have started for `/runs/active` to surface
- * it. Reconnect after this window won't replay the run — typical real-world
- * disconnects resolve in seconds, so 10 minutes is generous while keeping us
- * from resurrecting ancient turns when the user reopens an old thread.
+ * How recently a terminal run must have completed for `/runs/active` to surface
+ * it. This must outlast the durable browser watchdog (13 minutes) and the
+ * in-flight reader watchdog (15 minutes) so a quiet event stream can detach
+ * and still replay a run that completed while the browser was waiting.
+ * Reconnect after this window won't replay the run.
  */
-export const TERMINAL_RUN_RECONNECT_WINDOW_MS = 10 * 60 * 1000;
+export const TERMINAL_RUN_RECONNECT_WINDOW_MS = 20 * 60 * 1000;
 /** Fast poll cadence while a SQL-backed SSE subscription is actively receiving rows. */
 export const SQL_SUBSCRIPTION_ACTIVE_POLL_MS = 125;
 /** Baseline SQL-backed SSE poll cadence when the run is idle. */

package/dist/cli/claude-code-participant.d.ts

@@ -42,6 +42,7 @@ export interface RunClaudeCodeParticipantOptions {
     prompt: string;
     cwd: string;
     model?: string;
+    effort?: string;
     session?: ClaudeCodeParticipantSession;
     /** Either the fixed CLI name or an absolute executable path for packaged apps. */
     command?: string;
@@ -71,6 +72,6 @@ export interface ClaudeCodeSubscriptionStatusOptions {
 }
 export declare function readClaudeCodeSubscriptionStatus(options?: ClaudeCodeSubscriptionStatusOptions): Promise<ClaudeCodeSubscriptionStatus>;
 export declare function runClaudeCodeParticipant(options: RunClaudeCodeParticipantOptions): Promise<ClaudeCodeParticipantResult>;
-export declare function buildClaudeCodeParticipantArgs(options: Pick<RunClaudeCodeParticipantOptions, "role" | "model" | "session">): string[];
+export declare function buildClaudeCodeParticipantArgs(options: Pick<RunClaudeCodeParticipantOptions, "role" | "model" | "effort" | "session">): string[];
 export declare const CLAUDE_CODE_PARTICIPANT_TESTED_VERSION = "2.1.208";
 export {};

package/dist/cli/claude-code-participant.js

@@ -102,6 +102,9 @@ export function buildClaudeCodeParticipantArgs(options) {
     const model = readString(options.model);
     if (model)
         args.push("--model", model);
+    const effort = normalizeClaudeEffort(options.effort);
+    if (effort)
+        args.push("--effort", effort);
     const sessionId = readString(options.session?.sessionId);
     const resumeSessionId = readString(options.session?.resumeSessionId);
     if (sessionId)
@@ -112,6 +115,22 @@ export function buildClaudeCodeParticipantArgs(options) {
         args.push("--no-session-persistence");
     return args;
 }
+function normalizeClaudeEffort(effort) {
+    switch (effort) {
+        case "low":
+        case "medium":
+        case "high":
+        case "max":
+            return effort;
+        case "minimal":
+        case "none":
+            return "low";
+        case "xhigh":
+            return "high";
+        default:
+            return undefined;
+    }
+}
 function collectClaudeCodeParticipantResult(child, options) {
     const maxEvents = boundedLimit(options.maxEvents, DEFAULT_MAX_EVENTS);
     const maxStreamBytes = boundedLimit(options.maxStreamBytes, DEFAULT_MAX_STREAM_BYTES);

package/dist/cli/code-agent-executor.js

@@ -14,6 +14,7 @@ import { readAgentsBundleFromFs, generateDevelopmentSkillsPromptBlock, } from ".
 import { getAmbientOrgId, getAmbientUserEmail, runWithRequestContext, } from "../server/request-context.js";
 import { isReasoningEffort, } from "../shared/reasoning-effort.js";
 import { createAgentNativeConfigContext, loadResolvedAgentNativeConfig, } from "../vite/agent-native-config-loader.js";
+import { runClaudeCodeParticipant, } from "./claude-code-participant.js";
 import { codexMcpConfigArgs, mergeCodeAgentMcpConfig, restrictCodeAgentMcpConfig, } from "./code-agent-mcp-config.js";
 import { createCodeAgentOutputSmoother } from "./code-agent-output-smoother.js";
 import { addCodeAgentCommandToAllowlist, appendCodeAgentTranscriptEvent, dequeueCodeAgentFollowUp, getCodeAgentRunRecord, isCodeAgentCommandAllowed, listCodeAgentTranscriptEvents, updateCodeAgentRunRecord, } from "./code-agent-runs.js";
@@ -21,6 +22,8 @@ const DEFAULT_COMMAND_TIMEOUT_MS = 120_000;
 const MAX_TOOL_OUTPUT_CHARS = 50_000;
 const MAX_FILE_READ_CHARS = 120_000;
 const CODEX_CLI_ENGINE_NAME = "codex-cli";
+const CLAUDE_CLI_ENGINE_NAME = "claude-cli";
+const CLAUDE_CLI_DEFAULT_MODEL = "claude-sonnet-5";
 const RECAP_SOURCE_TOOL_PROFILE = "recap-source";
 const RECAP_SOURCE_OUTPUT_FILE = "recap-source.json";
 /**
@@ -110,6 +113,18 @@ export async function executeCodeAgentRun(options) {
             signal: options.signal,
         });
     }
+    if (requestedEngine === CLAUDE_CLI_ENGINE_NAME) {
+        return executeClaudeCliRun({
+            run: existing,
+            prompt: executionPrompt,
+            model: options.model ?? metadataString(existing, "model"),
+            reasoningEffort: options.reasoningEffort ?? metadataReasoningEffort(existing),
+            permissionMode: existing.permissionMode ?? "full-auto",
+            stdout: options.stdout,
+            streamToolOutputToStdout,
+            signal: options.signal,
+        });
+    }
     const engine = options.engine ?? (await resolveExecutorEngine(requestedEngine));
     if (!engine) {
         const message = "No LLM provider key was found. Set ANTHROPIC_API_KEY, OPENAI_API_KEY, GOOGLE_GENERATIVE_AI_API_KEY, another supported provider key, or run `codex login` to use Codex CLI.";
@@ -437,6 +452,214 @@ export function codeAgentMcpInvocationPolicy(permissionMode) {
         mode: permissionMode === "read-only" ? "read-only" : "allow-all",
     };
 }
+async function executeClaudeCliRun(options) {
+    const cwd = options.run.cwd || process.cwd();
+    const model = normalizeClaudeCliModel(options.model);
+    const reasoningEffort = normalizeClaudeCliEffort(options.reasoningEffort);
+    const streamToolOutputToStdout = options.streamToolOutputToStdout ??
+        process.env.AGENT_NATIVE_CODE_AGENT_STRUCTURED_STDOUT !== "1";
+    const assistantText = [];
+    appendCodeAgentTranscriptEvent({
+        runId: options.run.id,
+        kind: "status",
+        message: "Starting Claude Code with local Claude authentication.",
+        metadata: {
+            status: "running",
+            phase: "executing",
+            engine: CLAUDE_CLI_ENGINE_NAME,
+        },
+    });
+    try {
+        const result = await runClaudeCodeParticipant({
+            role: options.permissionMode === "full-auto" ? "driver" : "watchdog",
+            prompt: buildClaudeCliPrompt(options.run, options.prompt),
+            cwd,
+            model,
+            effort: reasoningEffort,
+            signal: options.signal,
+            onEvent: (event) => {
+                const text = readClaudeParticipantAssistantText(event);
+                if (!text)
+                    return;
+                assistantText.push(text);
+                if (streamToolOutputToStdout)
+                    options.stdout?.write(text);
+            },
+        });
+        const finalMessage = readClaudeParticipantResultText(result.events) ??
+            (assistantText.join("\n\n").trim() || "Claude Code run completed.");
+        appendCodeAgentTranscriptEvent({
+            runId: options.run.id,
+            kind: "system",
+            message: finalMessage,
+            metadata: {
+                role: "assistant",
+                engine: CLAUDE_CLI_ENGINE_NAME,
+                model,
+                ...(reasoningEffort ? { reasoningEffort } : {}),
+            },
+        });
+        const pendingFollowUp = dequeueCodeAgentFollowUp(options.run.id);
+        if (pendingFollowUp) {
+            const message = pendingFollowUp.mode === "queued"
+                ? "Claude Code run completed; running queued follow-up."
+                : "Claude Code run completed; applying steering follow-up.";
+            appendCodeAgentTranscriptEvent({
+                runId: options.run.id,
+                kind: "status",
+                message,
+                metadata: {
+                    status: "running",
+                    phase: "follow-up",
+                    followUpId: pendingFollowUp.id,
+                    followUpMode: pendingFollowUp.mode,
+                    engine: CLAUDE_CLI_ENGINE_NAME,
+                },
+            });
+            if (pendingFollowUp.permissionMode) {
+                updateCodeAgentRunRecord(options.run.id, {
+                    permissionMode: pendingFollowUp.permissionMode,
+                });
+            }
+            return executeCodeAgentRun({
+                runId: options.run.id,
+                prompt: pendingFollowUp.prompt,
+                attachments: pendingFollowUp.attachments ??
+                    userPromptAttachmentsForEvent(options.run.id, pendingFollowUp.eventId),
+                appendUserEvent: false,
+                stdout: options.stdout,
+                streamToolOutputToStdout: options.streamToolOutputToStdout,
+                signal: options.signal,
+            });
+        }
+        appendCodeAgentTranscriptEvent({
+            runId: options.run.id,
+            kind: "status",
+            message: "Claude Code run completed.",
+            metadata: {
+                status: "completed",
+                phase: "complete",
+                engine: CLAUDE_CLI_ENGINE_NAME,
+            },
+        });
+        return updateCodeAgentRunRecord(options.run.id, {
+            status: "completed",
+            phase: "complete",
+            needsApproval: false,
+            progress: {
+                label: "Complete",
+                completed: 1,
+                total: 1,
+                percent: 100,
+            },
+            metadata: {
+                executionCompletedAt: new Date().toISOString(),
+                engine: CLAUDE_CLI_ENGINE_NAME,
+                model,
+                ...(reasoningEffort ? { reasoningEffort } : {}),
+                permissionMode: options.permissionMode,
+            },
+        });
+    }
+    catch (error) {
+        const interrupted = options.signal?.aborted === true;
+        const message = error instanceof Error ? error.message : String(error);
+        const summary = interrupted
+            ? "Claude Code run paused."
+            : `Claude Code run failed: ${message}`;
+        if (streamToolOutputToStdout)
+            options.stdout?.write(`\n${summary}\n`);
+        appendCodeAgentTranscriptEvent({
+            runId: options.run.id,
+            kind: "status",
+            message: summary,
+            metadata: {
+                status: interrupted ? "paused" : "errored",
+                phase: interrupted ? "paused" : "error",
+                engine: CLAUDE_CLI_ENGINE_NAME,
+            },
+        });
+        return updateCodeAgentRunRecord(options.run.id, {
+            status: interrupted ? "paused" : "errored",
+            phase: interrupted ? "paused" : "error",
+            progress: {
+                label: interrupted ? "Paused" : "Error",
+                completed: 0,
+                total: 1,
+                failed: interrupted ? 0 : 1,
+                percent: 0,
+            },
+            metadata: {
+                ...(interrupted
+                    ? { executionPausedAt: new Date().toISOString() }
+                    : {
+                        executionError: message,
+                        executionErroredAt: new Date().toISOString(),
+                    }),
+                engine: CLAUDE_CLI_ENGINE_NAME,
+                model,
+            },
+        });
+    }
+}
+function buildClaudeCliPrompt(run, prompt) {
+    const permissionMode = run.permissionMode ?? "full-auto";
+    const mode = permissionMode === "full-auto" ? "Auto" : "Plan";
+    const modeInstruction = mode === "Plan"
+        ? "Inspect and explain only. Do not edit files or run mutating commands."
+        : "Edit and verify as needed. Do not create, switch, reset, rebase, or stash git branches.";
+    const additionalSkillsRoot = process.env.AGENT_NATIVE_CODE_AGENT_SKILLS_ROOT?.trim();
+    return [
+        `You are running from Agent-Native Code in ${run.cwd || process.cwd()}.`,
+        "Follow the repository AGENTS.md and any relevant skill instructions.",
+        ...(additionalSkillsRoot
+            ? [
+                `Additional installed Agent Plugin skills are available under ${additionalSkillsRoot}. Read any relevant SKILL.md files before acting.`,
+            ]
+            : []),
+        `Run mode: ${mode} (${permissionMode}). ${modeInstruction}`,
+        "",
+        "# User request",
+        prompt,
+    ].join("\n");
+}
+function normalizeClaudeCliModel(model) {
+    const trimmed = model?.trim();
+    return !trimmed || trimmed === "auto" || trimmed === CLAUDE_CLI_ENGINE_NAME
+        ? CLAUDE_CLI_DEFAULT_MODEL
+        : trimmed;
+}
+function normalizeClaudeCliEffort(effort) {
+    return effort && effort !== "auto" ? effort : undefined;
+}
+function readClaudeParticipantAssistantText(event) {
+    if (event.type !== "assistant")
+        return null;
+    const message = asRecordValue(event.message);
+    const content = message?.content;
+    if (!Array.isArray(content))
+        return null;
+    const text = content
+        .filter((part) => isRecordValue(part))
+        .map((part) => (typeof part.text === "string" ? part.text : ""))
+        .filter(Boolean)
+        .join("");
+    return text.trim() || null;
+}
+function readClaudeParticipantResultText(events) {
+    for (let index = events.length - 1; index >= 0; index -= 1) {
+        const result = events[index]?.result;
+        if (typeof result === "string" && result.trim())
+            return result.trim();
+    }
+    return null;
+}
+function isRecordValue(value) {
+    return Boolean(value && typeof value === "object" && !Array.isArray(value));
+}
+function asRecordValue(value) {
+    return isRecordValue(value) ? value : null;
+}
 async function executeCodexCliRun(options) {
     const cwd = options.run.cwd || process.cwd();
     const outputDir = fs.mkdtempSync(path.join(os.tmpdir(), "agent-native-code-codex-"));

package/dist/cli/create-workspace.js

@@ -1,8 +1,8 @@
 /**
  * @deprecated `create-workspace` is now an alias for `create`. In current
- * versions, `agent-native create <name>` defaults to scaffolding a workspace
- * with a multi-select template picker. Use `--standalone` for a single-app
- * standalone scaffold.
+ * versions, `agent-native create <name>` asks for a starting shape and its
+ * Chat/first-party template paths scaffold a workspace. Use `--standalone`
+ * for a single-app standalone scaffold.
  *
  * This module is kept for backwards compatibility with older docs and
  * scripts that still invoke `agent-native create-workspace`.

package/dist/cli/create.d.ts

@@ -32,8 +32,9 @@ export interface CreateAppOptions {
 /**
  * Main entry for `agent-native create [name]`.
  *
- * Default behavior: scaffold a workspace at <name>/ with a multi-select
- * template picker. Use --standalone for the single-app standalone flow.
+ * Default behavior: ask for a starting shape, with Chat and first-party
+ * templates creating a workspace at <name>/. Use --standalone for the
+ * single-app standalone flow.
  *
  * If run *inside* an existing workspace, falls through to the add-app
  * flow that scaffolds one new app under apps/<name>/.