@xfey/tutti 0.1.108 → 0.1.110

package/README.md

@@ -4,6 +4,10 @@
 
 `apps/server` 是 Tutti 的项目 host service，也是机器级 Local Console 的进程入口。
 
+`0.1.110` 发布候选加入每次 Chat invocation 的外部资料核验规则、本地／外部 provenance、从实际读取证据派生的回答来源线索，以及隔离多轮模型 smoke；配套 F.3 增量支持群资料确认与普通云盘文件。需要同步 Web／Relay／Integration 后再升级 Host；实际发布与真人验收状态见同一[按需资料计划](../../docs/roadmap/feishu-on-demand-reference-plan.md)。历史快照不删除，读取线索不继承新鲜度或权限。
+
+已发布的 `0.1.109` 统一验证 Codex `skills/extraRoots/set` / `skills/list` 与实际 `SKILL.md` 文件身份；Chat 的安全阶段日志可通过 invocation ref 关联外部 Reference 读取。候选安装／升级、registry byte match、本机 CLI／Console／测试 Host 更新及更新后 Docx 真人读取闭环已通过；连续更新／同次 pin／附件／失权 live 矩阵仍独立跟踪。证据见[按需资料计划](../../docs/roadmap/feishu-on-demand-reference-plan.md)，不以安装版本代替实际读取证据。
+
 它负责：
 
 - `tutti launch` 后的项目绑定、恢复和接管入口
@@ -41,7 +45,7 @@
 - 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。
+- 对外发布必须把同一 staging package 通过 `npm pack` 生成的已核验 `.tgz` 交给 `npm publish --auth-type=web`，不得直接发布 staging 目录；npm 的目录发布路径可能重新收集文件并遗漏 staging 内的 bundled dependencies。发布后核对 registry metadata 并回下载；若与已完成安装／CLI smoke 的 candidate 逐字节一致，复用候选证据，不重复安装。未被相同候选覆盖的 registry artifact 仍须补齐安装 smoke。
 - `prompts/` 是所有模型-facing prompt、指令模板和 Codex 执行模板的统一落点；长 prompt 不内联在 TypeScript 中。
 - 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。

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

@@ -0,0 +1,18 @@
+import type { ProviderInvocationProgress } from "../providers/invocation-progress.js";
+export type ChatAssistantLogger = {
+    info: (fields: Record<string, unknown>, message: string) => void;
+    warn: (fields: Record<string, unknown>, message: string) => void;
+};
+type ChatAssistantProgress = ProviderInvocationProgress | {
+    stage: "queued" | "inspection_wait" | "model_requested" | "reply_persisted" | "failed" | "skipped";
+    reason_code?: "queue_full" | "stopping" | "context_unavailable" | "answer_failed" | "reply_failed";
+    reference_source_count?: number;
+};
+export declare function createChatAssistantDiagnostics(options: {
+    logger?: ChatAssistantLogger;
+    projectId: string;
+    triggerMessageId: string;
+    scope: string;
+}): (event: ChatAssistantProgress) => void;
+export {};
+//# sourceMappingURL=diagnostics.d.ts.map

package/dist/chat-assistant/diagnostics.js

@@ -0,0 +1,27 @@
+import { createEventRef } from "@tutti/shared/ids";
+export function createChatAssistantDiagnostics(options) {
+    const requestRef = createEventRef();
+    const started = performance.now();
+    return (event) => {
+        try {
+            const fields = {
+                project_id: options.projectId,
+                chat_request_ref: requestRef,
+                trigger_message_ref: options.triggerMessageId,
+                scope: options.scope,
+                elapsed_ms: Math.round(performance.now() - started),
+                ...event,
+            };
+            if (event.stage === "failed" || event.stage === "provider_failed") {
+                options.logger?.warn(fields, "Chat assistant progress");
+            }
+            else {
+                options.logger?.info(fields, "Chat assistant progress");
+            }
+        }
+        catch {
+            /* Logging must not replace the answer or interrupt queue draining. */
+        }
+    };
+}
+//# sourceMappingURL=diagnostics.js.map

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

