@xfey/tutti 0.1.103 → 0.1.104

package/README.md

@@ -13,6 +13,8 @@
 - SQLite store、migrations、repository 与协作真相读写
 - `control-plane`、scheduler、`procedure-engine`、`run-engine`、`workspace-ops` 与 OpenAI provider 接入
 - host 到 Relay 的连接与工作区加入协作
+- machine-local `standalone | feishu` Project Surface authority，以及Standalone browser session / Feishu trusted integration的双向Host gate
+- Feishu主群聊Chat Assistant canonical response与Host-owned durable outbound handoff intent
 
 ## 结构
 
@@ -33,12 +35,14 @@
 
 - 已具备 Fastify host shell、后台 host manager CLI 套件、用户级 desktop integration / strict `tutti://projects` bridge、带 `service status / stop / restart`、卸载前 `shutdown`、并发启动锁、版本替换、strict terminal / desktop browser context、当前 runtime version bootstrap projection、idle / package update cleanup、全机readiness、exact npm global install、跨版本worker / recovery与私有日志的机器级 Local Console、Dev Runner、Host Project API、SSE、SQLite store、collaboration-state、workspace read-state、project timeline observability helper、Control Plane、Procedure / Run、workspace-ops、checks、Relay staged upload finalize、user skills 文件服务、artifacts 可视化产物查看层、current-generation Artifact feedback message / model formatter、Owner-only provider model discovery / update 和 OpenAI / Codex provider 接入。
 - 新 Host project 的空群聊会由 collaboration-state 幂等写入一条 Tutti 欢迎消息；它不经过 browser message command，不触发 `@tutti`、Chat read-state、Scratchpad 或 Timeline / execution 流程。
+- Feishu external source触发的主群聊Chat Assistant回复会在canonical message transaction中建立`platform_outbound_intents`，后台通过当前Host credential交给Relay；`handed_off`只表示Integration durable outbox已接受，不表示飞书最终delivered。
 - Host server 与 Local Console 支持在显式 `webStatic.root` 或 packaged `web/` 存在时服务 Web 静态产物；`/api/*`、SSE、health、host-local control 和 `/local-console/*` API 不被 SPA fallback 吞掉。
 - Root `pack:dry-run` 会先清理 build output、重新构建，再复制 `apps/web/dist` 到 package-local `web/`，生成临时 staging `@xfey/tutti` artifact，并校验 npm pack 文件列表包含 CLI、migrations、prompts、Web index、bundled `@tutti/shared` / `@tutti/relay-client` 以及它们的外部 runtime dependencies，同时排除源码、source map、日志、SQLite、`.env`、`.tutti-dev` 与测试产物。
 - Root `smoke:packed-cli` 同样从干净 build output 生成 staging `@xfey/tutti` tarball、在临时目录安装，并验证 SQLite native binding、`tutti --help` / desktop help / `tutti service --help` / `tutti service status` / `tutti shutdown --help` / `tutti launch --help` / `tutti archive --help` / `tutti --version`、desktop assets、migrations、prompts、Web static index、bundled internal dependencies、bundled external runtime dependencies、CLI QR dependency、仓库锁定的 `@openai/codex` binary 可执行性和临时全局安装路径；该 smoke 不需要 Tutti source repo 存在。
 - 对外发布必须把同一 staging package 通过 `npm pack` 生成的已核验 `.tgz` 交给 `npm publish`，不得直接发布 staging 目录；npm 的目录发布路径可能重新收集文件并遗漏 staging 内的 bundled dependencies。发布后必须从 registry 临时执行 CLI version / help smoke。
 - `prompts/` 是所有模型-facing prompt、指令模板和 Codex 执行模板的统一落点；长 prompt 不内联在 TypeScript 中。
-- Host Project API 只信任 Relay tunnel metadata 注入的 `relay_session_context`；direct loopback 缺少可信 context 时不作为浏览器工作区入口。
+- Host Project API只信任Relay tunnel metadata注入的Surface-matched browser context；direct loopback缺少可信context时不作为浏览器工作区入口。
+- `binding.json.surface_profile`是Project Surface的durable authority，legacy binding默认Standalone；已有project不能通过普通launch或Local Console隐式切换Surface。Relay只保存不可变mirror用于边缘gate。
 - 详细模块落点见 `src/README.md`；logger redaction、command idempotency、schema、provider 与 Codex 边界以 `docs/system/` 对应 canonical 文档为准。
 
 ## 约定
