@xfey/tutti 0.1.102 → 0.1.104

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

@@ -137,6 +137,21 @@ function isLaunchStatusPayload(value) {
     }
     const relay = record.relay;
     const visibility = relay.join_url_visibility;
+    const feishuSetup = relay.feishu_setup;
+    const validFeishuSetup = feishuSetup === undefined ||
+        (typeof feishuSetup === "object" &&
+            feishuSetup !== null &&
+            !Array.isArray(feishuSetup) &&
+            (feishuSetup.state === "account_handoff_required" ||
+                feishuSetup.state === "connected" ||
+                (feishuSetup.state === "pairing_required" &&
+                    ((feishuSetup.visibility === "visible_once" &&
+                        typeof feishuSetup.pairing_code === "string" &&
+                        typeof feishuSetup.command === "string" &&
+                        typeof feishuSetup.expires_at === "string") ||
+                        (feishuSetup.visibility === "not_recoverable" &&
+                            (feishuSetup.expires_at === undefined ||
+                                typeof feishuSetup.expires_at === "string"))))));
     return (typeof relay.relay_project_ref === "string" &&
         typeof relay.host_connection_ref === "string" &&
         (relay.join_url === undefined || typeof relay.join_url === "string") &&
@@ -145,7 +160,8 @@ function isLaunchStatusPayload(value) {
             typeof relay.join_token_expires_at === "string") &&
         (relay.join_token_reusable === undefined || typeof relay.join_token_reusable === "boolean") &&
         typeof relay.tunnel_url === "string" &&
-        typeof relay.connected_at === "string");
+        typeof relay.connected_at === "string" &&
+        validFeishuSetup);
 }
 export async function readExistingHostLaunchStatus(options) {
     try {

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

@@ -1,5 +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 HostProjectStore } from "../../store/index.js";
 import type { createHostServer } from "../http/create-server.js";
 import type { HostLocalLaunchStatus } from "../http/routes/local-control.js";
@@ -17,6 +18,7 @@ export type HostServerHandle = {
     log_file_path: string;
     runtime_endpoint: MachineRuntimeEndpointRecord;
     trusted_relay_metadata_store: TrustedRelaySessionMetadataStore;
+    integration_delivery: (command: TrustedConversationSourceIngestionCommand) => IntegrationDeliveryDisposition;
     attachRelayConnectionManager: (manager: HostRelayConnectionManager) => void;
     closed: Promise<void>;
     close: () => Promise<void>;

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

@@ -1,17 +1,19 @@
 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, resolveRelayUpload } from "@tutti/relay-client";
+import { completeRelayUpload, deliverRelayPlatformOutbound, RelayHostControlClientError, resolveRelayUpload, } from "@tutti/relay-client";
 import { ApprovalRequestManager } 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 { ensureInitialProjectWelcomeMessage } from "../../collaboration-state/index.js";
 import { Phase5ControlPlane } from "../../control-plane/index.js";
 import { resolveProjectOpenAiProcedureWorkflowRunner } from "../../control-plane/workflows/index.js";
 import { cleanupStaleCodexAppServerTempRoots } from "../../providers/openai/app-server/stale-temp-cleanup.js";
 import { CodexAppServerInvocationCoordinator } from "../../providers/openai/app-server/invocation-coordinator.js";
 import { resolveProjectOpenAiReadOnlyChatAssistantModel } from "../../providers/openai/chat-assistant.js";
+import { HostPlatformOutboundCoordinator, HostPlatformOutboundWorker, } from "../../platform-outbound/index.js";
 import { configureProjectOpenAiProvider, discoverProjectOpenAiModels, readOpenAiProviderConfigProjection, updateProjectOpenAiDefaultModel, } from "../../providers/openai/index.js";
 import { readProviderUsageProjection, recordProviderUsageEvent, } from "../../provider-usage/index.js";
 import { resolveProjectOpenAiRunPipelineRunner } from "../../run-pipeline/openai.js";
@@ -94,18 +96,21 @@ function createHostProviderModelService(options) {
     };
 }
 function createHostRuntimeLogger(options) {
+    const write = (level, fields, message) => {
+        const line = serializeRuntimeLogLine({
+            level,
+            service: "tutti-host",
+            component: options.component,
+            message,
+            fields,
+            now: options.now,
+        });
+        appendHostLogLine(options.logFilePath, line);
+    };
     return {
-        info(fields, message) {
-            const line = serializeRuntimeLogLine({
-                level: "info",
-                service: "tutti-host",
-                component: options.component,
-                message,
-                fields,
-                now: options.now,
-            });
-            appendHostLogLine(options.logFilePath, line);
-        },
+        info: (fields, message) => write("info", fields, message),
+        warn: (fields, message) => write("warn", fields, message),
+        error: (fields, message) => write("error", fields, message),
     };
 }
 function createLifecycleIncidentReporter(logger, consumer) {
@@ -284,6 +289,12 @@ export async function startForegroundHostServer(options) {
         logFilePath,
         now,
     });
