@xfey/tutti 0.1.96 → 0.1.98

package/dist/control-plane/task-compile-start.js

@@ -1,11 +1,13 @@
 import { createWorkflowInvocationRef, } from "@tutti/shared/ids";
-import { captureTaskCompileContext, readActiveTaskCompileContext, readCurrentScratchpadSourceRefs, readScratchpadProjection, readWorklistProjection, rollbackTaskCompileContext, } from "../collaboration-state/index.js";
+import { captureTaskCompileContext, readActiveTaskCompileContext, readCurrentScratchpadSourceRefs, readPendingTaskCompileSubmission, readScratchpadProjection, readScratchpadSourceState, readWorklistProjection, recordTaskCompileSubmission, rollbackTaskCompileContext, } from "../collaboration-state/index.js";
+import { withHostStoreTransaction } from "../store/index.js";
 import { initializeProjectDocs, readProjectDocsInitializationStatus, } from "../workspace-ops/index.js";
 import { logProcedureExecutionError } from "./procedure-logging.js";
 import { projectBriefShouldRefreshForUpdatedPaths, refreshProjectBriefProjection, } from "./project-brief-refresh.js";
 import { applyProjectDocsInitializationResult, buildProjectDocsInitializationContext, tryProjectContextBootstrapDocuments, } from "./project-context-bootstrap.js";
 import { readActiveScratchpadRefreshActivityRef, readControlPlaneScratchpadSourceBatch, runControlPlaneScratchpadRefreshProcedure, } from "./scratchpad-refresh-start.js";
 import { applyTaskCompileProcedureOutput } from "./task-compile-output.js";
+import { enqueueControlPlaneIntent } from "./dispatch-intents.js";
 import { materializePromptSourceMessages } from "./task-source-context.js";
 import { materializeRecentReferences, readPendingRecentReferenceSummaryPaths, readRecentReferenceSources, } from "./recent-references.js";
 import { startReferenceSummaryRefreshProcedure } from "./reference-summary-refresh.js";
@@ -19,6 +21,15 @@ export function startControlPlaneTaskCompile(options) {
             },
         };
     }
+    const pendingSubmission = readPendingTaskCompileSubmission(options.store.db);
+    if (pendingSubmission !== null) {
+        return {
+            disposition: {
+                kind: "already_running",
+                activity_ref: pendingSubmission.accepted_activity_ref,
+            },
+        };
+    }
     const scratchpad = readScratchpadProjection(options.store.db);
     if (options.payload.expected_scratchpad_updated_at !== undefined &&
         options.payload.expected_scratchpad_updated_at !== scratchpad.updated_at) {
@@ -43,7 +54,10 @@ export function startControlPlaneTaskCompile(options) {
         };
     }
     const taskCompileWorkflowRef = createWorkflowInvocationRef();
