@xfey/tutti 0.1.106 → 0.1.108

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

@@ -0,0 +1,83 @@
+import { Type } from "@sinclair/typebox";
+import { redactText } from "@tutti/shared/utils";
+import { ExternalReferenceTransportError } from "@tutti/relay-client";
+import { ReferenceCacheError } from "../../../reference-access/cache.js";
+import { WorkspaceOpsError } from "../../../workspace-ops/errors.js";
+import { authorizeAgentContextRequest } from "./agent-context-auth.js";
+import { AGENT_CONTEXT_BASE_PATH } from "./agent-context-shared.js";
+export function registerAgentContextExternalReferenceRoutes(app, options) {
+    for (const action of ["list", "read"])
+        app.get(`${AGENT_CONTEXT_BASE_PATH}/references/external${action === "read" ? "/file" : ""}`, {
+            schema: {
+                querystring: action === "read"
+                    ? Type.Object({ source_ref: Type.String({ pattern: "^external_ref_[a-f0-9]{32}$" }) }, { additionalProperties: false })
+                    : Type.Object({}, { additionalProperties: false }),
+            },
+        }, async (request, reply) => {
+            reply.header("cache-control", "no-store");
+            const invocation = authorizeAgentContextRequest(request, options, "references:external");
+            const service = options.externalReferences;
+            if (!service)
+                return { kind: "unavailable", reason: "external_references_not_enabled" };
+            const sourceRef = request.query.source_ref;
+            if (action === "read" &&
+                (sourceRef === undefined || !/^external_ref_[a-f0-9]{32}$/u.test(sourceRef)))
+                return { kind: "unavailable", reason: "reference_source_invalid" };
+            try {
+                if (action === "list")
+                    return { items: await service.list(invocation) };
+                const result = await service.read(invocation, sourceRef);
+                const { copy } = result;
+                request.log.info({
+                    stage: "external_reference_read",
+                    invocation_ref: invocation.reference_invocation_ref,
+                    activity_ref: invocation.activity_ref,
+                    source_ref: copy.source_ref,
+                    revision: copy.revision,
+                    sha256: copy.sha256,
+                    cache_hit: result.cache_hit,
+                    size_bytes: copy.size_bytes,
+                }, "External Reference working copy ready");
+                let text;
+                if (!result.content.includes(0)) {
+                    try {
+                        text = new TextDecoder("utf-8", { fatal: true }).decode(result.content);
+                    }
+                    catch {
+                        /* Binary resources are available as a controlled local working copy. */
+                    }
+                }
+                const limit = 128 * 1024;
+                const safeText = text === undefined ? undefined : Buffer.from(redactText(text), "utf8");
+                return {
+                    kind: text === undefined ? "local_file" : "text",
+                    ...copy,
+                    cache_hit: result.cache_hit,
+                    ...(safeText === undefined
+                        ? {}
+                        : {
+                            text: safeText.subarray(0, limit).toString("utf8"),
+                            truncated: safeText.byteLength > limit,
+                        }),
+                };
+            }
+            catch (error) {
+                const reason = error instanceof ReferenceCacheError
+                    ? error.code
+                    : error instanceof ExternalReferenceTransportError
+                        ? error.reasonCode
+                        : error instanceof WorkspaceOpsError
+                            ? "reference_cache_unsafe"
+                            : "reference_read_unavailable";
+                request.log.warn({
+                    stage: "external_reference_read",
+                    invocation_ref: invocation.reference_invocation_ref,
+                    activity_ref: invocation.activity_ref,
+                    ...(sourceRef === undefined ? {} : { source_ref: sourceRef }),
+                    reason_code: reason,
+                }, "External Reference read unavailable");
+                return { kind: "unavailable", reason };
+            }
+        });
+}
+//# sourceMappingURL=agent-context-external-reference-routes.js.map

package/dist/server-shell/http/routes/agent-context-shared.d.ts

@@ -1,6 +1,7 @@
 import type { HostProjectStore } from "../../../store/index.js";
 import type { HostProjectApiRouteOptions } from "./project-api.js";
 import type { AgentContextTokenRegistry } from "./agent-context-auth.js";
+import type { ExternalReferenceAccess } from "../../../reference-access/service.js";
 export declare const AGENT_CONTEXT_BASE_PATH: "/internal/agent-context";
 export declare const MESSAGE_LIMIT_DEFAULT = 50;
 export declare const MESSAGE_LIMIT_MAX = 100;
@@ -27,6 +28,7 @@ export declare const USER_SKILL_MD_DEFAULT_MAX_CHARS = 20000;
 export declare const USER_SKILL_MD_MAX_CHARS = 100000;
 export type AgentContextRouteOptions = Pick<HostProjectApiRouteOptions, "project" | "store" | "workspaceOps" | "tuttiHome" | "now"> & {
     tokenRegistry: AgentContextTokenRegistry;
+    externalReferences?: ExternalReferenceAccess;
 };
 export declare function requireProjectStore(options: AgentContextRouteOptions): HostProjectStore;
 export declare function requireWorkspaceRoot(options: AgentContextRouteOptions): string;

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

@@ -1,8 +1,9 @@
 import { registerAgentContextMessageRoutes } from "./agent-context-messages-routes.js";
 import { registerAgentContextProjectDocRoutes } from "./agent-context-project-doc-routes.js";
 import { registerAgentContextReferenceRoutes } from "./agent-context-reference-routes.js";