+    const platformOutboundLogger = createHostRuntimeLogger({
+        component: "platform-outbound",
+        logFilePath,
+        now,
+    });
+    let relayConnectionManager;
     const procedureLifecycleIncident = createLifecycleIncidentReporter(controlPlaneLogger, "procedure");
     const runLifecycleIncident = createLifecycleIncidentReporter(runPipelineLogger, "run");
     const chatLifecycleIncident = createLifecycleIncidentReporter(controlPlaneLogger, "chat_assistant");
@@ -353,6 +364,43 @@ 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,
@@ -377,6 +425,14 @@ export async function startForegroundHostServer(options) {
         },
         waitForInspectionAvailability: () => controlPlane.waitForRepoInspectionIdle(),
         onScratchpadSourceChanged: (message) => controlPlane.notifyScratchpadSourceChanged(message),
+        ...(platformOutboundCoordinator === undefined
+            ? {}
+            : {
+                onMainChatAgentMessageCreated: ({ tx, triggerMessage, responseMessage }) => platformOutboundCoordinator.captureAgentResponse(tx, {
+                    triggerMessage,
+                    responseMessage,
+                }),
+            }),
         now,
     });
     const projectRuntimeLifecycle = new HostProjectRuntimeLifecycle({
@@ -387,7 +443,6 @@ export async function startForegroundHostServer(options) {
         approvalManager,
     });
     let close = async () => { };
-    let relayConnectionManager;
     const packageUpdateReadiness = () => packageUpdateReadinessFromExecutionStatus(controlPlane.getExecutionStatus());
     const localControl = {
         token,
@@ -474,11 +529,19 @@ export async function startForegroundHostServer(options) {
             },
             logger: { file: logFilePath },
             lifecycle: {
-                close: () => projectRuntimeLifecycle.close(),
+                close: async () => {
+                    try {
+                        await projectRuntimeLifecycle.close();
+                    }
+                    finally {
+                        await platformOutboundCoordinator?.stop();
+                    }
+                },
             },
             localControl,
             now,
             projectApi: {
+                surfaceProfile: options.preparation.machine_local.binding.surface_profile,
                 project: projectApiProject,
                 server: {
                     version: HOST_SERVER_VERSION,
@@ -615,8 +678,19 @@ export async function startForegroundHostServer(options) {
         log_file_path: logFilePath,
         runtime_endpoint: runtimeEndpoint,
         trusted_relay_metadata_store: trustedMetadataStore,
+        integration_delivery: (command) => ingestTrustedConversationSource({
+            store,
+            events: workspaceEvents,
+            command,
+            scratchpadSource: {
+                notify: (message) => controlPlane.notifyScratchpadSourceChanged(message),
+            },
+            chatAssistant,
+            now,
+        }),
         attachRelayConnectionManager: (manager) => {
             relayConnectionManager = manager;
+            platformOutboundCoordinator?.start();
         },
         closed,
         close,

package/dist/server-shell/cli/launch-command.d.ts

@@ -1,4 +1,5 @@
 import type { LaunchConfirmationRequest } from "./git-bootstrap.js";
+import type { FeishuSetupProjection } from "@tutti/shared/schemas/internal";
 export declare function confirmFromTty(request: LaunchConfirmationRequest): Promise<boolean>;
 export declare function confirmTextFromTty(message: string): Promise<boolean>;
 export declare function renderCompletionPage(options: {
@@ -10,6 +11,12 @@ export declare function renderCompletionPage(options: {
     tty?: boolean;
     hyperlinks?: boolean;
 }): string;
+export declare function renderFeishuCompletionPage(options: {
+    feishuSetup?: FeishuSetupProjection;
+    projectId: string;
+    workspaceRoot: string;
+    tty?: boolean;
+}): string;
 export declare function runForegroundLaunchCommand(options: {
     target?: string;
     yes: boolean;

package/dist/server-shell/cli/launch-command.js

@@ -88,6 +88,32 @@ export function renderCompletionPage(options) {
         isTty ? borderedBlock(summaryLines) : summaryLines.join("\n"),
     ].join("\n");
 }
+export function renderFeishuCompletionPage(options) {
+    const isTty = options.tty ?? process.stdout.isTTY === true;
+    const summaryLines = [
+        "Tutti is hosting this project.",
+        `Project: ${formatProjectLabel(options.workspaceRoot, options.projectId)}`,
+        "Collaboration surface: Feishu",
+    ];
+    if (options.feishuSetup?.state === "connected") {
+        summaryLines.push("Feishu conversation: connected");
+    }
+    else if (options.feishuSetup?.state === "pairing_required" &&
+        options.feishuSetup.visibility === "visible_once") {
+        summaryLines.push(`Connect command: ${options.feishuSetup.command}`);
+        summaryLines.push(`Connect code expires at: ${options.feishuSetup.expires_at}`);
+    }
+    else if (options.feishuSetup?.state === "pairing_required") {
+        summaryLines.push("Feishu conversation: pairing code is not recoverable; restart from Local Console to rotate it");
+    }
+    else {
+        summaryLines.push("Feishu Owner: open this project through Local Console to connect an account");
+    }
+    return [
+        ...(isTty ? [CLEAR, renderTuttiTerminalLogo({ tty: true }), ""] : []),
+        isTty ? borderedBlock(summaryLines) : summaryLines.join("\n"),
+    ].join("\n");
+}
 async function ensureProviderConfigured(preparation) {
     if (preparation.provider_status === "configured") {
         return;
@@ -133,14 +159,26 @@ export async function runBackgroundLaunchCommand(options) {
         confirm: confirmFromTty,
     });
     await ensureProviderConfigured(preparation);
-    spawnDetachedHost({
+    const startup = spawnDetachedHost({
+        tuttiHome: preparation.tutti_home,
+        projectId: preparation.project_id,
         workspaceRoot: preparation.workspace_root,
     });
     const ready = await waitForManagedHostReady({
         tuttiHome: preparation.tutti_home,
         projectId: preparation.project_id,
         workspaceRoot: preparation.workspace_root,
+        startupAttemptRef: startup.startup_attempt_ref,
     });
+    if (preparation.machine_local.binding.surface_profile.kind === "feishu") {
+        process.stdout.write(`${renderFeishuCompletionPage({
+            ...(ready.feishu_setup === undefined ? {} : { feishuSetup: ready.feishu_setup }),
+            projectId: preparation.project_id,
+            workspaceRoot: preparation.workspace_root,
+            tty: process.stdout.isTTY === true,
+        })}\n`);
+        return;
+    }
     if (ready.join_url === undefined) {
         throw new LaunchError("relay_registration_failed", "Host started but Relay did not return a visible join URL", "Run `tutti invite` to rotate a fresh invite link.");
     }

package/dist/server-shell/cli/launch.d.ts

@@ -1,3 +1,4 @@
+import type { ProjectSurface } from "@tutti/shared/domain";
 import { type ProjectId } from "@tutti/shared/ids";
 import { type OpenAiProviderConfigProjection } from "../../providers/openai/index.js";
 import { type GitBootstrapResult, type LaunchConfirmationHandler } from "./git-bootstrap.js";
@@ -13,6 +14,7 @@ export type LaunchPreparationOptions = {
     allowWorkspaceRootTakeover?: boolean;
     projectDisplayName?: string;
     projectDescription?: string;
+    projectSurface?: ProjectSurface;
 };
 export type LaunchProviderStatus = OpenAiProviderConfigProjection["status"];
 export type LaunchPreparationResult = {

package/dist/server-shell/cli/launch.js

@@ -86,6 +86,9 @@ export async function prepareLaunchProject(options) {
     if (options.now !== undefined) {
         bindingOptions.now = options.now;
     }
+    if (options.projectSurface !== undefined) {
+        bindingOptions.surface = options.projectSurface;
+    }
     const machineLocal = ensureMachineProjectBinding(bindingOptions);
     const providerConfig = readOpenAiProviderConfigProjection({
         tuttiHome,

package/dist/server-shell/cli/machine-local.d.ts

@@ -1,6 +1,8 @@
+import { type ProjectSurface, type ProjectSurfaceProfile } from "@tutti/shared/domain";
 import { type ProjectId, type RelayProjectRef } from "@tutti/shared/ids";
 export type MachineProjectBindingRecord = {
     project_id: ProjectId;
+    surface_profile: ProjectSurfaceProfile;
     workspace_root: string;
     local_store_root: string;
     display_name_snapshot?: string;
@@ -17,6 +19,13 @@ export type HostRegistrationSecretFile = {
     created_at: string;
     updated_at: string;
 };
+export type FeishuOwnerAccountHandoffFile = {
+    kind: "feishu_owner_account_handoff_v1";
+    project_id: ProjectId;
+    token: string;
+    created_at: string;
+    expires_at: string;
+};
 export type MachineRuntimeEndpointRecord = {
     project_id: ProjectId;
     pid: number;
@@ -31,6 +40,7 @@ export type EnsureMachineProjectBindingOptions = {
     workspaceRoot: string;
     displayNameSnapshot?: string;
     relayUrl?: string;
+    surface?: ProjectSurface;
     allowWorkspaceRootTakeover?: boolean;
     now?: () => Date;
 };
@@ -48,6 +58,16 @@ export declare function ensureHostLogFile(logFilePath: string): void;
 export declare function appendHostLogLine(logFilePath: string, line: string): void;
 export declare function createHostRegistrationSecretRef(projectId: ProjectId): string;
 export declare function getHostRegistrationSecretPath(tuttiHome: string, projectId: ProjectId): string;
+export declare function getFeishuOwnerAccountHandoffPath(tuttiHome: string, projectId: ProjectId): string;
+export declare function writeFeishuOwnerAccountHandoff(options: {
+    tuttiHome: string;
+    projectId: ProjectId;
+    token: string;
+    expiresAt: string;
+    now?: Date;
+}): void;
+export declare function readFeishuOwnerAccountHandoff(tuttiHome: string, projectId: ProjectId, now?: Date): FeishuOwnerAccountHandoffFile | null;
+export declare function deleteFeishuOwnerAccountHandoff(tuttiHome: string, projectId: ProjectId): void;
 export declare function createHostRegistrationSecret(): string;
 export declare function createMachineRuntimeEndpointToken(): string;
 export declare function readMachineProjectBinding(tuttiHome: string, projectId: ProjectId): MachineProjectBindingRecord | null;

package/dist/server-shell/cli/machine-local.js

@@ -1,6 +1,7 @@
 import { randomBytes } from "node:crypto";
 import { appendFileSync, chmodSync, closeSync, existsSync, mkdirSync, openSync, readFileSync, renameSync, rmSync, unlinkSync, writeFileSync, } from "node:fs";
 import { dirname, join, resolve } from "node:path";
+import { createProjectSurfaceProfile, isProjectSurfaceProfile, } from "@tutti/shared/domain";
 import { ID_PREFIXES, isPrefixedId } from "@tutti/shared/ids";
 import { LaunchError } from "./errors.js";
 function isRecord(value) {
@@ -55,6 +56,58 @@ export function createHostRegistrationSecretRef(projectId) {
 export function getHostRegistrationSecretPath(tuttiHome, projectId) {
     return join(tuttiHome, "credentials", "host-registration", `${projectId}.json`);
 }
+export function getFeishuOwnerAccountHandoffPath(tuttiHome, projectId) {
+    return join(tuttiHome, "credentials", "feishu-owner-handoffs", `${projectId}.json`);
+}
+export function writeFeishuOwnerAccountHandoff(options) {
+    const now = options.now ?? new Date();
+    if (!/^[A-Za-z0-9_-]{32,128}$/u.test(options.token) ||
+        Number.isNaN(Date.parse(options.expiresAt)) ||
+        Date.parse(options.expiresAt) <= now.getTime()) {
+        throw new LaunchError("relay_registration_failed", "The private Feishu Owner account handoff is invalid or expired", "Return through the Local Console account gate, then launch the Feishu project again.");
+    }
+    const value = {
+        kind: "feishu_owner_account_handoff_v1",
+        project_id: options.projectId,
+        token: options.token,
+        created_at: now.toISOString(),
+        expires_at: options.expiresAt,
+    };
+    writePrivateJsonFile(getFeishuOwnerAccountHandoffPath(options.tuttiHome, options.projectId), value);
+}
+export function readFeishuOwnerAccountHandoff(tuttiHome, projectId, now = new Date()) {
+    const filePath = getFeishuOwnerAccountHandoffPath(tuttiHome, projectId);
+    const readResult = readJsonFile(filePath);
+    if (readResult.kind === "missing") {
+        return null;
+    }
+    const raw = readResult.value;
+    if (!isRecord(raw) ||
+        raw.kind !== "feishu_owner_account_handoff_v1" ||
+        raw.project_id !== projectId ||
+        typeof raw.token !== "string" ||
+        !/^[A-Za-z0-9_-]{32,128}$/u.test(raw.token) ||
+        typeof raw.created_at !== "string" ||
+        Number.isNaN(Date.parse(raw.created_at)) ||
+        typeof raw.expires_at !== "string" ||
+        Number.isNaN(Date.parse(raw.expires_at))) {
+        throw new LaunchError("relay_registration_failed", "The private Feishu Owner account handoff file is invalid", "Return through the Local Console account gate, then launch the Feishu project again.");
+    }
+    if (Date.parse(raw.expires_at) <= now.getTime()) {
+        unlinkSync(filePath);
+        return null;
+    }
+    return {
+        kind: raw.kind,
+        project_id: raw.project_id,
+        token: raw.token,
+        created_at: raw.created_at,
+        expires_at: raw.expires_at,
+    };
+}
+export function deleteFeishuOwnerAccountHandoff(tuttiHome, projectId) {
+    rmSync(getFeishuOwnerAccountHandoffPath(tuttiHome, projectId), { force: true });
+}
 export function createHostRegistrationSecret() {
     return randomBytes(32).toString("base64url");
 }
@@ -81,11 +134,13 @@ export function readMachineProjectBinding(tuttiHome, projectId) {
             typeof raw.host_registration_secret_ref !== "string") ||
         (raw.relay_url !== undefined &&
             (typeof raw.relay_url !== "string" || raw.relay_url.trim() === "")) ||
-        (raw.created_at !== undefined && typeof raw.created_at !== "string")) {
+        (raw.created_at !== undefined && typeof raw.created_at !== "string") ||
+        (raw.surface_profile !== undefined && !isProjectSurfaceProfile(raw.surface_profile))) {
         throw new LaunchError("project_identity_conflict", "Machine-local project binding is invalid or conflicts with the Git config project identity", "Inspect or remove the project binding under TUTTI_HOME after confirming it is not needed.");
     }
     const binding = {
         project_id: raw.project_id,
+        surface_profile: raw.surface_profile === undefined ? createProjectSurfaceProfile() : raw.surface_profile,
         workspace_root: raw.workspace_root,
         local_store_root: raw.local_store_root,
         updated_at: raw.updated_at,
@@ -259,6 +314,10 @@ export function ensureMachineProjectBinding(options) {
     const bindingPath = getMachineProjectBindingPath(options.tuttiHome, options.projectId);
     const secret = ensureHostRegistrationSecret(options.tuttiHome, options.projectId, now);
     const existing = readMachineProjectBinding(options.tuttiHome, options.projectId);
+    const requestedSurface = options.surface ?? existing?.surface_profile.kind ?? "standalone";
+    if (existing !== null && existing.surface_profile.kind !== requestedSurface) {
+        throw new LaunchError("project_surface_conflict", `This project is already configured for the ${existing.surface_profile.kind} collaboration surface`, "Use the existing project surface. Surface migration requires a separate explicit migration flow.");
+    }
     if (existing !== null &&
         resolve(existing.workspace_root) !== workspaceRoot &&
         options.allowWorkspaceRootTakeover !== true) {
@@ -266,6 +325,7 @@ export function ensureMachineProjectBinding(options) {
     }
     const binding = {
         project_id: options.projectId,
+        surface_profile: createProjectSurfaceProfile(requestedSurface),
         workspace_root: workspaceRoot,
         local_store_root: localStoreRoot,
         host_registration_secret_ref: existing?.host_registration_secret_ref ?? secret.ref,

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

@@ -1,16 +1,30 @@
+import { type ProjectId } from "@tutti/shared/ids";
 import { type FetchLike } from "./host-runtime-endpoint.js";
 import { type MachineRuntimeEndpointRecord } from "./machine-local.js";
-import type { ProjectId } from "@tutti/shared/ids";
+import type { FeishuSetupProjection } from "@tutti/shared/schemas/internal";
 export type ManagedHostReadyResult = {
     endpoint: MachineRuntimeEndpointRecord;
     join_url?: string;
     join_token_expires_at?: string;
     join_token_reusable?: boolean;
+    feishu_setup?: FeishuSetupProjection;
 };
+export type DetachedHostStartup = {
+    startup_attempt_ref: string;
+    pid?: number;
+};
+export declare function normalizeDetachedHostExecArgv(execArgv: readonly string[], resolveImport?: (specifier: string) => string): string[];
 export declare function spawnDetachedHost(options: {
+    tuttiHome: string;
+    projectId: ProjectId;
     workspaceRoot: string;
     env?: NodeJS.ProcessEnv;
     inheritProcessEnv?: boolean;
+}): DetachedHostStartup;
+export declare function recordInternalHostStartupFailure(options: {
+    tuttiHome: string;
+    error: unknown;
+    env?: NodeJS.ProcessEnv;
 }): void;
 export declare function waitForManagedHostReady(options: {
     tuttiHome: string;
@@ -19,5 +33,6 @@ export declare function waitForManagedHostReady(options: {
     fetchImpl?: FetchLike;
     inviteMode?: "required" | "preserve";
     timeoutMs?: number;
+    startupAttemptRef?: string;
 }): Promise<ManagedHostReadyResult>;
 //# sourceMappingURL=managed-host.d.ts.map