@hosty-sdk/app 0.35.1 → 0.37.0

package/README.md

@@ -298,6 +298,30 @@ PCM16 WAV. Browser microphone consent is separate from Core permission.
 credentials and the acting user's access. It does not expose general agent execution.
 See [Provider consumption](../../docs/features/provider-consumption/feature.md) for the full contract.
 
+## Tasks And Execution Providers
+
+Core 0.159.0 and SDK 0.36.0 support independent `tasks` and `task-executor` categories. Request
+`providers.tasks` or `providers.task-executor`, select an app/installation/key explicitly and use
+server-only clients. Models, credentials and Harness profile internals are not shared task fields.
+
+```ts
+import { ProviderClient } from "@hosty-sdk/app/providers/server";
+import { TaskClient, TaskExecutorClient } from "@hosty-sdk/app/tasks/server";
+const providers = new ProviderClient();
+const tasks = new TaskClient(providers, selectedTaskProvider, getCurrentUserToken);
+const draft = await tasks.create({ requestId, input: {
+  title: "Summarize the meeting", markdown: "List decisions and next steps.",
+  assignee: { kind: "app", executor: selectedExecutor, optionId }, resources: [],
+} });
+await tasks.action(draft.ref, { requestId: readyRequestId, expectedRevision: draft.revision, action: "ready" });
+const executions = new TaskExecutorClient(providers, selectedExecutor, getCurrentUserToken);
+const receipt = await executions.get(executionId);
+```
+
+Retain each UUID and exact body after a timeout. Clients do not retry mutations implicitly. A task
+provider persists execution intent before PUT; completed model output alone is not a task result.
+See [Basic Tasks](../../docs/features/basic-tasks/feature.md) for the protocol and authority boundaries.
+
 ### Assistant MCP credentials
 
 MCP handlers use `introspectMcpToken` from `@hosty-sdk/app/scoped-token` for online validation of
