@xfey/tutti 0.1.97 → 0.1.99

package/README.md

@@ -31,7 +31,7 @@
 
 ## 当前状态
 
-- 已具备 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 可视化产物查看层、Owner-only provider model discovery / update 和 OpenAI / Codex provider 接入。
+- 已具备 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 流程。
 - 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` 与测试产物。
@@ -55,6 +55,7 @@
 - 普通 `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。
 - 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 内身份字段。
+- 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 root 仍是 `apps/server`；对外 npm 名由 staging artifact 使用 `@xfey/tutti`，internal workspace dependency bundling、对应外部 runtime dependency bundling 和 packed CLI install smoke 已接通。

package/dist/artifact-feedback/index.d.ts

@@ -0,0 +1,19 @@
+import { type ArtifactFeedbackCommand, type ArtifactFeedbackRef, type ArtifactSemanticSnapshot, type MessageProjection } from "@tutti/shared/schemas/api";
+export declare class ArtifactFeedbackValidationError extends Error {
+    constructor(message: string);
+}
+export declare function normalizeArtifactFeedbackCommand(input: ArtifactFeedbackCommand): ArtifactFeedbackCommand;
+export declare function describeArtifactTarget(snapshot: ArtifactSemanticSnapshot): string;
+export declare function createArtifactFeedbackMessage(options: {
+    artifactTitle: string;
+    feedback: ArtifactFeedbackCommand;
+}): {
+    body: string;
+    ref: ArtifactFeedbackRef;
+};
+export declare function formatArtifactFeedbackForModel(ref: ArtifactFeedbackRef, options?: {
+    maxChars?: number;
+}): string;
+export declare function messageTextForModel(message: MessageProjection): string;
+export declare function messageTextForTuttiMention(message: MessageProjection): string;
+//# sourceMappingURL=index.d.ts.map

package/dist/artifact-feedback/index.js

