@xfey/tutti 0.1.103 → 0.1.105

package/dist/platform-outbound/coordinator.js

@@ -0,0 +1,48 @@
+import { createPlatformOutboundIntent } from "./repository.js";
+export class HostPlatformOutboundCoordinator {
+    worker;
+    logger;
+    now;
+    constructor(worker, logger, now = () => new Date()) {
+        this.worker = worker;
+        this.logger = logger;
+        this.now = now;
+    }
+    captureAgentResponse(tx, input) {
+        const result = createPlatformOutboundIntent(tx, {
+            triggerMessageId: input.triggerMessage.id,
+            canonicalMessageId: input.responseMessage.id,
+            now: this.now,
+        });
+        if (result === null) {
+            return undefined;
+        }
+        return () => {
+            try {
+                this.logger.info({
+                    stage: "platform_outbound_capture",
+                    disposition: result.created ? "created" : "duplicate",
+                    outbound_intent_ref: result.intent.intent_ref,
+                    canonical_message_ref: result.intent.canonical_message_id,
+                    trigger_message_ref: result.intent.trigger_message_id,
+                    installation_ref: result.intent.installation_ref,
+                    binding_ref: result.intent.binding_ref,
+                }, result.created
+                    ? "Platform outbound intent created"
+                    : "Platform outbound intent already exists");
+            }
+            catch {
+                // The committed canonical response and durable intent remain authoritative even when the
+                // machine-local log cannot be appended. The polling worker still guarantees handoff.
+            }
+            this.worker.wake();
+        };
+    }
+    start() {
+        this.worker.start();
+    }
+    stop() {
+        return this.worker.stop();
+    }
+}
+//# sourceMappingURL=coordinator.js.map

package/dist/platform-outbound/index.d.ts

@@ -0,0 +1,5 @@
+export * from "./coordinator.js";
+export * from "./repository.js";
+export * from "./types.js";
+export * from "./worker.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/platform-outbound/index.js

@@ -0,0 +1,5 @@
+export * from "./coordinator.js";
+export * from "./repository.js";
+export * from "./types.js";
+export * from "./worker.js";
+//# sourceMappingURL=index.js.map

package/dist/platform-outbound/repository.d.ts

@@ -0,0 +1,30 @@
+import type { SqliteDatabase } from "../store/index.js";
+import type { HostPlatformOutboundIntentRecord, HostPlatformOutboundWorkItem } from "./types.js";
+export declare function createPlatformOutboundIntent(tx: SqliteDatabase, input: {
+    triggerMessageId: string;
+    canonicalMessageId: string;
+    now?: () => Date;
+}): {
+    created: boolean;
+    intent: HostPlatformOutboundIntentRecord;
+} | null;
+export declare function recoverInterruptedPlatformOutboundIntents(db: SqliteDatabase, now?: () => Date): number;
+export declare function claimDuePlatformOutboundIntent(db: SqliteDatabase, now?: () => Date): HostPlatformOutboundWorkItem | null;
+export declare function markPlatformOutboundHandedOff(db: SqliteDatabase, input: {
+    intentRef: string;
+    deliveryRef: string;
+    now?: () => Date;
+}): void;
+export declare function markPlatformOutboundRetry(db: SqliteDatabase, input: {
+    intentRef: string;
+    errorCode: string;
+    nextAttemptAt: string;
+    now?: () => Date;
+}): void;
+export declare function markPlatformOutboundTerminal(db: SqliteDatabase, input: {
+    intentRef: string;
+    errorCode: string;
+    now?: () => Date;
+}): void;
+export declare function readPlatformOutboundIntent(db: SqliteDatabase, intentRef: string): HostPlatformOutboundIntentRecord | null;
+//# sourceMappingURL=repository.d.ts.map

package/dist/platform-outbound/repository.js

