@xfey/tenso 0.1.130

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

@@ -0,0 +1,116 @@
+import { redactText } from "@tutti/shared/utils";
+import { VIEWER_HARD_READ_LIMIT_BYTES, WorkspaceOpsError, readReferenceSummaryIndex, readViewerFile, referenceSummaryProjectionForEntry, } from "../../../workspace-ops/index.js";
+import { authorizeAgentContextRequest } from "./agent-context-auth.js";
+import { AgentContextBadRequestError } from "./agent-context-errors.js";
+import { boundedLimit, pageByOffset, queryString } from "./agent-context-query.js";
+import { mapReferenceUnavailableReason, localReferenceProvenance, managedReferencePaths, referenceListItems, } from "./agent-context-references.js";
+import { AGENT_CONTEXT_BASE_PATH, REFERENCE_FILE_DEFAULT_MAX_BYTES, REFERENCE_FILE_MAX_BYTES, REFERENCES_LIMIT_DEFAULT, REFERENCES_LIMIT_MAX, requireWorkspaceRoot, } from "./agent-context-shared.js";
+export function registerAgentContextReferenceRoutes(app, options) {
+    app.get(`${AGENT_CONTEXT_BASE_PATH}/references`, (request) => {
+        const invocation = authorizeAgentContextRequest(request, options, "references:list");
+        const started = performance.now();
+        request.log.info({
+            stage: "local_reference_request",
+            action: "list",
+            invocation_ref: invocation.reference_invocation_ref,
+        }, "Local Reference request started");
+        const query = request.query;
+        const limit = boundedLimit(query.limit, {
+            default: REFERENCES_LIMIT_DEFAULT,
+            max: REFERENCES_LIMIT_MAX,
+        });
+        const items = referenceListItems(options);
+        const cursor = queryString(query.cursor);
+        const page = pageByOffset(items, {
+            endpoint: "references",
+            ...(cursor === undefined ? {} : { cursor }),
+            limit,
+        });
+        request.log.info({
+            stage: "local_reference_list",
+            invocation_ref: invocation.reference_invocation_ref,
+            source_count: page.items.length,
+            elapsed_ms: Math.round(performance.now() - started),
+        }, "Local References listed; remote freshness not checked");
+        return {
+            items: page.items,
+            page: {
+                ...(page.page.next_cursor === undefined ? {} : { next_cursor: page.page.next_cursor }),
+                limit: page.page.limit,
+            },
+        };
+    });
+    app.get(`${AGENT_CONTEXT_BASE_PATH}/references/file`, (request) => {
+        const invocation = authorizeAgentContextRequest(request, options, "references:read");
+        const started = performance.now();
+        const diagnosticFields = {
+            invocation_ref: invocation.reference_invocation_ref,
+            action: "read",
+        };
+        request.log.info({ ...diagnosticFields, stage: "local_reference_request" }, "Local Reference request started");
+        const path = queryString(request.query.path);
+        if (path === undefined || path.trim() === "") {
+            throw new AgentContextBadRequestError("Reference path is required");
+        }
+        const maxBytes = Math.min(boundedLimit(request.query.max_bytes, {
+            default: REFERENCE_FILE_DEFAULT_MAX_BYTES,
+            max: REFERENCE_FILE_MAX_BYTES,
+        }), VIEWER_HARD_READ_LIMIT_BYTES);
+        try {
+            const file = readViewerFile({
+                workspaceRoot: requireWorkspaceRoot(options),
+                path,
+                maxBytes,
+                ...(options.now === undefined ? {} : { now: options.now }),
+            });
+            const summary = referenceSummaryProjectionForEntry({
+                entry: file.file,
+                summaries: readReferenceSummaryIndex({ workspaceRoot: requireWorkspaceRoot(options) }),
+            });
+            const provenance = localReferenceProvenance(file.file.path, managedReferencePaths(options));
+            request.log.info({
+                ...diagnosticFields,
+                stage: "local_reference_read",
+                ...provenance,
+                result_kind: file.content.kind,
+                elapsed_ms: Math.round(performance.now() - started),
+            }, "Local Reference read; remote freshness not checked");
+            if (file.content.kind !== "text") {
+                return {
+                    kind: "unavailable",
+                    path,
+                    reason: file.content.reason,
+                    summary,
+                    provenance,
+                };
+            }
+            return {
+                kind: "text",
+                path: file.file.path,
+                name: file.file.name,
+                summary,
+                provenance,
+                text: redactText(file.content.text),
+                truncated: file.content.truncated,
+                bytes_read: file.content.bytes_returned,
+            };
+        }
+        catch (error) {
+            request.log.warn({
+                ...diagnosticFields,
+                stage: "local_reference_unavailable",
+                reason_code: error instanceof WorkspaceOpsError ? error.code : "reference_read_unavailable",
+                elapsed_ms: Math.round(performance.now() - started),
+            }, "Local Reference read unavailable");
+            if (error instanceof WorkspaceOpsError) {
+                return {
+                    kind: "unavailable",
+                    path,
+                    reason: mapReferenceUnavailableReason(error),
+                };
+            }
+            throw error;
+        }
+    });
+}
+//# sourceMappingURL=agent-context-reference-routes.js.map

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