+import { registerAgentContextExternalReferenceRoutes } from "./agent-context-external-reference-routes.js";
 import { registerAgentContextSkillRoutes } from "./agent-context-skills-routes.js";
-import { AGENT_CONTEXT_BASE_PATH, } from "./agent-context-shared.js";
+import { AGENT_CONTEXT_BASE_PATH } from "./agent-context-shared.js";
 import { registerAgentContextWorkspaceRoutes } from "./agent-context-workspace-routes.js";
 export { DEFAULT_AGENT_CONTEXT_TOKEN_TTL_MS, AgentContextTokenRegistry, } from "./agent-context-auth.js";
 export { AGENT_CONTEXT_BASE_PATH };
@@ -11,6 +12,7 @@ export function registerAgentContextRoutes(app, options) {
     registerAgentContextProjectDocRoutes(app, options);
     registerAgentContextWorkspaceRoutes(app, options);
     registerAgentContextReferenceRoutes(app, options);
+    registerAgentContextExternalReferenceRoutes(app, options);
     registerAgentContextSkillRoutes(app, options);
 }
 //# sourceMappingURL=agent-context.js.map

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

@@ -4,8 +4,9 @@ import { REFERENCE_DIRECTORY_PATH } from "../../../../workspace-ops/index.js";
 import { decideCommandIdempotencyReplay, executeIdempotentCommand, readCommandIdempotencyRecord, } from "../../../command-idempotency/index.js";
 import { HOST_PROJECT_API_BASE_PATH } from "./constants.js";
 import { readReferenceFilesResponse, referenceSummaryProcedureInvalidates, } from "./reference-files.js";
-import { requireControlPlane, requireHostProjectSession, requireProjectStore, requireWorkspaceRoot, } from "./session-requirements.js";
+import { requireControlPlane, requireHostProjectSession, requireHostProjectOwnerSession, requireProjectStore, requireWorkspaceRoot, } from "./session-requirements.js";
 import { abortDownloadedStagedUpload, cleanupDownloadedStagedUpload, downloadStagedUpload, } from "./staged-uploads.js";