@@ -0,0 +1,108 @@
+import { createIdempotencyKey } from "@tutti/shared/ids";
+export function createPlatformOutboundIntent(tx, input) {
+    const existing = tx
+        .prepare("SELECT * FROM platform_outbound_intents WHERE canonical_message_id = ?")
+        .get(input.canonicalMessageId);
+    if (existing !== undefined) {
+        return { created: false, intent: existing };
+    }
+    const destination = tx
+        .prepare(`
+        SELECT platform, installation_ref, binding_ref
+        FROM external_source_mappings
+        WHERE message_id = ? AND platform = 'feishu'
+      `)
+        .get(input.triggerMessageId);
+    if (destination === undefined) {
+        return null;
+    }
+    const timestamp = (input.now ?? (() => new Date()))().toISOString();
+    const intentRef = createIdempotencyKey();
+    tx.prepare(`
+      INSERT INTO platform_outbound_intents (
+        intent_ref, platform, installation_ref, binding_ref,
+        trigger_message_id, canonical_message_id, disposition, attempt_count,
+        next_attempt_at, created_at, updated_at
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `).run(intentRef, destination.platform, destination.installation_ref, destination.binding_ref, input.triggerMessageId, input.canonicalMessageId, "pending", 0, timestamp, timestamp, timestamp);
+    return {
+        created: true,
+        intent: tx
+            .prepare("SELECT * FROM platform_outbound_intents WHERE intent_ref = ?")
+            .get(intentRef),
+    };
+}
+export function recoverInterruptedPlatformOutboundIntents(db, now = () => new Date()) {
+    const timestamp = now().toISOString();
+    return db
+        .prepare(`
+        UPDATE platform_outbound_intents
+        SET disposition = 'retry_wait', error_code = 'worker_interrupted',
+            next_attempt_at = ?, updated_at = ?
+        WHERE disposition = 'sending'
+      `)
+        .run(timestamp, timestamp).changes;
+}
+export function claimDuePlatformOutboundIntent(db, now = () => new Date()) {
+    return db.transaction(() => {
+        const timestamp = now().toISOString();
+        const row = db
+            .prepare(`
+          SELECT platform_outbound_intents.*, messages.body
+          FROM platform_outbound_intents
+          JOIN messages ON messages.id = platform_outbound_intents.canonical_message_id
+          WHERE platform_outbound_intents.disposition IN ('pending', 'retry_wait')
+            AND (
+              platform_outbound_intents.next_attempt_at IS NULL
+              OR platform_outbound_intents.next_attempt_at <= ?
+            )
+          ORDER BY platform_outbound_intents.created_at, platform_outbound_intents.intent_ref
+          LIMIT 1
+        `)
+            .get(timestamp);
+        if (row === undefined) {
+            return null;
+        }
+        db.prepare(`
+        UPDATE platform_outbound_intents
+        SET disposition = 'sending', attempt_count = attempt_count + 1,
+            last_attempt_at = ?, next_attempt_at = NULL, updated_at = ?
+        WHERE intent_ref = ?
+      `).run(timestamp, timestamp, row.intent_ref);
+        const intent = db
+            .prepare("SELECT * FROM platform_outbound_intents WHERE intent_ref = ?")
+            .get(row.intent_ref);
+        return { intent, body: row.body };
+    })();
+}
+export function markPlatformOutboundHandedOff(db, input) {
+    const timestamp = (input.now ?? (() => new Date()))().toISOString();
+    db.prepare(`
+      UPDATE platform_outbound_intents
+      SET disposition = 'handed_off', delivery_ref = ?, error_code = NULL,
+          handed_off_at = ?, updated_at = ?
+      WHERE intent_ref = ?
+    `).run(input.deliveryRef, timestamp, timestamp, input.intentRef);
+}
+export function markPlatformOutboundRetry(db, input) {
+    const timestamp = (input.now ?? (() => new Date()))().toISOString();
+    db.prepare(`
+      UPDATE platform_outbound_intents
+      SET disposition = 'retry_wait', error_code = ?, next_attempt_at = ?, updated_at = ?
+      WHERE intent_ref = ?
+    `).run(input.errorCode, input.nextAttemptAt, timestamp, input.intentRef);
+}
+export function markPlatformOutboundTerminal(db, input) {
+    const timestamp = (input.now ?? (() => new Date()))().toISOString();
+    db.prepare(`
+      UPDATE platform_outbound_intents
+      SET disposition = 'terminal', error_code = ?, next_attempt_at = NULL, updated_at = ?
+      WHERE intent_ref = ?
+    `).run(input.errorCode, timestamp, input.intentRef);
+}
+export function readPlatformOutboundIntent(db, intentRef) {
+    return (db
+        .prepare("SELECT * FROM platform_outbound_intents WHERE intent_ref = ?")
+        .get(intentRef) ?? null);
+}
+//# sourceMappingURL=repository.js.map