-    const sourceBatch = readControlPlaneScratchpadSourceBatch(options.store);
+    const sourceBatch = readControlPlaneScratchpadSourceBatch(options.store, {
+        ...(options.projectContext === undefined ? {} : { projectContext: options.projectContext }),
+        now: options.now,
+    });
     if (sourceBatch.source_message_count > 0) {
         const activeScratchpadRefresh = readActiveScratchpadRefreshActivityRef({
             engine: options.engine,
@@ -62,22 +76,70 @@ export function startControlPlaneTaskCompile(options) {
             runner: runnerResolution.runner,
             sourceBatch,
             taskCompileWorkflowRef,
+            recordRecoveryIntent: false,
+            onAccepted: (activityRef) => recordTaskCompileSubmissionIntent({
+                store: options.store,
+                workflowRef: taskCompileWorkflowRef,
+                acceptedActivityRef: activityRef,
+                sourceBatch,
+                now: options.now,
+            }),
         });
     }
     if (!scratchpadHasSubmittableContent(scratchpad)) {
         return { disposition: { kind: "scratchpad_empty" } };
     }
-    return startReferenceSummaryGateOrNextStage({
+    const started = startReferenceSummaryGateOrNextStage({
         ...options,
         runner: runnerResolution.runner,
         taskCompileWorkflowRef,
     });
+    if (started.disposition.kind === "accepted") {
+        const activityRef = started.result?.activity_ref;
+        if (activityRef === undefined) {
+            throw new Error("Accepted Task Compile chain is missing activity identity");
+        }
+        recordTaskCompileSubmissionIntent({
+            store: options.store,
+            workflowRef: taskCompileWorkflowRef,
+            acceptedActivityRef: activityRef,
+            sourceBatch,
+            now: options.now,
+        });
+    }
+    return started;
+}
+function recordTaskCompileSubmissionIntent(options) {
+    return withHostStoreTransaction(options.store.db, (tx) => {
+        const sourceState = readScratchpadSourceState(tx);
+        const through = options.sourceBatch.cursor_update.refreshed_through_cursor ??
+            sourceState.refreshed_through_cursor;
+        recordTaskCompileSubmission(tx, {
+            workflow_ref: options.workflowRef,
+            accepted_activity_ref: options.acceptedActivityRef,
+            source_window: {
+                ...(sourceState.cycle_start_cursor === undefined
+                    ? {}
+                    : { after: sourceState.cycle_start_cursor }),
+                ...(through === undefined ? {} : { through }),
+            },
+            now: options.now,
+        });
+        return enqueueControlPlaneIntent(tx, {
+            kind: "task_compile_start",
+            ownerKind: "task_compile",
+            ownerRef: options.workflowRef,
+            dedupeKey: `task_compile_start:${options.workflowRef}`,
+            lane: "foreground",
+            priority: 30,
+            now: options.now,
+        }).intent.intent_id;
+    });
 }
 function startControlPlaneTaskCompileActivity(options) {
     const activeContext = readActiveTaskCompileContext(options.store.db, options.taskCompileWorkflowRef);
     const scratchpad = readScratchpadProjection(options.store.db);
-    if (activeContext === null &&
-        !scratchpadHasSubmittableContent(scratchpad)) {
+    if (activeContext === null && !scratchpadHasSubmittableContent(scratchpad)) {
         return { disposition: { kind: "scratchpad_empty" } };
     }
     const workflowRef = options.taskCompileWorkflowRef;
@@ -88,7 +150,14 @@ function startControlPlaneTaskCompileActivity(options) {
         title: "Compile Worklist",
         summary: "Compiling Scratchpad into Worklist tasks.",
         now: options.now,
-        onTransition: options.publishProcedureTransition,
+        onTransition: (state) => {
+            options.publishProcedureTransition(state);
+            if (state.transition_kind === "terminal") {
+                options.onChainTerminal?.(state.activity.status === "failed"
+                    ? { state: "failed", errorCode: "procedure_failed" }
+                    : undefined);
+            }
+        },
         onError: ({ context, error }) => logProcedureExecutionError({
             logger: options.logger,
             workflowKind: "task_compile",
@@ -126,6 +195,7 @@ function startControlPlaneTaskCompileActivity(options) {
 }
 function startScratchpadRefreshBeforeTaskCompileActivity(options) {
     const workflowRef = createWorkflowInvocationRef();
+    let recoveryIntentId = options.recoveryIntentId;
     const start = options.engine.startProcedure({
         workflow_ref: workflowRef,
         workflow_kind: "scratchpad_refresh",
@@ -135,7 +205,14 @@ function startScratchpadRefreshBeforeTaskCompileActivity(options) {
         now: options.now,
         onTransition: (state) => {
             options.publishProcedureTransition(state);
-            if (state.transition_kind !== "terminal" || state.activity.status !== "finished") {
+            if (state.transition_kind !== "terminal") {
+                return;
+            }
+            if (state.activity.status !== "finished") {
+                options.onChainTerminal?.({
+                    state: "failed",
+                    errorCode: "scratchpad_refresh_failed",
+                });
                 return;
             }
             if (options.shouldContinue?.() === false) {
@@ -143,9 +220,19 @@ function startScratchpadRefreshBeforeTaskCompileActivity(options) {
             }
             const scratchpad = readScratchpadProjection(options.store.db);
             if (!scratchpadHasSubmittableContent(scratchpad)) {
+                options.onChainTerminal?.({
+                    state: "failed",
+                    errorCode: "scratchpad_empty_after_refresh",
+                });
                 return;
             }
-            void startReferenceSummaryGateOrNextStage(options);
+            const next = startReferenceSummaryGateOrNextStage(options);
+            if (next.disposition.kind !== "accepted" && next.disposition.kind !== "already_running") {
+                options.onChainTerminal?.({
+                    state: "failed",
+                    errorCode: "task_compile_stage_unavailable",
+                });
+            }
         },
         onError: ({ context, error }) => logProcedureExecutionError({
             logger: options.logger,
@@ -161,6 +248,11 @@ function startScratchpadRefreshBeforeTaskCompileActivity(options) {
             workflowRef,
             activityRef: context.activity_ref,
             sourceBatch: options.sourceBatch,
+            lane: "foreground",
+            ...(options.recordRecoveryIntent === undefined
+                ? {}
+                : { recordRecoveryIntent: options.recordRecoveryIntent }),
+            ...(recoveryIntentId === undefined ? {} : { recoveryIntentId }),
             now: options.now,
         }),
     });
@@ -172,6 +264,8 @@ function startScratchpadRefreshBeforeTaskCompileActivity(options) {
             },
         };
     }
+    recoveryIntentId =
+        options.onAccepted?.(start.activity.activity_ref) ?? recoveryIntentId;
     return {
         disposition: { kind: "accepted" },
         result: {
@@ -180,6 +274,116 @@ function startScratchpadRefreshBeforeTaskCompileActivity(options) {
         },
     };
 }
+function cursorIncludes(current, required) {
+    if (required === undefined) {
+        return true;
+    }
+    if (current === undefined) {
+        return false;
+    }
+    const timeOrder = current.created_at.localeCompare(required.created_at);
+    return timeOrder > 0 || (timeOrder === 0 && current.message_id >= required.message_id);
+}
+export function resumePendingTaskCompileSubmission(options) {
+    const submission = readPendingTaskCompileSubmission(options.store.db, options.taskCompileWorkflowRef);
+    if (submission === null) {
+        return { kind: "obsolete", errorCode: "task_compile_submission_absent" };
+    }
+    const runnerResolution = options.resolveWorkflowRunner();
+    if (runnerResolution.kind !== "ready") {
+        return {
+            kind: "not_ready",
+            errorCode: runnerResolution.kind === "not_configured"
+                ? "provider_not_configured"
+                : "provider_unavailable",
+        };
+    }
+    const sourceState = readScratchpadSourceState(options.store.db);
+    if (cursorIncludes(sourceState.refreshed_through_cursor, submission.source_window.through)) {
+        const result = startReferenceSummaryGateOrNextStage({
+            ...options,
+            runner: runnerResolution.runner,
+        });
+        if (result.disposition.kind === "accepted") {
+            return { kind: "accepted" };
+        }
+        if (result.disposition.kind === "already_running") {
+            const activityRef = result.disposition.activity_ref;
+            const attached = options.engine
+                .getActiveProcedures()
+                .some((activity) => activity.activity_ref === activityRef &&
+                activity.workflow_kind === "reference_summary_refresh");
+            return attached ? { kind: "accepted" } : { kind: "busy" };
+        }
+        return { kind: "not_ready", errorCode: "task_compile_stage_unavailable" };
+    }
+    if (readActiveScratchpadRefreshActivityRef(options) !== undefined) {
+        return { kind: "busy" };
+    }
+    if (sourceState.backoff_until !== undefined &&
+        sourceState.backoff_until > options.now().toISOString()) {
+        return {
+            kind: "not_ready",
+            errorCode: "scratchpad_refresh_backoff",
+            availableAt: sourceState.backoff_until,
+        };
+    }
+    const sourceBatch = readControlPlaneScratchpadSourceBatch(options.store, {
+        ...(options.projectContext === undefined ? {} : { projectContext: options.projectContext }),
+        sourceWindow: submission.source_window,
+        now: options.now,
+    });
+    if (sourceBatch.source_message_count === 0) {
+        return {
+            kind: "not_ready",
+            errorCode: "task_compile_source_boundary_unavailable",
+        };
+    }
+    const result = startScratchpadRefreshBeforeTaskCompileActivity({
+        ...options,
+        runner: runnerResolution.runner,
+        sourceBatch,
+        taskCompileWorkflowRef: submission.workflow_ref,
+        recordRecoveryIntent: false,
+        recoveryIntentId: options.recoveryIntentId,
+    });
+    return result.disposition.kind === "accepted"
+        ? { kind: "accepted" }
+        : result.disposition.kind === "already_running"
+            ? { kind: "busy" }
+            : { kind: "not_ready", errorCode: "scratchpad_refresh_unavailable" };
+}
+export function resumeControlPlaneTaskCompileChain(options) {
+    if (readActiveTaskCompileContext(options.store.db, options.taskCompileWorkflowRef) === null) {
+        return { kind: "obsolete", errorCode: "task_compile_context_absent" };
+    }
+    const runnerResolution = options.resolveWorkflowRunner();
+    if (runnerResolution.kind !== "ready") {
+        return { kind: "not_ready", errorCode: "workflow_runner_unavailable" };
+    }
+    const result = startReferenceSummaryGateOrNextStage({
+        ...options,
+        runner: runnerResolution.runner,
+    });
+    if (result.disposition.kind === "accepted") {
+        return { kind: "accepted" };
+    }
+    if (result.disposition.kind === "already_running") {
+        const activityRef = result.disposition.activity_ref;
+        const attached = options.engine
+            .getActiveProcedures()
+            .some((activity) => activity.activity_ref === activityRef &&
+            activity.workflow_kind === "reference_summary_refresh");
+        return attached ? { kind: "accepted" } : { kind: "busy" };
+    }
+    if (result.disposition.kind === "provider_not_configured") {
+        return { kind: "not_ready", errorCode: "provider_not_configured" };
+    }
+    if (result.disposition.kind === "provider_unavailable") {
+        return { kind: "not_ready", errorCode: "provider_unavailable" };
+    }
+    return { kind: "not_ready", errorCode: "task_compile_stage_unavailable" };
+}
 function startReferenceSummaryGateOrNextStage(options) {
     const sourceRefs = readActiveTaskCompileContext(options.store.db, options.taskCompileWorkflowRef)?.sources ??
         readCurrentScratchpadSourceRefs(options.store.db);
@@ -194,8 +398,9 @@ function startReferenceSummaryGateOrNextStage(options) {
     if (pendingPaths.length === 0) {
         return startNextTaskCompileStage(options);
     }
-    const activeReferenceSummary = options.engine.getActiveProcedures().find((activity) => activity.lane === "foreground" &&
-        activity.workflow_kind === "reference_summary_refresh");
+    const activeReferenceSummary = options.engine
+        .getActiveProcedures()
+        .find((activity) => activity.lane === "foreground" && activity.workflow_kind === "reference_summary_refresh");
     if (activeReferenceSummary !== undefined) {
         readOrCaptureTaskCompileContext({
             store: options.store,
@@ -218,10 +423,10 @@ function startReferenceSummaryGateOrNextStage(options) {
         paths: pendingPaths,
         resolveWorkflowRunner: () => ({ kind: "ready", runner: options.runner }),
         readActiveActivity: () => {
-            const active = options.engine.getActiveProcedures().find((activity) => activity.lane === "foreground");
-            return active === undefined
-                ? null
-                : { activity_ref: active.activity_ref };
+            const active = options.engine
+                .getActiveProcedures()
+                .find((activity) => activity.lane === "foreground");
+            return active === undefined ? null : { activity_ref: active.activity_ref };
         },
         projectContext: options.projectContext,
         logger: options.logger,
@@ -266,6 +471,7 @@ function registerReferenceSummaryGateWaiter(options, activityRef) {
                 workflow_ref: options.taskCompileWorkflowRef,
                 now: options.now,
             });
+            options.onChainTerminal?.({ state: "failed", errorCode: "reference_summary_failed" });
             return;
         }
         void startReferenceSummaryGateOrNextStage(options);
@@ -301,7 +507,11 @@ function startProjectContextBootstrapActivity(options) {
         now: options.now,
         onTransition: (state) => {
             options.publishProcedureTransition(state);
-            if (state.transition_kind !== "terminal" || state.activity.status !== "finished") {
+            if (state.transition_kind !== "terminal") {
+                return;
+            }
+            if (state.activity.status !== "finished") {
+                options.onChainTerminal?.({ state: "failed", errorCode: "project_context_failed" });
                 return;
             }
             if (options.shouldContinue?.() === false) {
@@ -434,15 +644,11 @@ export async function runControlPlaneTaskCompileProcedure(options) {
             scratchpad: context.scratchpad_snapshot,
             source_messages: materializePromptSourceMessages(options.store.db, context.sources),
             worklist: readWorklistProjection(options.store.db),
-            ...(recentReferences.length === 0
-                ? {}
-                : { recent_references: recentReferences }),
+            ...(recentReferences.length === 0 ? {} : { recent_references: recentReferences }),
         }, {
             workflow_ref: options.workflowRef,
             activity_ref: options.activityRef,
-            ...(options.reportProgress === undefined
-                ? {}
-                : { reportProgress: options.reportProgress }),
+            ...(options.reportProgress === undefined ? {} : { reportProgress: options.reportProgress }),
         });
         return applyTaskCompileProcedureOutput({
             store: options.store,
@@ -463,12 +669,24 @@ export async function runControlPlaneTaskCompileProcedure(options) {
     }
 }
 function readOrCaptureTaskCompileContext(input) {
-    return (readActiveTaskCompileContext(input.store.db, input.workflowRef) ??
-        captureTaskCompileContext(input.store.db, {
-            workflow_ref: input.workflowRef,
-            captured_by_activity_ref: input.activityRef,
+    return withHostStoreTransaction(input.store.db, (tx) => {
+        const context = readActiveTaskCompileContext(tx, input.workflowRef) ??
+            captureTaskCompileContext(tx, {
+                workflow_ref: input.workflowRef,
+                captured_by_activity_ref: input.activityRef,
+                now: input.now,
+            });
+        enqueueControlPlaneIntent(tx, {
+            kind: "task_compile_start",
+            ownerKind: "task_compile",
+            ownerRef: input.workflowRef,
+            dedupeKey: `task_compile_start:${input.workflowRef}`,
+            lane: "foreground",
+            priority: 30,
             now: input.now,
-        }));
+        });
+        return context;
+    });
 }
 function scratchpadHasSubmittableContent(scratchpad) {
     if (scratchpad.state !== "ready") {

package/dist/control-plane/types.d.ts

@@ -52,6 +52,8 @@ export type StartupRecoveryResult = {
     replayed_round_ids: ClarificationRoundRef[];
     interrupted_command_count: number;
     stale_replay_hint_count: number;
+    recovered_task_compile_count: number;
+    recovered_scratchpad_refresh_count: number;
 };
 export type RunDispatchTrigger = "auto_idle" | "task_arrival" | "manual_run_now" | "continuation" | "recovery";
 export type RunDispatchContext = {
@@ -128,7 +130,7 @@ export type RunPipelineStageProgress = {
     summary: string;
     runtime?: ExecutionRuntimeSnapshot;
 };
-export type RunPipelineResult = ({
+export type RunPipelineResult = {
     result_kind: "needs_human";
     summary: string;
     clarification_request_payload: ClarificationRequestPayload;
@@ -152,7 +154,7 @@ export type RunPipelineResult = ({
     retryable: boolean;
     changed_paths?: string[];
     promotion?: NonNullable<TaskDetailProjection["detail"]["result"]["promotion"]>;
-});
+};
 export type RunPipelineRunner = {
     runTask: (input: RunPipelineInput) => Promise<RunPipelineResult>;
 };

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

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

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

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

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

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

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

@@ -1,4 +1,4 @@
-import { REFERENCE_DIRECTORY_PATH, REFERENCE_FILES_DIRECTORY_PATH, REFERENCE_IMAGES_DIRECTORY_PATH, REFERENCE_INDEX_PATH, REFERENCE_TUTTI_DIRECTORY_PATH, VIEWER_HARD_READ_LIMIT_BYTES, WorkspaceOpsError, readViewerFile, readViewerSnapshot, readViewerTree, readReferenceSummaryIndex, referenceFileCategoryForPath, referenceFileSourceForPath, referenceMediaTypeForPath, referenceSummaryProjectionForEntry, } from "../../../../workspace-ops/index.js";
+import { REFERENCE_DIRECTORY_PATH, REFERENCE_FILES_DIRECTORY_PATH, REFERENCE_IMAGES_DIRECTORY_PATH, REFERENCE_INDEX_PATH, VIEWER_HARD_READ_LIMIT_BYTES, WorkspaceOpsError, readReferenceFileEntries, readReferenceSummaryIndex, readViewerFile, readViewerSnapshot, referenceFileCategoryForPath, referenceMediaTypeForPath, referenceSummaryProjectionForEntry, } from "../../../../workspace-ops/index.js";
 import { paginateViewerItems, viewerPageLimit } from "./viewer-projections.js";
 function unreadableReasonForReferenceContent(content) {
     if (content.kind === "text") {
@@ -34,7 +34,6 @@ export function toReferenceFileProjection(options) {
         path: options.entry.path,
         name: options.entry.name,
         category,
-        source: referenceFileSourceForPath(options.entry.path) ?? "human_upload",
         size_bytes: options.entry.size_bytes ?? 0,
         text_read: referenceTextReadProjection(options.workspaceRoot, options.entry, options.now),
         summary: referenceSummaryProjectionForEntry({
@@ -65,7 +64,6 @@ function referenceDirectoryProjection(options) {
             index_path: REFERENCE_INDEX_PATH,
             files_path: REFERENCE_FILES_DIRECTORY_PATH,
             images_path: REFERENCE_IMAGES_DIRECTORY_PATH,
-            tutti_path: REFERENCE_TUTTI_DIRECTORY_PATH,
             index_status: "missing",
         };
     }
@@ -82,7 +80,6 @@ function referenceDirectoryProjection(options) {
                 index_path: REFERENCE_INDEX_PATH,
                 files_path: REFERENCE_FILES_DIRECTORY_PATH,
                 images_path: REFERENCE_IMAGES_DIRECTORY_PATH,
-                tutti_path: REFERENCE_TUTTI_DIRECTORY_PATH,
                 index_status: "available",
             };
         }
@@ -92,7 +89,6 @@ function referenceDirectoryProjection(options) {
             index_path: REFERENCE_INDEX_PATH,
             files_path: REFERENCE_FILES_DIRECTORY_PATH,
             images_path: REFERENCE_IMAGES_DIRECTORY_PATH,
-            tutti_path: REFERENCE_TUTTI_DIRECTORY_PATH,
             index_status: "unreadable",
             index_unreadable_reason: file.content.reason,
         };
@@ -105,7 +101,6 @@ function referenceDirectoryProjection(options) {
                 index_path: REFERENCE_INDEX_PATH,
                 files_path: REFERENCE_FILES_DIRECTORY_PATH,
                 images_path: REFERENCE_IMAGES_DIRECTORY_PATH,
-                tutti_path: REFERENCE_TUTTI_DIRECTORY_PATH,
                 index_status: "missing",
             };
         }
@@ -119,14 +114,9 @@ export function readReferenceFilesResponse(options, query) {
         workspaceRoot,
         ...(now === undefined ? {} : { now }),
     });
-    let tree;
+    let entries;
     try {
-        tree = readViewerTree({
-            workspaceRoot,
-            path: REFERENCE_DIRECTORY_PATH,
-            depth: 3,
-            ...(now === undefined ? {} : { now }),
-        });
+        entries = readReferenceFileEntries({ workspaceRoot });
     }
     catch (error) {
         if (error instanceof WorkspaceOpsError && error.code === "not_found") {
@@ -148,11 +138,10 @@ export function readReferenceFilesResponse(options, query) {
     }
     const includeIndex = query.include_index ?? false;
     const summaryIndex = readReferenceSummaryIndex({ workspaceRoot });
-    const referenceItems = tree.items
-        .filter((entry) => entry.kind === "file")
+    const referenceItems = entries
         .filter((entry) => includeIndex || entry.path !== REFERENCE_INDEX_PATH)
         .filter((entry) => entry.path === REFERENCE_INDEX_PATH ||
-        referenceFileSourceForPath(entry.path) !== undefined)
+        referenceFileCategoryForPath(entry.path) !== undefined)
         .sort((left, right) => {
         const leftCategory = referenceFileCategoryForPath(left.path) ?? "file";
         const rightCategory = referenceFileCategoryForPath(right.path) ?? "file";
@@ -202,7 +191,7 @@ export function referenceFileMessageRef(file) {
     const ref = {
         path: file.path,
         name: file.name,
-        source: file.source,
+        source: "human_upload",
         category: file.category,
         size_bytes: file.size_bytes,
         text_read: file.text_read,

package/dist/workspace-ops/constants.d.ts

@@ -5,7 +5,6 @@ export declare const VIEWER_HARD_READ_LIMIT_BYTES: number;
 export declare const REFERENCE_DIRECTORY_PATH: "docs/reference";
 export declare const REFERENCE_FILES_DIRECTORY_PATH: "docs/reference/files";
 export declare const REFERENCE_IMAGES_DIRECTORY_PATH: "docs/reference/images";
-export declare const REFERENCE_TUTTI_DIRECTORY_PATH: "docs/reference/tutti";
 export declare const REFERENCE_INDEX_PATH: "docs/reference/README.md";
 export declare const MAX_REFERENCE_UPLOAD_BYTES: number;
 export declare const VIEWER_ASSET_READ_LIMIT_BYTES: number;

package/dist/workspace-ops/constants.js

@@ -5,7 +5,6 @@ export const VIEWER_HARD_READ_LIMIT_BYTES = 5 * 1024 * 1024;
 export const REFERENCE_DIRECTORY_PATH = "docs/reference";
 export const REFERENCE_FILES_DIRECTORY_PATH = "docs/reference/files";
 export const REFERENCE_IMAGES_DIRECTORY_PATH = "docs/reference/images";
-export const REFERENCE_TUTTI_DIRECTORY_PATH = "docs/reference/tutti";
 export const REFERENCE_INDEX_PATH = "docs/reference/README.md";
 export const MAX_REFERENCE_UPLOAD_BYTES = 10 * 1024 * 1024;
 export const VIEWER_ASSET_READ_LIMIT_BYTES = MAX_REFERENCE_UPLOAD_BYTES;

package/dist/workspace-ops/index.d.ts

@@ -1,10 +1,11 @@
-export { DEFAULT_VIEWER_MAX_BYTES, MAX_REFERENCE_UPLOAD_BYTES, MAX_VIEWER_MAX_BYTES, PROJECT_DOC_PATHS, REFERENCE_IMAGE_ASSET_CACHE_VERSION, REFERENCE_IMAGE_PREVIEW_MAX_EDGE_PX, REFERENCE_IMAGE_THUMBNAIL_MAX_EDGE_PX, REFERENCE_DIRECTORY_PATH, REFERENCE_FILES_DIRECTORY_PATH, REFERENCE_IMAGES_DIRECTORY_PATH, REFERENCE_INDEX_PATH, REFERENCE_TUTTI_DIRECTORY_PATH, VIEWER_ASSET_READ_LIMIT_BYTES, VIEWER_HARD_READ_LIMIT_BYTES, WORKSPACE_OPS_MAINLINE_BRANCH, } from "./constants.js";
+export { DEFAULT_VIEWER_MAX_BYTES, MAX_REFERENCE_UPLOAD_BYTES, MAX_VIEWER_MAX_BYTES, PROJECT_DOC_PATHS, REFERENCE_IMAGE_ASSET_CACHE_VERSION, REFERENCE_IMAGE_PREVIEW_MAX_EDGE_PX, REFERENCE_IMAGE_THUMBNAIL_MAX_EDGE_PX, REFERENCE_DIRECTORY_PATH, REFERENCE_FILES_DIRECTORY_PATH, REFERENCE_IMAGES_DIRECTORY_PATH, REFERENCE_INDEX_PATH, VIEWER_ASSET_READ_LIMIT_BYTES, VIEWER_HARD_READ_LIMIT_BYTES, WORKSPACE_OPS_MAINLINE_BRANCH, } from "./constants.js";
 export { WorkspaceOpsError } from "./errors.js";
 export { commitOwnedPaths, requireOwnedPathsWriteReady } from "./system-commits.js";
 export { collectProjectSourceDiff, createAcceptedCheckpoint, inspectProjectWorkspace, recoverAcceptedCheckpoint, } from "./project-workspace.js";
 export { initializeProjectDocs, readProjectDocsInitializationStatus, syncProjectDocs, } from "./project-docs.js";
 export { uploadReferenceFile } from "./reference-files.js";
-export { referenceFileCategoryForPath, referenceFileSourceForPath, referenceMediaTypeForPath, referenceTuttiGroupForPath, } from "./reference-metadata.js";
+export { isReferenceFilePath, referenceFileCategoryForPath, referenceFolderGroupForPath, referenceMediaTypeForPath, } from "./reference-metadata.js";
+export { readReferenceFileEntries } from "./reference-tree.js";
 export { readReferenceSummaryEntries, readReferenceSummaryIndex, readReferenceSummaryTargets, referenceSummaryProjectionForEntry, updateReferenceSummaries, } from "./reference-summaries.js";
 export { readViewerAsset, readViewerFile, readViewerSnapshot, readViewerTree } from "./viewer.js";
 export type { WorkspaceOpsErrorCode } from "./errors.js";