+import { HostProjectBadRequestError } from "./errors.js";
 export function registerReferenceFilesRoutes(app, { options, workspaceEvents, }) {
     app.get(`${HOST_PROJECT_API_BASE_PATH}/references/files`, {
         schema: {
@@ -90,7 +91,16 @@ export function registerReferenceFilesRoutes(app, { options, workspaceEvents, })
             },
         },
     }, (request) => {
-        requireHostProjectSession(request, options);
+        if (options.surfaceProfile?.kind === "feishu") {
+            requireHostProjectOwnerSession(request, options);
+            const paths = request.body.payload.paths;
+            if (paths?.length !== 1 || !paths[0]?.startsWith(`${REFERENCE_DIRECTORY_PATH}/`)) {
+                throw new HostProjectBadRequestError("Select one project Reference to retry its summary");
+            }
+        }
+        else {
+            requireHostProjectSession(request, options);
+        }
         const store = requireProjectStore(options);
         const execution = executeIdempotentCommand({
             db: store.db,
@@ -109,6 +119,13 @@ export function registerReferenceFilesRoutes(app, { options, workspaceEvents, })
         if (execution.result !== undefined) {
             response.result = execution.result;
         }
+        request.log.info({
+            command_id: execution.command_id,
+            disposition: execution.disposition.kind,
+            activity_ref: execution.result?.activity_ref,
+            workflow_ref: execution.result?.workflow_ref,
+            target_count: execution.result?.target_count,
+        }, "Reference summary refresh requested");
         return response;
     });
 }

package/dist/workspace-ops/project-workspace.js

@@ -2,6 +2,7 @@ import { classifyRepositoryPathMetadata } from "@tutti/shared/utils";
 import { WorkspaceOpsError } from "./errors.js";
 import { runGit, runGitRaw, runGitText, stagedChangesExist, summarizeGitFailure, tryGitText, } from "./git.js";
 import { requireMainlineBranch } from "./mainline.js";
+import { assertReferenceCacheIsolation } from "./reference-cache-policy.js";
 const MAX_RUN_DIFF_SUMMARY_BYTES = 32 * 1024;
 const ACCEPTED_TAG_PREFIX = "tutti/accepted/";
 function truncateText(text, maxBytes) {
@@ -48,6 +49,7 @@ function requireGitCommandSuccess(args, workspaceRoot) {
     return result;
 }
 export function collectProjectSourceDiff(workspaceRoot) {
+    assertReferenceCacheIsolation(workspaceRoot);
     const status = requireGitCommandSuccess(["status", "--porcelain=v1", "-z"], workspaceRoot);
     const changedPaths = parsePorcelainChangedPaths(status.stdout);
     const summaryParts = [];
@@ -80,12 +82,8 @@ function acceptedTagName(workspaceRoot, activityRef) {
     return tagName;
 }
 function nearestAcceptedCommit(workspaceRoot) {
-    const refs = requireGitCommandSuccess([
-        "for-each-ref",
-        "--format=%(objectname) %(refname:short)",
-        `refs/tags/${ACCEPTED_TAG_PREFIX}`,
-    ], workspaceRoot).stdout
-        .toString("utf8")
+    const refs = requireGitCommandSuccess(["for-each-ref", "--format=%(objectname) %(refname:short)", `refs/tags/${ACCEPTED_TAG_PREFIX}`], workspaceRoot)
+        .stdout.toString("utf8")
         .trim();
     if (refs.length === 0) {
         return null;
@@ -209,7 +207,9 @@ export function createAcceptedCheckpoint(options) {
         };
     }
     const inspection = inspectProjectWorkspace(options.workspaceRoot);
+    assertReferenceCacheIsolation(options.workspaceRoot);
     runGit(["add", "-A"], options.workspaceRoot);
+    assertReferenceCacheIsolation(options.workspaceRoot);
     if (!stagedChangesExist(options.workspaceRoot)) {
         throw new WorkspaceOpsError("validation_failed", "Accepted checkpoint has no staged source changes", { reason_code: "accepted_checkpoint_candidate_missing" });
     }

package/dist/workspace-ops/reference-cache-policy.d.ts

@@ -0,0 +1,6 @@
+export declare const REFERENCE_CACHE_PATH = "docs/reference/.tutti-cache";
+/** Only the exact managed namespace is eligible. Never adopt an existing directory. */
+export declare function initializeReferenceCacheDirectory(workspaceRoot: string): string;
+/** Fail closed on force-added cache or ignore drift; never unstage or delete user changes. */
+export declare function assertReferenceCacheIsolation(workspaceRoot: string, required?: boolean): void;
+//# sourceMappingURL=reference-cache-policy.d.ts.map

package/dist/workspace-ops/reference-cache-policy.js

@@ -0,0 +1,79 @@
+import { lstatSync, mkdirSync, readFileSync, realpathSync, writeFileSync } from "node:fs";
+import { dirname, isAbsolute, join, resolve } from "node:path";
+import { WorkspaceOpsError } from "./errors.js";
+import { runGit, runGitRaw, runGitText, tryGitText } from "./git.js";
+export const REFERENCE_CACHE_PATH = "docs/reference/.tutti-cache";
+const CONFIG_KEY = "tutti.reference-cache-path";
+function reject() {
+    throw new WorkspaceOpsError("conflict", "Reference cache isolation is unavailable", {
+        reason_code: "reference_cache_unsafe",
+    });
+}
+/** Only the exact managed namespace is eligible. Never adopt an existing directory. */
+export function initializeReferenceCacheDirectory(workspaceRoot) {
+    const root = realpathSync(workspaceRoot);
+    const configured = tryGitText(["config", "--local", "--get", CONFIG_KEY], root);
+    if (configured !== null && configured !== REFERENCE_CACHE_PATH)
+        reject();
+    let current = root;
+    for (const part of REFERENCE_CACHE_PATH.split("/")) {
+        current = join(current, part);
+        const stat = lstatSync(current, { throwIfNoEntry: false });
+        if (stat !== undefined) {
+            if (!stat.isDirectory() || stat.isSymbolicLink())
+                reject();
+            if (current === join(root, REFERENCE_CACHE_PATH) && configured === null)
+                reject();
+        }
+    }
+    if (runGitText(["ls-files", "--", REFERENCE_CACHE_PATH], root) !== "")
+        reject();
+    // Git-local exclusion preserves the project's own .gitignore and unrelated index state.
+    const gitPath = runGitText(["rev-parse", "--git-path", "info/exclude"], root);
+    const exclude = isAbsolute(gitPath) ? gitPath : resolve(root, gitPath);
+    const gitDirectory = realpathSync(dirname(dirname(exclude)));
+    const info = join(gitDirectory, "info");
+    const infoStat = lstatSync(info, { throwIfNoEntry: false });
+    if (infoStat !== undefined && (!infoStat.isDirectory() || infoStat.isSymbolicLink()))
+        reject();
+    mkdirSync(info, { recursive: true });
+    const excludeStat = lstatSync(exclude, { throwIfNoEntry: false });
+    if (excludeStat !== undefined && (!excludeStat.isFile() || excludeStat.isSymbolicLink()))
+        reject();
+    const previous = excludeStat === undefined ? "" : readFileSync(exclude, "utf8");
+    const rule = `/${REFERENCE_CACHE_PATH}/`;
+    if (!previous.split(/\r?\n/u).includes(rule)) {
+        writeFileSync(exclude, `${previous}${previous.endsWith("\n") ? "" : "\n"}${rule}\n`, {
+            flag: excludeStat === undefined ? "wx" : "w",
+            mode: 0o600,
+        });
+    }
+    runGit(["config", "--local", CONFIG_KEY, REFERENCE_CACHE_PATH], root);
+    assertReferenceCacheIsolation(root);
+    mkdirSync(join(root, REFERENCE_CACHE_PATH), { recursive: true, mode: 0o700 });
+    return join(root, REFERENCE_CACHE_PATH);
+}
+/** Fail closed on force-added cache or ignore drift; never unstage or delete user changes. */
+export function assertReferenceCacheIsolation(workspaceRoot, required = false) {
+    const configured = tryGitText(["config", "--local", "--get", CONFIG_KEY], workspaceRoot);
+    if (configured === null) {
+        if (required || lstatSync(join(workspaceRoot, REFERENCE_CACHE_PATH), { throwIfNoEntry: false }))
+            reject();
+        return;
+    }
+    if (configured !== REFERENCE_CACHE_PATH)
+        reject();
+    if (runGitText(["ls-files", "--", REFERENCE_CACHE_PATH], workspaceRoot) !== "")
+        reject();
+    const ignored = runGitRaw(["check-ignore", "--no-index", "-q", `${REFERENCE_CACHE_PATH}/isolation-probe`], workspaceRoot);
+    if (ignored.status !== 0)
+        reject();
+    let current = realpathSync(workspaceRoot);
+    for (const part of REFERENCE_CACHE_PATH.split("/")) {
+        current = join(current, part);
+        const stat = lstatSync(current, { throwIfNoEntry: false });
+        if (stat !== undefined && (!stat.isDirectory() || stat.isSymbolicLink()))
+            reject();
+    }
+}
+//# sourceMappingURL=reference-cache-policy.js.map

package/migrations/0021_external_reference_reads.sql

@@ -0,0 +1,11 @@
+CREATE TABLE external_reference_reads (
+  invocation_ref TEXT NOT NULL,
+  activity_ref TEXT,
+  source_ref TEXT NOT NULL,
+  revision TEXT NOT NULL,
+  content_sha256 TEXT NOT NULL,
+  size_bytes INTEGER NOT NULL CHECK (size_bytes >= 0),
+  checked_at TEXT NOT NULL,
+  PRIMARY KEY (invocation_ref, source_ref)
+);
+CREATE INDEX external_reference_reads_activity ON external_reference_reads(activity_ref);

package/node_modules/@tutti/relay-client/dist/external-references.d.ts

@@ -0,0 +1,11 @@
+import { type ExternalReferenceHostRequest } from "@tutti/shared/schemas/internal";
+export declare class ExternalReferenceTransportError extends Error {
+    readonly reasonCode: string;
+    constructor(reasonCode: string);
+}
+export declare function requestExternalReferences(options: {
+    relayUrl: string;
+    body: ExternalReferenceHostRequest;
+    fetchImpl?: typeof fetch;
+}): Promise<unknown>;
+//# sourceMappingURL=external-references.d.ts.map

package/node_modules/@tutti/relay-client/dist/external-references.js

@@ -0,0 +1,63 @@
+import { EXTERNAL_REFERENCE_HOST_PATH, isExternalReferenceList, isExternalReferenceReadResult, } from "@tutti/shared/schemas/internal";
+export class ExternalReferenceTransportError extends Error {
+    reasonCode;
+    constructor(reasonCode) {
+        super(reasonCode);
+        this.reasonCode = reasonCode;
+        this.name = "ExternalReferenceTransportError";
+    }
+}
+export async function requestExternalReferences(options) {
+    try {
+        const response = await (options.fetchImpl ?? fetch)(new URL(EXTERNAL_REFERENCE_HOST_PATH, options.relayUrl), {
+            method: "POST",
+            redirect: "error",
+            headers: { "content-type": "application/json" },
+            body: JSON.stringify(options.body),
+            signal: AbortSignal.timeout(90_000),
+        });
+        const reader = response.body?.getReader();
+        if (!reader)
+            throw new ExternalReferenceTransportError("reference_transport_invalid_response");
+        const chunks = [];
+        let size = 0;
+        try {
+            for (;;) {
+                const next = await reader.read();
+                if (next.done)
+                    break;
+                if (!(next.value instanceof Uint8Array))
+                    throw new ExternalReferenceTransportError("reference_transport_invalid_response");
+                size += next.value.byteLength;
+                if (size > 512 * 1024)
+                    throw new ExternalReferenceTransportError("reference_transport_invalid_response");
+                chunks.push(next.value);
+            }
+        }
+        finally {
+            await reader.cancel().catch(() => undefined);
+            reader.releaseLock();
+        }
+        const value = JSON.parse(Buffer.concat(chunks).toString("utf8"));
+        if (!response.ok) {
+            const reason = typeof value === "object" && value !== null && "reason_code" in value
+                ? value.reason_code
+                : null;
+            throw new ExternalReferenceTransportError(typeof reason === "string" &&
+                /^(reference|document_wiki|feishu|attachment)_[a-z_]{1,70}$/u.test(reason)
+                ? reason
+                : "reference_transport_unavailable");
+        }
+        if (options.body.action === "list"
+            ? !isExternalReferenceList(value)
+            : !isExternalReferenceReadResult(value))
+            throw new ExternalReferenceTransportError("reference_transport_invalid_response");
+        return value;
+    }
+    catch (error) {
+        throw error instanceof ExternalReferenceTransportError
+            ? error
+            : new ExternalReferenceTransportError("reference_transport_unavailable");
+    }
+}
+//# sourceMappingURL=external-references.js.map

package/node_modules/@tutti/relay-client/dist/host-control.d.ts

@@ -44,6 +44,7 @@ export type RegisterRelayHostConnectionPayload = {
             browser_secret_write: false;
             repo_viewer: boolean;
             integration_source_ingestion_v1?: boolean;
+            integration_external_references_v1?: boolean;
             integration_attachment_ingestion_v1?: boolean;
             integration_managed_reference_ingestion_v1?: boolean;
             integration_outbound_v1?: boolean;

package/node_modules/@tutti/relay-client/dist/host-control.js

@@ -57,6 +57,7 @@ function createRegisterPayload(options) {
                 browser_secret_write: false,
                 repo_viewer: capabilities.repo_viewer ?? false,
                 integration_source_ingestion_v1: capabilities.integration_source_ingestion_v1 ?? false,
+                integration_external_references_v1: capabilities.integration_external_references_v1 ?? false,
                 integration_attachment_ingestion_v1: capabilities.integration_attachment_ingestion_v1 ?? false,
                 integration_managed_reference_ingestion_v1: capabilities.integration_managed_reference_ingestion_v1 ?? false,
                 integration_outbound_v1: capabilities.integration_outbound_v1 ?? false,

package/node_modules/@tutti/relay-client/dist/index.d.ts

@@ -1,3 +1,4 @@
 export * from "./host-control.js";
 export * from "./tunnel.js";
+export * from "./external-references.js";
 //# sourceMappingURL=index.d.ts.map

package/node_modules/@tutti/relay-client/dist/index.js

@@ -1,3 +1,4 @@
 export * from "./host-control.js";
 export * from "./tunnel.js";
+export * from "./external-references.js";
 //# sourceMappingURL=index.js.map

package/node_modules/@tutti/shared/dist/schemas/api/clarifications.d.ts

@@ -507,6 +507,12 @@ export declare const SendClarificationRoundMessageResultSchema: import("@sinclai
         message_kind: import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TLiteral<"user_text">, import("@sinclair/typebox").TLiteral<"agent_text">, import("@sinclair/typebox").TLiteral<"system_notice">, import("@sinclair/typebox").TLiteral<"clarification_request">, import("@sinclair/typebox").TLiteral<"clarification_card">]>;
         body: import("@sinclair/typebox").TString;
         refs: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TObject<{
+            external_references: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TArray<import("@sinclair/typebox").TObject<{
+                source_ref: import("@sinclair/typebox").TString;
+                kind: import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TLiteral<"feishu_docx">, import("@sinclair/typebox").TLiteral<"feishu_file">, import("@sinclair/typebox").TLiteral<"feishu_image">]>;
+                name: import("@sinclair/typebox").TString;
+                created_at: import("@sinclair/typebox").TString;
+            }>>>;
             task_id: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
             activity_ref: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
             workflow_ref: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;

package/node_modules/@tutti/shared/dist/schemas/api/external-references.d.ts

@@ -0,0 +1,23 @@
+import { type Static } from "@sinclair/typebox";
+export declare const ExternalReferenceRefSchema: import("@sinclair/typebox").TString;
+export declare const ExternalReferenceDescriptorSchema: import("@sinclair/typebox").TObject<{
+    source_ref: import("@sinclair/typebox").TString;
+    kind: import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TLiteral<"feishu_docx">, import("@sinclair/typebox").TLiteral<"feishu_file">, import("@sinclair/typebox").TLiteral<"feishu_image">]>;
+    name: import("@sinclair/typebox").TString;
+    created_at: import("@sinclair/typebox").TString;
+}>;
+export declare const ExternalReferenceListSchema: import("@sinclair/typebox").TObject<{
+    can_register: import("@sinclair/typebox").TBoolean;
+    items: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TObject<{
+        source_ref: import("@sinclair/typebox").TString;
+        kind: import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TLiteral<"feishu_docx">, import("@sinclair/typebox").TLiteral<"feishu_file">, import("@sinclair/typebox").TLiteral<"feishu_image">]>;
+        name: import("@sinclair/typebox").TString;
+        created_at: import("@sinclair/typebox").TString;
+    }>>;
+}>;
+export declare const RegisterExternalReferenceBodySchema: import("@sinclair/typebox").TObject<{
+    document_url: import("@sinclair/typebox").TString;
+}>;
+export type ExternalReferenceDescriptor = Static<typeof ExternalReferenceDescriptorSchema>;
+export type ExternalReferenceList = Static<typeof ExternalReferenceListSchema>;
+//# sourceMappingURL=external-references.d.ts.map

package/node_modules/@tutti/shared/dist/schemas/api/external-references.js

@@ -0,0 +1,21 @@
+import { Type } from "@sinclair/typebox";
+import { IsoDateTimeStringSchema } from "../domain/index.js";
+export const ExternalReferenceRefSchema = Type.String({ pattern: "^external_ref_[a-f0-9]{32}$" });
+export const ExternalReferenceDescriptorSchema = Type.Object({
+    source_ref: ExternalReferenceRefSchema,
+    kind: Type.Union([
+        Type.Literal("feishu_docx"),
+        Type.Literal("feishu_file"),
+        Type.Literal("feishu_image"),
+    ]),
+    name: Type.String({ minLength: 1, maxLength: 240 }),
+    created_at: IsoDateTimeStringSchema,
+}, { additionalProperties: false });
+export const ExternalReferenceListSchema = Type.Object({
+    can_register: Type.Boolean(),
+    items: Type.Array(ExternalReferenceDescriptorSchema, { maxItems: 500 }),
+}, { additionalProperties: false });
+export const RegisterExternalReferenceBodySchema = Type.Object({
+    document_url: Type.String({ minLength: 1, maxLength: 2048 }),
+}, { additionalProperties: false });
+//# sourceMappingURL=external-references.js.map

package/node_modules/@tutti/shared/dist/schemas/api/feishu-documents.d.ts

@@ -0,0 +1,46 @@
+import { type Static } from "@sinclair/typebox";
+export declare const FEISHU_DOCUMENT_SOURCE_LIMIT = 100;
+export declare const FeishuDocumentSourceRefSchema: import("@sinclair/typebox").TString;
+export declare const ConnectFeishuDocumentBodySchema: import("@sinclair/typebox").TObject<{
+    document_url: import("@sinclair/typebox").TString;
+}>;
+export declare const RefreshFeishuDocumentBodySchema: import("@sinclair/typebox").TObject<{
+    expected_updated_at: import("@sinclair/typebox").TString;
+}>;
+export declare const FeishuDocumentSourceSchema: import("@sinclair/typebox").TObject<{
+    source_ref: import("@sinclair/typebox").TString;
+    reference_path: import("@sinclair/typebox").TString;
+    status: import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TLiteral<"syncing">, import("@sinclair/typebox").TLiteral<"current">, import("@sinclair/typebox").TLiteral<"waiting_for_host">, import("@sinclair/typebox").TLiteral<"retrying">, import("@sinclair/typebox").TLiteral<"authorization_required">, import("@sinclair/typebox").TLiteral<"permission_denied">, import("@sinclair/typebox").TLiteral<"failed">]>;
+    revision: import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TString, import("@sinclair/typebox").TNull]>;
+    last_checked_at: import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TString, import("@sinclair/typebox").TNull]>;
+    last_synced_at: import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TString, import("@sinclair/typebox").TNull]>;
+    next_attempt_at: import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TString, import("@sinclair/typebox").TNull]>;
+    updated_at: import("@sinclair/typebox").TString;
+    reason_code: import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TString, import("@sinclair/typebox").TNull]>;
+}>;
+export declare const FeishuDocumentSourcesSchema: import("@sinclair/typebox").TObject<{
+    can_manage: import("@sinclair/typebox").TBoolean;
+    items: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TObject<{
+        source_ref: import("@sinclair/typebox").TString;
+        reference_path: import("@sinclair/typebox").TString;
+        status: import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TLiteral<"syncing">, import("@sinclair/typebox").TLiteral<"current">, import("@sinclair/typebox").TLiteral<"waiting_for_host">, import("@sinclair/typebox").TLiteral<"retrying">, import("@sinclair/typebox").TLiteral<"authorization_required">, import("@sinclair/typebox").TLiteral<"permission_denied">, import("@sinclair/typebox").TLiteral<"failed">]>;
+        revision: import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TString, import("@sinclair/typebox").TNull]>;
+        last_checked_at: import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TString, import("@sinclair/typebox").TNull]>;
+        last_synced_at: import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TString, import("@sinclair/typebox").TNull]>;
+        next_attempt_at: import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TString, import("@sinclair/typebox").TNull]>;
+        updated_at: import("@sinclair/typebox").TString;
+        reason_code: import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TString, import("@sinclair/typebox").TNull]>;
+    }>>;
+}>;
+export type FeishuDocumentSource = Static<typeof FeishuDocumentSourceSchema>;
+export type FeishuDocumentSources = Static<typeof FeishuDocumentSourcesSchema>;
+export type ConnectFeishuDocumentBody = Static<typeof ConnectFeishuDocumentBodySchema>;
+export type RefreshFeishuDocumentBody = Static<typeof RefreshFeishuDocumentBodySchema>;
+export type FeishuDocumentLocator = {
+    kind: "docx" | "wiki";
+    token: string;
+};
+/** Parse a locator, never fetch a caller-controlled URL. Wiki tokens are not Docx IDs. */
+export declare function parseFeishuDocumentUrl(value: string): FeishuDocumentLocator | null;
+export declare function parseFeishuDocxUrl(value: string): string | null;
+//# sourceMappingURL=feishu-documents.d.ts.map