package/dist/platform-outbound/types.d.ts

@@ -0,0 +1,38 @@
+import type { IdempotencyKey, MessageId } from "@tutti/shared/ids";
+import type { MessageProjection } from "@tutti/shared/schemas/api";
+import type { PlatformOutboundHandoffResponse } from "@tutti/shared/schemas/internal";
+export type HostPlatformOutboundIntentDisposition = "pending" | "sending" | "retry_wait" | "handed_off" | "terminal";
+export type HostPlatformOutboundIntentRecord = {
+    intent_ref: IdempotencyKey;
+    platform: "feishu";
+    installation_ref: string;
+    binding_ref: string;
+    trigger_message_id: MessageId;
+    canonical_message_id: MessageId;
+    disposition: HostPlatformOutboundIntentDisposition;
+    attempt_count: number;
+    next_attempt_at: string | null;
+    last_attempt_at: string | null;
+    delivery_ref: string | null;
+    error_code: string | null;
+    created_at: string;
+    updated_at: string;
+    handed_off_at: string | null;
+};
+export type HostPlatformOutboundWorkItem = {
+    intent: HostPlatformOutboundIntentRecord;
+    body: string;
+};
+export type HostPlatformOutboundTransport = {
+    deliver(item: HostPlatformOutboundWorkItem): Promise<PlatformOutboundHandoffResponse>;
+};
+export type HostPlatformOutboundLogger = {
+    info(fields: Record<string, unknown>, message: string): void;
+    warn(fields: Record<string, unknown>, message: string): void;
+    error(fields: Record<string, unknown>, message: string): void;
+};
+export type HostPlatformOutboundAgentResponseInput = {
+    triggerMessage: MessageProjection;
+    responseMessage: MessageProjection;
+};
+//# sourceMappingURL=types.d.ts.map

package/dist/platform-outbound/types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=types.js.map

package/dist/platform-outbound/worker.d.ts

@@ -0,0 +1,36 @@
+import type { HostProjectStore } from "../store/index.js";
+import type { HostPlatformOutboundIntentRecord, HostPlatformOutboundLogger, HostPlatformOutboundTransport } from "./types.js";
+export type HostPlatformOutboundRunResult = {
+    kind: "idle";
+} | {
+    kind: "handed_off";
+    intent: HostPlatformOutboundIntentRecord;
+} | {
+    kind: "retry_wait" | "terminal";
+    intent: HostPlatformOutboundIntentRecord;
+    error_code: string;
+};
+export declare class HostPlatformOutboundWorker {
+    private readonly store;
+    private readonly transport;
+    private readonly logger;
+    private readonly now;
+    private readonly pollIntervalMs;
+    private readonly maxAttempts;
+    private timer;
+    private current;
+    private stopped;
+    private wakeRequested;
+    constructor(store: HostProjectStore, transport: HostPlatformOutboundTransport, logger: HostPlatformOutboundLogger, options?: {
+        now?: () => Date;
+        pollIntervalMs?: number;
+        maxAttempts?: number;
+    });
+    start(): void;
+    wake(): void;
+    stop(): Promise<void>;
+    runOnce(): Promise<HostPlatformOutboundRunResult>;
+    private markFailure;
+    private schedule;
+}
+//# sourceMappingURL=worker.d.ts.map

package/dist/platform-outbound/worker.js