@@ -51,10 +55,11 @@
 - 不实现绕过 Relay 的单人工作区路径。
 - packaged / production `tutti launch` 默认连接 `https://tutti.now`；`TUTTI_RELAY_URL` 可覆盖 Relay URL，本地开发 dev runner 默认使用 `http://127.0.0.1:4370`。
 - host 注册使用 machine-local `host_registration_secret`；该 secret 明文只可写入受限权限的 machine-local secret store，不写入目标项目 repo、Git local config 项目身份、SQLite 协作真相或日志，`binding.json` 只保存引用。
-- Relay registration 成功后只把 `relay_project_ref` 写回 machine-local binding；join URL 只在 host 本机终端或当前 host-local control 内存状态中展示，不写入 binding、runtime endpoint、SQLite 协作真相或日志。
-- 普通 `tutti launch` 默认后台运行 host，CLI 完成页展示 join URL 后直接退出；`tutti launch --foreground` 保留前台诊断模式。Host HTTP request log 与 Control Plane / Run Pipeline runtime log 写入 `TUTTI_HOME/logs/host.log`，不写入目标项目 repo 或常规 CLI stdout。
+- Relay registration 成功后只把 `relay_project_ref` 写回 machine-local binding；Standalone join URL只在host本机终端或当前host-local control内存状态中展示，不写入binding、runtime endpoint、SQLite协作真相或日志。Feishu project不签发join URL。
+- 普通 `tutti launch` 默认后台运行 host；Standalone完成页展示join URL，Feishu完成页只确认collaboration surface，然后CLI退出。`tutti launch --foreground` 保留前台诊断模式。后台spawn为每次启动生成唯一`startup_attempt_ref`，源码入口会先把`tsx` loader解析为不受目标project cwd影响的绝对URL；spawn、endpoint等待、Relay readiness、内部启动失败与timeout使用同一ref写入`TUTTI_HOME/logs/host.log`。Host HTTP request log 与 Control Plane / Run Pipeline runtime log也写入该文件，不写入目标项目 repo 或常规 CLI stdout。
+- Standalone Host只接受普通`relay_session_context`工作区请求；Feishu Host接受`feishu_platform_session_context` browser请求和固定internal path的`integration_delivery`。三种metadata严格三选一，cross-Surface browser request在进入Fastify业务route前403。Feishu browser只开放Project / Work精确只读allowlist；Host outbound使用独立host-control route，不借用browser transport。无状态`/api/v1/openapi.json`诊断仍可生成contract。
 - Reference 和 Skills 上传的最终写入由 Host Project API 完成；Host 只通过 Relay host-control resolve 获取短期 R2 URL 下载 staged object，不接收浏览器 base64 文件正文，也不持久化 presigned URL。
-- Host Project API command 的 browser session context 只信任 Relay tunnel metadata 中的 `relay_session_context`；route handler 不读取浏览器身份 header，也不接受 payload 内身份字段。
+- Host Project API的browser session context只信任Relay tunnel metadata中的Surface-matched variant；route handler不读取浏览器身份header，也不接受payload内身份字段。Feishu session在兼容projection中使用`client_session.transport = "feishu_platform_session"`，不代表创建Standalone Relay client session。
 - Artifact feedback 仍写入现有 `messages` truth并复用command idempotency；Host只在当前ready generation完全匹配时接受，Anchor技术字段仅保留审计ref，模型上下文使用bounded semantic formatter。
 - Fastify request log、debug log、SSE payload、activity event 和 run result 都必须经过 redaction，不得泄露 provider secret、host registration secret、host connection token、join token、cookie、host 绝对路径或 run workspace path。
 - Repo path metadata policy 与更严格的 Viewer content path policy 已拆分为可测试 helper：Phase 6 Viewer / Reference Files API 继续拒绝 secret-like 内容读取，Run / merge changed paths 可以完整报告结构性安全的 repo-relative 文件名；Phase 7 checks executor 已以 safe npm script discovery、结构化 `spawn`、timeout、stdout / stderr redaction 与 no-shell 执行为首批命令安全边界。

