@xfey/tutti 0.1.105 → 0.1.106

package/dist/collaboration-ingestion/reference-attachments.js

@@ -0,0 +1,132 @@
+import { createHash } from "node:crypto";
+import { INTEGRATION_REFERENCE_ATTACHMENT_TUNNEL_PATH, isTrustedReferenceAttachmentIngestionCommand, } from "@tutti/shared/schemas/internal";
+import { decideCommandIdempotencyReplay, readCommandIdempotencyRecord, } from "../server-shell/command-idempotency/index.js";
+import { ingestReferenceFile, REFERENCE_FILE_INGESTION_COMMAND_NAME, REFERENCE_FILE_INGESTION_TARGET_REF, } from "./reference-files.js";
+export const TRUSTED_INTEGRATION_REFERENCE_ATTACHMENT_PATH = INTEGRATION_REFERENCE_ATTACHMENT_TUNNEL_PATH;
+function referencePayload(command) {
+    return {
+        upload_id: command.staged_upload.upload_id,
+        file_name: command.staged_upload.file_name,
+        size_bytes: command.staged_upload.size_bytes,
+        sha256: command.staged_upload.sha256,
+        ...(command.staged_upload.media_type === undefined
+            ? {}
+            : { media_type: command.staged_upload.media_type }),
+    };
+}
+function readExistingAttachmentMessage(db, command) {
+    const installation = command.source.locator.conversation.installation;
+    return (db
+        .prepare(`
+          SELECT message_id
+          FROM external_source_mappings
+          WHERE platform = ?
+            AND installation_ref = ?
+            AND external_message_ref = ?
+        `)
+        .get(installation.platform, installation.installation_ref, command.source.locator.message_ref)
+        ?.message_id ?? null);
+}
+function insertAttachmentEvidence(tx, command, _file, message) {
+    const source = command.source;
+    const installation = source.locator.conversation.installation;
+    const contentSha256 = `sha256:${createHash("sha256")
+        .update(source.attachment.attachment_ref, "utf8")
+        .digest("hex")}`;
+    tx.prepare(`
+      INSERT INTO external_source_mappings (
+        platform, installation_ref, conversation_ref, thread_ref, parent_message_ref,
+        external_message_ref, message_id, binding_ref, receipt_key, external_subject_ref,
+        author_account_ref, author_display_name, external_created_at, accepted_at,
+        initial_revision_ref, initial_observed_at, content_sha256, adapter_version,
+        latest_revision_ref, latest_external_updated_at
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `).run(installation.platform, installation.installation_ref, source.locator.conversation.conversation_ref, source.locator.conversation.thread_ref ?? null, source.locator.conversation.parent_message_ref ?? null, source.locator.message_ref, message.id, command.binding_ref, command.receipt.receipt_key, source.author.external_subject.subject_ref, command.actor.account_ref, command.actor.display_name, source.external_created_at, message.created_at, command.receipt.external_event_ref, source.observed_at, contentSha256, source.adapter_version, command.receipt.external_event_ref, source.external_created_at);
+    tx.prepare(`
+      INSERT INTO external_source_revision_observations (
+        platform, installation_ref, external_message_ref, revision_ref, observation_kind,
+        content_sha256, external_updated_at, observed_at, adapter_version
+      ) VALUES (?, ?, ?, ?, 'created', ?, ?, ?, ?)
+    `).run(installation.platform, installation.installation_ref, source.locator.message_ref, command.receipt.external_event_ref, contentSha256, source.external_created_at, source.observed_at, source.adapter_version);
+}
+export async function ingestTrustedReferenceAttachment(options) {
+    if (!isTrustedReferenceAttachmentIngestionCommand(options.command)) {
+        return { kind: "invalid", reason_code: "trusted_attachment_command_invalid" };
+    }
+    const existingMessageId = readExistingAttachmentMessage(options.store.db, options.command);
+    if (existingMessageId !== null) {
+        return { kind: "duplicate", message_id: existingMessageId };
+    }
+    const commandId = options.command.command_id;
+    const payload = referencePayload(options.command);
+    const replay = decideCommandIdempotencyReplay(readCommandIdempotencyRecord(options.store.db, commandId), {
+        command_name: REFERENCE_FILE_INGESTION_COMMAND_NAME,
+        target_ref: REFERENCE_FILE_INGESTION_TARGET_REF,
+        payload,
+    });
+    if (replay.kind === "mismatch") {
+        return { kind: "invalid", reason_code: "attachment_command_replay_mismatch" };
+    }
+    let staged;
+    try {
+        if (replay.kind === "start") {
+            try {
+                staged = await options.resolveContent();
+            }
+            catch {
+                return {
+                    kind: "host_unavailable",
+                    retryable: true,
+                    reason_code: "attachment_stage_unavailable",
+                };
+            }
+        }
+        const response = await ingestReferenceFile({
+            store: options.store,
+            workspaceRoot: options.workspaceRoot,
+            events: options.events,
+            commandId,
+            payload,
+            content: staged?.content,
+            author: {
+                account_ref: options.command.actor.account_ref,
+                display_name: options.command.actor.display_name,
+            },
+            afterCreate: (tx, file, message) => insertAttachmentEvidence(tx, options.command, file, message),
+            ...(options.now === undefined ? {} : { now: options.now }),
+            afterCommit: async () => {
+                if (staged !== undefined) {
+                    await staged.complete();
+                    staged = undefined;
+                }
+            },
+            ...(options.scratchpadSource === undefined
+                ? {}
+                : { scratchpadSource: options.scratchpadSource }),
+            ...(options.referenceSummaries === undefined
+                ? {}
+                : { referenceSummaries: options.referenceSummaries }),
+        });
+        if (response.disposition.kind === "interrupted") {
+            return {
+                kind: "host_unavailable",
+                retryable: true,
+                reason_code: "command_interrupted",
+            };
+        }
+        const messageId = response.result?.message.id;
+        if (messageId === undefined) {
+            return { kind: "invalid", reason_code: "attachment_message_identity_missing" };
+        }
+        return replay.kind === "start"
+            ? { kind: "created", message_id: messageId }
+            : { kind: "duplicate", message_id: messageId };
+    }
+    catch {
+        if (staged !== undefined) {
+            await staged.abort();
+        }
+        return { kind: "invalid", reason_code: "reference_attachment_rejected" };
+    }
+}
+//# sourceMappingURL=reference-attachments.js.map