@@ -1,5 +1,7 @@
 import type { ProjectId } from "@tutti/shared/ids";
 import type { MessageProjection } from "@tutti/shared/schemas/api";
+import { type ChatAssistantLogger } from "./diagnostics.js";
+import type { ProviderInvocationProgressObserver } from "../providers/invocation-progress.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: {
@@ -19,6 +21,7 @@ export type ChatAssistantOutput = {
 };
 export type ChatAssistantPromptInput = {
     prompt: string;
+    onProgress?: ProviderInvocationProgressObserver;
 };
 export type ReadOnlyChatAssistantModel = {
     answer: (input: ChatAssistantPromptInput) => Promise<ChatAssistantOutput>;
@@ -35,6 +38,7 @@ export type ReadOnlyChatAssistantHandle = {
     stopAccepting: () => void;
 };
 export type ReadOnlyChatAssistantOptions = {
+    logger?: ChatAssistantLogger;
     project: {
         project_id: ProjectId;
         display_name: string;

package/dist/chat-assistant/index.js

@@ -1,7 +1,10 @@
+import { createChatAssistantDiagnostics } from "./diagnostics.js";
 import { createClarificationRoundAgentMessage, createMainChatAgentMessage, readClarificationRoundMessagesWindow, readClarificationRoundProjection, readMainChatMessageWindow, readMainChatMessagesBeforeCursor, readMessageProjectionById, } from "../collaboration-state/index.js";
 import { renderPromptTemplate } from "../prompt-templates/index.js";
 import { withHostStoreTransaction, } from "../store/index.js";
 import { messageTextForModel, messageTextForTuttiMention } from "../artifact-feedback/index.js";
+import { externalReferenceMessageContext } from "../reference-access/message-context.js";
+import { readExternalReferenceReadSources } from "../reference-access/read-evidence.js";
 const CHAT_ASSISTANT_CONTEXT_MESSAGE_LIMIT = 3;
 const CHAT_ASSISTANT_ROUND_MESSAGE_LIMIT = 50;
 const CHAT_ASSISTANT_ROUND_MESSAGE_MAX_CHARS = 2_000;
@@ -50,6 +53,7 @@ function messageToContext(message) {
             ? {}
             : { author_display_name: authorDisplayName }),
         text: messageTextForModel(message),
+        ...externalReferenceMessageContext(message.refs),
     };
 }
 function messageRole(message) {
@@ -89,6 +93,7 @@ function roundMessagesToContext(messages) {
                 ? {}
                 : { author_display_name: authorDisplayName }),
             text,
+            ...externalReferenceMessageContext(message.refs),
         });
     }
     return result;
@@ -111,13 +116,21 @@ export class ReadOnlyChatAssistant {
         if (!this.accepting) {
             return { triggered: false };
         }
+        const report = createChatAssistantDiagnostics({
+            ...(this.options.logger === undefined ? {} : { logger: this.options.logger }),
+            projectId: this.options.project.project_id,
+            triggerMessageId: input.message.id,
+            scope: input.message.scope.kind,
+        });
         if (this.pending.length >= this.maxQueuedMentions) {
+            report({ stage: "failed", reason_code: "queue_full" });
             this.appendAssistantMessageForTrigger(input.message, assistantFailureMessage(), {
                 scratchpad_source: "exclude",
             });
             return { triggered: true };
         }
-        this.pending.push(input.message);
+        report({ stage: "queued" });
+        this.pending.push({ message: input.message, report });
         this.pump();
         return { triggered: true };
     }
@@ -132,7 +145,8 @@ export class ReadOnlyChatAssistant {
             return;
         }
         this.accepting = false;
