@xfey/tutti 0.1.105 → 0.1.107

package/dist/platform-outbound/worker.js

@@ -1,14 +1,7 @@
-import { claimDuePlatformOutboundIntent, markPlatformOutboundHandedOff, markPlatformOutboundRetry, markPlatformOutboundTerminal, readPlatformOutboundIntent, recoverInterruptedPlatformOutboundIntents, } from "./repository.js";
+import { claimDuePlatformOutboundIntent, initializePlatformOutboundEventCapture, markPlatformOutboundHandedOff, markPlatformOutboundRetry, markPlatformOutboundTerminal, readPlatformOutboundIntent, recoverInterruptedPlatformOutboundIntents, materializePlatformStatusOutboundIntents, } from "./repository.js";
 const DEFAULT_POLL_INTERVAL_MS = 500;
 const DEFAULT_MAX_ATTEMPTS = 8;
 const MAX_BACKOFF_MS = 5 * 60 * 1_000;
-function boundedPlatformText(value) {
-    const trimmed = value.trim();
-    const characters = [...trimmed];
-    return characters.length <= 4_000
-        ? trimmed
-        : `${characters.slice(0, 3_997).join("")}...`;
-}
 export class HostPlatformOutboundWorker {
     store;
     transport;
@@ -33,6 +26,7 @@ export class HostPlatformOutboundWorker {
             return;
         }
         this.stopped = false;
+        initializePlatformOutboundEventCapture(this.store.db, this.now);
         const recovered = recoverInterruptedPlatformOutboundIntents(this.store.db, this.now);
         if (recovered > 0) {
             this.logger.warn({ stage: "platform_outbound_recovery", disposition: "retry_wait", count: recovered }, "Interrupted platform outbound intents recovered");
@@ -61,24 +55,46 @@ export class HostPlatformOutboundWorker {
         await this.current;
     }
     async runOnce() {
+        const materialized = materializePlatformStatusOutboundIntents(this.store.db, this.now);
+        for (const intent of materialized) {
+            this.logger.info({
+                stage: "platform_outbound_materialize",
+                disposition: "created",
+                outbound_intent_ref: intent.intent_ref,
+                event_kind: intent.event_kind,
+                event_key: intent.event_key,
+                subject_kind: intent.subject_kind,
+                subject_ref: intent.subject_ref,
+                target_kind: intent.target_kind,
+                ...(intent.canonical_message_id === null
+                    ? {}
+                    : { canonical_message_ref: intent.canonical_message_id }),
+            }, "Platform outbound status intent materialized");
+        }
         const item = claimDuePlatformOutboundIntent(this.store.db, this.now);
         if (item === null) {
             return { kind: "idle" };
         }
         const fields = {
             outbound_intent_ref: item.intent.intent_ref,
-            canonical_message_ref: item.intent.canonical_message_id,
-            trigger_message_ref: item.intent.trigger_message_id,
+            event_kind: item.intent.event_kind,
+            event_key: item.intent.event_key,
+            subject_kind: item.intent.subject_kind,
+            subject_ref: item.intent.subject_ref,
+            target_kind: item.intent.target_kind,
+            ...(item.intent.canonical_message_id === null
+                ? {}
+                : { canonical_message_ref: item.intent.canonical_message_id }),
+            ...(item.intent.trigger_message_id === null
+                ? {}
+                : { trigger_message_ref: item.intent.trigger_message_id }),
             installation_ref: item.intent.installation_ref,
             binding_ref: item.intent.binding_ref,
             attempt: item.intent.attempt_count,
         };
         this.logger.info({ ...fields, stage: "platform_outbound_attempt", disposition: "sending" }, "Platform outbound handoff attempted");
         try {
-            const response = await this.transport.deliver({
-                ...item,
-                body: boundedPlatformText(item.body),
-            });
+            const response = await this.transport.deliver(item);
             if (response.disposition.kind === "accepted" || response.disposition.kind === "duplicate") {
                 markPlatformOutboundHandedOff(this.store.db, {
                     intentRef: item.intent.intent_ref,

package/dist/providers/openai/app-server/read-only-procedure.d.ts

@@ -11,6 +11,8 @@ export type CodexAppServerReadOnlyProcedureInput<TOutput> = {
     workspaceRoot: string;
     appServerCwd?: string;
     readablePaths?: string[];
+    /** File-only workflows must not accept an answer produced without a filesystem tool attempt. */
+    requireFileToolUse?: boolean;
     prompt: string;
     outputSchema: unknown;
     validateOutput: (value: unknown) => value is TOutput;
@@ -66,11 +68,17 @@ export type CodexAppServerReadOnlyProcedureErrorDetails = {
     notification_methods?: string[];
     agent_message_excerpt?: string;
     stderr_excerpt?: string;
+    output_parse_reason?: "no_json_object" | "malformed_json";
+    agent_output_chars?: number;
+    json_candidate_count?: number;
+    agent_message_count?: number;
+    completed_tool_count?: number;
+    file_tool_count?: number;
 };
 export declare class CodexAppServerReadOnlyProcedureError extends Error {
-    readonly code: "app_server_protocol_error" | "auth_failed" | "thread_start_failed" | "turn_failed" | "turn_timeout" | "unexpected_server_request" | "skill_selection_failed" | "output_parse_failed" | "output_validation_failed" | "write_detected" | "secret_leak_detected" | "process_lifecycle_failed" | "admission_unavailable";
+    readonly code: "app_server_protocol_error" | "auth_failed" | "thread_start_failed" | "turn_failed" | "turn_timeout" | "unexpected_server_request" | "skill_selection_failed" | "output_parse_failed" | "output_validation_failed" | "file_read_not_observed" | "write_detected" | "secret_leak_detected" | "process_lifecycle_failed" | "admission_unavailable";
     readonly details: CodexAppServerReadOnlyProcedureErrorDetails;
-    constructor(code: "app_server_protocol_error" | "auth_failed" | "thread_start_failed" | "turn_failed" | "turn_timeout" | "unexpected_server_request" | "skill_selection_failed" | "output_parse_failed" | "output_validation_failed" | "write_detected" | "secret_leak_detected" | "process_lifecycle_failed" | "admission_unavailable", message: string, details?: CodexAppServerReadOnlyProcedureErrorDetails);
+    constructor(code: "app_server_protocol_error" | "auth_failed" | "thread_start_failed" | "turn_failed" | "turn_timeout" | "unexpected_server_request" | "skill_selection_failed" | "output_parse_failed" | "output_validation_failed" | "file_read_not_observed" | "write_detected" | "secret_leak_detected" | "process_lifecycle_failed" | "admission_unavailable", message: string, details?: CodexAppServerReadOnlyProcedureErrorDetails);
 }
 export declare function resolveReadOnlyWebSearchMode(input: {
     networkAccess?: boolean;

package/dist/providers/openai/app-server/read-only-procedure.js

@@ -4,14 +4,14 @@ import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { buildCodexAppServerProcessPlan } from "../codex-app-server.js";
 import { DEFAULT_OPENAI_MODEL } from "../model-config.js";
-import { CodexAppServerJsonRpcClient, CodexAppServerProtocolError, } from "./json-rpc.js";
+import { CodexAppServerJsonRpcClient, CodexAppServerProtocolError } from "./json-rpc.js";
 import { CodexAppServerInvocation, CodexAppServerLifecycleError, createManagedProcess, } from "./invocation-lifecycle.js";
 import { CodexAppServerAdmissionError, } from "./invocation-coordinator.js";
 import { createCodexAppServerRuntimeObserver, } from "./runtime-telemetry.js";
 import { createReadOnlySandboxPolicy } from "./sandbox-policy.js";
 import { buildCodexAppServerProviderConfigOverrides, resolveCodexAppServerModelProvider, } from "./provider-config.js";
 import { buildCodexAppServerTurnInput, resolveCodexAppServerContextRuntimeHint, resolveCodexAppServerSkillInputs, CodexAppServerSkillSelectionError, } from "./skills.js";
-import { containsKnownSecret, createCodexSpawnEnv, extractAgentText, extractServerRequestMethod, findJsonObjectCandidates, isApiKeyAccount, readThreadId, readTurnError, readTurnStatus, redactWithKnownValues, compactText, } from "./runtime-helpers.js";
+import { containsKnownSecret, createCodexSpawnEnv, extractAgentText, extractServerRequestMethod, findJsonObjectCandidates, isRecord, isApiKeyAccount, readThreadId, readTurnError, readTurnStatus, redactWithKnownValues, compactText, } from "./runtime-helpers.js";
 import { extractCodexAppServerTokenUsage } from "../token-usage.js";
 const DEFAULT_REQUEST_TIMEOUT_MS = 60_000;
 const DEFAULT_TURN_TIMEOUT_MS = 600_000;
@@ -65,7 +65,11 @@ function readOnlyTimeoutDetails(input) {
 export function parseCodexAppServerStructuredJson(text) {
     const candidates = findJsonObjectCandidates(text);
     if (candidates.length === 0) {
-        throw new CodexAppServerReadOnlyProcedureError("output_parse_failed", "Codex app-server did not return a JSON object.");
+        throw new CodexAppServerReadOnlyProcedureError("output_parse_failed", "Codex app-server did not return a JSON object.", {
+            output_parse_reason: "no_json_object",
+            agent_output_chars: text.length,
+            json_candidate_count: 0,
+        });
     }
     for (const jsonText of candidates.toReversed()) {
         try {
@@ -75,7 +79,37 @@ export function parseCodexAppServerStructuredJson(text) {
             // Earlier app-server progress can contain brace-shaped text.
         }
     }
-    throw new CodexAppServerReadOnlyProcedureError("output_parse_failed", "Codex app-server returned malformed JSON.");
+    throw new CodexAppServerReadOnlyProcedureError("output_parse_failed", "Codex app-server returned malformed JSON.", {
+        output_parse_reason: "malformed_json",
+        agent_output_chars: text.length,
+        json_candidate_count: candidates.length,
+    });
+}
+/** Counts only; model text, tool arguments and stderr never enter structured diagnostics. */
+function structuredOutputDetails(client, text) {
+    const itemTypes = client.notifications.flatMap((notification) => {
+        const params = notification.params;
+        return notification.method === "item/completed" &&
+            isRecord(params) &&
+            isRecord(params.item) &&
+            typeof params.item.type === "string"
+            ? [params.item.type]
+            : [];
+    });
+    return {
+        turn_status: "completed",
+        notification_count: client.notifications.length,
+        notification_methods: client.notifications
+            .map((notification) => notification.method)
+            .slice(-20),
+        server_request_methods: client.serverRequests.map(extractServerRequestMethod),
+        agent_output_chars: text.length,
+        json_candidate_count: findJsonObjectCandidates(text).length,
+        agent_message_count: itemTypes.filter((type) => type === "agentMessage").length,
+        completed_tool_count: itemTypes.filter((type) => ["commandExecution", "mcpToolCall", "dynamicToolCall", "imageView", "webSearch"].includes(type)).length,
+        file_tool_count: itemTypes.filter((type) => ["commandExecution", "imageView"].includes(type))
+            .length,
+    };
 }
 export async function runCodexAppServerReadOnlyProcedure(options) {
     if (options.invocationCoordinator !== undefined && options.invocationLease === undefined) {
@@ -102,14 +136,18 @@ export async function runCodexAppServerReadOnlyProcedure(options) {
     let contextRuntimeHint;
     try {
         skillInputs = resolveCodexAppServerSkillInputs({
-            ...(options.skillSelectionName === undefined ? {} : { selectionName: options.skillSelectionName }),
+            ...(options.skillSelectionName === undefined
+                ? {}
+                : { selectionName: options.skillSelectionName }),
             ...(options.userSkillsRoot === undefined ? {} : { userSkillsRoot: options.userSkillsRoot }),
             ...(options.builtInSkillsRoot === undefined
                 ? {}
                 : { builtInSkillsRoot: options.builtInSkillsRoot }),
         });
         contextRuntimeHint = resolveCodexAppServerContextRuntimeHint({
-            ...(options.skillSelectionName === undefined ? {} : { selectionName: options.skillSelectionName }),
+            ...(options.skillSelectionName === undefined
+                ? {}
+                : { selectionName: options.skillSelectionName }),
             ...(options.agentContext === undefined ? {} : { agentContext: options.agentContext }),
         });
     }
@@ -184,10 +222,7 @@ export async function runCodexAppServerReadOnlyProcedure(options) {
         ...(contextRuntimeHint?.sensitiveValues ?? []),
         ...skillInputs.map((skill) => skill.path),
     ];
-    const strictLeakCheckValues = [
-        options.apiKey,
-        ...(contextRuntimeHint?.sensitiveValues ?? []),
-    ];
+    const strictLeakCheckValues = [options.apiKey, ...(contextRuntimeHint?.sensitiveValues ?? [])];
     let primaryError;
     let procedureResult;
     let lifecycleError;
@@ -249,9 +284,7 @@ export async function runCodexAppServerReadOnlyProcedure(options) {
             input: buildCodexAppServerTurnInput({
                 prompt: options.prompt,
                 skills: skillInputs,
-                ...(contextRuntimeHint === undefined
-                    ? {}
-                    : { runtimeHints: [contextRuntimeHint.text] }),
+                ...(contextRuntimeHint === undefined ? {} : { runtimeHints: [contextRuntimeHint.text] }),
             }),
             cwd: appServerCwd,
             approvalPolicy: "never",
@@ -314,9 +347,26 @@ export async function runCodexAppServerReadOnlyProcedure(options) {
         const agentText = client.notifications
             .map((notification) => extractAgentText(notification))
             .join("");
-        const parsed = parseCodexAppServerStructuredJson(agentText);
+        let parsed;
+        try {
+            parsed = parseCodexAppServerStructuredJson(agentText);
+        }
+        catch (error) {
+            if (!(error instanceof CodexAppServerReadOnlyProcedureError))
+                throw error;
+            throw new CodexAppServerReadOnlyProcedureError(error.code, error.message, {
+                ...structuredOutputDetails(client, agentText),
+                ...error.details,
+            });
+        }
         if (!options.validateOutput(parsed)) {
-            throw new CodexAppServerReadOnlyProcedureError("output_validation_failed", "Codex app-server structured output did not match the expected schema.");
+            throw new CodexAppServerReadOnlyProcedureError("output_validation_failed", "Codex app-server structured output did not match the expected schema.", structuredOutputDetails(client, agentText));
+        }
+        if (options.requireFileToolUse === true) {
+            const details = structuredOutputDetails(client, agentText);
+            if (details.file_tool_count === 0) {
+                throw new CodexAppServerReadOnlyProcedureError("file_read_not_observed", "Codex app-server did not attempt to inspect the summary source file.", details);
+            }
         }
         const gitStatusAfter = readGitStatus(options.workspaceRoot);
         if (gitStatusAfter !== gitStatusBefore) {

package/dist/server-shell/cli/host-lifecycle.js

@@ -311,6 +311,9 @@ export async function startLaunchProject(options) {
                 projectSurface: preparation.machine_local.binding.surface_profile.kind,
                 trustedMetadataStore: host.trusted_relay_metadata_store,
                 integrationDelivery: host.integration_delivery,
+                integrationReferenceAttachment: host.integration_reference_attachment,
+                integrationManagedReference: host.integration_managed_reference,
+                integrationApprovalDecision: host.integration_approval_decision,
             }),
             handleStreamRequest: createHostProjectApiTunnelStreamRequestHandler({
                 baseUrl: host.runtime_endpoint.base_url,

package/dist/server-shell/cli/host-server-runtime.d.ts

@@ -1,6 +1,6 @@
 import type { FastifyInstance } from "fastify";
 import { type ExecutionStatusProjection } from "@tutti/shared/schemas/api";
-import type { IntegrationDeliveryDisposition, TrustedConversationSourceIngestionCommand } from "@tutti/shared/schemas/internal";
+import type { IntegrationApprovalDecisionDisposition, IntegrationDeliveryDisposition, IntegrationManagedReferenceDisposition, TrustedApprovalDecisionCommand, TrustedConversationSourceIngestionCommand, TrustedManagedReferenceIngestionCommand, TrustedReferenceAttachmentIngestionCommand } from "@tutti/shared/schemas/internal";
 import { type HostProjectStore } from "../../store/index.js";
 import type { createHostServer } from "../http/create-server.js";
 import type { HostLocalLaunchStatus } from "../http/routes/local-control.js";
@@ -19,6 +19,9 @@ export type HostServerHandle = {
     runtime_endpoint: MachineRuntimeEndpointRecord;
     trusted_relay_metadata_store: TrustedRelaySessionMetadataStore;
     integration_delivery: (command: TrustedConversationSourceIngestionCommand) => IntegrationDeliveryDisposition;
+    integration_approval_decision: (command: TrustedApprovalDecisionCommand) => IntegrationApprovalDecisionDisposition;
+    integration_reference_attachment: (command: TrustedReferenceAttachmentIngestionCommand) => Promise<IntegrationDeliveryDisposition>;
+    integration_managed_reference: (command: TrustedManagedReferenceIngestionCommand) => Promise<IntegrationManagedReferenceDisposition>;
     attachRelayConnectionManager: (manager: HostRelayConnectionManager) => void;
     closed: Promise<void>;
     close: () => Promise<void>;

package/dist/server-shell/cli/host-server-runtime.js

@@ -2,11 +2,11 @@ import { basename, join } from "node:path";
 import { MAX_PROVIDER_MODEL_NAME_LENGTH, } from "@tutti/shared/schemas/api";
 import { serializeRuntimeLogLine } from "@tutti/shared/utils";
 import { completeRelayUpload, deliverRelayPlatformOutbound, RelayHostControlClientError, resolveRelayUpload, } from "@tutti/relay-client";
-import { ApprovalRequestManager } from "../../approvals/index.js";
+import { ApprovalRequestManager, executeApprovalDecisionCommand } from "../../approvals/index.js";
 import { ArtifactPreviewManager } from "../../artifacts/index.js";
 import { ReadOnlyChatAssistant } from "../../chat-assistant/index.js";
 import { CheckProcessCoordinator } from "../../checks/index.js";
-import { ingestTrustedConversationSource } from "../../collaboration-ingestion/index.js";
+import { ingestTrustedConversationSource, ingestTrustedManagedReference, ingestTrustedReferenceAttachment, } from "../../collaboration-ingestion/index.js";
 import { ensureInitialProjectWelcomeMessage } from "../../collaboration-state/index.js";
 import { Phase5ControlPlane } from "../../control-plane/index.js";
 import { resolveProjectOpenAiProcedureWorkflowRunner } from "../../control-plane/workflows/index.js";
@@ -21,6 +21,7 @@ import { openHostProjectStore } from "../../store/index.js";
 import { resolvePackagedWebStaticRoot } from "../http/static-web.js";
 import { AGENT_CONTEXT_BASE_PATH, AgentContextTokenRegistry, } from "../http/routes/agent-context.js";
 import { readHostRepoProjection } from "../http/routes/project-api.js";
+import { abortDownloadedStagedUpload, cleanupDownloadedStagedUpload, downloadStagedUploadWithResolver, } from "../http/routes/project-api/staged-uploads.js";
 import { WorkspaceEventBus } from "../http/workspace-events.js";
 import { createTrustedRelaySessionMetadataStore, } from "../session/relay-session-context.js";
 import { LaunchError } from "./errors.js";
@@ -308,9 +309,60 @@ export async function startForegroundHostServer(options) {
         },
     });
     controlPlaneLogger.info(staleTempCleanup, "Codex app-server stale temp cleanup completed");
+    const platformOutboundWorker = options.preparation.machine_local.binding.surface_profile.kind === "feishu"
+        ? new HostPlatformOutboundWorker(store, {
+            deliver: async (item) => {
+                const connectionState = relayConnectionManager?.getState();
+                if (connectionState?.status !== "connected") {
+                    throw new RelayHostControlClientError("relay_unavailable", "Relay is not connected for platform outbound handoff", true);
+                }
+                const hostSecret = readHostRegistrationSecret(options.preparation.tutti_home, options.preparation.project_id);
+                const relayProjectRef = connectionState.connection.relay_project_ref;
+                return await deliverRelayPlatformOutbound({
+                    relayUrl: options.preparation.relay_url,
+                    projectId: options.preparation.project_id,
+                    relayProjectRef,
+                    hostConnectionRef: connectionState.connection.host_connection_ref,
+                    hostRegistrationSecret: hostSecret.secret,
+                    intent: {
+                        protocol_version: 1,
+                        intent_ref: item.intent.intent_ref,
+                        relay_project_ref: relayProjectRef,
+                        installation: {
+                            platform: item.intent.platform,
+                            installation_ref: item.intent.installation_ref,
+                        },
+                        binding_ref: item.intent.binding_ref,
+                        ...(item.intent.canonical_message_id === null
+                            ? {}
+                            : { canonical_message_ref: item.intent.canonical_message_id }),
+                        ...(item.intent.trigger_message_id === null
+                            ? {}
+                            : { trigger_message_ref: item.intent.trigger_message_id }),
+                        content: item.content,
+                        event: {
+                            kind: item.intent.event_kind,
+                            event_key: item.intent.event_key,
+                            subject: {
+                                kind: item.intent.subject_kind,
+                                ref: item.intent.subject_ref,
+                            },
+                            target: { kind: item.intent.target_kind },
+                        },
+                        created_at: item.intent.created_at,
+                        attempt: item.intent.attempt_count,
+                    },
+                });
+            },
+        }, platformOutboundLogger, { now })
+        : undefined;
+    const platformOutboundCoordinator = platformOutboundWorker === undefined
+        ? undefined
+        : new HostPlatformOutboundCoordinator(store, platformOutboundWorker, platformOutboundLogger, now);
     const approvalManager = new ApprovalRequestManager({
         events: workspaceEvents,
         now,
+        onPending: (request) => platformOutboundCoordinator?.captureApprovalRequest(request),
     });
     const codexInvocationCoordinator = new CodexAppServerInvocationCoordinator();
     const checkProcessCoordinator = new CheckProcessCoordinator();
@@ -364,43 +416,6 @@ export async function startForegroundHostServer(options) {
             onLifecycleIncident: procedureLifecycleIncident,
         }),
     });
-    const platformOutboundWorker = options.preparation.machine_local.binding.surface_profile.kind === "feishu"
-        ? new HostPlatformOutboundWorker(store, {
-            deliver: async (item) => {
-                const connectionState = relayConnectionManager?.getState();
-                if (connectionState?.status !== "connected") {
-                    throw new RelayHostControlClientError("relay_unavailable", "Relay is not connected for platform outbound handoff", true);
-                }
-                const hostSecret = readHostRegistrationSecret(options.preparation.tutti_home, options.preparation.project_id);
-                const relayProjectRef = connectionState.connection.relay_project_ref;
-                return await deliverRelayPlatformOutbound({
-                    relayUrl: options.preparation.relay_url,
-                    projectId: options.preparation.project_id,
-                    relayProjectRef,
-                    hostConnectionRef: connectionState.connection.host_connection_ref,
-                    hostRegistrationSecret: hostSecret.secret,
-                    intent: {
-                        protocol_version: 1,
-                        intent_ref: item.intent.intent_ref,
-                        relay_project_ref: relayProjectRef,
-                        installation: {
-                            platform: item.intent.platform,
-                            installation_ref: item.intent.installation_ref,
-                        },
-                        binding_ref: item.intent.binding_ref,
-                        canonical_message_ref: item.intent.canonical_message_id,
-                        trigger_message_ref: item.intent.trigger_message_id,
-                        content: { kind: "text", text: item.body },
-                        created_at: item.intent.created_at,
-                        attempt: item.intent.attempt_count,
-                    },
-                });
-            },
-        }, platformOutboundLogger, { now })
-        : undefined;
-    const platformOutboundCoordinator = platformOutboundWorker === undefined
-        ? undefined
-        : new HostPlatformOutboundCoordinator(platformOutboundWorker, platformOutboundLogger, now);
     const chatAssistant = new ReadOnlyChatAssistant({
         project: chatAssistantProject,
         store,
@@ -508,9 +523,10 @@ export async function startForegroundHostServer(options) {
         ...(options.getLaunchStatus === undefined ? {} : { getLaunchStatus: options.getLaunchStatus }),
     };
     let app;
+    let resolveStagedUpload;
     try {
         const webStaticRoot = resolvePackagedWebStaticRoot();
-        const resolveStagedUpload = createStagedUploadResolver({
+        resolveStagedUpload = createStagedUploadResolver({
             preparation: options.preparation,
             ...(options.getLaunchStatus === undefined
                 ? {}
@@ -688,6 +704,78 @@ export async function startForegroundHostServer(options) {
             chatAssistant,
             now,
         }),
+        integration_reference_attachment: async (command) => await ingestTrustedReferenceAttachment({
+            store,
+            workspaceRoot: options.preparation.workspace_root,
+            events: workspaceEvents,
+            command,
+            resolveContent: async () => {
+                if (resolveStagedUpload === undefined) {
+                    throw new Error("Staged upload resolver is unavailable");
+                }
+                const downloaded = await downloadStagedUploadWithResolver({
+                    resolveStagedUpload,
+                    expected: command.staged_upload,
+                    purpose: "reference_file",
+                });
+                return {
+                    content: downloaded.content,
+                    complete: async () => await cleanupDownloadedStagedUpload(downloaded),
+                    abort: async () => await abortDownloadedStagedUpload(downloaded),
+                };
+            },
+            scratchpadSource: {
+                notify: (message) => controlPlane.notifyScratchpadSourceChanged(message),
+            },
+            referenceSummaries: {
+                start: (paths) => controlPlane.startReferenceSummaryRefresh({ paths }),
+            },
+            now,
+        }),
+        integration_managed_reference: async (command) => await ingestTrustedManagedReference({
+            store,
+            workspaceRoot: options.preparation.workspace_root,
+            events: workspaceEvents,
+            command,
+            resolveContent: async () => {
+                if (resolveStagedUpload === undefined) {
+                    throw new Error("Staged upload resolver is unavailable");
+                }
+                const downloaded = await downloadStagedUploadWithResolver({
+                    resolveStagedUpload,
+                    expected: command.staged_upload,
+                    purpose: "reference_file",
+                });
+                return {
+                    content: downloaded.content,
+                    complete: async () => await cleanupDownloadedStagedUpload(downloaded),
+                    abort: async () => await abortDownloadedStagedUpload(downloaded),
+                };
+            },
+            referenceSummaries: {
+                start: (paths) => controlPlane.startReferenceSummaryRefresh({ paths }),
+            },
+            now,
+        }),
+        integration_approval_decision: (command) => {
+            try {
+                return executeApprovalDecisionCommand({
+                    db: store.db,
+                    approvalManager,
+                    commandId: command.command_id,
+                    approvalId: command.approval_id,
+                    decisionId: command.decision_id,
+                    actor: {
+                        account_ref: command.actor.account_ref,
+                        display_name: command.actor.display_name,
+                    },
+                    now,
+                }).disposition;
+            }
+            catch {
+                return { kind: "invalid", reason_code: "approval_command_rejected" };
+            }
+        },
         attachRelayConnectionManager: (manager) => {
             relayConnectionManager = manager;
             platformOutboundCoordinator?.start();

package/dist/server-shell/cli/relay-registration.js

@@ -37,7 +37,10 @@ export async function registerHostWithRelay(options) {
         joinToken: { mode: options.joinTokenMode ?? "rotate" },
         capabilities: {
             integration_source_ingestion_v1: true,
+            integration_attachment_ingestion_v1: true,
+            integration_managed_reference_ingestion_v1: true,
             integration_outbound_v1: true,
+            integration_approval_decision_v1: true,
         },
         fetch: options.fetchImpl,
         ...(options.signal === undefined ? {} : { signal: options.signal }),

package/dist/server-shell/http/host-tunnel.d.ts

@@ -1,6 +1,6 @@
 import type { FastifyInstance } from "fastify";
 import type { RelayHostTunnelRequestHandler, RelayHostTunnelStreamRequestHandler } from "@tutti/relay-client";
-import type { IntegrationDeliveryDisposition, TrustedConversationSourceIngestionCommand } from "@tutti/shared/schemas/internal";
+import type { IntegrationApprovalDecisionDisposition, IntegrationDeliveryDisposition, IntegrationManagedReferenceDisposition, TrustedApprovalDecisionCommand, TrustedConversationSourceIngestionCommand, TrustedManagedReferenceIngestionCommand, TrustedReferenceAttachmentIngestionCommand } from "@tutti/shared/schemas/internal";
 import type { ProjectSurface } from "@tutti/shared/domain";
 import { type TrustedRelaySessionMetadataStore } from "../session/relay-session-context.js";
 export type HostProjectApiTunnelDispatchOptions = {
@@ -8,6 +8,9 @@ export type HostProjectApiTunnelDispatchOptions = {
     projectSurface?: ProjectSurface;
     trustedMetadataStore: TrustedRelaySessionMetadataStore;
     integrationDelivery?: (command: TrustedConversationSourceIngestionCommand) => IntegrationDeliveryDisposition;
+    integrationApprovalDecision?: (command: TrustedApprovalDecisionCommand) => IntegrationApprovalDecisionDisposition;
+    integrationReferenceAttachment?: (command: TrustedReferenceAttachmentIngestionCommand) => Promise<IntegrationDeliveryDisposition>;
+    integrationManagedReference?: (command: TrustedManagedReferenceIngestionCommand) => Promise<IntegrationManagedReferenceDisposition>;
 };
 export type HostProjectApiTunnelStreamDispatchOptions = {
     baseUrl: string;