@@ -0,0 +1,164 @@
+import { claimDuePlatformOutboundIntent, markPlatformOutboundHandedOff, markPlatformOutboundRetry, markPlatformOutboundTerminal, readPlatformOutboundIntent, recoverInterruptedPlatformOutboundIntents, } 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;
+    logger;
+    now;
+    pollIntervalMs;
+    maxAttempts;
+    timer;
+    current;
+    stopped = true;
+    wakeRequested = false;
+    constructor(store, transport, logger, options = {}) {
+        this.store = store;
+        this.transport = transport;
+        this.logger = logger;
+        this.now = options.now ?? (() => new Date());
+        this.pollIntervalMs = options.pollIntervalMs ?? DEFAULT_POLL_INTERVAL_MS;
+        this.maxAttempts = options.maxAttempts ?? DEFAULT_MAX_ATTEMPTS;
+    }
+    start() {
+        if (!this.stopped) {
+            return;
+        }
+        this.stopped = false;
+        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");
+        }
+        this.schedule(0);
+    }
+    wake() {
+        if (this.stopped) {
+            return;
+        }
+        if (this.current !== undefined) {
+            this.wakeRequested = true;
+            return;
+        }
+        if (this.timer !== undefined) {
+            clearTimeout(this.timer);
+        }
+        this.schedule(0);
+    }
+    async stop() {
+        this.stopped = true;
+        if (this.timer !== undefined) {
+            clearTimeout(this.timer);
+            this.timer = undefined;
+        }
+        await this.current;
+    }
+    async runOnce() {
+        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,
+            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),
+            });
+            if (response.disposition.kind === "accepted" || response.disposition.kind === "duplicate") {
+                markPlatformOutboundHandedOff(this.store.db, {
+                    intentRef: item.intent.intent_ref,
+                    deliveryRef: response.disposition.delivery_ref,
+                    now: this.now,
+                });
+                const updated = readPlatformOutboundIntent(this.store.db, item.intent.intent_ref);
+                this.logger.info({
+                    ...fields,
+                    stage: "platform_outbound_handoff",
+                    disposition: response.disposition.kind,
+                    delivery_ref: response.disposition.delivery_ref,
+                }, "Platform outbound intent handed off");
+                return { kind: "handed_off", intent: updated };
+            }
+            if (response.disposition.kind === "unavailable") {
+                return this.markFailure(item.intent, response.disposition.reason_code, true, fields);
+            }
+            return this.markFailure(item.intent, response.disposition.reason_code, false, fields);
+        }
+        catch (error) {
+            const code = typeof error === "object" &&
+                error !== null &&
+                "code" in error &&
+                typeof error.code === "string"
+                ? error.code.slice(0, 128)
+                : "platform_outbound_transport_failed";
+            const retryable = typeof error === "object" &&
+                error !== null &&
+                "retryable" in error &&
+                error.retryable === false
+                ? false
+                : true;
+            return this.markFailure(item.intent, code, retryable, fields);
+        }
+    }
+    markFailure(intent, errorCode, retryable, fields) {
+        const terminal = !retryable || intent.attempt_count >= this.maxAttempts;
+        if (terminal) {
+            markPlatformOutboundTerminal(this.store.db, {
+                intentRef: intent.intent_ref,
+                errorCode,
+                now: this.now,
+            });
+        }
+        else {
+            const delay = Math.min(1_000 * 2 ** Math.max(0, intent.attempt_count - 1), MAX_BACKOFF_MS);
+            markPlatformOutboundRetry(this.store.db, {
+                intentRef: intent.intent_ref,
+                errorCode,
+                nextAttemptAt: new Date(this.now().getTime() + delay).toISOString(),
+                now: this.now,
+            });
+        }
+        const updated = readPlatformOutboundIntent(this.store.db, intent.intent_ref);
+        const disposition = terminal ? "terminal" : "retry_wait";
+        this.logger[terminal ? "error" : "warn"]({
+            ...fields,
+            stage: "platform_outbound_handoff",
+            disposition,
+            error_code: errorCode,
+        }, terminal
+            ? "Platform outbound intent failed terminally"
+            : "Platform outbound intent will retry");
+        return { kind: disposition, intent: updated, error_code: errorCode };
+    }
+    schedule(delay) {
+        if (this.stopped) {
+            return;
+        }
+        this.timer = setTimeout(() => {
+            this.timer = undefined;
+            this.current = this.runOnce().finally(() => {
+                this.current = undefined;
+                const nextDelay = this.wakeRequested ? 0 : this.pollIntervalMs;
+                this.wakeRequested = false;
+                this.schedule(nextDelay);
+            });
+        }, delay);
+        this.timer.unref?.();
+    }
+}
+//# sourceMappingURL=worker.js.map

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