@@ -0,0 +1,32 @@
+import { WorkspaceOpsError } from "../../../workspace-ops/index.js";
+import type { HostProjectStore } from "../../../store/index.js";
+type AgentContextWorkspaceOptions = {
+    store?: HostProjectStore;
+    workspaceOps?: {
+        workspaceRoot: string;
+    };
+    now?: () => Date;
+};
+export declare function localReferenceProvenance(path: string, managedPaths: ReadonlySet<string>): {
+    origin: "local_reference" | "managed_snapshot";
+    verification: "local_only";
+};
+export declare function managedReferencePaths(options: AgentContextWorkspaceOptions): ReadonlySet<string>;
+export declare function mapReferenceUnavailableReason(error: WorkspaceOpsError): string;
+export declare function referenceListItems(options: AgentContextWorkspaceOptions): {
+    can_read_text: boolean;
+    blocked_reason?: string;
+    summary: import("../../../workspace-ops/types.js").ReferenceSummaryProjection;
+    provenance: {
+        origin: "local_reference" | "managed_snapshot";
+        verification: "local_only";
+    };
+    extension?: string;
+    media_type?: string;
+    path: string;
+    name: string;
+    category: import("../../../workspace-ops/types.js").ReferenceFileCategory;
+    size_bytes: number;
+}[];
+export {};
+//# sourceMappingURL=agent-context-references.d.ts.map

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