@@ -0,0 +1,196 @@
+import { Value } from "@sinclair/typebox/value";
+import { ARTIFACT_FEEDBACK_MAX_AUTHORED_TEXT_LENGTH, ARTIFACT_FEEDBACK_MAX_SERIALIZED_BYTES, ArtifactFeedbackCommandSchema, } from "@tutti/shared/schemas/api";
+import { redactText, redactValue } from "@tutti/shared/utils";
+export class ArtifactFeedbackValidationError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "ArtifactFeedbackValidationError";
+    }
+}
+function normalizedLine(value) {
+    return value.trim().replace(/\s+/gu, " ");
+}
+function validateDocumentUrl(value) {
+    const normalized = value.trim();
+    let parsed;
+    try {
+        parsed = new URL(normalized, "https://artifact.invalid");
+    }
+    catch {
+        throw new ArtifactFeedbackValidationError("Artifact feedback page URL is invalid");
+    }
+    if (parsed.origin !== "https://artifact.invalid" || !normalized.startsWith("/")) {
+        throw new ArtifactFeedbackValidationError("Artifact feedback page URL must be relative");
+    }
+    if (redactText(normalized) !== normalized) {
+        throw new ArtifactFeedbackValidationError("Artifact feedback page URL contains restricted data");
+    }
+    return normalized;
+}
+export function normalizeArtifactFeedbackCommand(input) {
+    for (const annotation of input.annotations) {
+        validateDocumentUrl(annotation.document_url);
+    }
+    const redacted = redactValue(input);
+    if (!Value.Check(ArtifactFeedbackCommandSchema, redacted)) {
+        throw new ArtifactFeedbackValidationError("Artifact feedback payload is invalid");
+    }
+    const candidate = redacted;
+    const summary = candidate.summary === undefined ? undefined : normalizedLine(candidate.summary);
+    if (candidate.summary !== undefined && summary === "") {
+        throw new ArtifactFeedbackValidationError("Artifact feedback summary cannot be empty");
+    }
+    const annotations = candidate.annotations.map((annotation) => {
+        const comment = annotation.comment.trim();
+        if (comment === "") {
+            throw new ArtifactFeedbackValidationError("Artifact feedback comment cannot be empty");
+        }
+        return {
+            document_url: validateDocumentUrl(annotation.document_url),
+            comment,
+            target: annotation.target,
+        };
+    });
+    const authoredLength = (summary?.length ?? 0) + annotations.reduce((total, item) => total + item.comment.length, 0);
+    if (authoredLength > ARTIFACT_FEEDBACK_MAX_AUTHORED_TEXT_LENGTH) {
+        throw new ArtifactFeedbackValidationError(`Artifact feedback text cannot exceed ${ARTIFACT_FEEDBACK_MAX_AUTHORED_TEXT_LENGTH} characters`);
+    }
+    const normalized = {
+        expected_preview_generation: candidate.expected_preview_generation.trim(),
+        ...(summary === undefined ? {} : { summary }),
+        annotations,
+    };
+    if (normalized.expected_preview_generation === "" ||
+        Buffer.byteLength(JSON.stringify(normalized), "utf8") >
+            ARTIFACT_FEEDBACK_MAX_SERIALIZED_BYTES) {
+        throw new ArtifactFeedbackValidationError("Artifact feedback payload is too large");
+    }
+    return normalized;
+}
+function boundedMiddle(value, maxLength) {
+    const normalized = normalizedLine(value);
+    if (normalized.length <= maxLength) {
+        return normalized;
+    }
+    if (maxLength < 8) {
+        return normalized.slice(0, maxLength);
+    }
+    const head = Math.ceil((maxLength - 1) / 2);
+    const tail = Math.floor((maxLength - 1) / 2);
+    return `${normalized.slice(0, head)}…${normalized.slice(-tail)}`;
+}
+export function describeArtifactTarget(snapshot) {
+    const kind = snapshot.role ?? snapshot.tag_name;
+    const name = snapshot.accessible_name ?? snapshot.text_excerpt;
+    const direct = name === undefined ? kind : `${kind} “${boundedMiddle(name, 140)}”`;
+    const context = snapshot.context[0];
+    if (context === undefined) {
+        return direct;
+    }
+    const contextKind = context.role ?? context.tag_name;
+    const contextName = context.accessible_name;
+    return contextName === undefined
+        ? `${direct}, inside ${contextKind}`
+        : `${direct}, inside ${contextKind} “${boundedMiddle(contextName, 100)}”`;
+}
+function describeArtifactState(snapshot) {
+    if (snapshot.state === undefined) {
+        return undefined;
+    }
+    const labels = Object.entries(snapshot.state).map(([key, value]) => `${key}=${String(value)}`);
+    return labels.length === 0 ? undefined : labels.join(", ");
+}
+function buildMessageBody(ref, authoredBudget) {
+    const summaryBudget = Math.min(800, Math.floor(authoredBudget * 0.2));
+    const summary = ref.summary === undefined ? undefined : boundedMiddle(ref.summary, summaryBudget);
+    const remaining = authoredBudget - (summary?.length ?? 0);
+    const commentBudget = Math.max(120, Math.floor(remaining / ref.annotations.length));
+    const lines = [`Artifact feedback: ${normalizedLine(ref.artifact_title)}`];
+    if (summary !== undefined) {
+        lines.push(`Overall: ${summary}`);
+    }
+    for (const [index, annotation] of ref.annotations.entries()) {
+        lines.push("", `${index + 1}. Feedback: ${boundedMiddle(annotation.comment, commentBudget)}`, `   Target: ${boundedMiddle(describeArtifactTarget(annotation.target.snapshot), 220)}`, `   Page: ${boundedMiddle(annotation.document_url, 160)}`);
+        const state = describeArtifactState(annotation.target.snapshot);
+        if (state !== undefined) {
+            lines.push(`   State: ${boundedMiddle(state, 100)}`);
+        }
+    }
+    return lines.join("\n");
+}
+export function createArtifactFeedbackMessage(options) {
+    const ref = {
+        kind: "artifact_feedback",
+        version: 1,
+        preview_generation: options.feedback.expected_preview_generation,
+        artifact_title: options.artifactTitle,
+        inspector_version: 1,
+        ...(options.feedback.summary === undefined ? {} : { summary: options.feedback.summary }),
+        annotations: options.feedback.annotations,
+    };
+    for (let budget = ARTIFACT_FEEDBACK_MAX_AUTHORED_TEXT_LENGTH; budget >= 2_000; budget -= 250) {
+        const body = buildMessageBody(ref, budget);
+        if (body.length <= 8_000) {
+            return { body, ref };
+        }
+    }
+    const body = buildMessageBody(ref, 1_500);
+    if (body.length > 8_000) {
+        throw new ArtifactFeedbackValidationError("Artifact feedback message is too large");
+    }
+    return { body, ref };
+}
+function semanticModelText(snapshot, maxLength) {
+    const fields = [
+        `Target: ${snapshot.element_kind}/${snapshot.tag_name}${snapshot.role === undefined ? "" : ` role=${snapshot.role}`}${snapshot.accessible_name === undefined
+            ? ""
+            : ` name=“${normalizedLine(snapshot.accessible_name)}”`}`,
+    ];
+    if (snapshot.text_excerpt !== undefined) {
+        fields.push(`Text: ${normalizedLine(snapshot.text_excerpt)}`);
+    }
+    if (snapshot.context.length > 0) {
+        fields.push(`Context: ${snapshot.context
+            .map((item) => [item.role ?? item.tag_name, item.accessible_name].filter(Boolean).join(" “") +
+            (item.accessible_name === undefined ? "" : "”"))
+            .join(" > ")}`);
+    }
+    const state = describeArtifactState(snapshot);
+    if (state !== undefined) {
+        fields.push(`State: ${state}`);
+    }
+    const perField = Math.max(16, Math.floor(maxLength / fields.length));
+    return fields.map((field) => boundedMiddle(field, perField)).join("; ");
+}
+export function formatArtifactFeedbackForModel(ref, options = {}) {
+    const maxChars = Math.max(800, options.maxChars ?? 2_000);
+    const header = `Artifact feedback: ${boundedMiddle(ref.artifact_title, 120)}`;
+    const overall = ref.summary === undefined
+        ? undefined
+        : `Overall: ${boundedMiddle(ref.summary, Math.min(320, Math.floor(maxChars * 0.16)))}`;
+    const fixedLength = header.length + (overall?.length ?? 0) + 2;
+    const perAnnotation = Math.max(80, Math.floor((maxChars - fixedLength - ref.annotations.length * 2) / ref.annotations.length));
+    const annotations = ref.annotations.map((annotation, index) => {
+        const routeBudget = Math.max(24, Math.floor(perAnnotation * 0.18));
+        const semanticBudget = Math.max(36, Math.floor(perAnnotation * 0.42));
+        const prefix = `${index + 1}. ${boundedMiddle(annotation.document_url, routeBudget)} | `;
+        const semantic = semanticModelText(annotation.target.snapshot, semanticBudget);
+        const commentBudget = Math.max(24, perAnnotation - prefix.length - semantic.length - 13);
+        return `${prefix}${semantic} | Feedback: ${boundedMiddle(annotation.comment, commentBudget)}`;
+    });
+    return [header, ...(overall === undefined ? [] : [overall]), ...annotations].join("\n");
+}
+export function messageTextForModel(message) {
+    const feedback = message.refs?.artifact_feedback;
+    return feedback === undefined ? message.body : formatArtifactFeedbackForModel(feedback);
+}
+export function messageTextForTuttiMention(message) {
+    const feedback = message.refs?.artifact_feedback;
+    if (feedback === undefined) {
+        return message.body;
+    }
+    return [feedback.summary, ...feedback.annotations.map((annotation) => annotation.comment)]
+        .filter((value) => value !== undefined)
+        .join("\n");
+}
+//# sourceMappingURL=index.js.map