package/dist/chat-assistant/index.d.ts

@@ -1,6 +1,6 @@
 import type { ProjectId } from "@tutti/shared/ids";
 import type { MessageProjection } from "@tutti/shared/schemas/api";
-import type { HostProjectStore } from "../store/index.js";
+import { type HostProjectStore, type SqliteDatabase } from "../store/index.js";
 import type { WorkspaceEventBus } from "../server-shell/http/workspace-events.js";
 export declare const CHAT_ASSISTANT_OUTPUT_SCHEMA: {
     readonly type: "object";
@@ -45,6 +45,11 @@ export type ReadOnlyChatAssistantOptions = {
     model: ReadOnlyChatAssistantModel;
     promptsRoot?: string;
     onScratchpadSourceChanged?: (message: MessageProjection) => void;
+    onMainChatAgentMessageCreated?: (input: {
+        tx: SqliteDatabase;
+        triggerMessage: MessageProjection;
+        responseMessage: MessageProjection;
+    }) => void | (() => void);
     waitForInspectionAvailability?: () => Promise<void>;
     maxQueuedMentions?: number;
     now?: () => Date;

package/dist/chat-assistant/index.js

@@ -1,6 +1,7 @@
 import { createClarificationRoundAgentMessage, createMainChatAgentMessage, readClarificationRoundMessagesWindow, readClarificationRoundProjection, readMainChatMessageWindow, readMainChatMessagesBeforeCursor, readMessageProjectionById, } from "../collaboration-state/index.js";
 import { renderPromptTemplate } from "../prompt-templates/index.js";
-import { messageTextForModel, messageTextForTuttiMention, } from "../artifact-feedback/index.js";
+import { withHostStoreTransaction, } from "../store/index.js";
+import { messageTextForModel, messageTextForTuttiMention } from "../artifact-feedback/index.js";
 const CHAT_ASSISTANT_CONTEXT_MESSAGE_LIMIT = 3;
 const CHAT_ASSISTANT_ROUND_MESSAGE_LIMIT = 50;
 const CHAT_ASSISTANT_ROUND_MESSAGE_MAX_CHARS = 2_000;
@@ -30,11 +31,7 @@ export function containsTuttiMention(value) {
     return /(^|[^\p{L}\p{N}_])@tutti(?=$|[^\p{L}\p{N}_-])/iu.test(value);
 }
 function mainChatMessageInvalidates() {
-    return [
-        { kind: "messages", scope: "main_chat" },
-        { kind: "read_state" },
-        { kind: "bootstrap" },
-    ];
+    return [{ kind: "messages", scope: "main_chat" }, { kind: "read_state" }, { kind: "bootstrap" }];
 }
 function normalizeAnswer(answer) {
     const trimmed = answer.trim();
@@ -246,12 +243,25 @@ export class ReadOnlyChatAssistant {
             },
         });
     }