-        for (const message of this.pending.splice(0)) {
+        for (const { message, report } of this.pending.splice(0)) {
+            report({ stage: "skipped", reason_code: "stopping" });
             this.appendAssistantMessageForTrigger(message, assistantFailureMessage(), {
                 scratchpad_source: "exclude",
             });
@@ -143,12 +157,14 @@ export class ReadOnlyChatAssistant {
         if (this.active !== null) {
             return;
         }
-        const message = this.pending.shift();
-        if (message === undefined) {
+        const pending = this.pending.shift();
+        if (pending === undefined) {
             this.resolveIdleIfNeeded();
             return;
         }
-        const task = this.respond(message).catch(() => undefined);
+        const task = this.respond(pending.message, pending.report).catch(() => {
+            pending.report({ stage: "failed", reason_code: "reply_failed" });
+        });
         this.active = task;
         void task.finally(() => {
             if (this.active === task) {
@@ -167,18 +183,12 @@ export class ReadOnlyChatAssistant {
         this.idleWaiters.clear();
     }
     buildMainChatContext(triggerMessage) {
-        const authorDisplayName = triggerMessage.author.display_name?.trim();
         return {
             mode: "main_chat",
             project: {
                 display_name: this.options.project.display_name,
             },
-            trigger: {
-                ...(authorDisplayName === undefined || authorDisplayName === ""
-                    ? {}
-                    : { author_display_name: authorDisplayName }),
-                text: messageTextForModel(triggerMessage),
-            },
+            trigger: messageToContext(triggerMessage),
             recent_messages: readMainChatMessageWindow(this.options.store.db, {
                 limit: CHAT_ASSISTANT_CONTEXT_MESSAGE_LIMIT,
             }).items.map(messageToContext),
@@ -201,18 +211,12 @@ export class ReadOnlyChatAssistant {
                 before_id: cardMessage.id,
                 limit: CHAT_ASSISTANT_ROUND_MAIN_CHAT_CONTEXT_LIMIT,
             }).map(messageToContext);
-        const authorDisplayName = triggerMessage.author.display_name?.trim();
         return {
             mode: "clarification_round",
             project: {
                 display_name: this.options.project.display_name,
             },
-            trigger: {
-                ...(authorDisplayName === undefined || authorDisplayName === ""
-                    ? {}
-                    : { author_display_name: authorDisplayName }),
-                text: messageTextForModel(triggerMessage),
-            },
+            trigger: messageToContext(triggerMessage),
             round_request: {
                 ...(round.request_payload.title === undefined
                     ? {}
@@ -311,23 +315,43 @@ export class ReadOnlyChatAssistant {
         }
         this.appendMainChatAssistantMessage(triggerMessage, body, refs);
     }
-    async respond(triggerMessage) {
+    async respond(triggerMessage, report) {
+        let answer;
+        let invocationRef;
+        let readSources = [];
         try {
+            report({ stage: "inspection_wait" });
             await this.options.waitForInspectionAvailability?.();
             const prompt = this.renderPrompt(triggerMessage);
             if (prompt === null) {
+                report({ stage: "skipped", reason_code: "context_unavailable" });
                 return;
             }
+            report({ stage: "model_requested" });
             const output = await this.options.model.answer({
                 prompt,
+                onProgress: (event) => {
+                    if (event.stage === "context_ready")
+                        invocationRef = event.invocation_ref;
+                    report(event);
+                },
             });
-            this.appendAssistantMessageForTrigger(triggerMessage, normalizeAnswer(output.answer));
+            answer = normalizeAnswer(output.answer);
+            if (invocationRef !== undefined) {
+                readSources = readExternalReferenceReadSources(this.options.store.db, invocationRef);
+            }
         }
         catch {
+            report({ stage: "failed", reason_code: "answer_failed" });
             this.appendAssistantMessageForTrigger(triggerMessage, assistantFailureMessage(), {
                 scratchpad_source: "exclude",
             });
+            report({ stage: "reply_persisted" });
+            return;
         }
+        // Persistence/outbound-hook failure must not retry by creating a second reply.
+        this.appendAssistantMessageForTrigger(triggerMessage, answer, readSources.length === 0 ? undefined : { external_reference_reads: readSources });
+        report({ stage: "reply_persisted", reference_source_count: readSources.length });
     }
 }
 //# sourceMappingURL=index.js.map

package/dist/chat-assistant/reference-freshness-smoke-cli.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=reference-freshness-smoke-cli.d.ts.map

package/dist/chat-assistant/reference-freshness-smoke-cli.js

@@ -0,0 +1,40 @@
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { parseArgs } from "node:util";
+import { resolveOpenAiProviderConfig } from "../providers/openai/provider-config.js";
+import { readOpenAiApiKeyCredential } from "../providers/openai/credential-store.js";
+import { runReferenceFreshnessSmoke } from "./reference-freshness-smoke.js";
+async function main() {
+    const { values } = parseArgs({
+        options: {
+            "project-id": { type: "string" },
+            "tutti-home": { type: "string" },
+            "reread-only": { type: "boolean" },
+        },
+    });
+    if (!/^prj_[0-9A-Z]{26}$/u.test(values["project-id"] ?? ""))
+        throw new Error("invalid_project_id");
+    const projectId = values["project-id"];
+    const tuttiHome = values["tutti-home"] ?? join(homedir(), ".tutti");
+    const provider = resolveOpenAiProviderConfig({ tuttiHome, projectId });
+    if (provider.kind === "unavailable")
+        throw new Error("provider_unavailable");
+    const credential = readOpenAiApiKeyCredential(tuttiHome, projectId, provider.config.credential_ref);
+    // Read only the selected project's provider configuration; never its documents or database.
+    await runReferenceFreshnessSmoke({
+        apiKey: credential.secret,
+        model: provider.config.default_model,
+        rereadOnly: values["reread-only"] ?? false,
+        ...(provider.config.api_base_url === undefined
+            ? {}
+            : { apiBaseUrl: provider.config.api_base_url }),
+        report: (result) => console.log(JSON.stringify(result)),
+    });
+    console.log(JSON.stringify({ status: "passed", cases: values["reread-only"] ? 2 : 7 }));
+}
+void main().catch(() => {
+    // Provider errors and assertion messages can contain private runtime details.
+    console.error(JSON.stringify({ status: "failed", reason_code: "reference_freshness_smoke_failed" }));
+    process.exitCode = 1;
+});
+//# sourceMappingURL=reference-freshness-smoke-cli.js.map

package/dist/chat-assistant/reference-freshness-smoke.d.ts

@@ -0,0 +1,23 @@
+/** Fixture-only wording check, not a production semantic validator. */
+export declare function labelsPriorReferenceAsUnverified(answer: string): boolean;
+/** Explicit live-model gate. All documents, project state and platform transport are synthetic. */
+export declare function runReferenceFreshnessSmoke(input: {
+    apiKey: string;
+    apiBaseUrl?: string;
+    model: string;
+    rereadOnly?: boolean;
+    /** Optional inspection of synthetic fixture answers; the CLI never logs answer bodies. */
+    inspectSyntheticAnswer?: (result: {
+        case: string;
+        answer: string;
+    }) => void;
+    report: (result: {
+        case: string;
+        status: "started" | "passed" | "failed";
+        reason_code?: string;
+        external_reads: number;
+        history_reads: number;
+        local_reads: number;
+    }) => void;
+}): Promise<void>;
+//# sourceMappingURL=reference-freshness-smoke.d.ts.map

package/dist/chat-assistant/reference-freshness-smoke.js

@@ -0,0 +1,274 @@
+import assert from "node:assert/strict";
+import { mkdtempSync, mkdirSync, realpathSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { fileURLToPath } from "node:url";
+import Fastify from "fastify";
+import { ExternalReferenceTransportError } from "@tutti/relay-client";
+import { createProjectId } from "@tutti/shared/ids";
+import { createMainChatMessage, readMainChatMessageWindow } from "../collaboration-state/index.js";
+import { openHostProjectStore } from "../store/index.js";
+import { runGit } from "../workspace-ops/git.js";
+import { ExternalReferenceCache } from "../reference-access/cache.js";
+import { ExternalReferenceAccess } from "../reference-access/service.js";
+import { recordExternalReferenceRead } from "../reference-access/read-evidence.js";
+import { WorkspaceEventBus } from "../server-shell/http/workspace-events.js";
+import { AgentContextTokenRegistry } from "../server-shell/http/routes/agent-context-auth.js";
+import { registerAgentContextReferenceRoutes } from "../server-shell/http/routes/agent-context-reference-routes.js";
+import { registerAgentContextExternalReferenceRoutes } from "../server-shell/http/routes/agent-context-external-reference-routes.js";
+import { registerAgentContextMessageRoutes } from "../server-shell/http/routes/agent-context-messages-routes.js";
+import { runCodexAppServerReadOnlyProcedure } from "../providers/openai/app-server/read-only-procedure.js";
+import { CHAT_ASSISTANT_OUTPUT_SCHEMA, isChatAssistantOutput, ReadOnlyChatAssistant, } from "./index.js";
+/** Fixture-only wording check, not a production semantic validator. */
+export function labelsPriorReferenceAsUnverified(answer) {
+    return (/先前|此前|上次|之前|历史|previous|historical|last (?:read|known)/iu.test(answer) &&
+        /无法确认|不能|不代表|并非|不是|未能确认|cannot|not (?:current|verified)|does not (?:prove|establish)/iu.test(answer));
+}
+/** Explicit live-model gate. All documents, project state and platform transport are synthetic. */
+export async function runReferenceFreshnessSmoke(input) {
+    const root = realpathSync(mkdtempSync(join(tmpdir(), "tutti-reference-freshness-")));
+    const workspaceRoot = join(root, "repo");
+    mkdirSync(workspaceRoot);
+    const projectId = createProjectId();
+    const store = openHostProjectStore({
+        projectId,
+        localStoreRoot: join(root, "store"),
+        migrationsDirectory: fileURLToPath(new URL("../../migrations", import.meta.url)),
+    });
+    const app = Fastify({ logger: false });
+    let processCleanupUncertain = false;
+    try {
+        runGit(["init", "-q", "-b", "tutti/mainline"], workspaceRoot);
+        runGit(["config", "user.name", "Reference Smoke"], workspaceRoot);
+        runGit(["config", "user.email", "smoke@example.test"], workspaceRoot);
+        const legacyPath = "docs/reference/files/project-brief.md";
+        mkdirSync(join(workspaceRoot, "docs/reference/files"), { recursive: true });
+        writeFileSync(join(workspaceRoot, legacyPath), "# Project brief\nHistorical marker: ORCHID_17\n");
+        runGit(["add", "."], workspaceRoot);
+        runGit(["commit", "-qm", "Synthetic historical snapshot"], workspaceRoot);
+        const nowIso = new Date().toISOString();
+        store.db
+            .prepare(`INSERT INTO managed_reference_sources
+      (source_ref, adapter_key, reference_path, accepted_revision_ref, accepted_blob_oid,
+       accepted_content_sha256, created_at, updated_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?)`)
+            .run("managed_smoke", "feishu", legacyPath, "1", "a".repeat(40), "b".repeat(64), nowIso, nowIso);
+        const source = {
+            source_ref: `external_ref_${"a".repeat(32)}`,
+            kind: "feishu_docx",
+            name: "Project brief",
+            created_at: nowIso,
+        };
+        const other = {
+            ...source,
+            source_ref: `external_ref_${"b".repeat(32)}`,
+            kind: "feishu_file",
+            name: "Another team's attachment",
+        };
+        const sources = [source];
+        let revision = "1";
+        let marker = "CEDAR_29";
+        let deny = false;
+        let remoteReads = 0;
+        let historyReads = 0;
+        let localReads = 0;
+        const registry = new AgentContextTokenRegistry();
+        const service = new ExternalReferenceAccess({
+            createCache: () => new ExternalReferenceCache({ workspaceRoot, ledgerRoot: join(root, "cache") }),
+            list: () => Promise.resolve(sources.map((item) => ({ ...item }))),
+            read: (sourceRef) => {
+                remoteReads++;
+                if (deny)
+                    return Promise.reject(new ExternalReferenceTransportError("feishu_docx_access_denied"));
+                assert.equal(sourceRef, source.source_ref, "wrong_source_selected");
+                return Promise.resolve({
+                    content: Buffer.from(`# Project brief\nCurrent marker: ${marker}\n`),
+                    revision,
+                    media_type: "text/plain",
+                });
+            },
+            recordRead: (invocation, copy) => recordExternalReferenceRead(store.db, invocation, copy),
+        });
+        const routes = {
+            project: {
+                project_id: projectId,
+                display_name: "Reference smoke",
+                identity_source: "git_config",
+            },
+            store,
+            workspaceOps: { workspaceRoot, viewerAssetCacheRoot: join(root, "viewer-cache") },
+            tokenRegistry: registry,
+            externalReferences: service,
+        };
+        app.addHook("onRequest", (request, _reply, done) => {
+            const path = request.url.split("?")[0];
+            if (path === "/internal/agent-context/messages")
+                historyReads++;
+            if (path === "/internal/agent-context/references/file")
+                localReads++;
+            done();
+        });
+        registerAgentContextReferenceRoutes(app, routes);
+        registerAgentContextExternalReferenceRoutes(app, routes);
+        registerAgentContextMessageRoutes(app, routes);
+        const address = await app.listen({ port: 0, host: "127.0.0.1" });
+        const agentContext = {
+            baseUrl: `${address}/internal/agent-context`,
+            issueToken: (request) => {
+                const token = registry.issueToken({
+                    projectId,
+                    selection: "chat_assistant",
+                    scopes: request.scopes,
+                });
+                return {
+                    token: token.token,
+                    invocation_ref: token.reference_invocation_ref,
+                    expires_at: token.expires_at,
+                };
+            },
+        };
+        const say = (body, descriptors) => createMainChatMessage(store.db, {
+            author: { kind: "human", display_name: "Tester" },
+            body,
+            ...(descriptors === undefined ? {} : { refs: { external_references: descriptors } }),
+        });
+        const ask = async (name, question, expected) => {
+            const before = { remote: remoteReads, history: historyReads, local: localReads };
+            input.report({
+                case: name,
+                status: "started",
+                external_reads: 0,
+                history_reads: 0,
+                local_reads: 0,
+            });
+            const check = (condition, reason) => {
+                if (condition)
+                    return;
+                input.report({
+                    case: name,
+                    status: "failed",
+                    reason_code: reason,
+                    external_reads: remoteReads - before.remote,
+                    history_reads: historyReads - before.history,
+                    local_reads: localReads - before.local,
+                });
+                throw new Error("reference_freshness_assertion_failed");
+            };
+            let providerFailed = false;
+            // Each answer uses a new assistant instance and ephemeral app-server Thread.
+            const assistant = new ReadOnlyChatAssistant({
+                project: routes.project,
+                store,
+                workspaceRoot,
+                events: new WorkspaceEventBus(),
+                model: {
+                    answer: async (turn) => {
+                        try {
+                            const result = await runCodexAppServerReadOnlyProcedure({
+                                apiKey: input.apiKey,
+                                ...(input.apiBaseUrl === undefined ? {} : { apiBaseUrl: input.apiBaseUrl }),
+                                defaultModel: input.model,
+                                workspaceRoot,
+                                prompt: turn.prompt,
+                                outputSchema: CHAT_ASSISTANT_OUTPUT_SCHEMA,
+                                validateOutput: isChatAssistantOutput,
+                                skillSelectionName: "chat_assistant",
+                                agentContext,
+                                baseEnv: { PATH: process.env.PATH, HOME: root },
+                                webSearchMode: "disabled",
+                                requestTimeoutMs: 60_000,
+                                turnTimeoutMs: 180_000,
+                                ...(turn.onProgress === undefined ? {} : { onProgress: turn.onProgress }),
+                                onLifecycleIncident: () => {
+                                    processCleanupUncertain = true;
+                                },
+                            });
+                            return result.output;
+                        }
+                        catch (error) {
+                            providerFailed = true;
+                            throw error;
+                        }
+                    },
+                },
+            });
+            assistant.enqueue({ message: say(`@tutti ${question}`) });
+            await assistant.waitForIdle();
+            check(!providerFailed, "provider_failed");
+            const reply = readMainChatMessageWindow(store.db).items.at(-1);
+            input.inspectSyntheticAnswer?.({ case: name, answer: reply.body });
+            check(reply.author.kind === "agent", "reply_missing");
+            if (expected.marker)
+                check(reply.body.includes(expected.marker), "expected_content_missing");
+            if (expected.current) {
+                check(remoteReads - before.remote === 1, "current_read_missing_or_repeated");
+                check(JSON.stringify(reply.refs?.external_reference_reads) ===
+                    JSON.stringify([source.source_ref]), "evidence_missing");
+                check(!reply.body.includes("ORCHID_17"), "legacy_content_used");
+            }
+            else {
+                check(reply.refs?.external_reference_reads === undefined, "unverified_source_attached");
+                check(remoteReads - before.remote === (expected.denied ? 1 : 0), "unexpected_read_count");
+            }
+            if (expected.history)
+                check(historyReads > before.history, "history_not_consulted");
+            if (expected.local)
+                check(localReads > before.local, "historical_read_missing");
+            if (expected.denied) {
+                check(localReads === before.local, "legacy_fallback");
+                if (/ORCHID_17|CEDAR_29|MAPLE_43|BIRCH_61/u.test(reply.body)) {
+                    check(labelsPriorReferenceAsUnverified(reply.body), "unlabelled_historical_content");
+                }
+                check(/无法|不能|失败|权限|不可|未能|无法确认|unable|cannot|access|unavailable/iu.test(reply.body), "missing_access_limitation");
+            }
+            input.report({
+                case: name,
+                status: "passed",
+                external_reads: remoteReads - before.remote,
+                history_reads: historyReads - before.history,
+                local_reads: localReads - before.local,
+            });
+        };
+        say("这是本项目要使用的文档。", [source]);
+        await ask("initial_external", "读取这份文档，告诉我当前标记。", { marker, current: true });
+        await ask("reread_without_update", "请重新读取刚才的文档，核对当前内容。", {
+            marker,
+            current: true,
+        });
+        if (input.rereadOnly) {
+            assert.equal(processCleanupUncertain, false, "process_cleanup_unverified");
+            return;
+        }
+        revision = "2";
+        marker = "MAPLE_43";
+        source.name = "Renamed project plan";
+        say("我已经修改了文档内容，也改了文件名。");
+        await ask("reread_after_update_and_rename", "请重新读取刚才的文档，核对当前内容。", {
+            marker,
+            current: true,
+        });
+        sources.push(other);
+        say("这是另一个团队的附件，先不用处理。", [other]);
+        say("我们下午再讨论排期。");
+        say("会议室已经预订好了。");
+        say("好的，收到。");
+        revision = "3";
+        marker = "BIRCH_61";
+        await ask("reread_beyond_compact_window", "最开始那份项目文档又更新了。请重新读取并核对当前标记，不是另一个团队的附件。", { marker, current: true, history: true });
+        deny = true;
+        await ask("revoked_access_no_legacy_fallback", "请再次读取刚才那份项目文档，确认现在的标记。", {
+            current: false,
+            denied: true,
+        });
+        await ask("explicit_historical_read", `请读取本地历史快照 ${legacyPath}，只说明其中保存的旧标记，不要查在线版本。`, { marker: "ORCHID_17", current: false, local: true });
+        await ask("ordinary_question", "一加一等于几？", { current: false });
+        assert.equal(processCleanupUncertain, false, "process_cleanup_unverified");
+    }
+    finally {
+        await app.close();
+        store.close();
+        // Never remove a temp root while an unconfirmed app-server process may use it.
+        if (!processCleanupUncertain)
+            rmSync(root, { recursive: true, force: true });
+    }
+}
+//# sourceMappingURL=reference-freshness-smoke.js.map

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

@@ -1,7 +1,7 @@
 export { ingestTrustedConversationSource, TRUSTED_INTEGRATION_INGESTION_PATH, type IngestTrustedConversationSourceOptions, } from "./external-source.js";
 export { ingestMainChatMessage, type IngestMainChatMessageOptions, type MainChatMessageMaterialization, } from "./main-chat.js";
 export { ingestManagedReferenceSnapshot, publishManagedReferenceSnapshotChanged, type IngestManagedReferenceSnapshotOptions, } from "./managed-reference-snapshots.js";
-export { ingestTrustedManagedReference, type IngestTrustedManagedReferenceOptions, type ResolvedManagedReferenceContent, } from "./managed-reference-sources.js";
+export { ingestTrustedManagedReference, readManagedReferenceSourcePaths, type IngestTrustedManagedReferenceOptions, type ResolvedManagedReferenceContent, } from "./managed-reference-sources.js";
 export { ingestReferenceFile, REFERENCE_FILE_INGESTION_COMMAND_NAME, REFERENCE_FILE_INGESTION_TARGET_REF, toReferenceFileProjection, type IngestReferenceFileOptions, } from "./reference-files.js";
 export { ingestTrustedReferenceAttachment, TRUSTED_INTEGRATION_REFERENCE_ATTACHMENT_PATH, type IngestTrustedReferenceAttachmentOptions, type ResolvedReferenceAttachmentContent, } from "./reference-attachments.js";
 export type { ChatAssistantEnqueuer, ReferenceSummaryStarter, ScratchpadSourceNotifier, TrustedCollaborationAuthor, } from "./types.js";

package/dist/collaboration-ingestion/index.js

@@ -1,7 +1,7 @@
 export { ingestTrustedConversationSource, TRUSTED_INTEGRATION_INGESTION_PATH, } from "./external-source.js";
 export { ingestMainChatMessage, } from "./main-chat.js";
 export { ingestManagedReferenceSnapshot, publishManagedReferenceSnapshotChanged, } from "./managed-reference-snapshots.js";
-export { ingestTrustedManagedReference, } from "./managed-reference-sources.js";
+export { ingestTrustedManagedReference, readManagedReferenceSourcePaths, } from "./managed-reference-sources.js";
 export { ingestReferenceFile, REFERENCE_FILE_INGESTION_COMMAND_NAME, REFERENCE_FILE_INGESTION_TARGET_REF, toReferenceFileProjection, } from "./reference-files.js";
 export { ingestTrustedReferenceAttachment, TRUSTED_INTEGRATION_REFERENCE_ATTACHMENT_PATH, } from "./reference-attachments.js";
 //# sourceMappingURL=index.js.map

package/dist/collaboration-ingestion/managed-reference-sources.d.ts

@@ -1,7 +1,9 @@
 import type { IntegrationManagedReferenceDisposition, TrustedManagedReferenceIngestionCommand } from "@tutti/shared/schemas/internal";
-import type { HostProjectStore } from "../store/index.js";
+import type { HostProjectStore, SqliteDatabase } from "../store/index.js";
 import type { WorkspaceEventBus } from "../server-shell/http/workspace-events.js";
 import type { ReferenceSummaryStarter } from "./types.js";
+/** Dedicated source records identify snapshots; filenames and text are not provenance. */
+export declare function readManagedReferenceSourcePaths(db: SqliteDatabase): ReadonlySet<string>;
 export type ResolvedManagedReferenceContent = {
     content: Buffer;
     complete: () => Promise<void>;

package/dist/collaboration-ingestion/managed-reference-sources.js

@@ -2,6 +2,13 @@ import { createHash } from "node:crypto";
 import { isTrustedManagedReferenceIngestionCommand } from "@tutti/shared/schemas/internal";
 import { readManagedReferenceSnapshotState, WorkspaceOpsError, writeManagedReferenceSnapshot, } from "../workspace-ops/index.js";
 import { publishManagedReferenceSnapshotChanged } from "./managed-reference-snapshots.js";
+/** Dedicated source records identify snapshots; filenames and text are not provenance. */
+export function readManagedReferenceSourcePaths(db) {
+    return new Set(db
+        .prepare("SELECT reference_path FROM managed_reference_sources WHERE accepted_revision_ref IS NOT NULL")
+        .all()
+        .map((row) => row.reference_path));
+}
 function readSource(db, sourceRef) {
     return (db
         .prepare("SELECT * FROM managed_reference_sources WHERE source_ref = ?")