@agent-native/core 0.210.0 → 0.210.1-nightly-20261020010058

package/dist/cli/setup-agents.js

@@ -6,29 +6,100 @@ const FILE_SYMLINKS = [
 const DIR_SYMLINKS = [
     { link: ".claude/skills", target: "../.agents/skills" },
 ];
+export function prepareAgentSymlink(linkPath, target, type) {
+    let stat;
+    try {
+        stat = fs.lstatSync(linkPath);
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return "create";
+        throw error;
+    }
+    if (!stat.isSymbolicLink())
+        return "occupied";
+    let existingTarget;
+    try {
+        existingTarget = fs.readlinkSync(linkPath);
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return "create";
+        throw error;
+    }
+    const resolvedExistingTarget = path.resolve(path.dirname(linkPath), existingTarget);
+    const resolvedTarget = path.resolve(path.dirname(linkPath), target);
+    const sameTarget = process.platform === "win32"
+        ? resolvedExistingTarget.toLowerCase() === resolvedTarget.toLowerCase()
+        : resolvedExistingTarget === resolvedTarget;
+    if (sameTarget) {
+        return "matches";
+    }
+    try {
+        if (process.platform === "win32" && type === "dir") {
+            fs.rmdirSync(linkPath);
+        }
+        else {
+            fs.unlinkSync(linkPath);
+        }
+    }
+    catch (error) {
+        const code = error.code;
+        if (code !== "ENOENT" &&
+            code !== "EPERM" &&
+            code !== "EACCES" &&
+            code !== "EBUSY") {
+            throw error;
+        }
+        try {
+            fs.lstatSync(linkPath);
+        }
+        catch (statError) {
+            if (statError.code === "ENOENT")
+                return "create";
+        }
+        throw error;
+    }
+    return "create";
+}
+export function createAgentSymlink(target, linkPath, type) {
+    if (process.platform !== "win32" || type === "file") {
+        fs.symlinkSync(target, linkPath, type);
+        return;
+    }
+    try {
+        fs.symlinkSync(target, linkPath, "dir");
+    }
+    catch (error) {
+        const code = error.code;
+        if (code !== "EPERM" && code !== "EACCES")
+            throw error;
+        fs.symlinkSync(path.resolve(path.dirname(linkPath), target), linkPath, "junction");
+    }
+}
+export function rebaseAgentSymlinkTarget(sourceRoot, destinationRoot, sourceLinkPath, destinationLinkPath, target) {
+    const resolvedSourceRoot = path.resolve(sourceRoot);
+    const resolvedTarget = path.resolve(path.dirname(sourceLinkPath), target);
+    const targetWithinRoot = path.relative(resolvedSourceRoot, resolvedTarget);
+    if (targetWithinRoot === ".." ||
+        targetWithinRoot.startsWith(`..${path.sep}`) ||
+        path.isAbsolute(targetWithinRoot)) {
+        return undefined;
+    }
+    const copiedTargetPath = path.resolve(destinationRoot, targetWithinRoot);
+    return (path.relative(path.dirname(destinationLinkPath), copiedTargetPath) || ".");
+}
 export function setupAgentSymlinks(targetDir) {
     for (const { link, target } of FILE_SYMLINKS) {
         const linkPath = path.join(targetDir, link);
         const targetPath = path.join(targetDir, target);
         if (!fs.existsSync(targetPath))
             continue;
+        const state = prepareAgentSymlink(linkPath, target, "file");
+        if (state !== "create")
+            continue;
         try {
-            const stat = fs.lstatSync(linkPath);
-            if (stat.isSymbolicLink()) {
-                const existing = fs.readlinkSync(linkPath);
-                if (existing === target)
-                    continue;
-                fs.unlinkSync(linkPath);
-            }
-            else {
-                continue;
-            }
-        }
-        catch {
-            // lstatSync threw ENOENT — file doesn't exist, proceed to create
-        }
-        try {
-            fs.symlinkSync(target, linkPath);
+            createAgentSymlink(target, linkPath, "file");
         }
         catch {
             try {
@@ -46,25 +117,11 @@ export function setupAgentSymlinks(targetDir) {
         if (!fs.existsSync(absTarget))
             continue;
         fs.mkdirSync(parentDir, { recursive: true });
-        if (fs.existsSync(linkPath)) {
-            try {
-                const stat = fs.lstatSync(linkPath);
-                if (stat.isSymbolicLink()) {
-                    const existing = fs.readlinkSync(linkPath);
-                    if (existing === target)
-                        continue;
-                }
-                else {
-                    continue;
-                }
-            }
-            catch {
-                // Proceed to create
-            }
-        }
-        const type = process.platform === "win32" ? "junction" : "dir";
+        const state = prepareAgentSymlink(linkPath, target, "dir");
+        if (state !== "create")
+            continue;
         try {
-            fs.symlinkSync(target, linkPath, type);
+            createAgentSymlink(target, linkPath, "dir");
         }
         catch {
             try {

package/dist/cli/skills.js

@@ -12,7 +12,7 @@ import { resolveClients, runConnect, writeConnectClientPreferences, } from "./co
 import { CONTEXT_XRAY_SKILL_MD, installLocalContextXray, } from "./context-xray-local.js";
 import { CLIENTS, configPathFor } from "./mcp-config-writers.js";
 import { installScreenMemoryForClient, resolveScreenMemoryStoreDir, } from "./mcp.js";
-import { setupAgentSymlinks } from "./setup-agents.js";
+import { createAgentSymlink, prepareAgentSymlink, setupAgentSymlinks, } from "./setup-agents.js";
 import { ASSETS_SKILL_MD, AN_COMMAND_MD, AN_SKILL_MD, CANVAS_REFERENCE_MD, CONNECTION_REFERENCE_MD, CONTENT_SKILL_MD, DESIGN_EXPLORATION_SKILL_MD, DESIGN_VISUAL_EDIT_SKILL_MD, DOCUMENT_QUALITY_REFERENCE_MD, EXEMPLAR_REFERENCE_MD, HELP, LOCAL_FILES_REFERENCE_MD, REWIND_SKILL_MD, TURN_INTO_APP_ATTACHMENTS_REFERENCE_MD, TURN_INTO_APP_FRESH_PROJECT_REFERENCE_MD, TURN_INTO_APP_LOCAL_RUN_AND_DEPLOY_REFERENCE_MD, TURN_INTO_APP_OPENAI_YAML, TURN_INTO_APP_REVIEW_LOOP_REFERENCE_MD, TURN_INTO_APP_SKILL_MD, TURN_INTO_APP_SOURCE_BRIEF_REFERENCE_MD, TURN_INTO_APP_SPREADSHEET_SOURCE_REFERENCE_MD, TURN_INTO_APP_UI_ARCHETYPES_REFERENCE_MD, TURN_INTO_APP_UI_DIRECTION_REFERENCE_MD, TURN_INTO_APP_UI_PALETTES_REFERENCE_MD, VISUAL_PLANS_SKILL_MD, VISUAL_RECAP_SKILL_MD, VISUALIZE_REPO_SKILL_MD, WIREFRAME_REFERENCE_MD, } from "./skills-content/index.js";
 import { createCliTelemetry } from "./telemetry.js";
 import { applyTemplateLayer, readTemplateLayer } from "./template-layer.js";
@@ -1574,21 +1574,15 @@ function ensureWorkspaceRootSkillsLink(workspaceRoot, sharedPackageDir) {
     const linkPath = path.join(agentsDir, "skills");
     const target = path.relative(agentsDir, sharedSkillsDir);
     fs.mkdirSync(agentsDir, { recursive: true });
-    try {
-        const stat = fs.lstatSync(linkPath);
-        if (stat.isSymbolicLink()) {
-            if (fs.readlinkSync(linkPath) === target)
-                return;
-            fs.unlinkSync(linkPath);
-        }
-        else {
-            copyScaffoldGuidanceSkills([sharedSkillsDir], linkPath, listImmediateSkillDirs(sharedSkillsDir), false);
-            return;
-        }
+    const state = prepareAgentSymlink(linkPath, target, "dir");
+    if (state === "matches")
+        return;
+    if (state === "occupied") {
+        copyScaffoldGuidanceSkills([sharedSkillsDir], linkPath, listImmediateSkillDirs(sharedSkillsDir), false);
+        return;
     }
-    catch { }
     try {
-        fs.symlinkSync(target, linkPath, process.platform === "win32" ? "junction" : "dir");
+        createAgentSymlink(target, linkPath, "dir");
     }
     catch {
         try {

package/dist/cli/tar-command.d.ts

@@ -0,0 +1 @@
+export declare function resolveTarExecutable(platform?: NodeJS.Platform, systemRoot?: string): string;

package/dist/cli/tar-command.js

@@ -0,0 +1,9 @@
+import path from "node:path";
+export function resolveTarExecutable(platform = process.platform, systemRoot = process.env.SYSTEMROOT) {
+    if (platform !== "win32")
+        return "tar";
+    if (!systemRoot) {
+        throw new Error("SystemRoot is required to resolve the Windows tar executable.");
+    }
+    return path.win32.join(systemRoot, "System32", "tar.exe");
+}

package/dist/cli/template-baseline.js

@@ -2,6 +2,7 @@ import { execFileSync } from "node:child_process";
 import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
+import { resolveTarExecutable } from "./tar-command.js";
 const REF_NAMESPACE = "refs/agent-native";
 const GIT_IDENTITY = {
     GIT_AUTHOR_NAME: "agent-native",
@@ -51,7 +52,7 @@ export function writeBaseline(store, sourceDir, slot, meta) {
     if (!store.gitDir) {
         const file = baselineTarballPath(store, slot);
         fs.mkdirSync(path.dirname(file), { recursive: true });
-        execFileSync("tar", ["-czf", file, "-C", sourceDir, "."], {
+        execFileSync(resolveTarExecutable(), ["-czf", file, "-C", sourceDir, "."], {
             stdio: "pipe",
         });
         return { kind: "tarball", location: file, configuredRefspecs: [] };
@@ -130,7 +131,9 @@ export function materializeBaseline(store, slot) {
                 fs.rmSync(out, { recursive: true, force: true });
                 return null;
             }
-            execFileSync("tar", ["-xzf", file, "-C", out], { stdio: "pipe" });
+            execFileSync(resolveTarExecutable(), ["-xzf", file, "-C", out], {
+                stdio: "pipe",
+            });
             return out;
         }
         const ref = baselineRefName(store, slot);
@@ -144,7 +147,7 @@ export function materializeBaseline(store, slot) {
             args.push("--", store.prefix);
         git(store, args);
         const strip = store.prefix ? store.prefix.split("/").length : 0;
-        execFileSync("tar", [
+        execFileSync(resolveTarExecutable(), [
             "-xf",
             tarPath,
             "-C",

package/dist/cli/template-sync.d.ts

@@ -56,4 +56,5 @@ export declare function mergeTemplateTrees(appDir: string, baseDir: string, thei
 export declare function readProvenance(appDir: string): TemplateProvenance;
 export declare function resolveTargets(cwd: string, appArg?: string): AppTarget[];
 export declare function runTemplate(args: string[], io?: TemplateIO): Promise<number>;
-export {};
+declare function useLocalTemplate(target: AppTarget, ref: string | null): boolean;
+export { useLocalTemplate as _useLocalTemplate };

package/dist/cli/template-sync.js

@@ -615,8 +615,9 @@ function useLocalTemplate(target, ref) {
     const source = target.provenance.templateSource;
     if (source !== "bundled" && source !== "local-checkout")
         return false;
-    return ref === target.provenance.templateRef;
+    return _getGitHubTemplateRefCandidates().includes(ref);
 }
+export { useLocalTemplate as _useLocalTemplate };
 async function materializeForTarget(target, flags, ref) {
     return materializeTemplate({
         appName: target.appName,

package/dist/client/agent-chat.d.ts

@@ -115,6 +115,7 @@ export interface AgentChatContextMutationOptions {
 export interface AgentChatContextRemoveOptions extends AgentChatContextMutationOptions {
     key: string;
 }
+export declare const AGENT_CHAT_CONTEXT_STATE_KEY = "agent-chat-context";
 export declare const AGENT_CHAT_CONTEXT_CHANGED_EVENT = "agentNative.chatContextChanged";
 export declare const AGENT_CHAT_SET_CONTEXT_MESSAGE_TYPE = "agentNative.setChatContext";
 export declare const AGENT_CHAT_REMOVE_CONTEXT_MESSAGE_TYPE = "agentNative.removeChatContext";

package/dist/client/agent-chat.js

@@ -9,7 +9,7 @@ import { getFramePostMessageTargetOrigin, isTrustedFrameMessage, } from "./frame
 import { isOpenAiMcpAppHost, sendMcpAppHostMessage, } from "./mcp-app-host.js";
 export { appendAgentChatContextToMessage } from "../shared/agent-chat-context.js";
 const AGENT_CHAT_MESSAGE_TYPE = "agentNative.submitChat";
-const AGENT_CHAT_CONTEXT_STATE_KEY = "agent-chat-context";
+export const AGENT_CHAT_CONTEXT_STATE_KEY = "agent-chat-context";
 const AGENT_CHAT_EXEC_MODE_KEY = "agent-native-exec-mode";
 export const AGENT_CHAT_CONTEXT_CHANGED_EVENT = "agentNative.chatContextChanged";
 export const AGENT_CHAT_SET_CONTEXT_MESSAGE_TYPE = "agentNative.setChatContext";

package/dist/client/api-path.d.ts

@@ -20,6 +20,7 @@ export declare function isWorkspaceAppPath(path: string): boolean;
 export declare function appMountPath(appLocalRoute: string): string;
 export declare function appMountedPath(path: string, appLocalRoute: string): string;
 export declare function appPath(path: string): string;
+export declare function appPathFromLocalRoute(path: string): string;
 export declare function appApiPath(path: string): string;
 export declare function agentNativePath(path: string): string;
 export declare function agentChatStreamingUrl(): string | undefined;

package/dist/client/api-path.js

@@ -339,6 +339,12 @@ export function appPath(path) {
         return path;
     return `${basePath}${path}`;
 }
+export function appPathFromLocalRoute(path) {
+    if (!path.startsWith("/"))
+        return path;
+    const basePath = appBasePath();
+    return basePath ? `${basePath}${path}` : path;
+}
 export function appApiPath(path) {
     const normalized = path === "/api" || path.startsWith("/api/")
         ? path

package/dist/client/chat/agentkit-agent-native.js

@@ -3658,7 +3658,8 @@ export function createAgentNativeAgentKitTransport(options = {}) {
             const submittedRunId = typeof record?.submittedRunId === "string"
                 ? record.submittedRunId
                 : undefined;
-            const localRun = serverActiveRunId
+            const hasSubmittedReceipt = typeof submittedRunId === "string" && submittedRunId.length > 0;
+            const localRun = serverActiveRunId && !hasSubmittedReceipt
                 ? await protocolTransport.getRun?.({
                     threadId: input.threadId,
                     runId: serverActiveRunId,
@@ -3667,11 +3668,14 @@ export function createAgentNativeAgentKitTransport(options = {}) {
             const activeRunId = localRun?.id ?? serverActiveRunId;
             const explicitNonSlotCode = typeof record?.code === "string" &&
                 record.code !== "run_slot_busy" &&
+                record.code !== "queued_message_already_submitted" &&
                 record.code !== "http_409";
             if (record?.status === 409 &&
                 (error instanceof AgentKitRunSlotBusyError ||
                     record.code === "run_slot_busy" ||
-                    ((typeof activeRunId === "string" || submittedRunId !== undefined) &&
+                    (record.code === "queued_message_already_submitted" &&
+                        hasSubmittedReceipt) ||
+                    ((typeof activeRunId === "string" || hasSubmittedReceipt) &&
                         !explicitNonSlotCode))) {
                 const busy = new AgentKitRunSlotBusyError(typeof activeRunId === "string" ? activeRunId : undefined, submittedRunId);
                 Object.assign(busy, { status: 409 });

package/dist/client/chat/runtime.js

@@ -356,6 +356,9 @@ async function readHttpRuntimeError(response) {
     const explicitCode = typeof code === "string" ? code : undefined;
     const runSlotBusy = status === 409 &&
         (explicitCode === "run_slot_busy" ||
+            (explicitCode === "queued_message_already_submitted" &&
+                typeof submittedRunId === "string" &&
+                submittedRunId.length > 0) ||
             (explicitCode === undefined &&
                 (activeRunIdValue ||
                     (typeof submittedRunId === "string" && submittedRunId.length > 0))));

package/dist/client/use-agent-chat-context.js

@@ -1,8 +1,11 @@
 import { useCallback, useEffect, useMemo, useSyncExternalStore } from "react";
-import { clearAgentChatContext, filterAgentChatContextItems, getAgentChatContextState, refreshAgentChatContext, removeAgentChatContextItem, setAgentChatContextItem, subscribeAgentChatContext, } from "./agent-chat.js";
-import { useChangeVersion } from "./use-change-version.js";
+import { AGENT_CHAT_CONTEXT_STATE_KEY, clearAgentChatContext, filterAgentChatContextItems, getAgentChatContextState, refreshAgentChatContext, removeAgentChatContextItem, setAgentChatContextItem, subscribeAgentChatContext, } from "./agent-chat.js";
+import { useChangeVersions } from "./use-change-version.js";
 export function useAgentChatContext(enabled = true) {
-    const appStateVersion = useChangeVersion("app-state");
+    const appStateVersion = useChangeVersions([
+        `app-state:${AGENT_CHAT_CONTEXT_STATE_KEY}`,
+        "app-state:*",
+    ]);
     const state = useSyncExternalStore(subscribeAgentChatContext, getAgentChatContextState, getAgentChatContextState);
     const items = useMemo(() => filterAgentChatContextItems(state.items), [state.items]);
     useEffect(() => {

package/dist/client/use-db-sync.js

@@ -1254,6 +1254,9 @@ export function useDbSync(options = {}) {
                     if (typeof evt.key === "string" && evt.key) {
                         bumpChangeVersion(`${src}:${evt.key}`, ver);
                     }
+                    else if (src === "app-state") {
+                        bumpChangeVersion("app-state:*", ver);
+                    }
                 }
             }
             const invalidating = relevant.filter((e) => e.source !== "awareness");

package/dist/collab/awareness.d.ts

@@ -38,19 +38,19 @@ export declare const postAwareness: import("h3").EventHandlerWithFetch<import("h
     error: string;
     states?: undefined;
 } | {
-    error?: undefined;
     states: {
         clientId: number;
         state: string;
     }[];
+    error?: undefined;
 }>>;
 export declare const getActiveUsers: import("h3").EventHandlerWithFetch<import("h3").EventHandlerRequest, Promise<{
     error: string;
     users?: undefined;
 } | {
-    error?: undefined;
     users: {
         clientId: number;
         lastSeen: number;
     }[];
+    error?: undefined;
 }>>;

package/dist/collab/routes.d.ts

@@ -13,16 +13,16 @@ export declare const getCollabState: import("h3").EventHandlerWithFetch<import("
     };
 }>>;
 export declare const postCollabUpdate: import("h3").EventHandlerWithFetch<import("h3").EventHandlerRequest, Promise<{
-    ok?: undefined;
     error: string;
+    ok?: undefined;
 } | {
     error?: undefined;
     ok: boolean;
 }>>;
 export declare const postCollabText: import("h3").EventHandlerWithFetch<import("h3").EventHandlerRequest, Promise<{
     ok?: undefined;
-    text?: undefined;
     error: string;
+    text?: undefined;
 } | {
     error?: undefined;
     ok: boolean;

package/dist/deploy/immutable-assets.d.ts

@@ -4,7 +4,7 @@ export declare const IMMUTABLE_ASSET_CACHE_HEADERS: {
     readonly "cdn-cache-control": "public, max-age=31536000, immutable";
     readonly "netlify-cdn-cache-control": "public, max-age=31536000, immutable";
 };
-export declare const IMMUTABLE_ASSET_PATH_PATTERN = "^/assets/[^/]+-[A-Za-z0-9_-]{8}\\.[a-z0-9]+$";
+export declare const IMMUTABLE_ASSET_PATH_PATTERN = "^/assets/(?:[^/]+/)*[^/]+-[A-Za-z0-9_-]{8}\\.[a-z0-9]+$";
 export declare function isImmutableAssetPath(pathname: string): boolean;
 export declare function normalizeBasePath(basePath: string | undefined): string;
 export declare function prefixAssetPath(pathname: string, basePath: string | undefined): string;

package/dist/deploy/immutable-assets.js

@@ -6,7 +6,7 @@ export const IMMUTABLE_ASSET_CACHE_HEADERS = {
     "cdn-cache-control": IMMUTABLE_ASSET_CACHE_CONTROL,
     "netlify-cdn-cache-control": IMMUTABLE_ASSET_CACHE_CONTROL,
 };
-export const IMMUTABLE_ASSET_PATH_PATTERN = "^/assets/[^/]+-[A-Za-z0-9_-]{8}\\.[a-z0-9]+$";
+export const IMMUTABLE_ASSET_PATH_PATTERN = "^/assets/(?:[^/]+/)*[^/]+-[A-Za-z0-9_-]{8}\\.[a-z0-9]+$";
 const IMMUTABLE_ASSET_PATH_RE = new RegExp(IMMUTABLE_ASSET_PATH_PATTERN);
 export function isImmutableAssetPath(pathname) {
     return IMMUTABLE_ASSET_PATH_RE.test(pathname);

package/dist/deploy/workspace-deploy.js

@@ -568,11 +568,18 @@ function writeVercelBuildConfig(outputDir, apps, workspaceApps, rootPage, sweepC
 function vercelImmutableAssetHeaderRoutes(outputDir, apps) {
     return apps.flatMap((app) => {
         const staticDir = path.join(outputDir, "static", app);
-        return collectImmutableAssetPaths(staticDir).map((assetPath) => ({
-            src: vercelRouteSrc(`/${app}${assetPath}`),
-            headers: IMMUTABLE_ASSET_CACHE_HEADERS,
-            continue: true,
-        }));
+        const assetPaths = collectImmutableAssetPaths(staticDir);
+        if (assetPaths.length === 0)
+            return [];
+        return [
+            {
+                src: `^(?:${assetPaths
+                    .map((assetPath) => vercelRouteSrc(`/${app}${assetPath}`))
+                    .join("|")})$`,
+                headers: IMMUTABLE_ASSET_CACHE_HEADERS,
+                continue: true,
+            },
+        ];
     });
 }
 function vercelRouteSrc(pathname) {

package/dist/file-upload/actions/upload-image.d.ts

@@ -33,20 +33,20 @@ declare const _default: import("../../action.js").ActionDefinition<{
     idempotencyKey: string;
     deleted: boolean;
 } | {
+    id?: undefined;
     error: string;
     url?: undefined;
-    id?: undefined;
     provider?: undefined;
     configured?: undefined;
 } | {
     url: string;
     id: string;
     provider: string;
-    error?: undefined;
     configured?: undefined;
+    error?: undefined;
 } | {
-    url?: undefined;
     id?: undefined;
+    url?: undefined;
     provider?: undefined;
     error: string;
     configured: boolean;

package/dist/jobs/actions/manage-recurring-job.d.ts

@@ -11,9 +11,9 @@ declare const _default: import("../../action.js").ActionDefinition<{
     enabled?: undefined;
     nextRun?: undefined;
 } | {
-    deleted?: undefined;
     name: string;
     enabled: boolean;
     nextRun: string;
+    deleted?: undefined;
 }>;
 export default _default;

package/dist/jobs/background-automation-runner.js

@@ -9,6 +9,7 @@ import { foldReapedRunIntoThread } from "../agent/reaped-run-thread.js";
 import { AgentLoopAbortedError, runAgentLoopDirectWithSoftTimeout, } from "../agent/run-loop-with-resume.js";
 import { abortRun, resolveBackgroundAutomationSoftTimeoutMs, resolveBackgroundRunHardTimeoutMs, startRun, } from "../agent/run-manager.js";
 import { claimBackgroundRun, beginAgentExecutionStep, completeAgentExecutionStep, markAgentExecutionStepDispatched, insertRun, tryClaimRunSlot, releaseBackgroundRunBeforeStart, } from "../agent/run-store.js";
+import { buildAssistantMessageFromRunJournal } from "../agent/run-thread-projector.js";
 import { buildCurrentTimeUserContext, buildRuntimeContextPrompt, } from "../agent/runtime-context.js";
 import { buildAssistantMessage, buildUserMessage, extractThreadMeta, foldAssistantTurn, upsertUserMessage, threadDataToEngineMessages, threadMessageTextForEngine, } from "../agent/thread-data-builder.js";
 import { classifyToolCallJournal, buildResumeJournalNote, toolCallInputFingerprint, } from "../agent/tool-call-journal.js";
@@ -472,13 +473,20 @@ async function persistBackgroundAutomationTurn(input) {
                 },
             });
         }
-        const assistantMsg = buildAssistantMessage(events, input.run.runId, {
-            suppressInternalContinuation: !input.persistFailure,
-            turnId: input.run.turnId,
-            runDurationMs: Number.isFinite(input.run.startedAt)
-                ? Math.max(0, Date.now() - input.run.startedAt)
-                : undefined,
-        });
+        const assistantMsg = input.persistAssistant === false
+            ? null
+            : await buildAssistantMessageFromRunJournal({
+                threadId: input.threadId,
+                turnId: input.run.turnId,
+                runId: input.run.runId,
+                runEvents: events,
+                options: {
+                    suppressInternalContinuation: !input.persistFailure,
+                    runDurationMs: Number.isFinite(input.run.startedAt)
+                        ? Math.max(0, Date.now() - input.run.startedAt)
+                        : undefined,
+                },
+            });
         if (assistantMsg) {
             repo = foldAssistantTurn(repo, assistantMsg, {
                 runId: input.run.runId,
@@ -844,6 +852,7 @@ async function executeBackgroundAutomation(options, deps, historyId, runIdRef) {
                 threadTitle,
                 prompt: executionPrompt,
                 run: { runId, turnId, startedAt: Date.now(), events: [] },
+                persistAssistant: false,
             });
             const afterInsert = (tx) => withDbExec(tx, async () => {
                 await recordRunThread(historyId, thread.id, runId, Boolean(options.historyId), options.resume?.previousRunId);

package/dist/mcp/build-server.js

@@ -2004,6 +2004,7 @@ export async function createMCPServerForRequest(config, identity, requestMeta) {
             connectorNames.size > 0 ||
             automaticConnectorPolicyActive);
     const writesAreAskAppOnly = externalAgentWritesAreAskAppOnly(config);
+    const preserveCompactActions = config.connectorCatalog === undefined && !automaticConnectorPolicyActive;
     const advertisedActionsBeforeToolSearchScope = appCatalog
         ? Object.fromEntries(Object.entries(visibleActions).filter(([name]) => !denyNames.has(name)))
         : directoryCatalog
@@ -2016,8 +2017,11 @@ export async function createMCPServerForRequest(config, identity, requestMeta) {
                         return false;
                     if (COMPACT_MCP_APP_CATALOG_BUILTINS.has(name))
                         return true;
-                    if (!connectorNames.has(name))
+                    if (!connectorNames.has(name) &&
+                        !(preserveCompactActions &&
+                            isActionAdvertisedInCompactMcpAppCatalog(name, entry, config))) {
                         return false;
+                    }
                     if (writesAreAskAppOnly && !isMcpReadOnlyTool(entry)) {
                         return false;
                     }