@@ -2,6 +2,7 @@
 import { dirname, resolve } from "node:path";
 import { resolveTuttiHome } from "../../providers/openai/index.js";
 import { formatCliError, formatCliErrorReason, LaunchError } from "./errors.js";
+import { recordInternalHostStartupFailure } from "./managed-host.js";
 import { parseCliArgs, shouldEnsureDesktopIntegrationAutomatically } from "./args.js";
 import { confirmTextFromTty, runBackgroundLaunchCommand, runForegroundLaunchCommand, runInternalHostRunCommand, } from "./launch-command.js";
 import { resolveExistingProjectContext } from "./project-resolver.js";
@@ -362,8 +363,10 @@ async function runShutdownCommand(yes) {
         "Tutti is ready to uninstall.",
     ].join("\n");
 }
+let activeCommand;
 try {
     const command = parseCliArgs(process.argv.slice(2));
+    activeCommand = command;
     if (shouldEnsureDesktopIntegrationAutomatically(command)) {
         ensureDesktopIntegrationForConsole();
     }
@@ -451,6 +454,12 @@ try {
     }
 }
 catch (error) {
+    if (activeCommand?.kind === "internal-host-run") {
+        recordInternalHostStartupFailure({
+            tuttiHome: resolveTuttiHome(process.env.TUTTI_HOME, process.cwd()),
+            error,
+        });
+    }
     console.error(formatCliError(error));
     process.exitCode = 1;
 }

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

