@agent-native/core 0.157.5 → 0.157.7

package/corpus/templates/dispatch/netlify.toml

@@ -13,6 +13,9 @@ NPM_CONFIG_PRODUCTION = "false"
 # function, including workspace-resource updates delegated by sibling apps.
 AGENT_CHAT_DURABLE_BACKGROUND = "true"
 
+[context.production.environment]
+AGENT_NATIVE_HOSTED_HARNESS = "true"
+
 # A2A delegation calls run a full agent loop (LLM + tool calls + DB queries).
 # The framework does not impose a default agent-run timeout; if a template sets
 # AGENT_RUN_SOFT_TIMEOUT_MS, keep it below this function timeout so the hidden

package/corpus/templates/factory/netlify.toml

@@ -8,3 +8,6 @@ GA_MEASUREMENT_ID = "G-ESF7FYXGN9"
 GTM_CONTAINER_ID = "GTM-N3WSTXZ"
 NITRO_PRESET = "netlify"
 NPM_CONFIG_PRODUCTION = "false"
+
+[context.production.environment]
+AGENT_NATIVE_HOSTED_HARNESS = "true"

package/corpus/templates/forms/netlify.toml

@@ -10,6 +10,9 @@ GTM_CONTAINER_ID = "GTM-N3WSTXZ"
 NITRO_PRESET = "netlify"
 NPM_CONFIG_PRODUCTION = "false"
 
+[context.production.environment]
+AGENT_NATIVE_HOSTED_HARNESS = "true"
+
 # A2A delegation calls run a full agent loop (LLM + tool calls + DB queries).
 # The framework does not impose a default agent-run timeout; if a template sets
 # AGENT_RUN_SOFT_TIMEOUT_MS, keep it below this function timeout so the hidden

package/corpus/templates/macros/netlify.toml

@@ -9,3 +9,6 @@ GA_MEASUREMENT_ID = "G-ESF7FYXGN9"
 GTM_CONTAINER_ID = "GTM-N3WSTXZ"
 NITRO_PRESET = "netlify"
 NPM_CONFIG_PRODUCTION = "false"
+
+[context.production.environment]
+AGENT_NATIVE_HOSTED_HARNESS = "true"

package/corpus/templates/mail/agent-native.config.ts

@@ -0,0 +1,5 @@
+import { defineAgentNativeConfig } from "@agent-native/core/config";
+
+export default defineAgentNativeConfig({
+  harness: true,
+});

package/corpus/templates/mail/netlify.toml

@@ -10,6 +10,9 @@ GTM_CONTAINER_ID = "GTM-N3WSTXZ"
 NITRO_PRESET = "netlify"
 NPM_CONFIG_PRODUCTION = "false"
 
+[context.production.environment]
+AGENT_NATIVE_HOSTED_HARNESS = "true"
+
 # A2A delegation calls run a full agent loop (LLM + tool calls + DB queries).
 # The framework does not impose a default agent-run timeout; if a template sets
 # AGENT_RUN_SOFT_TIMEOUT_MS, keep it below this function timeout so the hidden

package/corpus/templates/plan/netlify.toml

@@ -11,6 +11,9 @@ NITRO_PRESET = "netlify"
 NPM_CONFIG_PRODUCTION = "false"
 AGENT_CHAT_DURABLE_BACKGROUND = "true"
 
+[context.production.environment]
+AGENT_NATIVE_HOSTED_HARNESS = "true"
+
 # A2A/MCP calls may include plan generation, artifact serialization, and
 # feedback polling. Keep this aligned with other agent-heavy hosted templates.
 # Agent chat runs are dispatched to the emitted Netlify background function;

package/corpus/templates/slides/netlify.toml

@@ -14,6 +14,9 @@ NITRO_PRESET = "netlify"
 NPM_CONFIG_PRODUCTION = "false"
 AGENT_CHAT_DURABLE_BACKGROUND = "true"
 
+[context.production.environment]
+AGENT_NATIVE_HOSTED_HARNESS = "true"
+
 # Function wall for the non-agent long-request paths (deck import/export,
 # image generation). Agent chat opts into the separate Netlify background
 # function so hosted creative turns can use the longer background budget.