package/node_modules/@tutti/shared/dist/schemas/api/feishu-documents.js

@@ -0,0 +1,53 @@
+import { Type } from "@sinclair/typebox";
+import { IsoDateTimeStringSchema } from "../domain/index.js";
+export const FEISHU_DOCUMENT_SOURCE_LIMIT = 100;
+export const FeishuDocumentSourceRefSchema = Type.String({
+    pattern: "^managed_ref_[a-f0-9]{32}$",
+    maxLength: 44,
+});
+export const ConnectFeishuDocumentBodySchema = Type.Object({ document_url: Type.String({ minLength: 1, maxLength: 2_048 }) }, { additionalProperties: false });
+export const RefreshFeishuDocumentBodySchema = Type.Object({ expected_updated_at: IsoDateTimeStringSchema }, { additionalProperties: false });
+export const FeishuDocumentSourceSchema = Type.Object({
+    source_ref: FeishuDocumentSourceRefSchema,
+    reference_path: Type.String({ pattern: "^docs/reference/feishu-docx-[a-f0-9]{12}\\.txt$" }),
+    status: Type.Union([
+        Type.Literal("syncing"),
+        Type.Literal("current"),
+        Type.Literal("waiting_for_host"),
+        Type.Literal("retrying"),
+        Type.Literal("authorization_required"),
+        Type.Literal("permission_denied"),
+        Type.Literal("failed"),
+    ]),
+    revision: Type.Union([Type.String({ maxLength: 512 }), Type.Null()]),
+    last_checked_at: Type.Union([IsoDateTimeStringSchema, Type.Null()]),
+    last_synced_at: Type.Union([IsoDateTimeStringSchema, Type.Null()]),
+    next_attempt_at: Type.Union([IsoDateTimeStringSchema, Type.Null()]),
+    updated_at: IsoDateTimeStringSchema,
+    reason_code: Type.Union([Type.String({ pattern: "^[a-z][a-z0-9_]{0,95}$" }), Type.Null()]),
+}, { additionalProperties: false });
+export const FeishuDocumentSourcesSchema = Type.Object({
+    can_manage: Type.Boolean(),
+    items: Type.Array(FeishuDocumentSourceSchema, { maxItems: FEISHU_DOCUMENT_SOURCE_LIMIT }),
+}, { additionalProperties: false });
+/** Parse a locator, never fetch a caller-controlled URL. Wiki tokens are not Docx IDs. */
+export function parseFeishuDocumentUrl(value) {
+    if (value.length > 2_048 ||
+        Array.from(value).some((char) => char.charCodeAt(0) < 32 || char.charCodeAt(0) === 127))
+        return null;
+    const match = /^https:\/\/(?:[a-z0-9-]+\.)?(?:feishu\.cn|larksuite\.com)(?::443)?\/(docx|wiki)\/([a-z0-9]{1,999})\/?(?:[?#][^\s]*)?$/iu.exec(value.trim());
+    if (match === null)
+        return null;
+    const kind = match[1]?.toLowerCase();
+    const token = match[2];
+    if (token === undefined || (kind !== "docx" && kind !== "wiki"))
+        return null;
+    if (kind === "docx" && token.length !== 27)
+        return null;
+    return { kind, token };
+}
+export function parseFeishuDocxUrl(value) {
+    const locator = parseFeishuDocumentUrl(value);
+    return locator?.kind === "docx" ? locator.token : null;
+}
+//# sourceMappingURL=feishu-documents.js.map

package/node_modules/@tutti/shared/dist/schemas/api/index.d.ts

@@ -5,8 +5,8 @@ export { CompleteDesktopEntryContinuationBodySchema, CompleteDesktopEntryContinu
 export type { CompleteDesktopEntryContinuationBody, CreateDesktopEntryContinuationResponse, GetDesktopEntryContinuationResponse, SealedDesktopEntryPayload, } from "./desktop-entry-continuations.js";
 export { LOCAL_CONSOLE_ACCOUNT_HANDOFF_TOKEN_MAX_LENGTH, LOCAL_CONSOLE_ACCOUNT_HANDOFF_TOKEN_MIN_LENGTH, RegisterLocalConsoleAccountHandoffBodySchema, RegisterLocalConsoleAccountHandoffResponseSchema, } from "./local-console-account-handoffs.js";
 export type { RegisterLocalConsoleAccountHandoffBody, RegisterLocalConsoleAccountHandoffResponse, } from "./local-console-account-handoffs.js";
-export { FEISHU_BROWSER_HANDOFF_TOKEN_LENGTH, FEISHU_DOCX_REQUIRED_USER_SCOPE, FEISHU_H5_AUTHORIZATION_CODE_MAX_LENGTH, FEISHU_H5_REQUIRED_USER_SCOPE, FEISHU_PLATFORM_STATE_LENGTH, FeishuPlatformSessionBootstrapBodySchema, FeishuPlatformSessionBootstrapResponseSchema, FeishuBrowserHandoffResponseSchema, FeishuBrowserHandoffTokenSchema, ConsumeFeishuBrowserHandoffBodySchema, FeishuDocumentAuthorizationBootstrapResponseSchema, FeishuDocumentAuthorizationExchangeBodySchema, FeishuDocumentAuthorizationProjectionSchema, FeishuPlatformSessionExchangeBodySchema, FeishuPlatformSessionProjectionSchema, FeishuPlatformStateSchema, } from "./platform-sessions.js";
-export type { FeishuPlatformSessionBootstrapBody, FeishuPlatformSessionBootstrapResponse, FeishuBrowserHandoffResponse, ConsumeFeishuBrowserHandoffBody, FeishuDocumentAuthorizationBootstrapResponse, FeishuDocumentAuthorizationExchangeBody, FeishuDocumentAuthorizationProjection, FeishuPlatformSessionExchangeBody, FeishuPlatformSessionProjection, } from "./platform-sessions.js";
+export { FEISHU_BROWSER_HANDOFF_TOKEN_LENGTH, FEISHU_DOCX_READWRITE_USER_SCOPE, FEISHU_DOCX_REQUIRED_USER_SCOPE, FEISHU_H5_AUTHORIZATION_CODE_MAX_LENGTH, FEISHU_H5_REQUIRED_USER_SCOPE, FEISHU_OFFLINE_ACCESS_SCOPE, FEISHU_WIKI_REQUIRED_USER_SCOPE, FeishuDocumentAuthorizationBootstrapBodySchema, FEISHU_PLATFORM_STATE_LENGTH, FeishuPlatformSessionBootstrapBodySchema, FeishuPlatformSessionBootstrapResponseSchema, FeishuBrowserHandoffResponseSchema, FeishuBrowserHandoffTokenSchema, ConsumeFeishuBrowserHandoffBodySchema, FeishuDocumentAuthorizationBootstrapResponseSchema, FeishuDocumentAuthorizationExchangeBodySchema, FeishuDocumentAuthorizationProjectionSchema, FeishuPlatformSessionExchangeBodySchema, FeishuPlatformSessionProjectionSchema, FeishuPlatformStateSchema, hasFeishuDocxReadCapability, hasFeishuWikiReadCapability, } from "./platform-sessions.js";
+export type { FeishuPlatformSessionBootstrapBody, FeishuPlatformSessionBootstrapResponse, FeishuBrowserHandoffResponse, ConsumeFeishuBrowserHandoffBody, FeishuDocumentAuthorizationBootstrapResponse, FeishuDocumentAuthorizationProfile, FeishuDocumentAuthorizationExchangeBody, FeishuDocumentAuthorizationProjection, FeishuPlatformSessionExchangeBody, FeishuPlatformSessionProjection, } from "./platform-sessions.js";
 export { ApiErrorCodeSchema, ApiErrorResponseSchema, CommandDispositionBaseSchema, CursorPageRequestSchema, DEFAULT_SSE_REPLAY_WINDOW_POLICY, InterruptedCommandDispositionSchema, QueryInvalidationHintSchema, RelayInvalidationHintSchema, RelaySseEventTypeSchema, SseReplayWindowPolicySchema, WorkspaceSseEventTypeSchema, commandEnvelopeSchema, commandResponseSchema, commandResponseWithResultSchema, cursorPageSchema, relaySseEventSchema, timelineWindowSchema, workspaceSseEventSchema, } from "./primitives.js";
 export { GetProviderModelsResponseSchema, MAX_PROVIDER_MODEL_NAME_LENGTH, ProviderConfigInvalidReasonCodeSchema, ProviderConfigProjectionSchema, ProviderModelDiscoveryUnavailableReasonSchema, ProviderModelNameSchema, ProviderModelValidationFailureReasonSchema, ProviderUnavailableReasonCodeSchema, ProjectProviderUnavailableReasonSchema, UpdateProviderDefaultModelBodySchema, UpdateProviderDefaultModelDispositionSchema, UpdateProviderDefaultModelPayloadSchema, UpdateProviderDefaultModelResponseSchema, } from "./provider-config.js";
 export { ProviderUsageBreakdownProjectionSchema, ProviderUsageCategorySchema, ProviderUsageModelSummaryProjectionSchema, ProviderUsageProjectionSchema, ProviderUsageSourceSummaryProjectionSchema, } from "./provider-usage.js";
@@ -22,4 +22,6 @@ export { ArtifactKindSchema, ArtifactManifestSchema, ArtifactPreviewProjectionSc
 export { DeleteSkillBodySchema, DeleteSkillDispositionSchema, DeleteSkillPayloadSchema, DeleteSkillResponseSchema, GetSkillParamsSchema, GetSkillResponseSchema, GetSkillsResponseSchema, ImportSkillZipBodySchema, ImportSkillZipDispositionSchema, ImportSkillZipPayloadSchema, ImportSkillZipResponseSchema, ImportSkillZipResultSchema, SkillDetailProjectionSchema, SkillNameSchema, SkillProjectionSchema, } from "./skills.js";
 export { ActivityEventProjectionSchema, ActivityEventSsePayloadSchema, ApprovalChangedEventPayloadSchema, ActivityProjectionSchema, ConnectionReadyEventPayloadSchema, ExecutionActivitySummarySchema, ExecutionStatusChangedEventPayloadSchema, ExecutionStatusKindSchema, ExecutionStatusProjectionSchema, ProcedureLaneSchema, ProviderConfigChangedEventPayloadSchema, QueryInvalidateEventPayloadSchema, ScratchpadUpdatedEventPayloadSchema, TaskDetailUpdatedEventPayloadSchema, TaskUpdatedEventPayloadSchema, WorklistChangedEventPayloadSchema, WorkspaceRecoveredEventPayloadSchema, } from "./runtime-events.js";
 export { ContextSyncBodySchema, ContextSyncDispositionSchema, ContextSyncPayloadSchema, ContextSyncResponseSchema, ContextSyncResultSchema, InitializeProjectDocsBodySchema, InitializeProjectDocsDispositionSchema, InitializeProjectDocsPayloadSchema, InitializeProjectDocsResponseSchema, InitializeProjectDocsResultSchema, ProjectDocsProcedureStartResultSchema, RefreshScratchpadDispositionSchema, RefreshScratchpadResultSchema, RunSchedulerNowBodySchema, RunSchedulerNowDispositionSchema, RunSchedulerNowPayloadSchema, RunSchedulerNowResponseSchema, RetryTaskBodySchema, RetryTaskDispositionSchema, RetryTaskPayloadSchema, RetryTaskResponseSchema, SubmitWorklistBodySchema, SubmitWorklistDispositionSchema, SubmitWorklistPayloadSchema, SubmitWorklistResponseSchema, SubmitWorklistResultSchema, UpdateProjectDescriptionBodySchema, UpdateProjectDescriptionDispositionSchema, UpdateProjectDescriptionPayloadSchema, UpdateProjectDescriptionResponseSchema, UpdateProjectDescriptionResultSchema, UpdateProjectDisplayNameBodySchema, UpdateProjectDisplayNameDispositionSchema, UpdateProjectDisplayNamePayloadSchema, UpdateProjectDisplayNameResponseSchema, UpdateProjectDisplayNameResultSchema, } from "./workspace-commands.js";
+export * from "./feishu-documents.js";
+export * from "./external-references.js";
 //# sourceMappingURL=index.d.ts.map