@agent-native/core 0.157.6 → 0.157.8

package/dist/extensions/actions.js

@@ -1242,6 +1242,27 @@ async function summarizeExtensionForAgentRead(row, hiddenIds, includeContent, fo
     const fingerprint = contentFingerprint(row.content);
     if (contentQuery) {
         const summary = await summarizeExtension(row, hiddenIds, false);
+        // The whole-body read below is deduped per run, but this branch returned
+        // above it, so a repeated excerpt request re-sent bytes already in context.
+        // One production turn spent 48 of 110 reads re-fetching the same spans.
+        const excerptCtx = getRequestRunContext();
+        const excerpts = excerptCtx
+            ? (excerptCtx.extensionExcerptReads ??= {})
+            : undefined;
+        const excerptKey = `${row.id}:${fingerprint}:${contentContextChars}:${contentQuery}`;
+        if (excerpts?.[excerptKey]) {
+            return {
+                ...summary,
+                contentOmitted: {
+                    reason: "identical-excerpt-already-returned-this-run",
+                    contentHash: fingerprint,
+                    contentLength: row.content.length,
+                    next: 'These exact excerpts were already returned earlier in this run and the body has not changed. Use them to call update-extension with operation="edit"; use a different contentQuery only for a source area you have not read yet.',
+                },
+            };
+        }
+        if (excerpts)
+            excerpts[excerptKey] = true;
         return {
             ...summary,
             contentMatches: findExtensionContentMatches(row.content, contentQuery, contentContextChars),
@@ -1266,7 +1287,7 @@ async function summarizeExtensionForAgentRead(row, hiddenIds, includeContent, fo
                 contentHash: fingerprint,
                 contentLength: row.content.length,
                 inlineContentLimit: LARGE_EXTENSION_INLINE_CONTENT_MAX_CHARS,
-                next: "Call get-extension again with contentQuery set to the relevant function, variable, section marker, or literal text. Use forceContent=true only for a broad rewrite that truly needs the entire body.",
+                next: `Call get-extension again with contentQuery set to the relevant function, variable, section marker, or literal text. If you expect to read more than about three separate areas of this ${row.content.length}-char body, call get-extension once with forceContent=true instead — repeated excerpt reads of the same file cost more context than one whole read.`,
             },
         };
     }

package/dist/hosted-harness/actions/get-hosted-harness-config.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("../../action.js").ActionDefinition<Record<string, never>, import("../../server/hosted-harness-policy.js").HostedHarnessPolicy>;
+export default _default;

package/dist/hosted-harness/actions/get-hosted-harness-config.js

@@ -0,0 +1,13 @@
+import { z } from "zod";
+import { defineAction } from "../../action.js";
+import { hostedHarnessStatusForClient, resolveHostedHarnessPolicy, } from "../../server/hosted-harness-policy.js";
+export default defineAction({
+    description: "Return whether this app's hosted tools-only harness is enabled for the current organization and which runtimes are available.",
+    schema: z.object({}),
+    http: { method: "GET" },
+    agentTool: false,
+    run: async (_args, context) => hostedHarnessStatusForClient(await resolveHostedHarnessPolicy({
+        orgId: context?.orgId,
+        userEmail: context?.userEmail,
+    })),
+});

package/dist/hosted-harness/actions/set-hosted-harness-enabled.d.ts

@@ -0,0 +1,4 @@
+declare const _default: import("../../action.js").ActionDefinition<{
+    enabled: boolean;
+}, import("../../server/hosted-harness-policy.js").HostedHarnessPolicy>;
+export default _default;

package/dist/hosted-harness/actions/set-hosted-harness-enabled.js

@@ -0,0 +1,32 @@
+import { z } from "zod";
+import { defineAction } from "../../action.js";
+import { HOSTED_HARNESS_ORG_SETTING_KEY } from "../../agent/harness/hosted.js";
+import { getOrgRoleForEmail } from "../../mcp/actions/service-token-access.js";
+import { canManageOrg } from "../../org/permissions.js";
+import { hostedHarnessStatusForClient, resolveHostedHarnessPolicy, } from "../../server/hosted-harness-policy.js";
+import { putOrgSetting } from "../../settings/org-settings.js";
+export default defineAction({
+    description: "Enable or disable the hosted tools-only harness for the current organization. Organization owners and admins only.",
+    schema: z.object({ enabled: z.boolean() }),
+    http: { method: "POST" },
+    agentTool: false,
+    run: async (args, context) => {
+        const email = context?.userEmail?.trim().toLowerCase();
+        const orgId = context?.orgId?.trim();
+        if (!email)
+            throw new Error("Sign in to manage hosted harnesses.");
+        if (!orgId)
+            throw new Error("Select an organization to manage harnesses.");
+        const role = await getOrgRoleForEmail(orgId, email);
+        if (!canManageOrg(role)) {
+            throw new Error("Only organization owners and admins can manage hosted harnesses.");
+        }
+        await putOrgSetting(orgId, HOSTED_HARNESS_ORG_SETTING_KEY, {
+            enabled: args.enabled,
+        });
+        return hostedHarnessStatusForClient(await resolveHostedHarnessPolicy({
+            orgId,
+            userEmail: email,
+        }));
+    },
+});

package/dist/localization/default-messages.d.ts

@@ -733,6 +733,9 @@ declare const messages: {
         statusDone: string;
         statusFailed: string;
         statusStopped: string;
+        statusNeedsApproval: string;
+        statusNeedsInput: string;
+        statusPaused: string;
         updatedJustNow: string;
         finishedJustNow: string;
         updatedMinutes: string;
@@ -743,7 +746,7 @@ declare const messages: {
         finishedDate: string;
     };
     agentTask: {
-        backgroundTask: string;
+        spawnedAgent: string;
         stop: string;
         openThread: string;
     };

package/dist/localization/default-messages.js

@@ -739,6 +739,9 @@ const messages = {
         statusDone: "Done",
         statusFailed: "Failed",
         statusStopped: "Stopped",
+        statusNeedsApproval: "Needs approval",
+        statusNeedsInput: "Needs input",
+        statusPaused: "Paused",
         updatedJustNow: "Updated just now",
         finishedJustNow: "Finished just now",
         updatedMinutes: "Updated {{count}}m ago",
@@ -749,8 +752,8 @@ const messages = {
         finishedDate: "Finished {{date}}",
     },
     agentTask: {
-        backgroundTask: "Background task",
-        stop: "Stop background task",
+        spawnedAgent: "Spawned agent",
+        stop: "Stop spawned agent",
         openThread: "Open task thread",
     },
     codeRequired: {

package/dist/notifications/routes.d.ts

@@ -28,6 +28,6 @@ export declare function createNotificationsHandler(): import("h3").EventHandlerW
 } | {
     count?: undefined;
     updated?: undefined;
-    ok: boolean;
     error?: undefined;
+    ok: boolean;
 }>>;

package/dist/provider-api/actions/custom-provider-registration.d.ts

@@ -75,8 +75,9 @@ export declare function createCustomProviderRegistrationAction<TSchema extends Z
         user: "user";
     }>>;
 }, z.core.$strip>>, {
-    id?: undefined;
     message?: undefined;
+    id?: undefined;
+    provider?: undefined;
     deleted?: undefined;
     providers: {
         id: string;
@@ -88,14 +89,13 @@ export declare function createCustomProviderRegistrationAction<TSchema extends Z
         updatedAt: number;
     }[];
     count: number;
-    provider?: undefined;
     found?: undefined;
     registered?: undefined;
     label?: undefined;
 } | {
-    id?: undefined;
     message?: undefined;
     count?: undefined;
+    id?: undefined;
     deleted?: undefined;
     providers?: undefined;
     found: boolean;
@@ -105,9 +105,9 @@ export declare function createCustomProviderRegistrationAction<TSchema extends Z
 } | {
     message?: undefined;
     count?: undefined;
+    provider?: undefined;
     deleted?: undefined;
     providers?: undefined;
-    provider?: undefined;
     found: boolean;
     id: string;
     registered?: undefined;
@@ -115,8 +115,8 @@ export declare function createCustomProviderRegistrationAction<TSchema extends Z
 } | {
     message?: undefined;
     count?: undefined;
-    providers?: undefined;
     provider?: undefined;
+    providers?: undefined;
     found?: undefined;
     deleted: boolean;
     id: string;
@@ -124,9 +124,9 @@ export declare function createCustomProviderRegistrationAction<TSchema extends Z
     label?: undefined;
 } | {
     count?: undefined;
+    provider?: undefined;
     deleted?: undefined;
     providers?: undefined;
-    provider?: undefined;
     found?: undefined;
     registered: boolean;
     id: string;

package/dist/provider-api/actions/provider-api.d.ts

@@ -313,7 +313,6 @@ export declare function createProviderApiActions(runtime: Pick<ProviderApiRuntim
     }, {
         deleted?: undefined;
         id?: undefined;
-        provider?: undefined;
         providers: {
             id: string;
             label: string;
@@ -324,6 +323,7 @@ export declare function createProviderApiActions(runtime: Pick<ProviderApiRuntim
             updatedAt: number;
         }[];
         count: number;
+        provider?: undefined;
         found?: undefined;
         registered?: undefined;
         label?: undefined;
@@ -340,18 +340,18 @@ export declare function createProviderApiActions(runtime: Pick<ProviderApiRuntim
         message?: undefined;
     } | {
         deleted?: undefined;
-        provider?: undefined;
         providers?: undefined;
         count?: undefined;
+        provider?: undefined;
         found: boolean;
         id: string;
         registered?: undefined;
         label?: undefined;
         message?: undefined;
     } | {
-        provider?: undefined;
         providers?: undefined;
         count?: undefined;
+        provider?: undefined;
         found?: undefined;
         deleted: boolean;
         id: string;
@@ -360,9 +360,9 @@ export declare function createProviderApiActions(runtime: Pick<ProviderApiRuntim
         message?: undefined;
     } | {
         deleted?: undefined;
-        provider?: undefined;
         providers?: undefined;
         count?: undefined;
+        provider?: undefined;
         found?: undefined;
         registered: boolean;
         id: string;

package/dist/server/action-discovery.js

@@ -529,6 +529,10 @@ export const ALWAYS_ON_CORE_ACTIONS = new Set([
     "revoke-org-service-token",
     "list-mcp-tools",
     "call-mcp-tool",
+    // Hosted harness capability/policy routes are UI-facing and deliberately
+    // never enter the model's action surface (`agentTool: false`).
+    "get-hosted-harness-config",
+    "set-hosted-harness-enabled",
 ]);
 export async function mergeCoreSharingActions(registry) {
     const entries = [
@@ -592,6 +596,14 @@ export async function mergeCoreSharingActions(registry) {
             "get-feature-flags",
             () => import("../feature-flags/actions/get-feature-flags.js"),
         ],
+        [
+            "get-hosted-harness-config",
+            () => import("../hosted-harness/actions/get-hosted-harness-config.js"),
+        ],
+        [
+            "set-hosted-harness-enabled",
+            () => import("../hosted-harness/actions/set-hosted-harness-enabled.js"),
+        ],
         [
             "list-feature-flags",
             () => import("../feature-flags/actions/list-feature-flags.js"),

package/dist/server/agent-chat-plugin.js

@@ -12,6 +12,7 @@ import { AGENT_CHAT_BACKGROUND_RUN_FIELD, AGENT_CHAT_PROCESS_RUN_PATH, backgroun
 import { resolveEngine, createAnthropicEngine, getStoredModelForEngine, normalizeModelForEngine, resolveDelegatedRunModel, getAgentEngineEntry, isAgentEnginePackageInstalled, isStoredEngineUsableForRequest, listAgentEngines, registerBuiltinEngines, } from "../agent/engine/index.js";
 import { SYSTEM_PROMPT_CACHE_SPLIT } from "../agent/engine/prompt-cache.js";
 import { PROVIDER_TO_ENV } from "../agent/engine/provider-env-vars.js";
+import { hostedHarnessSystemPrompt } from "../agent/harness/hosted.js";
 import { createProductionAgentHandler, actionsToEngineTools, executeAgentToolCall, filterActionsByAllowedNames, readPersistedActionSurface, toolCallCacheKey, getActiveRunForThreadAsync, abortRunDurably, abortTurnDurably, subscribeToRun, } from "../agent/production-agent.js";
 import { callerHasRunAccess, callerHasThreadAccess, } from "../agent/run-ownership.js";
 import { markTurnAborted, readBackgroundRunClaim } from "../agent/run-store.js";
@@ -44,6 +45,7 @@ import { captureError } from "./capture-error.js";
 import { getH3App, markDefaultPluginProvided, trackPluginInit, } from "./framework-request-handler.js";
 import { getOrigin } from "./google-oauth.js";
 import { readBody } from "./h3-helpers.js";
+import { loadHostedHarnessConfig } from "./hosted-harness-policy.js";
 import { startIntervalJob } from "./interval-job.js";
 import { getModelFamilyOverlay } from "./prompts/index.js";
 import { mountRealtimeVoiceRoutes } from "./realtime-voice.js";
@@ -309,6 +311,7 @@ export function createAgentChatPlugin(options) {
             // `/runs/active` reaps the requested run on demand, and the periodic
             // recovery sweep below handles abandoned runs with no connected client.
             const env = process.env.NODE_ENV;
+            const hostedHarnessConfig = await loadHostedHarnessConfig();
             // AGENT_MODE=production forces production agent constraints even in dev
             const canToggle = (env === "development" || env === "test") &&
                 process.env.AGENT_MODE !== "production";
@@ -2694,6 +2697,13 @@ Non-code requests are still fine on this surface: read data, navigate the UI, su
                     const codeEditingSurfaceRestriction = shouldBlockInProductCodeEditing(event)
                         ? APP_RENDERED_CHAT_NO_DIRECT_CODE_PROMPT
                         : "";
+                    const hostedHarnessRuntime = getRequestRunContext()?.hostedHarnessRuntime;
+                    const hostedHarnessPromptNote = hostedHarnessRuntime
+                        ? hostedHarnessSystemPrompt(hostedHarnessRuntime)
+                        : "";
+                    const requestProdCodeExecPromptNote = hostedHarnessRuntime
+                        ? ""
+                        : prodCodeExecPromptNote;
                     // Per-model overlay: nudge GPT/Gemini engines toward our behavioral norms.
                     const modelOverlay = resolveModelOverlay();
                     // Stable-first ordering: base prompt / schema / extra come before
@@ -2705,7 +2715,7 @@ Non-code requests are still fine on this surface: read data, navigate the UI, su
                     // `SYSTEM_PROMPT_CACHE_SPLIT` marks where the cacheable prefix ends,
                     // so everything after it can change without a cache write.
                     if (leanPrompt) {
-                        const leanRunPolicyPrompt = buildLeanRunPolicyPrompt(codeEditingSurfaceRestriction, prodCodeExecPromptNote);
+                        const leanRunPolicyPrompt = buildLeanRunPolicyPrompt(codeEditingSurfaceRestriction, `${requestProdCodeExecPromptNote}${hostedHarnessPromptNote ? `\n\n${hostedHarnessPromptNote}` : ""}`);
                         const resources = await loadResourcesForPrompt(owner, true, options?.appId, undefined, { disabledFrameworkGroups });
                         await emitContextXraySystemSections(event, {
                             frameworkPrompt: requestLeanPrompt.slice(0, Math.max(0, requestLeanPrompt.length - requestLeanActionsPrompt.length)),
@@ -2740,20 +2750,26 @@ Non-code requests are still fine on this surface: read data, navigate the UI, su
                         extra,
                         modelOverlay,
                         runtimeContext,
-                        additionalFramework: codeEditingSurfaceRestriction + prodCodeExecPromptNote,
+                        additionalFramework: codeEditingSurfaceRestriction +
+                            requestProdCodeExecPromptNote +
+                            (hostedHarnessPromptNote ? `\n\n${hostedHarnessPromptNote}` : ""),
                     });
                     return setSystemPromptOnContext(requestBasePrompt +
                         SYSTEM_PROMPT_CACHE_SPLIT +
                         resources +
                         schemaBlock +
                         codeEditingSurfaceRestriction +
-                        prodCodeExecPromptNote +
+                        requestProdCodeExecPromptNote +
+                        (hostedHarnessPromptNote
+                            ? `\n\n${hostedHarnessPromptNote}`
+                            : "") +
                         extra +
                         modelOverlay +
                         runtimeContext);
                 },
                 model: options?.model,
                 appId: options?.appId,
+                hostedHarnessConfig,
                 apiKey: options?.apiKey,
                 ...resolveInteractiveAgentRunOptions(options),
                 finalResponseGuard: options?.finalResponseGuard,
@@ -4692,9 +4708,13 @@ Non-code requests are still fine on this surface: read data, navigate the UI, su
                     // `prodHandler.systemPrompt` then steers source changes to a
                     // separate agent surface such as Builder or the dev frame.
                     const blockInProductCodeEditing = shouldBlockInProductCodeEditing(event);
+                    const hostedHarnessRequest = getHeader(event, "x-agent-native-hosted-harness") === "1";
                     const handler = ownerContext.anonymous && anonymousHandler
                         ? anonymousHandler
-                        : !blockInProductCodeEditing && currentDevMode && devHandler
+                        : !hostedHarnessRequest &&
+                            !blockInProductCodeEditing &&
+                            currentDevMode &&
+                            devHandler
                             ? devHandler
                             : prodHandler;
                     return handler(event);

package/dist/server/agent-teams.d.ts

@@ -66,6 +66,10 @@ export interface AgentTask {
     taskId: string;
     threadId: string;
     parentThreadId?: string;
+    /** Request owner used to scope every browser-visible task read and control. */
+    ownerEmail?: string | null;
+    /** Organization scope captured when the task was spawned. */
+    orgId?: string | null;
     name?: string;
     description: string;
     status: "running" | "completed" | "errored";
@@ -85,6 +89,10 @@ export interface AgentTask {
      */
     delegationDepth?: number;
 }
+export interface AgentTeamOwnerScope {
+    ownerEmail: string | null;
+    orgId?: string | null;
+}
 export type AgentTeamBackgroundRun = Omit<BackgroundAgentRun, "kind" | "source" | "sourceRecord" | "status" | "cwd" | "goalId" | "transcriptPath" | "artifactRoot"> & {
     kind: "agent-team";
     source: "hosted-agent-team";
@@ -272,25 +280,25 @@ export declare function processAgentTeamRun(opts: ProcessAgentTeamRunOptions): P
     ok: boolean;
     skipped?: string;
 }>;
-/** Get task by ID */
-export declare function getTask(taskId: string): Promise<AgentTask | undefined>;
-/** Get task by thread ID */
-export declare function getTaskByThread(threadId: string): Promise<AgentTask | undefined>;
-/** List all tasks (most recent first) */
-export declare function listTasks(): Promise<AgentTask[]>;
-export declare function listAgentTeamBackgroundRuns(): Promise<AgentTeamBackgroundRun[]>;
-export declare function getAgentTeamBackgroundRun(runId: string): Promise<AgentTeamBackgroundRun | null>;
-export declare function listAgentTeamBackgroundTranscriptEvents(runId: string): Promise<AgentTeamBackgroundTranscriptEvent[]>;
+/** Get task by ID, optionally constrained to the current request scope. */
+export declare function getTask(taskId: string, scope?: AgentTeamOwnerScope): Promise<AgentTask | undefined>;
+/** Get task by thread ID, optionally constrained to the current request scope. */
+export declare function getTaskByThread(threadId: string, scope?: AgentTeamOwnerScope): Promise<AgentTask | undefined>;
+/** List tasks in the current owner/org scope (most recent first). */
+export declare function listTasks(scope?: AgentTeamOwnerScope): Promise<AgentTask[]>;
+export declare function listAgentTeamBackgroundRuns(scope?: AgentTeamOwnerScope): Promise<AgentTeamBackgroundRun[]>;
+export declare function getAgentTeamBackgroundRun(runId: string, scope?: AgentTeamOwnerScope): Promise<AgentTeamBackgroundRun | null>;
+export declare function listAgentTeamBackgroundTranscriptEvents(runId: string, scope?: AgentTeamOwnerScope): Promise<AgentTeamBackgroundTranscriptEvent[]>;
 export declare function subscribeToAgentTeamBackgroundRun(runId: string, fromSeq?: number): ReadableStream<Uint8Array> | null;
 /** Send a message/update to a running sub-agent via application state */
-export declare function sendToTask(taskId: string, message: string): Promise<{
+export declare function sendToTask(taskId: string, message: string, scope?: AgentTeamOwnerScope): Promise<{
     ok: boolean;
     error?: string;
     messageId?: string;
     queuedCount?: number;
 }>;
-export declare function sendToAgentTeamBackgroundRun(runId: string, message: string): Promise<SendToAgentTeamBackgroundRunResult>;
-export declare function stopAgentTeamBackgroundRun(runId: string, reason?: string): Promise<ControlAgentTeamBackgroundRunResult>;
+export declare function sendToAgentTeamBackgroundRun(runId: string, message: string, scope?: AgentTeamOwnerScope): Promise<SendToAgentTeamBackgroundRunResult>;
+export declare function stopAgentTeamBackgroundRun(runId: string, reason?: string, scope?: AgentTeamOwnerScope): Promise<ControlAgentTeamBackgroundRunResult>;
 /** Mark a task as errored */
 export declare function markTaskErrored(taskId: string, error: string): Promise<void>;
 export declare const _agentTeamsQueueForTests: {

package/dist/server/agent-teams.js

@@ -936,10 +936,24 @@ export async function spawnTask(opts) {
     }
     const runId = taskRunId(taskId);
     const createdAt = Date.now();
+    let orgId;
+    if (hasRequestContext()) {
+        orgId = getRequestOrgId() ?? null;
+    }
+    else {
+        try {
+            orgId = await resolveOrgIdForEmail(opts.ownerEmail);
+        }
+        catch {
+            orgId = null;
+        }
+    }
     const task = {
         taskId,
         threadId: thread.id,
         ...(opts.parentThreadId ? { parentThreadId: opts.parentThreadId } : {}),
+        ownerEmail: opts.ownerEmail,
+        orgId,
         ...(opts.name ? { name: opts.name } : {}),
         description: opts.description,
         status: "running",
@@ -972,18 +986,6 @@ export async function spawnTask(opts) {
     // (integrations/webhook-handler.ts). Execution happens in `processAgentTeamRun`,
     // invoked by the `/_agent-native/agent-teams/_process-run` route mounted
     // inside the agent-chat plugin (where the action/prompt/engine closures live).
-    let orgId;
-    if (hasRequestContext()) {
-        orgId = getRequestOrgId() ?? null;
-    }
-    else {
-        try {
-            orgId = await resolveOrgIdForEmail(opts.ownerEmail);
-        }
-        catch {
-            orgId = null;
-        }
-    }
     const payload = {
         description: opts.description,
         instructions: opts.instructions,
@@ -1505,35 +1507,45 @@ export async function processAgentTeamRun(opts) {
         return { ok: true };
     });
 }
-/** Get task by ID */
-export async function getTask(taskId) {
+/** Get task by ID, optionally constrained to the current request scope. */
+export async function getTask(taskId, scope) {
     const task = await loadTask(taskId);
-    return task ? await reconcileTaskWithRun(task) : undefined;
+    if (!task || !taskMatchesOwnerScope(task, resolveOwnerScope(scope))) {
+        return undefined;
+    }
+    return await reconcileTaskWithRun(task);
 }
-/** Get task by thread ID */
-export async function getTaskByThread(threadId) {
+/** Get task by thread ID, optionally constrained to the current request scope. */
+export async function getTaskByThread(threadId, scope) {
     const task = await loadTaskByThread(threadId);
-    return task ? await reconcileTaskWithRun(task) : undefined;
+    if (!task || !taskMatchesOwnerScope(task, resolveOwnerScope(scope))) {
+        return undefined;
+    }
+    return await reconcileTaskWithRun(task);
 }
-/** List all tasks (most recent first) */
-export async function listTasks() {
+/** List tasks in the current owner/org scope (most recent first). */
+export async function listTasks(scope) {
+    const ownerScope = resolveOwnerScope(scope);
     const entries = await listAppState(TASK_PREFIX);
-    const tasks = entries.map((e) => e.value);
+    const tasks = entries
+        .map((e) => e.value)
+        .filter((task) => taskMatchesOwnerScope(task, ownerScope));
     const reconciled = await Promise.all(tasks.map(reconcileTaskWithRun));
     return reconciled.sort((a, b) => (b.updatedAt ?? b.completedAt ?? b.createdAt) -
         (a.updatedAt ?? a.completedAt ?? a.createdAt));
 }
-export async function listAgentTeamBackgroundRuns() {
-    return (await listTasks()).map(toAgentTaskBackgroundRun);
+export async function listAgentTeamBackgroundRuns(scope) {
+    return (await listTasks(scope)).map(toAgentTaskBackgroundRun);
 }
-export async function getAgentTeamBackgroundRun(runId) {
-    const task = await loadTask(taskIdFromBackgroundRunId(runId));
-    return task
-        ? toAgentTaskBackgroundRun(await reconcileTaskWithRun(task))
-        : null;
+export async function getAgentTeamBackgroundRun(runId, scope) {
+    const task = await getTask(taskIdFromBackgroundRunId(runId), scope);
+    return task ? toAgentTaskBackgroundRun(task) : null;
 }
-export async function listAgentTeamBackgroundTranscriptEvents(runId) {
+export async function listAgentTeamBackgroundTranscriptEvents(runId, scope) {
     const taskId = taskIdFromBackgroundRunId(runId);
+    const ownerScope = resolveOwnerScope(scope);
+    if (ownerScope && !(await getTask(taskId, ownerScope)))
+        return [];
     const normalizedRunId = taskRunId(taskId);
     const runIds = await transcriptRunIdsForTask(taskId);
     const output = [];
@@ -1589,10 +1601,11 @@ async function getPersistedRunEvents(runId) {
         .filter((event) => Boolean(event));
 }
 /** Send a message/update to a running sub-agent via application state */
-export async function sendToTask(taskId, message) {
+export async function sendToTask(taskId, message, scope) {
     const task = await loadTask(taskId);
-    if (!task)
+    if (!task || !taskMatchesOwnerScope(task, resolveOwnerScope(scope))) {
         return { ok: false, error: "Task not found" };
+    }
     if (task.status !== "running")
         return { ok: false, error: "Task is not running" };
     if (message.trim().length === 0)
@@ -1612,8 +1625,8 @@ export async function sendToTask(taskId, message) {
         return { ok: false, error: "Unable to queue message" };
     }
 }
-export async function sendToAgentTeamBackgroundRun(runId, message) {
-    return sendToTask(taskIdFromBackgroundRunId(runId), message);
+export async function sendToAgentTeamBackgroundRun(runId, message, scope) {
+    return sendToTask(taskIdFromBackgroundRunId(runId), message, scope);
 }
 async function sendAgentTeamBackgroundAgentFollowUp(input) {
     const prompt = input.prompt.trim();
@@ -1655,11 +1668,12 @@ async function controlAgentTeamBackgroundAgentRun(input) {
         error: result.error,
     };
 }
-export async function stopAgentTeamBackgroundRun(runId, reason = "user") {
+export async function stopAgentTeamBackgroundRun(runId, reason = "user", scope) {
     const taskId = taskIdFromBackgroundRunId(runId);
     const task = await loadTask(taskId);
-    if (!task)
+    if (!task || !taskMatchesOwnerScope(task, resolveOwnerScope(scope))) {
         return { ok: false, error: "Task not found" };
+    }
     if (task.status !== "running") {
         return { ok: false, error: "Task is not running" };
     }
@@ -1678,6 +1692,26 @@ export async function stopAgentTeamBackgroundRun(runId, reason = "user") {
     await completeAgentTeamRun(task.taskId, "failed");
     return { ok: true };
 }
+function resolveOwnerScope(scope) {
+    if (scope)
+        return scope;
+    const ownerEmail = getRequestUserEmail();
+    if (ownerEmail === undefined)
+        return undefined;
+    return {
+        ownerEmail,
+        // A few non-HTTP test/CLI hosts only provide the user scope. Keep that
+        // owner check active without requiring every lightweight request-context
+        // adapter to implement organization lookup.
+        orgId: typeof getRequestOrgId === "function" ? getRequestOrgId() : undefined,
+    };
+}
+function taskMatchesOwnerScope(task, scope) {
+    if (!scope)
+        return true;
+    return ((task.ownerEmail ?? null) === scope.ownerEmail &&
+        (scope.orgId === undefined || (task.orgId ?? null) === scope.orgId));
+}
 /** Mark a task as errored */
 export async function markTaskErrored(taskId, error) {
     const task = await loadTask(taskId);

package/dist/server/hosted-harness-policy.d.ts

@@ -0,0 +1,17 @@
+import { type HostedHarnessRuntime } from "../agent/harness/hosted.js";
+import type { AgentNativeHarnessSetting } from "../config.js";
+export interface HostedHarnessPolicy {
+    enabled: boolean;
+    configEnabled: boolean;
+    envEnabled: boolean;
+    organizationEnabled: boolean;
+    runtimes: HostedHarnessRuntime[];
+}
+export declare function isHostedHarnessEnvEnabled(env?: Record<string, string | undefined>): boolean;
+export declare function loadHostedHarnessConfig(cwd?: string): Promise<AgentNativeHarnessSetting | undefined>;
+export declare function resolveHostedHarnessPolicy(options: {
+    config?: AgentNativeHarnessSetting;
+    orgId?: string | null;
+    userEmail?: string | null;
+}): Promise<HostedHarnessPolicy>;
+export declare function hostedHarnessStatusForClient(policy: HostedHarnessPolicy): HostedHarnessPolicy;