@@ -1,4 +1,4 @@
-export type LaunchErrorCode = "unsafe_project_root" | "unsupported_tutti_schema" | "project_identity_conflict" | "git_bootstrap_failed" | "sensitive_file_detected" | "relay_unavailable" | "relay_registration_failed" | "host_not_running" | "shutdown_confirmation_required" | "shutdown_rejected" | "archive_confirmation_required" | "archive_rejected" | "forget_confirmation_required" | "forget_rejected" | "project_target_ambiguous" | "project_target_not_found" | "provider_configuration_required" | "provider_setup_cancelled" | "provider_validation_failed" | "store_migration_failed" | "existing_server_unhealthy" | "takeover_rejected" | "takeover_failed" | "port_unavailable" | "desktop_integration_unavailable" | "desktop_protocol_invalid" | "desktop_open_failed";
+export type LaunchErrorCode = "unsafe_project_root" | "unsupported_tutti_schema" | "project_identity_conflict" | "project_surface_conflict" | "project_surface_mismatch" | "git_bootstrap_failed" | "sensitive_file_detected" | "relay_unavailable" | "relay_registration_failed" | "host_not_running" | "shutdown_confirmation_required" | "shutdown_rejected" | "archive_confirmation_required" | "archive_rejected" | "forget_confirmation_required" | "forget_rejected" | "project_target_ambiguous" | "project_target_not_found" | "provider_configuration_required" | "provider_setup_cancelled" | "provider_validation_failed" | "store_migration_failed" | "existing_server_unhealthy" | "takeover_rejected" | "takeover_failed" | "port_unavailable" | "desktop_integration_unavailable" | "desktop_protocol_invalid" | "desktop_open_failed";
 export declare class LaunchError extends Error {
     readonly code: LaunchErrorCode;
     readonly next: string;

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

@@ -1,4 +1,5 @@
 import type { ProjectId } from "@tutti/shared/ids";
+import { type ProjectSurfaceProfile } from "@tutti/shared/domain";
 import { TUTTI_MAINLINE_BRANCH } from "./git-bootstrap.js";
 import { type FetchLike, type HostRuntimeEndpointProbe } from "./host-runtime-endpoint.js";
 import { type HostServerFactory, type HostServerHandle } from "./host-server-runtime.js";
@@ -12,6 +13,7 @@ export type { HostServerHandle } from "./host-server-runtime.js";
 export type HostRuntimeStatus = "created" | "connected" | "recovered" | "taken_over";
 export type HostRuntimeSummary = {
     status: HostRuntimeStatus;
+    surface_profile: ProjectSurfaceProfile;
     workspace_root: string;
     project_id: ProjectId;
     branch: typeof TUTTI_MAINLINE_BRANCH;

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

@@ -1,4 +1,5 @@
 import { resolve } from "node:path";
+import { createProjectSurfaceProfile } from "@tutti/shared/domain";
 import { connectRelayHostTunnel, RelayHostControlClientError, refreshRelayJoinToken as refreshRelayJoinTokenWithRelay, registerRelayHostConnection as registerRelayHostConnectionWithRelay, } from "@tutti/relay-client";
 import { createHostServer } from "../http/create-server.js";
 import { createHostProjectApiTunnelRequestHandler, createHostProjectApiTunnelStreamRequestHandler, } from "../http/host-tunnel.js";
@@ -56,6 +57,7 @@ async function requireTakeoverConfirmation(options) {
 function createSummary(options) {
     const summary = {
         status: options.status,
+        surface_profile: options.surfaceProfile,
         workspace_root: options.workspaceRoot,
         project_id: options.projectId,
         branch: TUTTI_MAINLINE_BRANCH,
@@ -129,6 +131,12 @@ export async function startLaunchProject(options) {
     let allowWorkspaceRootTakeover = false;
     if (context.existing_identity.kind === "present") {
         const projectId = context.existing_identity.project_id;
+        const existingBinding = readMachineProjectBinding(context.tutti_home, projectId);
+        const existingSurfaceProfile = existingBinding?.surface_profile ?? createProjectSurfaceProfile();
+        if (options.projectSurface !== undefined &&
+            existingSurfaceProfile.kind !== options.projectSurface) {
+            throw new LaunchError("project_surface_conflict", `This project is already configured for the ${existingSurfaceProfile.kind} collaboration surface`, "Use the existing project surface. Surface migration requires a separate explicit migration flow.");
+        }
         await reconcileReplacedWorkspaceHosts({
             tuttiHome: context.tutti_home,
             workspaceRoot: context.workspace_root,
@@ -181,6 +189,7 @@ export async function startLaunchProject(options) {
                     kind: "connected",
                     summary: createSummary({
                         status: "connected",
+                        surfaceProfile: existingSurfaceProfile,
                         workspaceRoot: context.workspace_root,
                         projectId,
                         relayUrl: context.relay_url,
@@ -260,6 +269,9 @@ export async function startLaunchProject(options) {
     };
     const getLaunchStatus = () => hostLocalLaunchStatusFromConnectionManagerState(preparation.project_id, readConnectionState());
     const refreshRelayJoinUrl = async () => {
+        if (preparation.machine_local.binding.surface_profile.kind !== "standalone") {
+            return relayStateFromConnectionManagerState(preparation.relay_url, readConnectionState());
+        }
         if (relayRuntime.connectionManager === undefined) {
             return relayStateFromConnectionManagerState(preparation.relay_url, readConnectionState());
         }
@@ -296,10 +308,13 @@ export async function startLaunchProject(options) {
             heartbeatIntervalMs: registered.heartbeatIntervalMs,
             handleRequest: createHostProjectApiTunnelRequestHandler({
                 app: host.app,
+                projectSurface: preparation.machine_local.binding.surface_profile.kind,
                 trustedMetadataStore: host.trusted_relay_metadata_store,
+                integrationDelivery: host.integration_delivery,
             }),
             handleStreamRequest: createHostProjectApiTunnelStreamRequestHandler({
                 baseUrl: host.runtime_endpoint.base_url,
+                projectSurface: preparation.machine_local.binding.surface_profile.kind,
                 trustedMetadataStore: host.trusted_relay_metadata_store,
             }),
         }),
@@ -354,6 +369,7 @@ export async function startLaunchProject(options) {
         host,
         summary: createSummary({
             status: startupStatus,
+            surfaceProfile: preparation.machine_local.binding.surface_profile,
             workspaceRoot: preparation.workspace_root,
             projectId: preparation.project_id,
             relayUrl: preparation.relay_url,
@@ -374,7 +390,24 @@ export function formatLaunchLifecycleResult(result, options = {}) {
     if (summary.setup_url !== undefined) {
         fields.push(urlLine("Setup URL", summary.setup_url, options));
     }
-    if (summary.relay?.join_url !== undefined) {
+    if (summary.surface_profile.kind === "feishu") {
+        fields.push("Collaboration surface: Feishu");
+        if (summary.relay?.feishu_setup?.state === "pairing_required" &&
+            summary.relay.feishu_setup.visibility === "visible_once") {
+            fields.push(`Connect command: ${summary.relay.feishu_setup.command}`);
+            fields.push(`Connect code expires at: ${summary.relay.feishu_setup.expires_at}`);
+        }
+        else if (summary.relay?.feishu_setup?.state === "pairing_required") {
+            fields.push("Feishu conversation: pairing code is not recoverable; restart from Local Console to rotate it");
+        }
+        else if (summary.relay?.feishu_setup?.state === "connected") {
+            fields.push("Feishu conversation: connected");
+        }
+        else {
+            fields.push("Feishu Owner: open this project through Local Console to connect an account");
+        }
+    }
+    else if (summary.relay?.join_url !== undefined) {
         fields.push(urlLine("Join URL", summary.relay.join_url, options));
         fields.push(formatJoinLinkValidity({
             ...(summary.relay.join_token_expires_at === undefined

package/dist/server-shell/cli/host-relay-connection-manager.js

@@ -12,17 +12,28 @@ class WorkspaceUnavailableError extends Error {
 const DEFAULT_RETRY_DELAYS_MS = [0, 1_000, 2_000, 5_000, 10_000, 30_000];
 const DEFAULT_JITTER_RATIO = 0.2;
 const DEFAULT_WORKSPACE_CHECK_INTERVAL_MS = 30_000;
-function mergeKnownJoinUrl(previous, next) {
-    if (next.join_url !== undefined ||
-        previous?.join_url === undefined ||
-        previous.join_token_expires_at !== next.join_token_expires_at) {
-        return next;
+function mergeKnownVisibleCapabilities(previous, next) {
+    let merged = next;
+    if (next.join_url === undefined &&
+        previous?.join_url !== undefined &&
+        previous.join_token_expires_at === next.join_token_expires_at) {
+        merged = {
+            ...merged,
+            join_url: previous.join_url,
+            join_url_visibility: previous.join_url_visibility,
+        };
     }
-    return {
-        ...next,
-        join_url: previous.join_url,
-        join_url_visibility: previous.join_url_visibility,
-    };
+    const previousSetup = previous?.feishu_setup;
+    const nextSetup = next.feishu_setup;
+    if (previousSetup?.state === "pairing_required" &&
+        previousSetup.visibility === "visible_once" &&
+        nextSetup?.state === "pairing_required" &&
+        nextSetup.visibility === "not_recoverable" &&
+        nextSetup.expires_at !== undefined &&
+        previousSetup.expires_at === nextSetup.expires_at) {
+        merged = { ...merged, feishu_setup: previousSetup };
+    }
+    return merged;
 }
 function retryableConnectionError(error) {
     if (error instanceof RelayHostControlClientError) {
@@ -249,7 +260,7 @@ class DefaultHostRelayConnectionManager {
                 tunnel.close(1000, "host stopping");
                 throw new Error("Relay connection attempt was cancelled");
             }
-            const connection = mergeKnownJoinUrl(this.lastConnection, registered.summary);
+            const connection = mergeKnownVisibleCapabilities(this.lastConnection, registered.summary);
             const previousTunnel = this.activeTunnel;
             this.pendingTunnel = undefined;
             this.activeTunnel = tunnel;

package/dist/server-shell/cli/host-relay-status.js

@@ -97,6 +97,7 @@ export function relayStatusFromLocalStatus(status) {
         join_token_reusable: status.relay.join_token_reusable ?? true,
         tunnel_url: status.relay.tunnel_url,
         connected_at: status.relay.connected_at,
+        ...(status.relay.feishu_setup === undefined ? {} : { feishu_setup: status.relay.feishu_setup }),
     };
 }
 //# sourceMappingURL=host-relay-status.js.map