package/dist/agent/harness/acp-adapter.js

@@ -167,8 +167,12 @@ class AcpHarnessSession {
                 this.acpSessionId = resume.sessionId;
                 return;
             }
-            catch {
-                // Fall through to a fresh session if the agent could not load it.
+            catch (error) {
+                if (!isExplicitlyMissingAcpSession(error))
+                    throw error;
+                // A provider can legitimately evict an old session. Only that
+                // explicit condition may fall back to a fresh session; transport or
+                // permission failures must remain visible to the caller.
             }
         }
         const created = await this.connection.newSession({
@@ -321,6 +325,9 @@ class AcpHarnessSession {
         return { content: sliceTextFile(raw, params.line, params.limit) };
     }
     async handleWriteTextFile(params) {
+        if (this.permissionMode === "allow-reads") {
+            throw new Error("[acp-harness] File writes are disabled in allow-reads mode.");
+        }
         const abs = resolveAcpWorkspacePath(this.cwd, params.path);
         const existed = await fileExists(abs);
         await fs.mkdir(path.dirname(abs), { recursive: true });
@@ -604,6 +611,14 @@ function acpErrorMessage(error) {
     }
     return typeof error === "string" ? error : "ACP request failed";
 }
+function isExplicitlyMissingAcpSession(error) {
+    const message = error instanceof Error
+        ? error.message
+        : typeof error === "string"
+            ? error
+            : "";
+    return /(?:session|conversation).*(?:not found|does not exist|unknown|unsupported)|(?:unknown|unsupported).*(?:session|conversation)/i.test(message);
+}
 /** Minimal async queue bridging ACP's callback updates to an async iterable. */
 class AsyncEventQueue {
     values = [];

package/dist/agent/harness/ai-sdk-adapter.js

@@ -199,8 +199,11 @@ async function createNativeSession(agent, options) {
         try {
             return await agent.createSession({ resumeState: options.resumeState });
         }
-        catch {
-            return agent.createSession();
+        catch (error) {
+            if (isExplicitlyMissingHarnessSession(error)) {
+                return agent.createSession();
+            }
+            throw error;
         }
     }
     if (typeof agent.createSession !== "function") {
@@ -237,7 +240,7 @@ class AiSdkHarnessSession {
     }
     async *continueTurn(input = {}) {
         if (typeof this.agent.continueStream !== "function") {
-            return;
+            throw new Error("[agent-harness] This runtime cannot continue a harness turn.");
         }
         const result = await this.agent.continueStream({
             session: this.nativeSession,
@@ -353,3 +356,11 @@ function normalizeFileOperation(value) {
         ? value
         : "unknown";
 }
+function isExplicitlyMissingHarnessSession(error) {
+    const message = error instanceof Error
+        ? error.message
+        : typeof error === "string"
+            ? error
+            : "";
+    return /(?:session|conversation).*(?:not found|does not exist|unknown|unsupported)|(?:unknown|unsupported).*(?:session|conversation)/i.test(message);
+}

package/dist/agent/harness/background.js

@@ -98,7 +98,7 @@ function toAgentHarnessBackgroundRun(session) {
         },
         title: `${session.harnessName} harness`,
         subtitle: session.status === "running" ? "Running" : undefined,
-        status: backgroundStatus(session.status),
+        status: backgroundStatus(session.status, Boolean(session.pendingApproval)),
         phase: session.status,
         createdAt,
         updatedAt,
@@ -218,14 +218,17 @@ function parseRunEvent(row) {
         return null;
     }
 }
-function backgroundStatus(status) {
+function backgroundStatus(status, needsApproval) {
     if (status === "running")
         return "running";
     if (status === "errored")
         return "errored";
-    if (status === "idle" || status === "stopped" || status === "destroyed") {
+    if (needsApproval)
+        return "needs-approval";
+    if (status === "idle")
+        return "paused";
+    if (status === "stopped" || status === "destroyed")
         return "completed";
-    }
     return "unknown";
 }
 async function sendAgentHarnessBackgroundFollowUp(input, scope) {
@@ -253,7 +256,9 @@ async function controlAgentHarnessBackgroundRun(input, scope) {
     }
     if (input.command === "approve" || input.command === "deny") {
         const session = await getAgentHarnessSessionByRunId(input.runId);
-        if (!session || session.ownerEmail !== scope.ownerEmail) {
+        if (!session ||
+            session.ownerEmail !== scope.ownerEmail ||
+            (scope.orgId !== undefined && session.orgId !== scope.orgId)) {
             return missingHarnessRunResult(input.runId);
         }
         const pending = session.pendingApproval;

package/dist/agent/harness/hosted.d.ts

@@ -0,0 +1,20 @@
+import type { AgentNativeHarnessRuntime } from "../../config.js";
+export type HostedHarnessRuntime = AgentNativeHarnessRuntime;
+export declare const HOSTED_HARNESS_ENV_KEY: "AGENT_NATIVE_HOSTED_HARNESS";
+export declare const HOSTED_HARNESS_ORG_SETTING_KEY: "agent-harness.enabled";
+export declare const HOSTED_HARNESS_RUNTIME_ORDER: readonly HostedHarnessRuntime[];
+export declare const HOSTED_HARNESS_AGENT_DESCRIPTIONS: Record<HostedHarnessRuntime, string>;
+export declare const HOSTED_HARNESS_AGENT_LABELS: Record<HostedHarnessRuntime, string>;
+export declare const HOSTED_HARNESS_BLOCKED_TOOL_NAMES: Set<string>;
+export declare function isHostedHarnessRuntime(value: unknown): value is HostedHarnessRuntime;
+export declare function normalizeHostedHarnessRuntime(value: unknown): HostedHarnessRuntime | undefined;
+export declare function normalizeHostedHarnessRuntimes(value: unknown): HostedHarnessRuntime[];
+export declare function isHostedHarnessConfigured(value: unknown): boolean;
+export declare function hostedHarnessAgentOption(runtime: HostedHarnessRuntime): {
+    id: AgentNativeHarnessRuntime;
+    label: string;
+    description: string;
+};
+export declare function isHostedHarnessBlockedToolName(name: string): boolean;
+export declare function filterHostedHarnessToolNames(names: readonly string[]): string[];
+export declare function hostedHarnessSystemPrompt(runtime: HostedHarnessRuntime): string;

package/dist/agent/harness/hosted.js

@@ -0,0 +1,100 @@
+export const HOSTED_HARNESS_ENV_KEY = "AGENT_NATIVE_HOSTED_HARNESS";
+export const HOSTED_HARNESS_ORG_SETTING_KEY = "agent-harness.enabled";
+export const HOSTED_HARNESS_RUNTIME_ORDER = [
+    "claude-code",
+    "codex",
+    "pi",
+    "opencode",
+];
+export const HOSTED_HARNESS_AGENT_DESCRIPTIONS = {
+    "claude-code": "Production mode is tools-only: no repository, shell, or code editing. Use the Electron app for full coding workflows.",
+    codex: "Production mode is tools-only: no repository, shell, or code editing. Use the Electron app for full coding workflows.",
+    pi: "Production mode is tools-only: no repository, shell, or code editing. Use the Electron app for full coding workflows.",
+    opencode: "Production mode is tools-only: no repository, shell, or code editing. Use the Electron app for full coding workflows.",
+};
+export const HOSTED_HARNESS_AGENT_LABELS = {
+    "claude-code": "Claude Code",
+    codex: "Codex",
+    pi: "Pi",
+    opencode: "OpenCode",
+};
+export const HOSTED_HARNESS_BLOCKED_TOOL_NAMES = new Set([
+    "bash",
+    "edit",
+    "read",
+    "write",
+    "run-code",
+    "tool-orchestration",
+    "get-code-execution",
+    "read-file",
+    "write-file",
+    "read-local-file",
+    "write-local-file",
+    "apply-source-edit",
+    "update-file",
+    "delete-file",
+    "github-repo-list-files",
+    "github-repo-read-file",
+    "github-repo-search-code",
+    "github-repo-write-file",
+    "github-repo-delete-file",
+    "save-data-program",
+    "preview-data-program",
+    "run-data-program",
+    "list-data-programs",
+    "get-data-program",
+    "delete-data-program",
+    "workspace-files",
+    "show-workspace-file",
+    "read-workspace-file",
+    "write-workspace-file",
+    "delete-workspace-file",
+    "grep-workspace-file",
+    "connect-builder",
+]);
+export function isHostedHarnessRuntime(value) {
+    return (value === "claude-code" ||
+        value === "codex" ||
+        value === "pi" ||
+        value === "opencode");
+}
+export function normalizeHostedHarnessRuntime(value) {
+    if (value === "claude")
+        return "claude-code";
+    return isHostedHarnessRuntime(value) ? value : undefined;
+}
+export function normalizeHostedHarnessRuntimes(value) {
+    if (!Array.isArray(value))
+        return [...HOSTED_HARNESS_RUNTIME_ORDER];
+    const runtimes = value
+        .map((runtime) => normalizeHostedHarnessRuntime(runtime))
+        .filter((runtime) => runtime !== undefined);
+    return [...new Set(runtimes)];
+}
+export function isHostedHarnessConfigured(value) {
+    return (value === true ||
+        (!!value && typeof value === "object" && !Array.isArray(value)));
+}
+export function hostedHarnessAgentOption(runtime) {
+    return {
+        id: runtime,
+        label: HOSTED_HARNESS_AGENT_LABELS[runtime],
+        description: HOSTED_HARNESS_AGENT_DESCRIPTIONS[runtime],
+    };
+}
+export function isHostedHarnessBlockedToolName(name) {
+    return (HOSTED_HARNESS_BLOCKED_TOOL_NAMES.has(name) ||
+        name.startsWith("workspace-file-") ||
+        name.startsWith("data-program-"));
+}
+export function filterHostedHarnessToolNames(names) {
+    return names.filter((name) => !isHostedHarnessBlockedToolName(name));
+}
+export function hostedHarnessSystemPrompt(runtime) {
+    return `<hosted-tools-only-harness runtime="${runtime}">
+You are running as a hosted ${HOSTED_HARNESS_AGENT_LABELS[runtime]} inside a production app.
+This is a tools-only mode. You have no repository, shell, filesystem, code-editing, or code-execution tools.
+Use the app's typed actions and SQL-backed resources for mail, calendar, analytics, and working state.
+For full coding work, tell the user to use the Agent Native Electron app.
+</hosted-tools-only-harness>`;
+}

package/dist/agent/harness/runner.js

@@ -6,92 +6,115 @@ export function startAgentHarnessRun(opts) {
     let harnessSession = opts.session;
     const detachOnComplete = opts.detachOnComplete !== false;
     return startRun(opts.runId, opts.threadId, async (send, signal) => {
-        send({
-            type: "activity",
-            label: `Starting ${opts.adapter.label}`,
-            tool: "harness",
-        });
-        harnessSession ??= await opts.adapter.createSession({
-            ...(opts.createSession ?? {}),
-            threadId: opts.threadId,
-            runId: opts.runId,
-            ownerEmail: opts.ownerEmail ?? opts.createSession?.ownerEmail ?? null,
-            orgId: opts.orgId ?? opts.createSession?.orgId ?? null,
-            signal,
-        });
-        await saveAgentHarnessSession({
-            id: opts.createSession?.sessionId ?? harnessSession.id,
-            harnessName: opts.adapter.name,
-            threadId: opts.threadId,
-            runId: opts.runId,
-            providerSessionId: harnessSession.id,
-            status: "running",
-            resumeState: opts.createSession?.resumeState,
-            ownerEmail: opts.ownerEmail ?? opts.createSession?.ownerEmail ?? null,
-            orgId: opts.orgId ?? opts.createSession?.orgId ?? null,
-        });
-        const storedSessionId = opts.createSession?.sessionId ?? harnessSession.id;
-        registerLiveAgentHarnessSession({
-            sessionId: storedSessionId,
-            adapter: opts.adapter,
-            session: harnessSession,
-            createSession: opts.createSession,
-            ownerEmail: opts.ownerEmail ?? opts.createSession?.ownerEmail ?? null,
-            orgId: opts.orgId ?? opts.createSession?.orgId ?? null,
-        });
-        const input = {
-            ...opts.input,
-            abortSignal: signal,
-        };
-        let pendingApproval = null;
-        for await (const event of harnessSession.streamTurn(input)) {
-            if (signal.aborted)
-                break;
-            await opts.onHarnessEvent?.(event);
-            if (event.type === "approval-request") {
-                pendingApproval = event;
-                await updateAgentHarnessSession(opts.createSession?.sessionId ?? harnessSession.id, {
-                    status: "idle",
-                    pendingApproval: event,
-                });
+        let storedSessionId;
+        let keepLiveSession = false;
+        try {
+            send({
+                type: "activity",
+                label: `Starting ${opts.adapter.label}`,
+                tool: "harness",
+            });
+            harnessSession ??= await opts.adapter.createSession({
+                ...(opts.createSession ?? {}),
+                threadId: opts.threadId,
+                runId: opts.runId,
+                ownerEmail: opts.ownerEmail ?? opts.createSession?.ownerEmail ?? null,
+                orgId: opts.orgId ?? opts.createSession?.orgId ?? null,
+                signal,
+            });
+            storedSessionId = opts.createSession?.sessionId ?? harnessSession.id;
+            await saveAgentHarnessSession({
+                id: storedSessionId,
+                harnessName: opts.adapter.name,
+                threadId: opts.threadId,
+                runId: opts.runId,
+                providerSessionId: harnessSession.id,
+                status: "running",
+                resumeState: opts.createSession?.resumeState,
+                ownerEmail: opts.ownerEmail ?? opts.createSession?.ownerEmail ?? null,
+                orgId: opts.orgId ?? opts.createSession?.orgId ?? null,
+            });
+            registerLiveAgentHarnessSession({
+                sessionId: storedSessionId,
+                adapter: opts.adapter,
+                session: harnessSession,
+                createSession: opts.createSession,
+                ownerEmail: opts.ownerEmail ?? opts.createSession?.ownerEmail ?? null,
+                orgId: opts.orgId ?? opts.createSession?.orgId ?? null,
+            });
+            const input = {
+                ...opts.input,
+                abortSignal: signal,
+            };
+            let pendingApproval = null;
+            for await (const event of harnessSession.streamTurn(input)) {
+                if (signal.aborted)
+                    break;
+                await opts.onHarnessEvent?.(event);
+                if (event.type === "approval-request") {
+                    pendingApproval = event;
+                    await updateAgentHarnessSession(storedSessionId, {
+                        status: "idle",
+                        pendingApproval: event,
+                    });
+                }
+                if (event.type === "error") {
+                    throw new Error(event.error);
+                }
+                for (const chatEvent of agentHarnessEventToAgentChatEvents(event)) {
+                    send(chatEvent);
+                }
             }
-            if (event.type === "error") {
-                throw new Error(event.error);
+            if (signal.aborted) {
+                await stopHarnessSession(harnessSession);
+                releaseLiveAgentHarnessSession(storedSessionId, harnessSession);
+                await markAgentHarnessSessionStopped(storedSessionId, "stopped");
+                return;
             }
-            for (const chatEvent of agentHarnessEventToAgentChatEvents(event)) {
-                send(chatEvent);
+            if (pendingApproval) {
+                const stored = await getAgentHarnessSession(storedSessionId);
+                const stillPending = stored?.pendingApproval &&
+                    typeof stored.pendingApproval === "object" &&
+                    "id" in stored.pendingApproval &&
+                    stored.pendingApproval.id === pendingApproval.id;
+                if (stillPending) {
+                    keepLiveSession = true;
+                    await updateAgentHarnessSession(storedSessionId, {
+                        status: "idle",
+                        pendingApproval,
+                    });
+                    return;
+                }
+            }
+            let resumeState = opts.createSession?.resumeState;
+            if (detachOnComplete && harnessSession.detach) {
+                resumeState = await harnessSession.detach();
             }
-        }
-        if (signal.aborted) {
-            await stopHarnessSession(harnessSession);
             releaseLiveAgentHarnessSession(storedSessionId, harnessSession);
-            await markAgentHarnessSessionStopped(opts.createSession?.sessionId ?? harnessSession.id, "stopped");
-            return;
+            await updateAgentHarnessSession(storedSessionId, {
+                status: "idle",
+                resumeState,
+                pendingApproval: null,
+            });
         }
-        if (pendingApproval) {
-            const stored = await getAgentHarnessSession(storedSessionId);
-            const stillPending = stored?.pendingApproval &&
-                typeof stored.pendingApproval === "object" &&
-                "id" in stored.pendingApproval &&
-                stored.pendingApproval.id === pendingApproval.id;
-            if (stillPending) {
+        catch (error) {
+            if (harnessSession && !keepLiveSession) {
+                await stopHarnessSession(harnessSession).catch(() => undefined);
+            }
+            if (storedSessionId) {
+                releaseLiveAgentHarnessSession(storedSessionId, harnessSession);
                 await updateAgentHarnessSession(storedSessionId, {
-                    status: "idle",
-                    pendingApproval,
-                });
-                return;
+                    status: "errored",
+                    pendingApproval: null,
+                }).catch(() => undefined);
             }
+            throw error;
         }
-        let resumeState = opts.createSession?.resumeState;
-        if (detachOnComplete && harnessSession.detach) {
-            resumeState = await harnessSession.detach();
+        finally {
+            if (!keepLiveSession && storedSessionId) {
+                releaseLiveAgentHarnessSession(storedSessionId, harnessSession);
+            }
         }
-        releaseLiveAgentHarnessSession(storedSessionId, harnessSession);
-        await updateAgentHarnessSession(opts.createSession?.sessionId ?? harnessSession.id, {
-            status: "idle",
-            resumeState,
-            pendingApproval: null,
-        });
     }, opts.onRunComplete, {
         ...(opts.runOptions ?? {}),
         turnId: opts.turnId ?? opts.runOptions?.turnId,

package/dist/agent/observational-memory/observer.js

@@ -31,6 +31,18 @@ export async function runObserver(options) {
         threadId: options.threadId,
     });
     const startIndex = observedThrough + 1;
+    // The cursor is a position in whatever array the previous pass observed. The
+    // live agent loop passes the engine array, where each tool result is its own
+    // entry; other callers pass the store-derived array, which folds those into
+    // their tool-call parts and runs several times shorter. A cursor past the end
+    // of THIS array is a basis mismatch, not an up-to-date thread: the window can
+    // never become non-empty again, so the thread silently stops accruing memory.
+    // Measured in production — 17 of 19 threads carry a cursor above their stored
+    // message count, one at 57 against 9.
+    if (startIndex > options.messages.length) {
+        console.warn(`[observational-memory] thread ${options.threadId}: cursor ${observedThrough} is past the end of this ${options.messages.length}-message window, so nothing can be observed on this basis.`);
+        return { observed: false, unobservedTokens: 0 };
+    }
     const unobserved = options.messages.slice(startIndex);
     if (unobserved.length === 0) {
         return { observed: false, unobservedTokens: 0 };

package/dist/agent/production-agent.d.ts

@@ -1,6 +1,7 @@
 import type { EventHandler as H3EventHandler } from "h3";
 import type { Task } from "../a2a/types.js";
 import { type ActionAutomationContext, type ActionCaller } from "../action.js";
+import type { AgentNativeHarnessSetting } from "../config.js";
 import { fireInternalDispatch } from "../server/self-dispatch.js";
 import { type ReasoningEffort } from "../shared/reasoning-effort.js";
 import { type ResolveEngineConfig } from "./engine/index.js";
@@ -299,6 +300,8 @@ export interface ProductionAgentOptions {
     model?: string;
     /** App/template id used for org-scoped per-app model defaults. */
     appId?: string;
+    /** Static app capability for the hosted tools-only harness picker. */
+    hostedHarnessConfig?: AgentNativeHarnessSetting;
     /** Default effort for requests that do not supply an override. */
     reasoningEffort?: ReasoningEffort;
     /** Provider-specific options passed through to the engine */