package/dist/collaboration-ingestion/reference-files.d.ts

@@ -1,6 +1,6 @@
 import type { IdempotencyKey } from "@tutti/shared/ids";
-import type { ReferenceFileProjection, UploadReferenceFilePayload, UploadReferenceFileResponse } from "@tutti/shared/schemas/api";
-import type { HostProjectStore } from "../store/index.js";
+import type { MessageProjection, ReferenceFileProjection, UploadReferenceFilePayload, UploadReferenceFileResponse } from "@tutti/shared/schemas/api";
+import type { HostProjectStore, SqliteDatabase } from "../store/index.js";
 import { readReferenceSummaryIndex, type ViewerTreeEntry } from "../workspace-ops/index.js";
 import type { WorkspaceEventBus } from "../server-shell/http/workspace-events.js";
 import type { ReferenceSummaryStarter, ScratchpadSourceNotifier, TrustedCollaborationAuthor } from "./types.js";
@@ -20,6 +20,7 @@ export type IngestReferenceFileOptions = {
     payload: UploadReferenceFilePayload;
     content: Buffer | undefined;
     author: TrustedCollaborationAuthor;
+    afterCreate?: (tx: SqliteDatabase, file: ReferenceFileProjection, message: MessageProjection) => void;
     afterCommit?: () => Promise<void>;
     scratchpadSource?: ScratchpadSourceNotifier;
     referenceSummaries?: ReferenceSummaryStarter;

package/dist/collaboration-ingestion/reference-files.js

@@ -121,6 +121,7 @@ export async function ingestReferenceFile(options) {
                 actor: { kind: "human", ref: options.author.account_ref },
                 occurred_at: message.created_at,
             });