@@ -572,12 +596,19 @@ See [UI composition and browser acceptance](../../docs/features/sdk-ui-compositi
 
 `@hosty-sdk/app/sandbox/react` exports `CoreEnvironmentPanel` for operator-facing child Core
 management. Supply an authenticated `EnvironmentRequest` transport, a tab-local replay storage key
-and optionally a workspace with its active worktrees. Shell and Workspaces use this shared panel
-for create/start, current/source Core selection, normal test-account setup, app status, preview and
-confirmed deletion. The component does not grant authority: Core independently checks the optional
+and optionally a workspace with its active worktrees. It supports create/start, current/source
+Core selection, normal test-account setup, app status, preview and confirmed deletion. Shell has
+its own combined Core/environment rows and current-mode creation dialog. The component does not grant authority: Core independently checks the optional
 `core.environments.inspect/operate` grants, administrator identity and workspace source access.
 
-`@hosty-sdk/app/sandbox/server` provides the server-side clients for independent app sandboxes and
-child Core environments. Caller-owned `core.environments.read/manage` authority remains distinct
+`@hosty-sdk/app/sandbox/server` provides CoreEnvironmentClient for child Core environments. Caller-owned `core.environments.read/manage` authority remains distinct
 from the operator panel's cross-caller permissions. See the
-[sandbox contract](../../docs/features/app-sandbox-runtimes/feature.md) for lifecycle and cleanup rules.
+[environment contract](../../docs/features/app-sandbox-runtimes/feature.md) for lifecycle and cleanup rules.
+
+Version 0.37 removes SandboxClient, SandboxAction, the single-app Sandbox* request/view types,
+SandboxIdentity/SandboxTarget, readSandboxIdentity and readSandboxTarget. No relay identity or
+HOSTY_SANDBOX_* protocol is supported. Use CoreEnvironmentClient plus ordinary child app/user APIs;
+apps run with the same normal identity and app-owned roles as any other Core installation. Existing
+core.environments.* grants require their ordinary review; removed apps.sandboxes.* grants confer
+no replacement authority. The /sandbox/server and /sandbox/react module paths remain for the
+retained child-environment API.

package/dist/index.d.ts

@@ -206,8 +206,3 @@ export declare function decideRecoveryAction(input: {
 }): RecoveryAction;
 /** Paint-time navigation policy. Kept in the pure entry point for Node and edge consumers. */
 export declare function chromeBootstrapScript(defaults?: import("./ui-types").UiChromeOverrides): string;
-/** Execution scope is independent of the principal's role. Never infer it from an app ID. */
-import type { SandboxTarget, SandboxIdentityContext } from "./sandbox-identity.js";
-export type { SandboxTarget, SandboxIdentityContext } from "./sandbox-identity.js";
-export declare function readSandboxTarget(environment: Record<string, string | undefined>): SandboxTarget | null;
-export declare function readSandboxIdentity(payload: Record<string, unknown>, expected: SandboxTarget | null): SandboxIdentityContext | null;

package/dist/index.js

@@ -269,24 +269,3 @@ export function chromeBootstrapScript(defaults = {}) {
         throw new Error("Invalid navigation default.");
     return `(()=>{try{const d=${JSON.stringify({ navigation })},p=new URLSearchParams(location.search),h=new URLSearchParams();for(const k of ["hosty_navigation","hosty_tools","hosty_tool_launcher","hosty_launch"])for(const v of p.getAll(k))h.append(k,v);document.documentElement.setAttribute('data-hosty-chrome-hints',h.toString());const one=k=>p.getAll(k).length===1?p.get(k):null,n=one('hosty_navigation'),l=one('hosty_launch');document.documentElement.setAttribute('data-hosty-navigation',n==='show'||n==='hide'?n:d.navigation??(l==='native'||l==='embedded'?'hide':'show'));}catch{}})();`;
 }
-export function readSandboxTarget(environment) {
-    const fields = [environment.HOSTY_SANDBOX_INSTANCE_ID, environment.HOSTY_SANDBOX_GENERATION, environment.HOSTY_SANDBOX_DATA_REVISION];
-    if (!environment.HOSTY_SANDBOX_PROTOCOL && fields.every(value => !value))
-        return null;
-    if (environment.HOSTY_SANDBOX_PROTOCOL !== "hosty-sandbox-v1" || fields.some(value => !/^[a-f0-9]{32}$/.test(value ?? "")))
-        throw new Error("The sandbox execution target is missing or unsupported.");
-    return { runtimeInstanceId: fields[0], generation: fields[1], dataRevision: fields[2] };
-}
-export function readSandboxIdentity(payload, expected) {
-    if (!expected) {
-        if (payload.identityRealm === "sandbox" || payload.runtimeInstanceId != null || payload.generation != null || payload.dataRevision != null)
-            throw new Error("An installed app cannot accept a sandbox identity.");
-        return null;
-    }
-    if (payload.runtimeInstanceId !== expected.runtimeInstanceId || payload.generation !== expected.generation || payload.dataRevision !== expected.dataRevision
-        || (payload.identityRealm !== "sandbox" && payload.identityRealm !== "core") || typeof payload.appRole !== "string"
-        || !Array.isArray(payload.permissions) || !payload.permissions.every(value => typeof value === "string")
-        || (payload.identityRealm === "sandbox" && payload.hostRole != null))
-        throw new Error("The identity belongs to a different or unsupported sandbox target.");
-    return { ...expected, identityRealm: payload.identityRealm, appRole: payload.appRole, permissions: payload.permissions };
-}

package/dist/overlay-react.js

@@ -7,7 +7,7 @@ import { useAppActivity } from "./activity-react.js";
 import { APP_SESSION_ENDED, APP_SESSION_RESTORED, APP_ACTIVITY_RENEWED, acceptAppAuthProtocol } from "./browser-auth.js";
 import { buildCoreOpenUrl, readRecoveryParams } from "./index.js";
 import { permissionReviewUrl, requestPermissionReview } from "./permissions.js";
-import { SdkBrand, SdkChromeStyles, SdkLoader } from "./sdk-chrome.js";
+import { SdkBrand, SdkChromeStyles, SdkIcon, SdkLoader } from "./sdk-chrome.js";
 import { HostyUiRoot } from "./ui-react.js";
 function snapshot(body) {
     const value = body;
@@ -19,6 +19,7 @@ function snapshot(body) {
     const openUrl = recovery.appId ? buildCoreOpenUrl(recovery.corePublicOrigin, recovery.appId, window.location) : null;
     // The activity policy remains authoritative even when renewal discovery fails.
     return { userId: value.userId, setup, notice: value.hosty?.notice,
+        permissionWarning: value.hosty?.permissionWarning === "unsupported",
         activityRequired: value.activityRequired === true,
         activeUntil: typeof value.activeUntil === "string" ? value.activeUntil : null,
         recoveryReady: !!openUrl && !!acceptAppAuthProtocol(new URL(openUrl).origin, recovery.appAuthProtocol) };
@@ -189,7 +190,7 @@ export function HostyOverlay({ children, probePath = "/api/hosty/session", appCo
     }
     const localOffline = (identity.ui.kind === "unavailable" || (identity.ui.kind === "active" && session?.setup === "unavailable"))
         && localContent !== undefined;
-    return _jsxs(_Fragment, { children: [localOffline && _jsxs("div", { "data-hosty-local-content": true, children: [_jsxs("div", { "data-hosty-sdk": true, className: "hosty-overlay-offline", role: "status", children: [_jsx(SdkChromeStyles, {}), _jsx("style", { children: styles }), _jsx(SdkBrand, {}), _jsx("span", { children: "Hosty is unavailable. Local content remains available." }), _jsx("button", { type: "button", className: "hosty-sdk-button", onClick: () => { void refreshRef.current(); }, children: "Retry" })] }), localContent] }), _jsx("div", { "data-hosty-content": true, hidden: !ready, inert: !ready, style: ready ? { display: "contents" } : { display: "none" }, children: _jsx(HostyUiRoot, { chrome: chrome, navigation: navigation, uiPath: uiPath, panelLayout: panelLayout, active: ready, children: mounted.current ? children : null }) }), !ready && !localOffline && _jsx(OverlaySurface, { pending: pending, title: title, message: message, action: action, actionLabel: actionLabel, reviewUrl: reviewUrl })] });
+    return _jsxs(_Fragment, { children: [ready && session?.permissionWarning && _jsxs("div", { "data-hosty-sdk": true, role: "status", className: "hosty-overlay-offline", children: [_jsx(SdkChromeStyles, {}), _jsx("style", { children: styles }), _jsx(SdkIcon, { name: "warning" }), _jsxs("span", { children: ["This Core does not support some permissions requested by this app. Update the app or Core. These permissions are not granted; some app features may not work.", session.notice?.permissions?.unsupportedRequired?.length ? ` (${session.notice.permissions.unsupportedRequired.join(", ")})` : ""] })] }), localOffline && _jsxs("div", { "data-hosty-local-content": true, children: [_jsxs("div", { "data-hosty-sdk": true, className: "hosty-overlay-offline", role: "status", children: [_jsx(SdkChromeStyles, {}), _jsx("style", { children: styles }), _jsx(SdkBrand, {}), _jsx("span", { children: "Hosty is unavailable. Local content remains available." }), _jsx("button", { type: "button", className: "hosty-sdk-button", onClick: () => { void refreshRef.current(); }, children: "Retry" })] }), localContent] }), _jsx("div", { "data-hosty-content": true, hidden: !ready, inert: !ready, style: ready ? { display: "contents" } : { display: "none" }, children: _jsx(HostyUiRoot, { chrome: chrome, navigation: navigation, uiPath: uiPath, panelLayout: panelLayout, active: ready, children: mounted.current ? children : null }) }), !ready && !localOffline && _jsx(OverlaySurface, { pending: pending, title: title, message: message, action: action, actionLabel: actionLabel, reviewUrl: reviewUrl })] });
 }
 function OverlaySurface({ pending, title, message, action, actionLabel, reviewUrl }) {
     const [portal, setPortal] = useState(null);

package/dist/permissions-react.js

@@ -42,9 +42,7 @@ export function MissingPermissionsNotice({ endpoint = "/api/hosty/permissions" }
     const kind = state && permissionNotice(state);
     if (dismissed || !kind || !state)
         return null;
-    return _jsxs("section", { "data-hosty-sdk": true, "data-hosty-activity-control": true, role: "alert", "aria-label": "Required permissions", className: "hosty-permissions-notice", children: [_jsx(SdkChromeStyles, {}), _jsx("style", { children: styles }), _jsxs("header", { children: [_jsx(SdkBrand, {}), _jsx(SdkIcon, { name: "warning" }), _jsx("strong", { children: "Permissions needed" })] }), kind === "unsupported"
-                ? _jsxs("p", { children: ["Core does not support required permissions: ", state.permissions.unsupportedRequired.join(", "), ". Update the app or Core."] })
-                : _jsx("p", { children: "This app needs required permissions. Operations using them are unavailable until approval." }), kind === "missing" && state.permissions?.reviewAvailable !== false && state.corePublicOrigin &&
+    return _jsxs("section", { "data-hosty-sdk": true, "data-hosty-activity-control": true, role: "alert", "aria-label": "Required permissions", className: "hosty-permissions-notice", children: [_jsx(SdkChromeStyles, {}), _jsx("style", { children: styles }), _jsxs("header", { children: [_jsx(SdkBrand, {}), _jsx(SdkIcon, { name: "warning" }), _jsx("strong", { children: "Permissions needed" })] }), !!state.permissions?.unsupportedRequired?.length && _jsxs("p", { children: ["This Core does not support requested permissions: ", state.permissions.unsupportedRequired.join(", "), ". Update the app or Core. These permissions are not granted; some app features may not work."] }), kind === "missing" && _jsx("p", { children: "This app needs required permissions. Operations using them are unavailable until approval." }), kind === "missing" && state.permissions?.reviewAvailable !== false && state.corePublicOrigin &&
                 _jsx("button", { type: "button", className: "hosty-sdk-button", onClick: () => { requestPermissionReview(state); setPending(true); }, children: "Request permissions" }), pending && _jsxs("p", { className: "hosty-sdk-status", children: [_jsx(SdkSpinner, {}), "Review permissions in Core, then return here. You can leave this app installed without approving."] }), _jsx("button", { type: "button", onClick: () => { setDismissed(true); setPending(false); }, className: "hosty-sdk-button hosty-sdk-ghost", children: "Dismiss" })] });
 }
 const styles = `

package/dist/permissions.js

@@ -4,9 +4,9 @@ export function permissionNotice(state) {
     if (state.hostRole !== "host.admin" || !state.permissions)
         return null;
     const p = state.permissions;
-    if (p.unsupportedRequired?.length)
-        return "unsupported";
-    return p.required.some(name => !p.granted.includes(name)) ? "missing" : null;
+    if (p.required.some(name => !p.unsupportedRequired?.includes(name) && !p.granted.includes(name)))
+        return "missing";
+    return p.unsupportedRequired?.length ? "unsupported" : null;
 }
 export function permissionReviewUrl(corePublicOrigin, appId) {
     const core = new URL(corePublicOrigin);

package/dist/providers-server.d.ts

@@ -30,6 +30,8 @@ export declare class ProviderClient {
     assistant(provider: Pick<ProviderDescriptor, "appId" | "key"> & {
         installationId?: string | null;
     }, userToken: () => Promise<string>): Promise<AssistantClient>;
+    /** Bounded task protocol transport. The selected installation is checked on every operation. */
+    taskRequest<T>(provider: import("./tasks.js").TaskProviderRef, kind: "tasks" | "task-executor", route: string, method: string, input?: unknown, userToken?: () => Promise<string>, signal?: AbortSignal): Promise<T>;
     /** Provider-side validation checks live grants on every request; never cache this result. */
     validate(token: string, kind: ProviderKind, key?: string, signal?: AbortSignal): Promise<ProviderInvocation>;
 }

package/dist/providers-server.js

@@ -79,6 +79,19 @@ export class ProviderClient {
             return { token: fresh.token };
         });
     }
+    /** Bounded task protocol transport. The selected installation is checked on every operation. */
+    async taskRequest(provider, kind, route, method, input, userToken, signal) {
+        const allowed = kind === "tasks"
+            ? /^(?:\/capabilities|\/tasks(?:\?[a-zA-Z0-9%=&_-]*|\/[a-zA-Z0-9-]+(?:\/actions)?)?)$/
+            : /^(?:\/options|\/executions\/[a-zA-Z0-9-]+(?:\/cancel)?)$/;
+        if (!allowed.test(route) || !["GET", "POST", "PATCH", "PUT"].includes(method))
+            throw new ProviderError("task_route_invalid", "Use a version-one task operation.", 400);
+        const binding = await this.connect({ ...provider, kind }, signal, await userToken?.());
+        return read(await fetch(`${binding.url}${route}`, { method, redirect: "error", cache: "no-store",
+            signal: signal ? AbortSignal.any([signal, AbortSignal.timeout(15_000)]) : AbortSignal.timeout(15_000),
+            headers: { authorization: `Bearer ${binding.token}`, "content-type": "application/json" },
+            body: input === undefined ? undefined : JSON.stringify(input) }));
+    }
     /** Provider-side validation checks live grants on every request; never cache this result. */
     validate(token, kind, key = "default", signal) {
         return this.coreRequest("/provider/introspect", { token, kind, key }, signal);

package/dist/providers.d.ts

@@ -1,5 +1,5 @@
-/** Provider categories supported by Core. Agent execution is intentionally not part of this contract. */
-export type ProviderKind = "speech-to-text" | "assistant" | "translation";
+/** Provider categories supported by Core. Task execution does not expose model/profile configuration. */
+export type ProviderKind = "speech-to-text" | "assistant" | "translation" | "tasks" | "task-executor";
 export type ProviderDescriptor = {
     appId: string;
     displayName: string;

package/dist/sandbox-server.d.ts

@@ -1,39 +1,9 @@
 import type { ProviderServerOptions } from "./providers-server.js";
-export type SandboxSource = {
-    kind: "worktree";
-    worktreeId: string;
-} | {
-    kind: "appArtifact";
-    artifactDigest?: string;
-};
-export interface SandboxLimits {
-    memoryBytes?: number;
-    cpus?: number;
-    pids?: number;
-    dataBytes?: number;
-    cacheBytes?: number;
-    startupSeconds?: number;
-}
 export interface SandboxContext {
     workspaceId?: string;
     sessionId?: string;
     jobId?: string;
 }
-export interface SandboxPlanInput {
-    appId: string;
-    profile: string;
-    source: SandboxSource;
-    limits?: SandboxLimits;
-    context?: SandboxContext;
-}
-export interface SandboxPlan {
-    id: string;
-    digest: string;
-    inputDigest: string;
-    request: SandboxPlanInput;
-    blockers: string[];
-    expiresAt: string;
-}
 export interface SandboxOperation {
     id: string;
     kind: string;
@@ -41,96 +11,11 @@ export interface SandboxOperation {
     errorCode?: string;
     message?: string;
 }
-export interface SandboxUser {
-    id: string;
-    fixtureKey: string;
-    displayName: string;
-    role: string;
-    permissions: string[];
-    enabled: boolean;
-    revision: number;
-}
-export interface SandboxInstance {
-    id: string;
-    appId: string;
-    source: SandboxSource;
-    context?: SandboxContext;
-    revision: number;
-    generation: string;
-    dataRevision: string;
-    state: string;
-    previewUrl?: string;
-    errorCode?: string;
-    operations: SandboxOperation[];
-    users: SandboxUser[];
-    viewers?: string[];
-    endpoints?: {
-        key: string;
-        url: string;
-    }[];
-    metrics?: {
-        at: string;
-        memoryBytes: number | null;
-        sampledPeakMemoryBytes: number | null;
-        services: {
-            service: string;
-            memoryBytes: number | null;
-            cpuPercent: number | null;
-        }[];
-    };
-    storage?: {
-        at: string;
-        dataBytes: number;
-        seedBytes: number;
-        cacheBytes: number;
-        evidenceBytes: number;
-        totalBytes: number;
-        warning: boolean;
-        errorCode?: string;
-    };
-}
-export interface SandboxDiagnostics {
-    instanceId: string;
-    state: string;
-    errorCode?: string;
-    services: {
-        service: string;
-        state: string;
-        text: string;
-    }[];
-}
-export declare const sandboxActions: readonly ["sandbox-logs", "sandbox-plan", "sandbox-prepare", "sandbox-list", "sandbox-status", "sandbox-users", "sandbox-seed", "sandbox-start", "sandbox-restart", "sandbox-stop", "sandbox-reset", "sandbox-dispose", "sandbox-browser", "sandbox-export", "sandbox-user-delete", "sandbox-viewers", "sandbox-evidence-clear", "sandbox-preview", "sandbox-browser-cancel"];
-export type SandboxAction = typeof sandboxActions[number];
 export declare class SandboxError extends Error {
     readonly code: string;
     readonly status: number | null;
     constructor(code: string, message: string, status: number | null);
 }
-/** Server-only transport. The authority callback can supply an interactive grant or an explicitly
- * approved BackgroundGrantClient.token(); neither workspaces nor assistant roles are required. */
-export declare class SandboxClient {
-    private readonly authority;
-    private readonly origin;
-    private readonly appId;
-    private readonly service;
-    constructor(authority: () => Promise<string>, options?: ProviderServerOptions);
-    plan(input: SandboxPlanInput): Promise<SandboxPlan>;
-    prepare(input: {
-        requestId: string;
-        planId: string;
-        digest: string;
-    }): Promise<SandboxInstance>;
-    list(): Promise<{
-        instances: SandboxInstance[];
-    }>;
-    status(runtimeInstanceId: string): Promise<SandboxInstance>;
-    command(runtimeInstanceId: string, action: "start" | "restart" | "stop" | "reset" | "dispose", input: {
-        requestId: string;
-        expectedRevision: number;
-        seedRevision?: string;
-    }): Promise<SandboxInstance>;
-    call<T = unknown>(action: SandboxAction, input: Record<string, unknown>): Promise<T>;
-}
 export declare const coreEnvironmentActions: readonly ["environment-consent", "environment-create", "environment-list", "environment-status", "environment-start", "environment-stop", "environment-restart", "environment-finish", "environment-setup", "environment-api", "environment-initialization", "environment-initialization-resume", "environment-setup-link"];
 export type CoreEnvironmentAction = typeof coreEnvironmentActions[number];
 export interface CoreEnvironmentSavedConsent {
@@ -153,6 +38,7 @@ export interface CoreEnvironment {
     dataRoot?: string;
     previewUrl: string;
     initializationRequested?: boolean;
+    coreVersion?: string | null;
     process?: {
         pid: number;
         startedAt: string;

package/dist/sandbox-server.js

@@ -1,5 +1,3 @@
-export const sandboxActions = ["sandbox-logs", "sandbox-plan", "sandbox-prepare", "sandbox-list", "sandbox-status", "sandbox-users", "sandbox-seed",
-    "sandbox-start", "sandbox-restart", "sandbox-stop", "sandbox-reset", "sandbox-dispose", "sandbox-browser", "sandbox-export", "sandbox-user-delete", "sandbox-viewers", "sandbox-evidence-clear", "sandbox-preview", "sandbox-browser-cancel"];
 export class SandboxError extends Error {
     code;
     status;
@@ -10,89 +8,6 @@ export class SandboxError extends Error {
         this.name = "SandboxError";
     }
 }
-/** Server-only transport. The authority callback can supply an interactive grant or an explicitly
- * approved BackgroundGrantClient.token(); neither workspaces nor assistant roles are required. */
-export class SandboxClient {
-    authority;
-    origin;
-    appId;
-    service;
-    constructor(authority, options = {}) {
-        this.authority = authority;
-        this.origin = new URL(options.coreOrigin ?? process.env.HOSTY_CORE_ORIGIN ?? "http://127.0.0.1:7070");
-        this.appId = options.appId ?? process.env.HOSTY_APP_ID ?? "";
-        this.service = options.serviceToken ?? process.env.HOSTY_APP_SERVICE_TOKEN ?? "";
-        if (!this.appId || !this.service || !["http:", "https:"].includes(this.origin.protocol) || this.origin.username || this.origin.password
-            || this.origin.pathname !== "/" || this.origin.search || this.origin.hash)
-            throw new Error("A valid Core origin and calling app service identity are required.");
-    }
-    plan(input) { return this.call("sandbox-plan", input); }
-    prepare(input) { return this.call("sandbox-prepare", input); }
-    list() { return this.call("sandbox-list", {}); }
-    status(runtimeInstanceId) { return this.call("sandbox-status", { runtimeInstanceId }); }
-    command(runtimeInstanceId, action, input) {
-        return this.call(`sandbox-${action}`, { runtimeInstanceId, ...input });
-    }
-    async call(action, input) {
-        if (!sandboxActions.includes(action))
-            throw new SandboxError("sandbox_operation_invalid", "Unknown sandbox operation.", 400);
-        const { runtimeInstanceId, ...body } = input;
-        const jobId = body.jobId;
-        const root = `/api/internal/apps/${encodeURIComponent(this.appId)}/sandbox-instances`;
-        const read = action === "sandbox-logs" || action === "sandbox-list" || action === "sandbox-status" || action === "sandbox-export" || action === "sandbox-preview";
-        let suffix = "";
-        if (action === "sandbox-plan")
-            suffix = "/plans";
-        else if (action !== "sandbox-list" && action !== "sandbox-prepare") {
-            if (typeof runtimeInstanceId !== "string" || !/^[a-f0-9]{32}$/.test(runtimeInstanceId))
-                throw new SandboxError("sandbox_id_invalid", "Use the Core-issued runtime instance ID.", 400);
-            suffix = `/${runtimeInstanceId}`;
-            if (action === "sandbox-logs")
-                suffix += "/diagnostics";
-            else if (action === "sandbox-users")
-                suffix += "/users";
-            else if (action === "sandbox-user-delete")
-                suffix += "/users/delete";
-            else if (action === "sandbox-viewers")
-                suffix += "/viewers";
-            else if (action === "sandbox-evidence-clear")
-                suffix += "/evidence/clear";
-            else if (action === "sandbox-seed")
-                suffix += "/seeds";
-            else if (action === "sandbox-browser")
-                suffix += "/browser-runs";
-            else if (action === "sandbox-browser-cancel")
-                suffix += "/browser-runs/cancel";
-            else if (action === "sandbox-preview")
-                suffix += "/preview" + (typeof body.userId === "string" ? "?userId=" + encodeURIComponent(body.userId) : "");
-            else if (action === "sandbox-export") {
-                if (typeof jobId !== "string" || !/^[a-f0-9]{32}$/.test(jobId))
-                    throw new SandboxError("sandbox_job_invalid", "Select a recorded browser run.", 400);
-                suffix += `/browser-runs/${jobId}`;
-            }
-            else if (!read)
-                suffix += `/operations/${action.slice("sandbox-".length)}`;
-        }
-        if (!read && action !== "sandbox-plan" && (typeof body.requestId !== "string" || !/^[a-f0-9-]{32,36}$/i.test(body.requestId)))
-            throw new SandboxError("sandbox_request_required", "Persist a request UUID before sending a mutation. Replay the same UUID and arguments after an uncertain result.", 400);
-        const credential = await this.authority();
-        let response;
-        try {
-            response = await fetch(new URL(root + suffix, this.origin), { method: read ? "GET" : "POST", redirect: "error", cache: "no-store",
-                headers: { authorization: `Bearer ${this.service}`, "X-Hosty-User-Token": credential, "content-type": "application/json" },
-                body: read ? undefined : JSON.stringify(body), signal: AbortSignal.timeout(action === "sandbox-browser" ? 330_000 : 180_000) });
-        }
-        catch {
-            throw new SandboxError("sandbox_outcome_unknown", "Core could not confirm the outcome. Read the operation or replay its original request UUID and arguments.", null);
-        }
-        const result = await response.json().catch(() => null);
-        if (!result)
-            throw new SandboxError("sandbox_outcome_unknown", "Core returned no readable outcome; keep the original operation identity.", response.status);
-        if (!response.ok)
-            throw new SandboxError(result.code ?? "sandbox_failed", result.message ?? "Sandbox request failed.", response.status);
-        return result;
-    }
-}
 export const coreEnvironmentActions = ["environment-consent", "environment-create", "environment-list", "environment-status", "environment-start",
     "environment-stop", "environment-restart", "environment-finish", "environment-setup", "environment-api", "environment-initialization", "environment-initialization-resume", "environment-setup-link"];
 /** Full child Core transport. Requires core.environments permissions and live administrator authority.

package/dist/server.d.ts

@@ -1,5 +1,4 @@
 import "server-only";
-import { type SandboxIdentityContext } from "./index.js";
 import { type AppContinuity } from "./continuity.js";
 import { type AppAuthProtocol } from "./app-code.js";
 export { isValidCodeVerifier } from "./app-code.js";
@@ -28,8 +27,6 @@ export interface HostIdentity {
     activeUntil?: string | null;
     activityRequired?: boolean;
     continuity?: AppContinuity;
-    /** Present for every identity (including real viewers) acting inside a sandbox. */
-    sandbox?: SandboxIdentityContext;
 }
 /** Structured detail for a failed resolution: the Core HTTP status (null when Core was
  * never reached) plus a machine-readable code and human-readable message. Codes pass

package/dist/server.js

@@ -1,7 +1,6 @@
 // Server slice: Next route-handler factories and Core revalidation. Never reaches a client
 // bundle — the service token lives here.
 import "server-only";
-import { readSandboxTarget, readSandboxIdentity } from "./index.js";
 import { readAppContinuity } from "./continuity.js";
 import { createHostySessionResponse } from "./session-server.js";
 import { createHostyUiResponse } from "./ui-server.js";
@@ -68,8 +67,6 @@ export function readAppIdentityToken(headers, config) {
             return token;
         }
     }
-    if (process.env.HOSTY_SANDBOX_PROTOCOL)
-        return headers.get(HOSTY_APP_IDENTITY_HEADER)?.trim() || readCookie(headers.get("cookie"), config.identityCookieName) || null;
     return readCookie(headers.get("cookie"), config.identityCookieName) || headers.get(HOSTY_APP_IDENTITY_HEADER)?.trim() || null;
 }
 /** True when the effective request protocol is https (honouring the forwarded proto). */
@@ -122,8 +119,7 @@ export async function resolveAppSession(token, config) {
         };
     }
     const now = Date.now();
-    // Synthetic subject changes and instance revocation are checked online on every request.
-    const cached = process.env.HOSTY_SANDBOX_PROTOCOL ? undefined : revalidationCache.get(token);
+    const cached = revalidationCache.get(token);
     if (cached) {
         if (now - cached.cachedAt < REVALIDATION_CACHE_TTL_MS && now < cached.expiresAtMs) {
             return { status: "active", identity: cached.identity };
@@ -215,13 +211,6 @@ async function revalidateWithCore(token, coreOrigin, serviceToken, config) {
     if (!payload || payload.active !== true || !userId) {
         return { status: "expired" };
     }
-    let sandbox;
-    try {
-        sandbox = readSandboxIdentity(payload, readSandboxTarget(process.env));
-    }
-    catch {
-        return { status: "forbidden", error: { status: 403, code: "sandbox_identity_mismatch", message: "The identity does not match this execution target." } };
-    }
     const hostRole = readString(payload.hostRole);
     const expiresAt = readString(payload.expiresAt);
     const identity = {
@@ -229,15 +218,14 @@ async function revalidateWithCore(token, coreOrigin, serviceToken, config) {
         email: readString(payload.email),
         displayName: readString(payload.displayName),
         hostRole,
-        appRole: sandbox?.identityRealm === "sandbox" ? sandbox.appRole : config.mapHostRole ? config.mapHostRole(hostRole) : hostRole,
+        appRole: config.mapHostRole ? config.mapHostRole(hostRole) : hostRole,
         expiresAt,
         activeUntil: readString(payload.activeUntil),
         activityRequired: payload.activityRequired === true,
         continuity: readAppContinuity(payload.continuity),
-        ...(sandbox ? { sandbox } : {}),
     };
     const expiresAtMs = expiresAt ? Date.parse(expiresAt) : Number.NaN;
-    if (!sandbox && Number.isFinite(expiresAtMs) && expiresAtMs > Date.now()) {
+    if (Number.isFinite(expiresAtMs) && expiresAtMs > Date.now()) {
         pruneRevalidationCache();
         revalidationCache.set(token, { identity, expiresAtMs, cachedAt: Date.now() });
     }

package/dist/session-server.d.ts

@@ -1,6 +1,5 @@
 import { type ProviderServerOptions } from "@hosty-sdk/app/providers/server";
 import type { AppSessionStatus, SessionRecoveryParams } from "./session-types.js";
-import type { SandboxIdentityContext } from "./sandbox-identity.js";
 import type { AppContinuity } from "./continuity.js";
 /** Framework-neutral server adapter. Call with an already authenticated app session, never request data. */
 export type HostySessionInput = {
@@ -11,7 +10,6 @@ export type HostySessionInput = {
         activeUntil?: string | null;
         activityRequired?: boolean;
         continuity?: AppContinuity;
-        sandbox?: SandboxIdentityContext;
     };
     error?: {
         code: string;

package/dist/session-server.js

@@ -7,20 +7,15 @@ export async function createHostySessionResponse(session, recovery, options = {}
     const identity = session.identity;
     if (options.administratorOnly && identity.hostRole !== "host.admin")
         return Response.json({ status: "forbidden", recovery }, { headers });
-    if (identity.sandbox) {
-        // Core admits only recipes without required global permissions in this offline profile.
-        // The revalidated execution identity is authoritative; never query the installed app's
-        // permission state or advertise a global permission-review action from a test realm.
-        return Response.json({ status: "active", ...identity, recovery, hosty: { version: 1, setup: "ready" } }, { headers });
-    }
     let setup = "unavailable";
+    let permissionWarning;
     let notice;
     try {
         const permissions = await new ProviderClient({ ...options, appId: recovery.appId ?? undefined }).permissions(options.signal);
         if (![permissions.required, permissions.optional, permissions.granted, permissions.unsupportedRequired ?? []].every(list => Array.isArray(list) && list.every(name => typeof name === "string")))
             throw new Error("Invalid permission state.");
-        setup = permissions.unsupportedRequired?.length ? "unsupported"
-            : permissions.required.some(name => !permissions.granted.includes(name)) ? "missing" : "ready";
+        setup = permissions.required.some(name => !permissions.unsupportedRequired?.includes(name) && !permissions.granted.includes(name)) ? "missing" : "ready";
+        permissionWarning = permissions.unsupportedRequired?.length ? "unsupported" : undefined;
         if (identity.hostRole === "host.admin")
             notice = { hostRole: identity.hostRole, appId: recovery.appId ?? "",
                 corePublicOrigin: recovery.corePublicOrigin, permissions };
@@ -29,5 +24,5 @@ export async function createHostySessionResponse(session, recovery, options = {}
         if (error instanceof ProviderError && error.status === 404)
             setup = "incompatible";
     }
-    return Response.json({ status: "active", ...identity, recovery, hosty: { version: 1, setup, notice } }, { headers });
+    return Response.json({ status: "active", ...identity, recovery, hosty: { version: 1, setup, permissionWarning, notice } }, { headers });
 }

package/dist/tasks-server.d.ts

@@ -0,0 +1,33 @@
+import type { ProviderClient } from "./providers-server.js";
+import type { TaskProviderRef, TaskRef, TaskRecord, TaskPage, TaskCreate, TaskEdit, TaskAction, TaskStatus, TaskCapabilities, TaskExecutorOptions, TaskExecutionInput, TaskExecutionReceipt } from "./tasks.js";
+/** Server-side task API. Every request obtains a fresh Core binding; no mutation is retried implicitly. */
+export declare class TaskClient {
+    private readonly providers;
+    private readonly provider;
+    private readonly userToken?;
+    constructor(providers: ProviderClient, provider: TaskProviderRef, userToken?: (() => Promise<string>) | undefined);
+    private call;
+    private id;
+    capabilities(signal?: AbortSignal): Promise<TaskCapabilities>;
+    list(options?: {
+        cursor?: string;
+        limit?: number;
+        status?: TaskStatus;
+        signal?: AbortSignal;
+    }): Promise<TaskPage>;
+    create(input: TaskCreate, signal?: AbortSignal): Promise<TaskRecord>;
+    get(ref: TaskRef, signal?: AbortSignal): Promise<TaskRecord>;
+    edit(ref: TaskRef, input: TaskEdit, signal?: AbortSignal): Promise<TaskRecord>;
+    action(ref: TaskRef, input: TaskAction, signal?: AbortSignal): Promise<TaskRecord>;
+}
+export declare class TaskExecutorClient {
+    private readonly providers;
+    private readonly executor;
+    private readonly userToken?;
+    constructor(providers: ProviderClient, executor: TaskProviderRef, userToken?: (() => Promise<string>) | undefined);
+    private call;
+    options(signal?: AbortSignal): Promise<TaskExecutorOptions>;
+    accept(executionId: string, input: TaskExecutionInput, signal?: AbortSignal): Promise<TaskExecutionReceipt>;
+    get(executionId: string, signal?: AbortSignal): Promise<TaskExecutionReceipt>;
+    cancel(executionId: string, requestId: string, signal?: AbortSignal): Promise<TaskExecutionReceipt>;
+}

package/dist/tasks-server.js

@@ -0,0 +1,57 @@
+/** Server-side task API. Every request obtains a fresh Core binding; no mutation is retried implicitly. */
+export class TaskClient {
+    providers;
+    provider;
+    userToken;
+    constructor(providers, provider, userToken) {
+        this.providers = providers;
+        this.provider = provider;
+        this.userToken = userToken;
+    }
+    call(route, method = "GET", input, signal) {
+        return this.providers.taskRequest(this.provider, "tasks", route, method, input, this.userToken, signal);
+    }
+    id(ref) {
+        if (ref.appId !== this.provider.appId || ref.installationId !== this.provider.installationId || ref.key !== this.provider.key)
+            throw new Error("The task belongs to another provider installation.");
+        return encodeURIComponent(ref.id);
+    }
+    capabilities(signal) { return this.call("/capabilities", "GET", undefined, signal); }
+    list(options = {}) {
+        const query = new URLSearchParams();
+        if (options.cursor)
+            query.set("cursor", options.cursor);
+        if (options.limit !== undefined)
+            query.set("limit", String(options.limit));
+        if (options.status)
+            query.set("status", options.status);
+        return this.call(`/tasks?${query}`, "GET", undefined, options.signal);
+    }
+    create(input, signal) { return this.call("/tasks", "POST", input, signal); }
+    get(ref, signal) { return this.call(`/tasks/${this.id(ref)}`, "GET", undefined, signal); }
+    edit(ref, input, signal) { return this.call(`/tasks/${this.id(ref)}`, "PATCH", input, signal); }
+    action(ref, input, signal) { return this.call(`/tasks/${this.id(ref)}/actions`, "POST", input, signal); }
+}
+export class TaskExecutorClient {
+    providers;
+    executor;
+    userToken;
+    constructor(providers, executor, userToken) {
+        this.providers = providers;
+        this.executor = executor;
+        this.userToken = userToken;
+    }
+    call(route, method = "GET", input, signal) {
+        return this.providers.taskRequest(this.executor, "task-executor", route, method, input, this.userToken, signal);
+    }
+    options(signal) { return this.call("/options", "GET", undefined, signal); }
+    accept(executionId, input, signal) {
+        return this.call(`/executions/${encodeURIComponent(executionId)}`, "PUT", input, signal);
+    }
+    get(executionId, signal) {
+        return this.call(`/executions/${encodeURIComponent(executionId)}`, "GET", undefined, signal);
+    }
+    cancel(executionId, requestId, signal) {
+        return this.call(`/executions/${encodeURIComponent(executionId)}/cancel`, "POST", { requestId }, signal);
+    }
+}

package/dist/tasks.d.ts

@@ -0,0 +1,148 @@
+/** Core's version-one task contract. Numbers are opaque; references bind an installation. */
+export type TaskProviderRef = {
+    appId: string;
+    installationId: string;
+    key: string;
+};
+export type TaskRef = TaskProviderRef & {
+    id: string;
+};
+export type TaskStatus = "Draft" | "Ready" | "InProgress" | "Blocked" | "Done" | "Cancelled";
+export type TaskResource = {
+    kind: "app" | "workspace" | "external";
+    owner: string;
+    id: string;
+    label?: string;
+    version: {
+        mode: "live";
+    } | {
+        mode: "pinned";
+        revision: string;
+    };
+};
+export type TaskAssignee = {
+    kind: "human";
+    userId: string;
+    name?: string;
+} | {
+    kind: "app";
+    executor: TaskProviderRef;
+    optionId?: string;
+    name?: string;
+};
+export type TaskInput = {
+    title: string;
+    markdown: string;
+    assignee: TaskAssignee | null;
+    requiresReview: boolean;
+    resources: TaskResource[];
+    workspaceId?: string;
+};
+export type TaskActor = {
+    userId: string | null;
+    appId: string | null;
+    installationId?: string;
+};
+export type TaskResult = {
+    markdown: string;
+    resources: TaskResource[];
+};
+export type TaskExecutionState = "accepted" | "running" | "awaiting_input" | "cancelling" | "completed" | "failed" | "cancelled" | "interrupted";
+export type TaskExecutionInput = {
+    taskRef: TaskRef;
+    taskRevision: number;
+    executorOptionId?: string;
+    input: Omit<TaskInput, "assignee">;
+};
+export type TaskExecutionReceipt = {
+    executionId: string;
+    revision: number;
+    state: TaskExecutionState;
+    stopConfirmed: boolean;
+    createdAt: string;
+    updatedAt: string;
+    result?: TaskResult;
+    error?: {
+        code: string;
+        message: string;
+    }; /** An absolute HTTP(S) UI URL for cross-app readers; same-app readers can resolve a local path. */
+    sessionRef?: {
+        id: string;
+        path: string;
+    };
+};
+export type TaskAttempt = {
+    executionId: string;
+    executor: TaskProviderRef;
+    request: TaskExecutionInput;
+    receipt?: TaskExecutionReceipt;
+    cancelRequested: boolean;
+    createdAt: string;
+};
+export type TaskOutcome = {
+    inputRevision: number;
+    result: TaskResult;
+    recordedAt: string;
+    executionId?: string;
+};
+export type TaskRecord = TaskInput & {
+    ref: TaskRef;
+    number: string;
+    revision: number;
+    inputRevision: number;
+    status: TaskStatus;
+    createdBy: TaskActor;
+    owner: TaskActor;
+    createdAt: string;
+    updatedAt: string;
+    blocked?: {
+        reason: string;
+        message: string;
+    };
+    cancelRequested: boolean;
+    result?: TaskResult;
+    resultInputRevision?: number;
+    attempts: TaskAttempt[];
+    outcomes?: TaskOutcome[];
+};
+export type TaskMutation = {
+    requestId: string;
+    expectedRevision: number;
+};
+export type TaskInputWrite = Omit<TaskInput, "requiresReview"> & {
+    requiresReview?: boolean;
+};
+export type TaskCreate = {
+    requestId: string;
+    input: TaskInputWrite;
+};
+export type TaskEdit = TaskMutation & {
+    input: TaskInputWrite;
+};
+export type TaskAction = TaskMutation & {
+    action: "ready" | "draft" | "start" | "complete" | "cancel" | "accept" | "request_changes";
+    result?: TaskResult;
+    resultInputRevision?: number;
+    feedback?: string;
+};
+export type TaskPage = {
+    tasks: TaskRecord[];
+    nextCursor: string | null;
+};
+export type TaskCapabilities = {
+    version: 1;
+    prefix: string;
+    statuses: TaskStatus[];
+    maxPageSize: number;
+};
+export type TaskExecutorOption = {
+    id: string;
+    name: string;
+    capabilities: string[];
+};
+export type TaskExecutorOptions = {
+    options: TaskExecutorOption[];
+    defaultId: string | null;
+};
+export declare const taskStatuses: TaskStatus[];
+export declare const taskExecutionTerminal: (state: TaskExecutionState) => boolean;

package/dist/tasks.js

@@ -0,0 +1,2 @@
+export const taskStatuses = ["Draft", "Ready", "InProgress", "Blocked", "Done", "Cancelled"];
+export const taskExecutionTerminal = (state) => ["completed", "failed", "cancelled", "interrupted"].includes(state);

package/dist/ui-server.d.ts

@@ -1,4 +1,3 @@
-import type { SandboxIdentityContext } from "./sandbox-identity.js";
 import type { ProviderServerOptions } from "@hosty-sdk/app/providers/server";
 import { type ToolActivity, type PanelTarget, type UiBootstrap, type UiPanel, type UiResolvedPanel, type UiNavigationCatalog, type UiNavigationTarget, type UiResolvedNavigation } from "@hosty-sdk/app/ui/types";
 /** Server transport for generic UI metadata. Credentials never appear in returned metadata. */
@@ -22,7 +21,6 @@ type UiAuthenticatedContext = {
         status: "active";
         identity: {
             hostRole: string | null;
-            sandbox?: SandboxIdentityContext;
         };
     } | {
         status: "not-present" | "expired" | "forbidden" | "unavailable" | "misconfigured";

package/dist/ui-server.js

@@ -58,8 +58,6 @@ export async function createHostyUiResponse(request, context, options = {}) {
         }
         if (options.administratorOnly && context.session.identity.hostRole !== "host.admin")
             throw new UiError("admin_required", "This application requires administrator access.", 403);
-        if (context.session.identity.sandbox)
-            throw new UiError("unsupported_sandbox_ui", "Global application panels are unavailable inside this sandbox profile.", 409);
         const url = new URL(request.url);
         const prefix = (options.uiPath ?? "/api/hosty/ui").replace(/\/$/, "");
         const route = url.pathname.startsWith(prefix + "/") ? url.pathname.slice(prefix.length + 1) : "";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hosty-sdk/app",
-  "version": "0.35.1",
+  "version": "0.37.0",
   "description": "Hosty app auth: session state machine, recovery bridge, Core revalidation, and the embedder responder.",
   "license": "AGPL-3.0-only",
   "type": "module",
@@ -132,6 +132,14 @@
     "./tool-activity/server": {
       "types": "./dist/tool-activity-server.d.ts",
       "default": "./dist/tool-activity-server.js"
+    },
+    "./tasks": {
+      "types": "./dist/tasks.d.ts",
+      "default": "./dist/tasks.js"
+    },
+    "./tasks/server": {
+      "types": "./dist/tasks-server.d.ts",
+      "default": "./dist/tasks-server.js"
     }
   },
   "scripts": {

package/dist/sandbox-identity.d.ts

@@ -1,10 +0,0 @@
-export interface SandboxTarget {
-    runtimeInstanceId: string;
-    generation: string;
-    dataRevision: string;
-}
-export interface SandboxIdentityContext extends SandboxTarget {
-    identityRealm: "sandbox" | "core";
-    appRole: string;
-    permissions: string[];
-}

package/dist/sandbox-identity.js

@@ -1 +0,0 @@
-export {};