package/dist/chat-assistant/index.js

@@ -1,5 +1,6 @@
 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";
 const CHAT_ASSISTANT_CONTEXT_MESSAGE_LIMIT = 3;
 const CHAT_ASSISTANT_ROUND_MESSAGE_LIMIT = 50;
 const CHAT_ASSISTANT_ROUND_MESSAGE_MAX_CHARS = 2_000;
@@ -51,7 +52,7 @@ function messageToContext(message) {
         ...(authorDisplayName === undefined || authorDisplayName === ""
             ? {}
             : { author_display_name: authorDisplayName }),
-        text: message.body,
+        text: messageTextForModel(message),
     };
 }
 function messageRole(message) {
@@ -107,7 +108,7 @@ export class ReadOnlyChatAssistant {
         this.maxQueuedMentions = options.maxQueuedMentions ?? 8;
     }
     enqueue(input) {
-        if (!containsTuttiMention(input.message.body)) {
+        if (!containsTuttiMention(messageTextForTuttiMention(input.message))) {
             return { triggered: false };
         }
         if (!this.accepting) {
@@ -179,7 +180,7 @@ export class ReadOnlyChatAssistant {
                 ...(authorDisplayName === undefined || authorDisplayName === ""
                     ? {}
                     : { author_display_name: authorDisplayName }),
-                text: triggerMessage.body,
+                text: messageTextForModel(triggerMessage),
             },
             recent_messages: readMainChatMessageWindow(this.options.store.db, {
                 limit: CHAT_ASSISTANT_CONTEXT_MESSAGE_LIMIT,
@@ -213,7 +214,7 @@ export class ReadOnlyChatAssistant {
                 ...(authorDisplayName === undefined || authorDisplayName === ""
                     ? {}
                     : { author_display_name: authorDisplayName }),
-                text: triggerMessage.body,
+                text: messageTextForModel(triggerMessage),
             },
             round_request: {
                 ...(round.request_payload.title === undefined

package/dist/collaboration-state/task-compile-context.d.ts

@@ -16,12 +16,12 @@ export declare function completeTaskCompileContext(db: SqliteDatabase, input: Co
     submitted_by_activity_ref?: string;
     submitted_by_workflow_ref?: string;
     id: "current";
+    state: "ready" | "empty" | "submitted";
     topic: string;
     background_summary: string;
     current_consensus: string[];
     open_questions: string[];
     task_changes: string[];
-    state: "ready" | "empty" | "submitted";
     receipts: {
         compiled_tasks?: {
             status: "failed" | "done" | "todo" | "running" | "pending";

package/dist/control-plane/index.js

@@ -1,7 +1,7 @@
-import { readActiveClarificationProjection, readActiveTaskCompileContext, markScratchpadRefreshSucceeded, readPendingTaskCompileSubmission, readTaskProjectionByActivityRef, readScratchpadSourceState, readWorklistProjection, } from "../collaboration-state/index.js";
+import { readActiveClarificationProjection, readActiveTaskCompileContext, markScratchpadRefreshSucceeded, readPendingTaskCompileSubmission, readTaskDetailProjection, readTaskProjectionByActivityRef, readScratchpadSourceState, readWorklistProjection, } from "../collaboration-state/index.js";
 import { ProcedureEngine } from "../procedure-engine/index.js";
 import { RunEngine } from "../run-engine/index.js";
-import { WorkspaceOpsError, readReferenceSummaryTargets } from "../workspace-ops/index.js";
+import { WorkspaceOpsError, isReferenceFilePath, readReferenceSummaryTargets, } from "../workspace-ops/index.js";
 import { publishProcedureTransition as publishProcedureTransitionEvent, publishRunResultRecorded as publishRunResultRecordedEvent, publishRunTransition as publishRunTransitionEvent, publishTaskRunStarted as publishTaskRunStartedEvent, } from "./event-publishers.js";
 import { startContextSyncAnalysisProcedure } from "./context-sync.js";
 import { refreshProjectBriefProjection, } from "./project-brief-refresh.js";
@@ -488,10 +488,22 @@ export class Phase5ControlPlane {
         this.pendingRunInputs.delete(activityRef);
         if (state.activity.status === "finished") {
             if (state.activity.task_id !== undefined) {
+                const taskId = state.activity.task_id;
+                const detail = readTaskDetailProjection(this.store.db, taskId);
+                const result = detail?.detail.result;
+                if (result?.result_kind === "finished" &&
+                    result.outcome === "completed" &&
+                    result.promotion?.status === "promoted") {
+                    for (const path of result.changed_paths ?? []) {
+                        if (isReferenceFilePath(path)) {
+                            this.pendingReferenceSummaryPaths.add(path);
+                        }
+                    }
+                }
                 emitTaskCompletedResultMessage({
                     store: this.store,
                     events: this.events,
-                    taskId: state.activity.task_id,
+                    taskId,
                     activityRef: state.activity.activity_ref,
                     ...(this.projectContext === undefined
                         ? {}

package/dist/control-plane/scratchpad-source-messages.js

@@ -1,3 +1,4 @@
+import { messageTextForModel } from "../artifact-feedback/index.js";
 const MAX_SOURCE_MESSAGE_TEXT_CHARS = 2_000;
 export const MAX_SOURCE_MESSAGES_TOTAL_CHARS = 10_000;
 export const MIN_SOURCE_MESSAGE_TEXT_CHARS = 160;
@@ -48,7 +49,7 @@ export function truncateTextMiddle(text, maxChars) {
 function sourceText(message) {
     const reference = message.refs?.reference_file;
     if (reference === undefined) {
-        return message.body;
+        return messageTextForModel(message);
     }
     return `Reference file (${reference.category}:${reference.name})\n${message.body}`;
 }

package/dist/control-plane/task-source-context.js

@@ -1,4 +1,5 @@
 import { readMessageProjectionById } from "../collaboration-state/index.js";
+import { messageTextForModel } from "../artifact-feedback/index.js";
 function promptSourceMessage(db, source) {
     const message = readMessageProjectionById(db, source.message_id);
     if (message === null) {
@@ -14,13 +15,13 @@ function promptSourceMessage(db, source) {
             ...(displayName === undefined || displayName === ""
                 ? {}
                 : { author_display_name: displayName }),
-            text: message.body,
+            text: messageTextForModel(message),
         };
     }
     if (message.message_kind === "agent_text" && message.author.kind === "agent") {
         return {
             role: "tutti",
-            text: message.body,
+            text: messageTextForModel(message),
         };
     }
     throw new Error("Task source message has an unsupported kind or author");

package/dist/control-plane/worklist-terminal-feedback.js

@@ -1,4 +1,4 @@
-import { readViewerFile, referenceFileSourceForPath, referenceMediaTypeForPath, referenceTuttiGroupForPath, } from "../workspace-ops/index.js";
+import { isReferenceFilePath, readViewerFile, referenceFolderGroupForPath, referenceMediaTypeForPath, } from "../workspace-ops/index.js";
 import { createMainChatAgentMessage, hasMainChatTaskResultMessage, hasMainChatWorklistFeedbackMessage, readCompletedWorklistFeedbackTaskIds, readTaskDetailProjection, readWorklistProjection, } from "../collaboration-state/index.js";
 import { mainChatInvalidates } from "./invalidations.js";
 const BODY_ITEM_LIMIT = 12;
@@ -62,7 +62,7 @@ function generatedFileProjection(file) {
         name: file.name,
         size_bytes: file.size_bytes,
     };
-    const group = referenceTuttiGroupForPath(file.path);
+    const group = referenceFolderGroupForPath(file.path);
     if (group !== undefined) {
         projection.group = group;
     }
@@ -73,7 +73,7 @@ function generatedFileProjection(file) {
     return projection;
 }
 function readGeneratedFile(input) {
-    if (referenceFileSourceForPath(input.path) !== "tutti_output") {
+    if (!isReferenceFilePath(input.path)) {
         return null;
     }
     try {
@@ -100,7 +100,7 @@ function generatedFilesForCompletedEntries(input, entries) {
             continue;
         }
         for (const path of entry.detail?.detail.result.changed_paths ?? []) {
-            if (referenceFileSourceForPath(path) === "tutti_output") {
+            if (isReferenceFilePath(path)) {
                 paths.add(path);
             }
         }

package/dist/server-shell/http/routes/agent-context-references.js

@@ -1,4 +1,4 @@
-import { REFERENCE_DIRECTORY_PATH, REFERENCE_INDEX_PATH, WorkspaceOpsError, readReferenceSummaryIndex, readViewerFile, readViewerTree, referenceFileCategoryForPath, referenceMediaTypeForPath, referenceSummaryProjectionForEntry, } from "../../../workspace-ops/index.js";
+import { REFERENCE_INDEX_PATH, WorkspaceOpsError, readReferenceFileEntries, readReferenceSummaryIndex, readViewerFile, referenceFileCategoryForPath, referenceMediaTypeForPath, referenceSummaryProjectionForEntry, } from "../../../workspace-ops/index.js";
 import { AgentContextBadRequestError } from "./agent-context-errors.js";
 function requireWorkspaceRoot(options) {
     if (options.workspaceOps === undefined) {
@@ -46,14 +46,11 @@ function unavailableReasonForContent(content) {
 }
 function referenceEntries(options) {
     const workspaceRoot = requireWorkspaceRoot(options);
-    let tree;
     try {
-        tree = readViewerTree({
-            workspaceRoot,
-            path: REFERENCE_DIRECTORY_PATH,
-            depth: 2,
-            ...(options.now === undefined ? {} : { now: options.now }),
-        });
+        return readReferenceFileEntries({ workspaceRoot })
+            .filter((entry) => entry.path !== REFERENCE_INDEX_PATH)
+            .filter((entry) => referenceFileCategoryForPath(entry.path) !== undefined)
+            .sort((left, right) => left.path.localeCompare(right.path, "en", { sensitivity: "base" }));
     }
     catch (error) {
         if (error instanceof WorkspaceOpsError && error.code === "not_found") {
@@ -61,11 +58,6 @@ function referenceEntries(options) {
         }
         throw error;
     }
-    return tree.items
-        .filter((entry) => entry.kind === "file")
-        .filter((entry) => entry.path !== REFERENCE_INDEX_PATH)
-        .filter((entry) => referenceFileCategoryForPath(entry.path) !== undefined)
-        .sort((left, right) => left.path.localeCompare(right.path, "en", { sensitivity: "base" }));
 }
 function canReadReferenceText(options, path) {
     try {
@@ -76,7 +68,9 @@ function canReadReferenceText(options, path) {
             ...(options.now === undefined ? {} : { now: options.now }),
         });
         const reason = unavailableReasonForContent(file.content);
-        return reason === undefined ? { can_read_text: true } : { can_read_text: false, blocked_reason: reason };
+        return reason === undefined
+            ? { can_read_text: true }
+            : { can_read_text: false, blocked_reason: reason };
     }
     catch {
         return { can_read_text: false, blocked_reason: "restricted_path" };

package/dist/server-shell/http/routes/project-api/artifacts-routes.d.ts

@@ -1,8 +1,9 @@
 import type { FastifyInstance } from "fastify";
+import { ArtifactPreviewManager } from "../../../../artifacts/index.js";
 import type { WorkspaceEventBus } from "../../workspace-events.js";
 import type { HostProjectApiRouteOptions } from "./types.js";
 export declare function registerArtifactsRoutes(app: FastifyInstance, { options, workspaceEvents, }: {
     options: HostProjectApiRouteOptions;
     workspaceEvents: WorkspaceEventBus;
-}): void;
+}): ArtifactPreviewManager;
 //# sourceMappingURL=artifacts-routes.d.ts.map

package/dist/server-shell/http/routes/project-api/artifacts-routes.js

@@ -144,5 +144,6 @@ export function registerArtifactsRoutes(app, { options, workspaceEvents, }) {
             .header("cache-control", "private, max-age=60")
             .send(preview.content);
     });
+    return artifactPreviewManager;
 }
 //# sourceMappingURL=artifacts-routes.js.map

package/dist/server-shell/http/routes/project-api/messages-routes.d.ts

@@ -1,8 +1,10 @@
 import type { FastifyInstance } from "fastify";
+import type { ArtifactPreviewManager } from "../../../../artifacts/index.js";
 import type { WorkspaceEventBus } from "../../workspace-events.js";
 import type { HostProjectApiRouteOptions } from "./types.js";
-export declare function registerMessagesRoutes(app: FastifyInstance, { options, workspaceEvents, }: {
+export declare function registerMessagesRoutes(app: FastifyInstance, { options, workspaceEvents, artifactPreviewManager, }: {
     options: HostProjectApiRouteOptions;
     workspaceEvents: WorkspaceEventBus;
+    artifactPreviewManager: ArtifactPreviewManager;
 }): void;
 //# sourceMappingURL=messages-routes.d.ts.map

package/dist/server-shell/http/routes/project-api/messages-routes.js

@@ -1,11 +1,12 @@
 import { GetMessagesRequestSchema, MessageWindowSchema, SendMainChatMessageBodySchema, SendMainChatMessageResponseSchema, } from "@tutti/shared/schemas/api";
-import { createMainChatMessage, readMainChatMessageWindow, } from "../../../../collaboration-state/index.js";
+import { createMainChatMessage, readMessageProjectionById, readMainChatMessageWindow, } from "../../../../collaboration-state/index.js";
+import { createArtifactFeedbackMessage, } from "../../../../artifact-feedback/index.js";
 import { executeIdempotentCommand } from "../../../command-idempotency/index.js";
 import { HOST_PROJECT_API_BASE_PATH } from "./constants.js";
 import { mainChatMessageInvalidates } from "./invalidations.js";
 import { requireValidMessageWindowRequest, requireValidSendMainChatPayload, } from "./payload-validation.js";
-import { requireHostProjectSession, requireProjectStore, } from "./session-requirements.js";
-export function registerMessagesRoutes(app, { options, workspaceEvents, }) {
+import { requireHostProjectSession, requireProjectStore, requireWorkspaceRoot, } from "./session-requirements.js";
+export function registerMessagesRoutes(app, { options, workspaceEvents, artifactPreviewManager, }) {
     app.get(`${HOST_PROJECT_API_BASE_PATH}/messages`, {
         schema: {
             querystring: GetMessagesRequestSchema,
@@ -34,45 +35,76 @@ export function registerMessagesRoutes(app, { options, workspaceEvents, }) {
             command_id: request.body.command_id,
             command_name: "messages.create",
             target_ref: "main_chat",
-            payload: {
-                body: payload.body,
-                author_ref: session.account.account_ref,
-            },
+            payload: { ...payload, author_ref: session.account.account_ref },
             ...(options.now === undefined ? {} : { now: options.now }),
-            execute: (tx) => ({
-                disposition: { kind: "created" },
-                result: {
-                    message: createMainChatMessage(tx, {
-                        body: payload.body,
-                        author: {
-                            kind: "human",
-                            ref: session.account.account_ref,
-                            display_name: session.account.display_name,
-                            avatar: session.account.avatar,
-                        },
-                        ...(options.now === undefined ? {} : { now: options.now }),
-                    }),
-                },
-            }),
+            execute: (tx) => {
+                let body;
+                let refs;
+                if ("artifact_feedback" in payload) {
+                    const projection = artifactPreviewManager.readProjection({
+                        workspaceRoot: requireWorkspaceRoot(options),
+                    });
+                    if (projection.artifact.status !== "declared" ||
+                        projection.artifact.preview.status !== "ready") {
+                        return { disposition: { kind: "artifact_unavailable" } };
+                    }
+                    if (projection.artifact.preview_generation !==
+                        payload.artifact_feedback.expected_preview_generation) {
+                        return { disposition: { kind: "artifact_changed" } };
+                    }
+                    const feedbackMessage = createArtifactFeedbackMessage({
+                        artifactTitle: projection.artifact.artifact.title,
+                        feedback: payload.artifact_feedback,
+                    });
+                    body = feedbackMessage.body;
+                    refs = { artifact_feedback: feedbackMessage.ref };
+                }
+                else {
+                    body = payload.body;
+                }
+                const message = createMainChatMessage(tx, {
+                    body,
+                    author: {
+                        kind: "human",
+                        ref: session.account.account_ref,
+                        display_name: session.account.display_name,
+                        avatar: session.account.avatar,
+                    },
+                    ...(refs === undefined ? {} : { refs }),
+                    ...(options.now === undefined ? {} : { now: options.now }),
+                });
+                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(store.db, execution.disposition.message_id)
+            : null;
+        const result = execution.result ?? (replayedMessage === null ? undefined : { message: replayedMessage });
         const response = {
             command_id: execution.command_id,
             disposition: execution.disposition,
-            invalidates: mainChatMessageInvalidates(),
+            ...(execution.disposition.kind === "created"
+                ? { invalidates: mainChatMessageInvalidates() }
+                : {}),
         };
-        if (execution.result !== undefined) {
-            response.result = execution.result;
+        if (result !== undefined) {
+            response.result = result;
         }
-        if (!execution.replayed && execution.result !== undefined) {
+        if (!execution.replayed && result !== undefined) {
             workspaceEvents.publish({
                 event_type: "message.created",
                 payload: {
-                    message: execution.result.message,
+                    message: result.message,
                 },
                 invalidates: mainChatMessageInvalidates(),
             });
-            options.controlPlane?.notifyScratchpadSourceChanged(execution.result.message);
-            options.chatAssistant?.enqueue({ message: execution.result.message });
+            options.controlPlane?.notifyScratchpadSourceChanged(result.message);
+            options.chatAssistant?.enqueue({ message: result.message });
         }
         return response;
     });

package/dist/server-shell/http/routes/project-api/openapi-viewer-routes.d.ts

@@ -283,14 +283,12 @@ export declare const HOST_PROJECT_VIEWER_OPENAPI_ROUTES: ({
                     index_path: import("@sinclair/typebox").TLiteral<"docs/reference/README.md">;
                     files_path: import("@sinclair/typebox").TLiteral<"docs/reference/files">;
                     images_path: import("@sinclair/typebox").TLiteral<"docs/reference/images">;
-                    tutti_path: import("@sinclair/typebox").TLiteral<"docs/reference/tutti">;
                     index_status: import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TLiteral<"available">, import("@sinclair/typebox").TLiteral<"missing">, import("@sinclair/typebox").TLiteral<"unreadable">]>;
                     index_unreadable_reason: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TLiteral<"restricted_path">, import("@sinclair/typebox").TLiteral<"secret_like">, import("@sinclair/typebox").TLiteral<"binary">, import("@sinclair/typebox").TLiteral<"unsupported_encoding">, import("@sinclair/typebox").TLiteral<"too_large">]>>;
                 }>;
                 items: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TObject<{
                     path: import("@sinclair/typebox").TString;
                     name: import("@sinclair/typebox").TString;
-                    source: import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TLiteral<"human_upload">, import("@sinclair/typebox").TLiteral<"tutti_output">]>;
                     category: import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TLiteral<"file">, import("@sinclair/typebox").TLiteral<"image">]>;
                     size_bytes: import("@sinclair/typebox").TInteger;
                     media_type: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;