@@ -0,0 +1,93 @@
+import { REFERENCE_INDEX_PATH, WorkspaceOpsError, readReferenceFileEntries, readReferenceSummaryIndex, readViewerFile, referenceFileCategoryForPath, referenceMediaTypeForPath, referenceSummaryProjectionForEntry, } from "../../../workspace-ops/index.js";
+import { AgentContextBadRequestError } from "./agent-context-errors.js";
+import { readManagedReferenceSourcePaths } from "../../../collaboration-ingestion/index.js";
+export function localReferenceProvenance(path, managedPaths) {
+    return {
+        origin: managedPaths.has(path) ? "managed_snapshot" : "local_reference",
+        verification: "local_only",
+    };
+}
+export function managedReferencePaths(options) {
+    return options.store === undefined
+        ? new Set()
+        : readManagedReferenceSourcePaths(options.store.db);
+}
+function requireWorkspaceRoot(options) {
+    if (options.workspaceOps === undefined) {
+        throw new AgentContextBadRequestError("Workspace viewer is unavailable");
+    }
+    return options.workspaceOps.workspaceRoot;
+}
+export function mapReferenceUnavailableReason(error) {
+    if (error.code === "not_found") {
+        return "not_found";
+    }
+    if (error.code === "forbidden") {
+        const reasonCode = typeof error.details?.reason_code === "string"
+            ? error.details.reason_code
+            : undefined;
+        return reasonCode === "secret_like_path" ? "secret_like" : "restricted_path";
+    }
+    if (error.code === "validation_failed") {
+        return "restricted_path";
+    }
+    throw error;
+}
+export function referenceListItems(options) {
+    const workspaceRoot = requireWorkspaceRoot(options);
+    const summaries = readReferenceSummaryIndex({ workspaceRoot });
+    const managedPaths = managedReferencePaths(options);
+    return referenceEntries(options).map((entry) => {
+        const category = referenceFileCategoryForPath(entry.path) ?? "file";
+        const mediaType = referenceMediaTypeForPath(entry.path);
+        const read = canReadReferenceText(options, entry.path);
+        const summary = referenceSummaryProjectionForEntry({ entry, summaries });
+        return {
+            path: entry.path,
+            name: entry.name,
+            category,
+            size_bytes: entry.size_bytes ?? 0,
+            ...(mediaType === undefined ? {} : { media_type: mediaType }),
+            ...(entry.extension === undefined ? {} : { extension: entry.extension }),
+            summary,
+            provenance: localReferenceProvenance(entry.path, managedPaths),
+            ...read,
+        };
+    });
+}
+function unavailableReasonForContent(content) {
+    return content.kind === "text" ? undefined : content.reason;
+}
+function referenceEntries(options) {
+    const workspaceRoot = requireWorkspaceRoot(options);
+    try {
+        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") {
+            return [];
+        }
+        throw error;
+    }
+}
+function canReadReferenceText(options, path) {
+    try {
+        const file = readViewerFile({
+            workspaceRoot: requireWorkspaceRoot(options),
+            path,
+            maxBytes: 1,
+            ...(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 };
+    }
+    catch {
+        return { can_read_text: false, blocked_reason: "restricted_path" };
+    }
+}
+//# sourceMappingURL=agent-context-references.js.map

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

@@ -0,0 +1,37 @@
+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;
+export declare const MESSAGE_BODY_MAX_CHARS = 6000;
+export declare const PROJECT_DOC_FILE_DEFAULT_MAX_BYTES = 131072;
+export declare const PROJECT_DOC_FILE_MAX_BYTES = 524288;
+export declare const SCRATCHPAD_TOPIC_MAX_CHARS = 500;
+export declare const SCRATCHPAD_BACKGROUND_MAX_CHARS = 8000;
+export declare const SCRATCHPAD_ARRAY_ITEM_MAX_CHARS = 2000;
+export declare const SCRATCHPAD_ARRAY_MAX_ITEMS = 50;
+export declare const WORKLIST_LIMIT_DEFAULT = 100;
+export declare const WORKLIST_LIMIT_MAX = 200;
+export declare const WORKLIST_TITLE_MAX_CHARS = 500;
+export declare const WORKLIST_SUMMARY_MAX_CHARS = 2000;
+export declare const TASK_CONTRACT_ITEM_MAX_CHARS = 2000;
+export declare const TASK_RESULT_SUMMARY_MAX_CHARS = 4000;
+export declare const REFERENCES_LIMIT_DEFAULT = 100;
+export declare const REFERENCES_LIMIT_MAX = 500;
+export declare const REFERENCE_FILE_DEFAULT_MAX_BYTES = 131072;
+export declare const REFERENCE_FILE_MAX_BYTES = 524288;
+export declare const USER_SKILLS_LIMIT_DEFAULT = 100;
+export declare const USER_SKILLS_LIMIT_MAX = 500;
+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;
+export declare function requireTuttiHome(options: AgentContextRouteOptions): string;
+export declare function requireProjectUserSkillsRoot(options: AgentContextRouteOptions): string;
+//# sourceMappingURL=agent-context-shared.d.ts.map

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

@@ -0,0 +1,48 @@
+import { getProjectUserSkillsRoot } from "../../../skills/index.js";
+import { AgentContextBadRequestError } from "./agent-context-errors.js";
+export const AGENT_CONTEXT_BASE_PATH = "/internal/agent-context";
+export const MESSAGE_LIMIT_DEFAULT = 50;
+export const MESSAGE_LIMIT_MAX = 100;
+export const MESSAGE_BODY_MAX_CHARS = 6_000;
+export const PROJECT_DOC_FILE_DEFAULT_MAX_BYTES = 131_072;
+export const PROJECT_DOC_FILE_MAX_BYTES = 524_288;
+export const SCRATCHPAD_TOPIC_MAX_CHARS = 500;
+export const SCRATCHPAD_BACKGROUND_MAX_CHARS = 8_000;
+export const SCRATCHPAD_ARRAY_ITEM_MAX_CHARS = 2_000;
+export const SCRATCHPAD_ARRAY_MAX_ITEMS = 50;
+export const WORKLIST_LIMIT_DEFAULT = 100;
+export const WORKLIST_LIMIT_MAX = 200;
+export const WORKLIST_TITLE_MAX_CHARS = 500;
+export const WORKLIST_SUMMARY_MAX_CHARS = 2_000;
+export const TASK_CONTRACT_ITEM_MAX_CHARS = 2_000;
+export const TASK_RESULT_SUMMARY_MAX_CHARS = 4_000;
+export const REFERENCES_LIMIT_DEFAULT = 100;
+export const REFERENCES_LIMIT_MAX = 500;
+export const REFERENCE_FILE_DEFAULT_MAX_BYTES = 131_072;
+export const REFERENCE_FILE_MAX_BYTES = 524_288;
+export const USER_SKILLS_LIMIT_DEFAULT = 100;
+export const USER_SKILLS_LIMIT_MAX = 500;
+export const USER_SKILL_MD_DEFAULT_MAX_CHARS = 20_000;
+export const USER_SKILL_MD_MAX_CHARS = 100_000;
+export function requireProjectStore(options) {
+    if (options.store === undefined) {
+        throw new AgentContextBadRequestError("Project store is unavailable");
+    }
+    return options.store;
+}
+export function requireWorkspaceRoot(options) {
+    if (options.workspaceOps === undefined) {
+        throw new AgentContextBadRequestError("Workspace viewer is unavailable");
+    }
+    return options.workspaceOps.workspaceRoot;
+}
+export function requireTuttiHome(options) {
+    if (options.tuttiHome === undefined) {
+        throw new AgentContextBadRequestError("User skills are unavailable");
+    }
+    return options.tuttiHome;
+}
+export function requireProjectUserSkillsRoot(options) {
+    return getProjectUserSkillsRoot(requireTuttiHome(options), options.project.project_id);
+}
+//# sourceMappingURL=agent-context-shared.js.map

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

@@ -0,0 +1,4 @@
+import type { FastifyInstance } from "fastify";
+import { type AgentContextRouteOptions } from "./agent-context-shared.js";
+export declare function registerAgentContextSkillRoutes(app: FastifyInstance, options: AgentContextRouteOptions): void;
+//# sourceMappingURL=agent-context-skills-routes.d.ts.map

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

@@ -0,0 +1,86 @@
+import { redactText } from "@tutti/shared/utils";
+import { listUserSkills, readUserSkill, SkillServiceError } from "../../../skills/index.js";
+import { authorizeAgentContextRequest } from "./agent-context-auth.js";
+import { AgentContextBadRequestError } from "./agent-context-errors.js";
+import { boundedLimit, pageByOffset, queryString, truncateText } from "./agent-context-query.js";
+import { AGENT_CONTEXT_BASE_PATH, USER_SKILLS_LIMIT_DEFAULT, USER_SKILLS_LIMIT_MAX, USER_SKILL_MD_DEFAULT_MAX_CHARS, USER_SKILL_MD_MAX_CHARS, requireProjectUserSkillsRoot, } from "./agent-context-shared.js";
+function skillUnavailable(input) {
+    return {
+        kind: "unavailable",
+        skill_name: input.skillName,
+        reason: input.reason,
+    };
+}
+function handleSkillReadError(error, skillName) {
+    if (!(error instanceof SkillServiceError)) {
+        throw error;
+    }
+    switch (error.code) {
+        case "invalid_skill_name":
+            throw new AgentContextBadRequestError("Skill name is invalid");
+        case "skill_not_found":
+            return skillUnavailable({ skillName, reason: "not_found" });
+        case "validation_failed":
+            return skillUnavailable({ skillName, reason: "invalid" });
+        case "filesystem_error":
+        case "read_limit_exceeded":
+            return skillUnavailable({ skillName, reason: "unavailable" });
+        case "invalid_zip":
+            return skillUnavailable({ skillName, reason: "invalid" });
+    }
+    throw error;
+}
+export function registerAgentContextSkillRoutes(app, options) {
+    app.get(`${AGENT_CONTEXT_BASE_PATH}/skills`, (request) => {
+        authorizeAgentContextRequest(request, options, "skills:list");
+        const limit = boundedLimit(request.query.limit, {
+            default: USER_SKILLS_LIMIT_DEFAULT,
+            max: USER_SKILLS_LIMIT_MAX,
+        });
+        const cursor = queryString(request.query.cursor);
+        const page = pageByOffset(listUserSkills(requireProjectUserSkillsRoot(options)), {
+            endpoint: "skills",
+            ...(cursor === undefined ? {} : { cursor }),
+            limit,
+        });
+        return {
+            items: page.items,
+            page: {
+                ...(page.page.next_cursor === undefined ? {} : { next_cursor: page.page.next_cursor }),
+                limit: page.page.limit,
+                has_more: page.page.has_more,
+            },
+        };
+    });
+    app.get(`${AGENT_CONTEXT_BASE_PATH}/skills/:skillName`, (request) => {
+        authorizeAgentContextRequest(request, options, "skills:read");
+        const maxChars = boundedLimit(request.query.max_chars, {
+            default: USER_SKILL_MD_DEFAULT_MAX_CHARS,
+            max: USER_SKILL_MD_MAX_CHARS,
+        });
+        const skillName = request.params.skillName;
+        try {
+            const skill = readUserSkill(requireProjectUserSkillsRoot(options), skillName);
+            const skillMd = truncateText(redactText(skill.skill_md), maxChars);
+            return {
+                kind: "skill",
+                skill: {
+                    name: skill.name,
+                    description: skill.description,
+                    ...(skill.short_description === undefined
+                        ? {}
+                        : { short_description: skill.short_description }),
+                    enabled: skill.enabled,
+                    source: skill.source,
+                    ...(skill.updated_at === undefined ? {} : { updated_at: skill.updated_at }),
+                },
+                skill_md: skillMd.text,
+                skill_md_truncated: skillMd.truncated,
+            };
+        }
+        catch (error) {
+            return handleSkillReadError(error, skillName);
+        }
+    });
+}
+//# sourceMappingURL=agent-context-skills-routes.js.map

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

@@ -0,0 +1,4 @@
+import type { FastifyInstance } from "fastify";
+import { type AgentContextRouteOptions } from "./agent-context-shared.js";
+export declare function registerAgentContextWorkspaceRoutes(app: FastifyInstance, options: AgentContextRouteOptions): void;
+//# sourceMappingURL=agent-context-workspace-routes.d.ts.map

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

@@ -0,0 +1,130 @@
+import { readScratchpadProjection, readTaskDetailProjection, readTaskRunResultsPage, readWorklistProjection, } from "../../../collaboration-state/index.js";
+import { authorizeAgentContextRequest } from "./agent-context-auth.js";
+import { AgentContextBadRequestError } from "./agent-context-errors.js";
+import { boundedLimit, pageByOffset, queryString, truncateArray, truncateText, } from "./agent-context-query.js";
+import { AGENT_CONTEXT_BASE_PATH, SCRATCHPAD_ARRAY_ITEM_MAX_CHARS, SCRATCHPAD_ARRAY_MAX_ITEMS, SCRATCHPAD_BACKGROUND_MAX_CHARS, SCRATCHPAD_TOPIC_MAX_CHARS, TASK_CONTRACT_ITEM_MAX_CHARS, TASK_RESULT_SUMMARY_MAX_CHARS, WORKLIST_LIMIT_DEFAULT, WORKLIST_LIMIT_MAX, WORKLIST_SUMMARY_MAX_CHARS, WORKLIST_TITLE_MAX_CHARS, requireProjectStore, } from "./agent-context-shared.js";
+export function registerAgentContextWorkspaceRoutes(app, options) {
+    app.get(`${AGENT_CONTEXT_BASE_PATH}/scratchpad`, (request) => {
+        authorizeAgentContextRequest(request, options, "scratchpad:read");
+        const scratchpad = readScratchpadProjection(requireProjectStore(options).db);
+        const topic = truncateText(scratchpad.topic, SCRATCHPAD_TOPIC_MAX_CHARS);
+        const background = truncateText(scratchpad.background_summary, SCRATCHPAD_BACKGROUND_MAX_CHARS);
+        const consensus = truncateArray(scratchpad.current_consensus, SCRATCHPAD_ARRAY_MAX_ITEMS, SCRATCHPAD_ARRAY_ITEM_MAX_CHARS);
+        const questions = truncateArray(scratchpad.open_questions, SCRATCHPAD_ARRAY_MAX_ITEMS, SCRATCHPAD_ARRAY_ITEM_MAX_CHARS);
+        const taskChanges = truncateArray(scratchpad.task_changes, SCRATCHPAD_ARRAY_MAX_ITEMS, SCRATCHPAD_ARRAY_ITEM_MAX_CHARS);
+        return {
+            state: scratchpad.state,
+            ...(scratchpad.updated_at === undefined ? {} : { updated_at: scratchpad.updated_at }),
+            topic: topic.text,
+            topic_truncated: topic.truncated,
+            background_summary: background.text,
+            background_summary_truncated: background.truncated,
+            current_consensus: consensus.items,
+            current_consensus_truncated: consensus.truncated,
+            open_questions: questions.items,
+            open_questions_truncated: questions.truncated,
+            task_changes: taskChanges.items,
+            task_changes_truncated: taskChanges.truncated,
+        };
+    });
+    app.get(`${AGENT_CONTEXT_BASE_PATH}/worklist`, (request) => {
+        authorizeAgentContextRequest(request, options, "worklist:read");
+        const query = request.query;
+        const limit = boundedLimit(query.limit, {
+            default: WORKLIST_LIMIT_DEFAULT,
+            max: WORKLIST_LIMIT_MAX,
+        });
+        const worklist = readWorklistProjection(requireProjectStore(options).db);
+        const items = worklist.modules.flatMap((moduleEntry) => moduleEntry.tasks.map((task) => {
+            const title = truncateText(task.title, WORKLIST_TITLE_MAX_CHARS);
+            const summary = truncateText(task.summary, WORKLIST_SUMMARY_MAX_CHARS);
+            const moduleSummary = truncateText(moduleEntry.module.summary, WORKLIST_SUMMARY_MAX_CHARS);
+            return {
+                module: {
+                    module_id: moduleEntry.module.id,
+                    name: moduleEntry.module.name,
+                    ...(moduleEntry.module.summary === undefined
+                        ? {}
+                        : {
+                            summary: moduleSummary.text,
+                            summary_truncated: moduleSummary.truncated,
+                        }),
+                },
+                task: {
+                    task_id: task.id,
+                    title: title.text,
+                    title_truncated: title.truncated,
+                    status: task.status,
+                    summary: summary.text,
+                    summary_truncated: summary.truncated,
+                    updated_at: task.updated_at,
+                },
+            };
+        }));
+        const cursor = queryString(query.cursor);
+        return pageByOffset(items, {
+            endpoint: "worklist",
+            ...(cursor === undefined ? {} : { cursor }),
+            limit,
+        });
+    });
+    app.get(`${AGENT_CONTEXT_BASE_PATH}/tasks/:taskId`, (request) => {
+        authorizeAgentContextRequest(request, options, "task:read");
+        const taskId = request.params.taskId;
+        const detail = readTaskDetailProjection(requireProjectStore(options).db, taskId);
+        if (detail === null) {
+            throw new AgentContextBadRequestError("Task was not found");
+        }
+        const worklist = readWorklistProjection(requireProjectStore(options).db);
+        const module = worklist.modules.find((entry) => entry.module.id === detail.task.module_id);
+        const title = truncateText(detail.task.title, WORKLIST_TITLE_MAX_CHARS);
+        const moduleSummary = truncateText(module?.module.summary, WORKLIST_SUMMARY_MAX_CHARS);
+        const contract = detail.detail.contract;
+        const goal = truncateText(contract.goal, TASK_CONTRACT_ITEM_MAX_CHARS);
+        const scope = truncateArray(contract.scope, 100, TASK_CONTRACT_ITEM_MAX_CHARS);
+        const latestResultSummary = truncateText(detail.detail.result.summary, TASK_RESULT_SUMMARY_MAX_CHARS);
+        const latestRunPage = readTaskRunResultsPage(requireProjectStore(options).db, taskId, {
+            limit: 1,
+        });
+        const latestRun = latestRunPage?.items[0];
+        return {
+            task_id: detail.task.id,
+            title: title.text,
+            title_truncated: title.truncated,
+            status: detail.task.status,
+            module: {
+                module_id: detail.task.module_id,
+                name: module?.module.name ?? "Unassigned",
+                ...(module?.module.summary === undefined
+                    ? {}
+                    : {
+                        summary: moduleSummary.text,
+                        summary_truncated: moduleSummary.truncated,
+                    }),
+            },
+            contract: {
+                goal: goal.text,
+                goal_truncated: goal.truncated,
+                scope: scope.items,
+                scope_truncated: scope.truncated,
+            },
+            ...(detail.detail.result.summary === undefined && latestRun === undefined
+                ? {}
+                : {
+                    latest_result: {
+                        conclusion: detail.detail.result.result_kind ?? latestRun?.result_kind ?? "unknown",
+                        summary: detail.detail.result.summary === undefined
+                            ? truncateText(latestRun?.summary, TASK_RESULT_SUMMARY_MAX_CHARS).text
+                            : latestResultSummary.text,
+                        summary_truncated: detail.detail.result.summary === undefined
+                            ? truncateText(latestRun?.summary, TASK_RESULT_SUMMARY_MAX_CHARS).truncated
+                            : latestResultSummary.truncated,
+                        ...(latestRun?.created_at === undefined
+                            ? {}
+                            : { completed_at: latestRun.created_at }),
+                    },
+                }),
+        };
+    });
+}
+//# sourceMappingURL=agent-context-workspace-routes.js.map

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

@@ -0,0 +1,8 @@
+import type { FastifyInstance } from "fastify";
+import { AGENT_CONTEXT_BASE_PATH, type AgentContextRouteOptions } from "./agent-context-shared.js";
+export { DEFAULT_AGENT_CONTEXT_TOKEN_TTL_MS, AgentContextTokenRegistry, } from "./agent-context-auth.js";
+export type { AgentContextTokenRecord } from "./agent-context-auth.js";
+export { AGENT_CONTEXT_BASE_PATH };
+export type { AgentContextRouteOptions };
+export declare function registerAgentContextRoutes(app: FastifyInstance, options: AgentContextRouteOptions): void;
+//# sourceMappingURL=agent-context.d.ts.map

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

@@ -0,0 +1,18 @@
+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 { 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 };
+export function registerAgentContextRoutes(app, options) {
+    registerAgentContextMessageRoutes(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/health.d.ts

@@ -0,0 +1,11 @@
+import type { FastifyInstance } from "fastify";
+export type HostHealthRouteOptions = {
+    readiness?: {
+        relay?: () => "not_connected" | "connected";
+        store?: () => "not_configured" | "ready";
+    };
+    now: () => Date;
+    serviceVersion: string;
+};
+export declare function registerHostHealthRoute(app: FastifyInstance, options: HostHealthRouteOptions): void;
+//# sourceMappingURL=health.d.ts.map

package/dist/server-shell/http/routes/health.js

@@ -0,0 +1,41 @@
+const HostHealthResponseSchema = {
+    type: "object",
+    required: ["service", "status", "version", "time", "readiness"],
+    additionalProperties: false,
+    properties: {
+        service: { type: "string" },
+        status: { type: "string", enum: ["ok"] },
+        version: { type: "string" },
+        time: { type: "string" },
+        readiness: {
+            type: "object",
+            required: ["api", "store", "relay"],
+            additionalProperties: false,
+            properties: {
+                api: { type: "string", enum: ["ready"] },
+                store: { type: "string", enum: ["not_configured", "ready"] },
+                relay: { type: "string", enum: ["not_connected", "connected"] },
+            },
+        },
+    },
+};
+export function registerHostHealthRoute(app, options) {
+    app.get("/health", {
+        schema: {
+            response: {
+                200: HostHealthResponseSchema,
+            },
+        },
+    }, () => ({
+        service: "tutti-host",
+        status: "ok",
+        version: options.serviceVersion,
+        time: options.now().toISOString(),
+        readiness: {
+            api: "ready",
+            store: options.readiness?.store?.() ?? "not_configured",
+            relay: options.readiness?.relay?.() ?? "not_connected",
+        },
+    }));
+}
+//# sourceMappingURL=health.js.map