-    appendMainChatAssistantMessage(body, refs) {
-        const message = createMainChatAgentMessage(this.options.store.db, {
-            body,
-            ...(refs === undefined ? {} : { refs }),
-            ...(this.options.now === undefined ? {} : { now: this.options.now }),
+    appendMainChatAssistantMessage(triggerMessage, body, refs) {
+        let afterCommit;
+        const message = withHostStoreTransaction(this.options.store.db, (tx) => {
+            const responseMessage = createMainChatAgentMessage(tx, {
+                body,
+                ...(refs === undefined ? {} : { refs }),
+                ...(this.options.now === undefined ? {} : { now: this.options.now }),
+            });
+            const callback = this.options.onMainChatAgentMessageCreated?.({
+                tx,
+                triggerMessage,
+                responseMessage,
+            });
+            if (typeof callback === "function") {
+                afterCommit = callback;
+            }
+            return responseMessage;
         });
+        afterCommit?.();
         this.options.events.publish({
             event_type: "message.created",
             payload: {
@@ -299,7 +309,7 @@ export class ReadOnlyChatAssistant {
             });
             return;
         }
-        this.appendMainChatAssistantMessage(body, refs);
+        this.appendMainChatAssistantMessage(triggerMessage, body, refs);
     }
     async respond(triggerMessage) {
         try {

package/dist/collaboration-ingestion/external-source.d.ts

@@ -0,0 +1,15 @@
+import type { IntegrationDeliveryDisposition, TrustedConversationSourceIngestionCommand } from "@tutti/shared/schemas/internal";
+import type { HostProjectStore } from "../store/index.js";
+import type { WorkspaceEventBus } from "../server-shell/http/workspace-events.js";
+import type { ChatAssistantEnqueuer, ScratchpadSourceNotifier } from "./types.js";
+export declare const TRUSTED_INTEGRATION_INGESTION_PATH = "/internal/integration/v1/conversation-sources";
+export type IngestTrustedConversationSourceOptions = {
+    store: HostProjectStore;
+    events: WorkspaceEventBus;
+    command: TrustedConversationSourceIngestionCommand;
+    scratchpadSource?: ScratchpadSourceNotifier;
+    chatAssistant?: ChatAssistantEnqueuer;
+    now?: () => Date;
+};
+export declare function ingestTrustedConversationSource(options: IngestTrustedConversationSourceOptions): IntegrationDeliveryDisposition;
+//# sourceMappingURL=external-source.d.ts.map

package/dist/collaboration-ingestion/external-source.js

@@ -0,0 +1,120 @@
+import { createHash } from "node:crypto";
+import { INTEGRATION_CONVERSATION_SOURCE_TUNNEL_PATH, isTrustedConversationSourceIngestionCommand, } from "@tutti/shared/schemas/internal";
+import { ingestMainChatMessage } from "./main-chat.js";
+export const TRUSTED_INTEGRATION_INGESTION_PATH = INTEGRATION_CONVERSATION_SOURCE_TUNNEL_PATH;
+function sha256Text(value) {
+    return `sha256:${createHash("sha256").update(value, "utf8").digest("hex")}`;
+}
+function readExternalSourceMapping(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) ?? null);
+}
+function insertExternalSourceEvidence(tx, command, message) {
+    const source = command.source;
+    const installation = source.locator.conversation.installation;
+    const acceptedAt = message.created_at;
+    const contentSha256 = sha256Text(source.content.text);
+    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, source.author.account_ref, source.author.display_name, source.external_created_at, acceptedAt, source.revision_ref, source.observed_at, contentSha256, source.adapter_version, source.revision_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, source.revision_ref, contentSha256, source.external_created_at, source.observed_at, source.adapter_version);
+}
+export function ingestTrustedConversationSource(options) {
+    if (!isTrustedConversationSourceIngestionCommand(options.command)) {
+        return { kind: "invalid", reason_code: "trusted_command_invalid" };
+    }
+    const existing = readExternalSourceMapping(options.store.db, options.command);
+    if (existing !== null) {
+        return { kind: "duplicate", message_id: existing.message_id };
+    }
+    const source = options.command.source;
+    if (source.attachments.length > 0) {
+        return { kind: "unsupported", reason_code: "attachments_unsupported" };
+    }
+    if (source.content.text.length > 8_000) {
+        return { kind: "unsupported", reason_code: "message_too_long" };
+    }
+    const response = ingestMainChatMessage({
+        store: options.store,
+        events: options.events,
+        commandId: options.command.command_id,
+        payload: { body: source.content.text },
+        author: {
+            account_ref: options.command.actor.account_ref,
+            display_name: options.command.actor.display_name,
+        },
+        materialize: () => ({ kind: "message", body: source.content.text }),
+        idempotencyContext: {
+            kind: "external_conversation_source",
+            platform: source.locator.conversation.installation.platform,
+            installation_ref: source.locator.conversation.installation.installation_ref,
+            external_message_ref: source.locator.message_ref,
+            binding_ref: options.command.binding_ref,
+            receipt_key: options.command.receipt.receipt_key,
+        },
+        afterCreate: (tx, message) => insertExternalSourceEvidence(tx, options.command, message),
+        ...(options.scratchpadSource === undefined
+            ? {}
+            : { scratchpadSource: options.scratchpadSource }),
+        ...(options.chatAssistant === undefined ? {} : { chatAssistant: options.chatAssistant }),
+        ...(options.now === undefined ? {} : { now: options.now }),
+    });
+    if (response.disposition.kind === "interrupted") {
+        return {
+            kind: "host_unavailable",
+            retryable: true,
+            reason_code: "command_interrupted",
+        };
+    }
+    if (response.disposition.kind !== "created") {
+        return { kind: "invalid", reason_code: "main_chat_ingestion_rejected" };
+    }
+    const messageId = response.disposition.message_id ?? response.result?.message.id;
+    return messageId === undefined
+        ? { kind: "invalid", reason_code: "message_identity_missing" }
+        : { kind: "created", message_id: messageId };
+}
+//# sourceMappingURL=external-source.js.map

package/dist/collaboration-ingestion/index.d.ts

@@ -0,0 +1,5 @@
+export { ingestTrustedConversationSource, TRUSTED_INTEGRATION_INGESTION_PATH, type IngestTrustedConversationSourceOptions, } from "./external-source.js";
+export { ingestMainChatMessage, type IngestMainChatMessageOptions, type MainChatMessageMaterialization, } from "./main-chat.js";
+export { ingestReferenceFile, REFERENCE_FILE_INGESTION_COMMAND_NAME, REFERENCE_FILE_INGESTION_TARGET_REF, toReferenceFileProjection, type IngestReferenceFileOptions, } from "./reference-files.js";
+export type { ChatAssistantEnqueuer, ReferenceSummaryStarter, ScratchpadSourceNotifier, TrustedCollaborationAuthor, } from "./types.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/collaboration-ingestion/index.js

@@ -0,0 +1,4 @@
+export { ingestTrustedConversationSource, TRUSTED_INTEGRATION_INGESTION_PATH, } from "./external-source.js";
+export { ingestMainChatMessage, } from "./main-chat.js";
+export { ingestReferenceFile, REFERENCE_FILE_INGESTION_COMMAND_NAME, REFERENCE_FILE_INGESTION_TARGET_REF, toReferenceFileProjection, } from "./reference-files.js";
+//# sourceMappingURL=index.js.map

package/dist/collaboration-ingestion/invalidations.d.ts

@@ -0,0 +1,4 @@
+import type { QueryInvalidationHint } from "@tutti/shared/schemas/api";
+export declare function mainChatIngestionInvalidates(): QueryInvalidationHint[];
+export declare function referenceIngestionInvalidates(): QueryInvalidationHint[];
+//# sourceMappingURL=invalidations.d.ts.map

package/dist/collaboration-ingestion/invalidations.js

@@ -0,0 +1,15 @@
+import { REFERENCE_DIRECTORY_PATH } from "../workspace-ops/index.js";
+export function mainChatIngestionInvalidates() {
+    return [{ kind: "messages", scope: "main_chat" }, { kind: "read_state" }, { kind: "bootstrap" }];
+}
+export function referenceIngestionInvalidates() {
+    return [
+        { kind: "viewer", path: REFERENCE_DIRECTORY_PATH },
+        { kind: "messages", scope: "main_chat" },
+        { kind: "execution_status" },
+        { kind: "workspace" },
+        { kind: "read_state" },
+        { kind: "bootstrap" },
+    ];
+}
+//# sourceMappingURL=invalidations.js.map

package/dist/collaboration-ingestion/main-chat.d.ts

@@ -0,0 +1,33 @@
+import type { IdempotencyKey } from "@tutti/shared/ids";
+import type { MessageProjection, SendMainChatMessagePayload, SendMainChatMessageResponse } from "@tutti/shared/schemas/api";
+import type { HostProjectStore } from "../store/index.js";
+import type { SqliteDatabase } from "../store/index.js";
+import type { WorkspaceEventBus } from "../server-shell/http/workspace-events.js";
+import type { ChatAssistantEnqueuer, ScratchpadSourceNotifier, TrustedCollaborationAuthor } from "./types.js";
+export type MainChatMessageMaterialization = {
+    kind: "message";
+    body: string;
+    refs?: MessageProjection["refs"];
+} | {
+    kind: "rejected";
+    disposition: {
+        kind: "artifact_changed";
+    } | {
+        kind: "artifact_unavailable";
+    };
+};
+export type IngestMainChatMessageOptions = {
+    store: HostProjectStore;
+    events: WorkspaceEventBus;
+    commandId: IdempotencyKey;
+    payload: SendMainChatMessagePayload;
+    author: TrustedCollaborationAuthor;
+    materialize: () => MainChatMessageMaterialization;
+    scratchpadSource?: ScratchpadSourceNotifier;
+    chatAssistant?: ChatAssistantEnqueuer;
+    idempotencyContext?: unknown;
+    afterCreate?: (tx: SqliteDatabase, message: MessageProjection) => void;
+    now?: () => Date;
+};
+export declare function ingestMainChatMessage(options: IngestMainChatMessageOptions): SendMainChatMessageResponse;
+//# sourceMappingURL=main-chat.d.ts.map

package/dist/collaboration-ingestion/main-chat.js

@@ -0,0 +1,67 @@
+import { createMainChatMessage, readMessageProjectionById } from "../collaboration-state/index.js";
+import { executeIdempotentCommand } from "../server-shell/command-idempotency/index.js";
+import { mainChatIngestionInvalidates } from "./invalidations.js";
+export function ingestMainChatMessage(options) {
+    const execution = executeIdempotentCommand({
+        db: options.store.db,
+        command_id: options.commandId,
+        command_name: "messages.create",
+        target_ref: "main_chat",
+        payload: {
+            ...options.payload,
+            author_ref: options.author.account_ref,
+            ...(options.idempotencyContext === undefined
+                ? {}
+                : { ingestion_context: options.idempotencyContext }),
+        },
+        ...(options.now === undefined ? {} : { now: options.now }),
+        execute: (tx) => {
+            const materialized = options.materialize();
+            if (materialized.kind === "rejected") {
+                return { disposition: materialized.disposition };
+            }
+            const message = createMainChatMessage(tx, {
+                body: materialized.body,
+                author: {
+                    kind: "human",
+                    ref: options.author.account_ref,
+                    display_name: options.author.display_name,
+                    ...(options.author.avatar === undefined ? {} : { avatar: options.author.avatar }),
+                },
+                ...(materialized.refs === undefined ? {} : { refs: materialized.refs }),
+                ...(options.now === undefined ? {} : { now: options.now }),
+            });
+            options.afterCreate?.(tx, message);
+            return {
+                disposition: { kind: "created", message_id: message.id },
+                result: { message },
+            };
+        },
+    });
+    const replayedMessage = execution.result === undefined &&
+        execution.disposition.kind === "created" &&
+        execution.disposition.message_id !== undefined
+        ? readMessageProjectionById(options.store.db, execution.disposition.message_id)
+        : null;
+    const result = execution.result ?? (replayedMessage === null ? undefined : { message: replayedMessage });
+    const invalidates = mainChatIngestionInvalidates();
+    const response = {
+        command_id: execution.command_id,
+        disposition: execution.disposition,
+        ...(execution.disposition.kind === "created" ? { invalidates } : {}),
+    };
+    if (result !== undefined) {
+        response.result = result;
+    }
+    if (!execution.replayed && result !== undefined) {
+        options.events.publish({
+            event_type: "message.created",
+            payload: { message: result.message },
+            invalidates,
+        });
+        options.scratchpadSource?.notify(result.message);
+        options.chatAssistant?.enqueue({ message: result.message });
+    }
+    return response;
+}
+//# sourceMappingURL=main-chat.js.map

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

@@ -0,0 +1,29 @@
+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 { 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";
+export declare const REFERENCE_FILE_INGESTION_COMMAND_NAME: "references.files.upload";
+export declare const REFERENCE_FILE_INGESTION_TARGET_REF: "docs/reference";
+export declare function toReferenceFileProjection(options: {
+    workspaceRoot: string;
+    entry: ViewerTreeEntry;
+    summaryIndex?: ReturnType<typeof readReferenceSummaryIndex>;
+    now?: () => Date;
+}): ReferenceFileProjection;
+export type IngestReferenceFileOptions = {
+    store: HostProjectStore;
+    workspaceRoot: string;
+    events: WorkspaceEventBus;
+    commandId: IdempotencyKey;
+    payload: UploadReferenceFilePayload;
+    content: Buffer | undefined;
+    author: TrustedCollaborationAuthor;
+    afterCommit?: () => Promise<void>;
+    scratchpadSource?: ScratchpadSourceNotifier;
+    referenceSummaries?: ReferenceSummaryStarter;
+    now?: () => Date;
+};
+export declare function ingestReferenceFile(options: IngestReferenceFileOptions): Promise<UploadReferenceFileResponse>;
+//# sourceMappingURL=reference-files.d.ts.map

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

@@ -0,0 +1,158 @@
+import { createMainChatMessage, recordReadNotificationEvent, } from "../collaboration-state/index.js";
+import { REFERENCE_DIRECTORY_PATH, VIEWER_HARD_READ_LIMIT_BYTES, readReferenceSummaryIndex, readViewerFile, referenceFileCategoryForPath, referenceMediaTypeForPath, referenceSummaryProjectionForEntry, uploadReferenceFile, } from "../workspace-ops/index.js";
+import { executeIdempotentCommand } from "../server-shell/command-idempotency/index.js";
+import { referenceIngestionInvalidates } from "./invalidations.js";
+export const REFERENCE_FILE_INGESTION_COMMAND_NAME = "references.files.upload";
+export const REFERENCE_FILE_INGESTION_TARGET_REF = REFERENCE_DIRECTORY_PATH;
+function unreadableReasonForReferenceContent(content) {
+    return content.kind === "text" ? undefined : content.reason;
+}
+function referenceTextReadProjection(workspaceRoot, entry, now) {
+    if (entry.size_bytes !== undefined && entry.size_bytes > VIEWER_HARD_READ_LIMIT_BYTES) {
+        return { can_read: false, blocked_reason: "too_large" };
+    }
+    try {
+        const file = readViewerFile({
+            workspaceRoot,
+            path: entry.path,
+            maxBytes: 1,
+            ...(now === undefined ? {} : { now }),
+        });
+        const reason = unreadableReasonForReferenceContent(file.content);
+        return reason === undefined ? { can_read: true } : { can_read: false, blocked_reason: reason };
+    }
+    catch {
+        return { can_read: false, blocked_reason: "unknown" };
+    }
+}
+export function toReferenceFileProjection(options) {
+    const category = referenceFileCategoryForPath(options.entry.path) ?? "file";
+    const summaryIndex = options.summaryIndex ?? readReferenceSummaryIndex({ workspaceRoot: options.workspaceRoot });
+    const projection = {
+        path: options.entry.path,
+        name: options.entry.name,
+        category,
+        size_bytes: options.entry.size_bytes ?? 0,
+        text_read: referenceTextReadProjection(options.workspaceRoot, options.entry, options.now),
+        summary: referenceSummaryProjectionForEntry({
+            entry: options.entry,
+            summaries: summaryIndex,
+        }),
+    };
+    if (options.entry.blob_oid !== undefined) {
+        projection.blob_oid = options.entry.blob_oid;
+    }
+    if (options.entry.extension !== undefined) {
+        projection.extension = options.entry.extension;
+    }
+    if (options.entry.language_hint !== undefined) {
+        projection.language_hint = options.entry.language_hint;
+    }
+    const mediaType = referenceMediaTypeForPath(options.entry.path);
+    if (mediaType !== undefined) {
+        projection.media_type = mediaType;
+    }
+    return projection;
+}
+function referenceUploadMessageBody(file) {
+    return file.category === "image" ? `Uploaded image: ${file.name}` : `Uploaded file: ${file.name}`;
+}
+function referenceFileMessageRef(file) {
+    const ref = {
+        path: file.path,
+        name: file.name,
+        source: "human_upload",
+        category: file.category,
+        size_bytes: file.size_bytes,
+        text_read: file.text_read,
+    };
+    if (file.media_type !== undefined) {
+        ref.media_type = file.media_type;
+    }
+    if (file.blob_oid !== undefined) {
+        ref.blob_oid = file.blob_oid;
+    }
+    return ref;
+}
+export async function ingestReferenceFile(options) {
+    const invalidates = referenceIngestionInvalidates();
+    const execution = executeIdempotentCommand({
+        db: options.store.db,
+        command_id: options.commandId,
+        command_name: REFERENCE_FILE_INGESTION_COMMAND_NAME,
+        target_ref: REFERENCE_FILE_INGESTION_TARGET_REF,
+        payload: options.payload,
+        ...(options.now === undefined ? {} : { now: options.now }),
+        execute: (tx) => {
+            if (options.content === undefined) {
+                throw new Error("Staged reference upload was not downloaded");
+            }
+            const uploaded = uploadReferenceFile({
+                workspaceRoot: options.workspaceRoot,
+                commandId: options.commandId,
+                fileName: options.payload.file_name,
+                content: options.content,
+                ...(options.payload.media_type === undefined
+                    ? {}
+                    : { mediaType: options.payload.media_type }),
+                ...(options.payload.note === undefined ? {} : { note: options.payload.note }),
+                ...(options.now === undefined ? {} : { now: options.now }),
+            });
+            const file = toReferenceFileProjection({
+                workspaceRoot: options.workspaceRoot,
+                entry: uploaded.file,
+                ...(options.now === undefined ? {} : { now: options.now }),
+            });
+            const message = createMainChatMessage(tx, {
+                body: referenceUploadMessageBody(file),
+                author: {
+                    kind: "human",
+                    ref: options.author.account_ref,
+                    display_name: options.author.display_name,
+                    ...(options.author.avatar === undefined ? {} : { avatar: options.author.avatar }),
+                },
+                refs: { reference_file: referenceFileMessageRef(file) },
+                ...(options.now === undefined ? {} : { now: options.now }),
+            });
+            recordReadNotificationEvent(tx, {
+                scope: "references",
+                source_kind: "reference_file",
+                source_ref: file.path,
+                actor: { kind: "human", ref: options.author.account_ref },
+                occurred_at: message.created_at,
+            });
+            return {
+                disposition: { kind: "created" },
+                result: { file, message, index_path: uploaded.index_path },
+            };
+        },
+    });
+    const response = {
+        command_id: execution.command_id,
+        disposition: execution.disposition,
+        invalidates,
+    };
+    if (execution.result !== undefined) {
+        response.result = execution.result;
+    }
+    if (!execution.replayed && execution.result !== undefined) {
+        await options.afterCommit?.();
+        options.events.publish({
+            event_type: "message.created",
+            payload: { message: execution.result.message },
+            invalidates,
+        });
+        options.events.publish({
+            event_type: "query.invalidate",
+            payload: {
+                reason: "viewer_changed",
+                message: "Reference files changed.",
+            },
+            invalidates,
+        });
+        options.scratchpadSource?.notify(execution.result.message);
+        options.referenceSummaries?.start([execution.result.file.path]);
+    }
+    return response;
+}
+//# sourceMappingURL=reference-files.js.map

package/dist/collaboration-ingestion/types.d.ts

@@ -0,0 +1,19 @@
+import type { AccountAvatarProjection } from "@tutti/shared/domain";
+import type { MessageProjection } from "@tutti/shared/schemas/api";
+export type TrustedCollaborationAuthor = {
+    account_ref: string;
+    display_name: string;
+    avatar?: AccountAvatarProjection;
+};
+export type ScratchpadSourceNotifier = {
+    notify: (message: MessageProjection) => void;
+};
+export type ChatAssistantEnqueuer = {
+    enqueue: (input: {
+        message: MessageProjection;
+    }) => unknown;
+};
+export type ReferenceSummaryStarter = {
+    start: (paths: string[]) => unknown;
+};
+//# sourceMappingURL=types.d.ts.map

package/dist/collaboration-ingestion/types.js

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

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

@@ -0,0 +1,17 @@
+import type { MessageProjection } from "@tutti/shared/schemas/api";
+import type { SqliteDatabase } from "../store/index.js";
+import type { HostPlatformOutboundLogger } from "./types.js";
+import type { HostPlatformOutboundWorker } from "./worker.js";
+export declare class HostPlatformOutboundCoordinator {
+    private readonly worker;
+    private readonly logger;
+    private readonly now;
+    constructor(worker: HostPlatformOutboundWorker, logger: HostPlatformOutboundLogger, now?: () => Date);
+    captureAgentResponse(tx: SqliteDatabase, input: {
+        triggerMessage: MessageProjection;
+        responseMessage: MessageProjection;
+    }): (() => void) | undefined;
+    start(): void;
+    stop(): Promise<void>;
+}
+//# sourceMappingURL=coordinator.d.ts.map