+            options.afterCreate?.(tx, file, message);
             return {
                 disposition: { kind: "created" },
                 result: { file, message, index_path: uploaded.index_path },

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

@@ -1,16 +1,19 @@
-import type { MessageProjection } from "@tutti/shared/schemas/api";
+import type { ApprovalRequestProjection, MessageProjection } from "@tutti/shared/schemas/api";
 import type { SqliteDatabase } from "../store/index.js";
+import type { HostProjectStore } from "../store/index.js";
 import type { HostPlatformOutboundLogger } from "./types.js";
 import type { HostPlatformOutboundWorker } from "./worker.js";
 export declare class HostPlatformOutboundCoordinator {
+    private readonly store;
     private readonly worker;
     private readonly logger;
     private readonly now;
-    constructor(worker: HostPlatformOutboundWorker, logger: HostPlatformOutboundLogger, now?: () => Date);
+    constructor(store: HostProjectStore, worker: HostPlatformOutboundWorker, logger: HostPlatformOutboundLogger, now?: () => Date);
     captureAgentResponse(tx: SqliteDatabase, input: {
         triggerMessage: MessageProjection;
         responseMessage: MessageProjection;
     }): (() => void) | undefined;
+    captureApprovalRequest(request: ApprovalRequestProjection): void;
     start(): void;
     stop(): Promise<void>;
 }

package/dist/platform-outbound/coordinator.js

@@ -1,9 +1,12 @@
-import { createPlatformOutboundIntent } from "./repository.js";
+import { createHash } from "node:crypto";
+import { createPlatformOutboundIntent, createPlatformStatusOutboundIntent } from "./repository.js";
 export class HostPlatformOutboundCoordinator {
+    store;
     worker;
     logger;
     now;
-    constructor(worker, logger, now = () => new Date()) {
+    constructor(store, worker, logger, now = () => new Date()) {
+        this.store = store;
         this.worker = worker;
         this.logger = logger;
         this.now = now;
@@ -38,6 +41,96 @@ export class HostPlatformOutboundCoordinator {
             this.worker.wake();
         };
     }
+    captureApprovalRequest(request) {
+        const bounded = (value, maximum) => [...value.trim()].slice(0, maximum).join("");
+        const title = bounded(request.title, 512);
+        const summary = bounded(request.summary, 4_000);
+        const reason = request.reason === undefined ? undefined : bounded(request.reason, 2_000);
+        const decisions = request.decisions.slice(0, 8).map((decision) => ({
+            decision_id: bounded(decision.decision_id, 256),
+            kind: decision.kind,
+            label: bounded(decision.label, 256),
+            tone: decision.tone,
+        }));
+        const revisionSource = JSON.stringify({
+            approval_id: request.approval_id,
+            title,
+            summary,
+            reason,
+            requested_at: request.requested_at,
+            expires_at: request.expires_at,
+            decisions,
+        });
+        const cardRevision = `cardrev_${createHash("sha256")
+            .update(revisionSource, "utf8")
+            .digest("hex")
+            .slice(0, 32)}`;
+        const content = {
+            kind: "approval_request",
+            approval_id: request.approval_id,
+            card_revision: cardRevision,
+            title,
+            summary,
+            ...(reason === undefined ? {} : { reason }),
+            requested_at: request.requested_at,
+            ...(request.expires_at === undefined ? {} : { expires_at: request.expires_at }),
+            decisions,
+        };
+        const eventKey = `approval_request:${request.approval_id}:opened`;
+        let result;
+        try {
+            result = this.store.db.transaction(() => createPlatformStatusOutboundIntent(this.store.db, {
+                eventKind: "needs_input",
+                eventKey,
+                subjectKind: "approval_request",
+                subjectRef: request.approval_id,
+                targetKind: "project",
+                content,
+                now: this.now,
+            }))();
+        }
+        catch {
+            try {
+                this.logger.warn({
+                    stage: "platform_outbound_capture",
+                    disposition: "failed",
+                    event_kind: "needs_input",
+                    event_key: eventKey,
+                    subject_kind: "approval_request",
+                    subject_ref: request.approval_id,
+                    target_kind: "project",
+                    error_code: "approval_outbound_capture_failed",
+                }, "Platform outbound approval intent capture failed");
+            }
+            catch {
+                // Approval correctness remains independent from both capture and logging failures.
+            }
+            return;
+        }
+        if (result === null) {
+            return;
+        }
+        try {
+            this.logger.info({
+                stage: "platform_outbound_capture",
+                disposition: result.created ? "created" : "duplicate",
+                outbound_intent_ref: result.intent.intent_ref,
+                event_kind: result.intent.event_kind,
+                event_key: result.intent.event_key,
+                subject_kind: result.intent.subject_kind,
+                subject_ref: result.intent.subject_ref,
+                target_kind: result.intent.target_kind,
+                installation_ref: result.intent.installation_ref,
+                binding_ref: result.intent.binding_ref,
+            }, result.created
+                ? "Platform outbound approval intent created"
+                : "Platform outbound approval intent already exists");
+        }
+        catch {
+            // The pending approval and durable intent remain authoritative when logging fails.
+        }
+        this.worker.wake();
+    }
     start() {
         this.worker.start();
     }

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

@@ -1,5 +1,22 @@
+import { type PlatformOutboundContent } from "@tutti/shared/schemas/internal";
 import type { SqliteDatabase } from "../store/index.js";
 import type { HostPlatformOutboundIntentRecord, HostPlatformOutboundWorkItem } from "./types.js";
+export declare function initializePlatformOutboundEventCapture(db: SqliteDatabase, now?: () => Date): string;
+export declare function createPlatformStatusOutboundIntent(tx: SqliteDatabase, input: {
+    eventKind: "needs_input" | "task_completed" | "task_failed";
+    eventKey: string;
+    subjectKind: "clarification_round" | "approval_request" | "task_result";
+    subjectRef: string;
+    targetKind: "project" | "work";
+    canonicalMessageId?: string;
+    contentText?: string;
+    content?: PlatformOutboundContent;
+    now?: () => Date;
+}): {
+    created: boolean;
+    intent: HostPlatformOutboundIntentRecord;
+} | null;
+export declare function materializePlatformStatusOutboundIntents(db: SqliteDatabase, now?: () => Date): HostPlatformOutboundIntentRecord[];
 export declare function createPlatformOutboundIntent(tx: SqliteDatabase, input: {
     triggerMessageId: string;
     canonicalMessageId: string;

package/dist/platform-outbound/repository.js

@@ -1,4 +1,170 @@
 import { createIdempotencyKey } from "@tutti/shared/ids";
+import { Value } from "@sinclair/typebox/value";
+import { PlatformOutboundContentSchema, } from "@tutti/shared/schemas/internal";
+const MAX_PLATFORM_OUTBOUND_TEXT_LENGTH = 4_000;
+function boundedPlatformOutboundText(value) {
+    const characters = [...value.trim()];
+    if (characters.length <= MAX_PLATFORM_OUTBOUND_TEXT_LENGTH) {
+        return characters.join("");
+    }
+    return `${characters.slice(0, MAX_PLATFORM_OUTBOUND_TEXT_LENGTH - 3).join("")}...`;
+}
+function readLatestFeishuDestination(tx) {
+    return (tx
+        .prepare(`
+          SELECT platform, installation_ref, binding_ref
+          FROM external_source_mappings
+          WHERE platform = 'feishu'
+          ORDER BY accepted_at DESC, message_id DESC
+          LIMIT 1
+        `)
+        .get() ?? null);
+}
+function readJsonObject(value) {
+    if (value === null) {
+        return {};
+    }
+    try {
+        const parsed = JSON.parse(value);
+        return typeof parsed === "object" && parsed !== null && !Array.isArray(parsed)
+            ? parsed
+            : {};
+    }
+    catch {
+        return {};
+    }
+}
+function readNestedObject(value, key) {
+    const nested = value[key];
+    return typeof nested === "object" && nested !== null && !Array.isArray(nested)
+        ? nested
+        : null;
+}
+export function initializePlatformOutboundEventCapture(db, now = () => new Date()) {
+    const timestamp = now().toISOString();
+    db.prepare(`
+      INSERT INTO platform_outbound_event_capture_state (id, capture_after, updated_at)
+      VALUES (1, ?, ?)
+      ON CONFLICT(id) DO NOTHING
+    `).run(timestamp, timestamp);
+    return (db
+        .prepare("SELECT capture_after FROM platform_outbound_event_capture_state WHERE id = 1")
+        .get()?.capture_after ?? timestamp);
+}
+export function createPlatformStatusOutboundIntent(tx, input) {
+    const existing = tx
+        .prepare("SELECT * FROM platform_outbound_intents WHERE event_key = ?")
+        .get(input.eventKey);
+    if (existing !== undefined) {
+        return { created: false, intent: existing };
+    }
+    const destination = readLatestFeishuDestination(tx);
+    if (destination === null) {
+        return null;
+    }
+    const contentText = input.contentText?.trim();
+    if (input.canonicalMessageId === undefined &&
+        (contentText === undefined || contentText.length === 0) &&
+        input.content === undefined) {
+        throw new TypeError("Platform status outbound content is missing");
+    }
+    if (contentText !== undefined && [...contentText].length > 4_000) {
+        throw new TypeError("Platform status outbound content is too long");
+    }
+    if (input.content !== undefined && !Value.Check(PlatformOutboundContentSchema, input.content)) {
+        throw new TypeError("Platform status outbound structured content is invalid");
+    }
+    const contentJson = input.content === undefined ? null : JSON.stringify(input.content);
+    const timestamp = (input.now ?? (() => new Date()))().toISOString();
+    const intentRef = createIdempotencyKey();
+    tx.prepare(`
+      INSERT INTO platform_outbound_intents (
+        intent_ref, platform, installation_ref, binding_ref,
+        event_kind, event_key, subject_kind, subject_ref, target_kind,
+        canonical_message_id, content_text, content_json, disposition, attempt_count,
+        next_attempt_at, created_at, updated_at
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `).run(intentRef, destination.platform, destination.installation_ref, destination.binding_ref, input.eventKind, input.eventKey, input.subjectKind, input.subjectRef, input.targetKind, input.canonicalMessageId ?? null, contentText ?? null, contentJson, "pending", 0, timestamp, timestamp, timestamp);
+    return {
+        created: true,
+        intent: tx
+            .prepare("SELECT * FROM platform_outbound_intents WHERE intent_ref = ?")
+            .get(intentRef),
+    };
+}
+export function materializePlatformStatusOutboundIntents(db, now = () => new Date()) {
+    return db.transaction(() => {
+        const captureAfter = initializePlatformOutboundEventCapture(db, now);
+        const candidates = db
+            .prepare(`
+          SELECT messages.id, messages.message_kind, messages.refs_json
+          FROM messages
+          LEFT JOIN platform_outbound_intents
+            ON platform_outbound_intents.canonical_message_id = messages.id
+          LEFT JOIN clarification_rounds
+            ON clarification_rounds.card_message_id = messages.id
+          LEFT JOIN clarification_threads
+            ON clarification_threads.id = clarification_rounds.clarification_thread_id
+          WHERE messages.created_at >= ?
+            AND platform_outbound_intents.intent_ref IS NULL
+            AND (
+              (
+                messages.message_kind = 'clarification_card'
+                AND clarification_rounds.status = 'writable'
+                AND clarification_threads.status = 'active'
+                AND clarification_threads.current_round_id = clarification_rounds.id
+              )
+              OR json_type(messages.refs_json, '$.task_result') = 'object'
+            )
+          ORDER BY messages.created_at, messages.id
+        `)
+            .all(captureAfter);
+        const created = [];
+        for (const candidate of candidates) {
+            const refs = readJsonObject(candidate.refs_json);
+            if (candidate.message_kind === "clarification_card") {
+                const roundRef = refs.clarification_round_ref;
+                if (typeof roundRef !== "string" || roundRef.length === 0) {
+                    continue;
+                }
+                const result = createPlatformStatusOutboundIntent(db, {
+                    eventKind: "needs_input",
+                    eventKey: `clarification_round:${roundRef}:opened`,
+                    subjectKind: "clarification_round",
+                    subjectRef: roundRef,
+                    targetKind: "project",
+                    canonicalMessageId: candidate.id,
+                    now,
+                });
+                if (result?.created === true) {
+                    created.push(result.intent);
+                }
+                continue;
+            }
+            const taskResult = readNestedObject(refs, "task_result");
+            const resultKey = taskResult?.result_key;
+            const status = taskResult?.status;
+            if (typeof resultKey !== "string" ||
+                resultKey.length === 0 ||
+                (status !== "completed" && status !== "failed")) {
+                continue;
+            }
+            const result = createPlatformStatusOutboundIntent(db, {
+                eventKind: status === "completed" ? "task_completed" : "task_failed",
+                eventKey: `task_result:${resultKey}`,
+                subjectKind: "task_result",
+                subjectRef: resultKey,
+                targetKind: "work",
+                canonicalMessageId: candidate.id,
+                now,
+            });
+            if (result?.created === true) {
+                created.push(result.intent);
+            }
+        }
+        return created;
+    })();
+}
 export function createPlatformOutboundIntent(tx, input) {
     const existing = tx
         .prepare("SELECT * FROM platform_outbound_intents WHERE canonical_message_id = ?")
@@ -21,10 +187,11 @@ export function createPlatformOutboundIntent(tx, input) {
     tx.prepare(`
       INSERT INTO platform_outbound_intents (
         intent_ref, platform, installation_ref, binding_ref,
+        event_kind, event_key, subject_kind, subject_ref, target_kind,
         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);
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `).run(intentRef, destination.platform, destination.installation_ref, destination.binding_ref, "chat_response", `chat_response:${input.canonicalMessageId}`, "message", input.canonicalMessageId, "project", input.triggerMessageId, input.canonicalMessageId, "pending", 0, timestamp, timestamp, timestamp);
     return {
         created: true,
         intent: tx
@@ -48,9 +215,10 @@ export function claimDuePlatformOutboundIntent(db, now = () => new Date()) {
         const timestamp = now().toISOString();
         const row = db
             .prepare(`
-          SELECT platform_outbound_intents.*, messages.body
+          SELECT platform_outbound_intents.*,
+                 COALESCE(platform_outbound_intents.content_text, messages.body) AS body
           FROM platform_outbound_intents
-          JOIN messages ON messages.id = platform_outbound_intents.canonical_message_id
+          LEFT 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
@@ -63,6 +231,23 @@ export function claimDuePlatformOutboundIntent(db, now = () => new Date()) {
         if (row === undefined) {
             return null;
         }
+        let content = null;
+        if (row.content_json !== null) {
+            try {
+                const parsed = JSON.parse(row.content_json);
+                content = Value.Check(PlatformOutboundContentSchema, parsed) ? parsed : null;
+            }
+            catch {
+                content = null;
+            }
+        }
+        else if (row.body !== null) {
+            const body = boundedPlatformOutboundText(row.body);
+            content = body.length === 0 ? null : { kind: "text", text: body };
+        }
+        if (content === null) {
+            return null;
+        }
         db.prepare(`
         UPDATE platform_outbound_intents
         SET disposition = 'sending', attempt_count = attempt_count + 1,
@@ -72,7 +257,7 @@ export function claimDuePlatformOutboundIntent(db, now = () => new Date()) {
         const intent = db
             .prepare("SELECT * FROM platform_outbound_intents WHERE intent_ref = ?")
             .get(row.intent_ref);
-        return { intent, body: row.body };
+        return { intent, content };
     })();
 }
 export function markPlatformOutboundHandedOff(db, input) {

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

@@ -1,14 +1,24 @@
 import type { IdempotencyKey, MessageId } from "@tutti/shared/ids";
 import type { MessageProjection } from "@tutti/shared/schemas/api";
 import type { PlatformOutboundHandoffResponse } from "@tutti/shared/schemas/internal";
+import type { PlatformOutboundContent } from "@tutti/shared/schemas/internal";
 export type HostPlatformOutboundIntentDisposition = "pending" | "sending" | "retry_wait" | "handed_off" | "terminal";
+export type HostPlatformOutboundEventKind = "chat_response" | "needs_input" | "task_completed" | "task_failed";
+export type HostPlatformOutboundSubjectKind = "message" | "clarification_round" | "approval_request" | "task_result";
 export type HostPlatformOutboundIntentRecord = {
     intent_ref: IdempotencyKey;
     platform: "feishu";
     installation_ref: string;
     binding_ref: string;
-    trigger_message_id: MessageId;
-    canonical_message_id: MessageId;
+    event_kind: HostPlatformOutboundEventKind;
+    event_key: string;
+    subject_kind: HostPlatformOutboundSubjectKind;
+    subject_ref: string;
+    target_kind: "project" | "work";
+    trigger_message_id: MessageId | null;
+    canonical_message_id: MessageId | null;
+    content_text: string | null;
+    content_json: string | null;
     disposition: HostPlatformOutboundIntentDisposition;
     attempt_count: number;
     next_attempt_at: string | null;
@@ -21,7 +31,7 @@ export type HostPlatformOutboundIntentRecord = {
 };
 export type HostPlatformOutboundWorkItem = {
     intent: HostPlatformOutboundIntentRecord;
-    body: string;
+    content: PlatformOutboundContent;
 };
 export type HostPlatformOutboundTransport = {
     deliver(item: HostPlatformOutboundWorkItem): Promise<PlatformOutboundHandoffResponse>;

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/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,