@xfey/tutti 0.1.0

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

@@ -0,0 +1,274 @@
+import type { MessageProjection, RunResultProjection, ScratchpadProjection, TaskDetailProjection, WorklistProjection } from "@tutti/shared/schemas/api";
+import type { ClarificationRequestPayload, TaskContractProjection } from "@tutti/shared/schemas/api";
+import type { ProjectDocKey } from "@tutti/shared/schemas/api";
+import type { ActivityRef, ClarificationRoundRef, ClarificationThreadRef, MessageId, TaskId, TaskModuleId, WorkflowInvocationRef } from "@tutti/shared/ids";
+import type { RunLineage } from "@tutti/shared/domain";
+import type { ProjectBriefSnapshot, ProjectBriefSourceDocument } from "../../project-brief/index.js";
+export type ScratchpadRefreshWorkflowInput = {
+    project_brief?: ProjectBriefSnapshot;
+    previous: {
+        topic?: string;
+        background?: string;
+        consensus?: string[];
+        questions?: string[];
+        changes?: string[];
+    };
+    recent_messages: ScratchpadRefreshSourceMessageInput[];
+    new_messages: ScratchpadRefreshSourceMessageInput[];
+};
+export type ScratchpadRefreshSourceMessageInput = {
+    role: "human" | "tutti";
+    author_display_name?: string;
+    text: string;
+    ref?: string;
+};
+export type ScratchpadRefreshWorkflowContext = {
+    workflow_ref: WorkflowInvocationRef;
+    activity_ref: ActivityRef;
+};
+export type ProcedureWorkflowRunContext = {
+    workflow_ref: WorkflowInvocationRef;
+    activity_ref: ActivityRef;
+};
+export type ScratchpadRefreshWorkflowOutput = {
+    decision: "ready";
+    scratchpad_snapshot: {
+        topic: string;
+        background_summary: string;
+        current_consensus: string[];
+        open_questions: string[];
+        task_changes: string[];
+    };
+} | {
+    decision: "needs_human";
+    request_payload: {
+        summary: string;
+        request: string;
+    };
+};
+export type TaskCompileProposal = {
+    modules: TaskCompileProposalModule[];
+    tasks: TaskCompileProposalTask[];
+};
+export type TaskCompileProposalModule = {
+    temp_key: string;
+    name: string;
+};
+export type TaskCompileProposalTask = {
+    module_temp_key?: string;
+    existing_module_key?: TaskModuleId;
+    title: string;
+    summary: string;
+    contract: TaskContractProjection;
+};
+export type TaskCompileWorkflowInput = {
+    workflow_ref: WorkflowInvocationRef;
+    scratchpad: ScratchpadProjection;
+    worklist: WorklistProjection;
+    clarification?: {
+        request_payload: ClarificationRequestPayload;
+        messages: MessageProjection[];
+    };
+};
+export type TaskCompileWorkflowOutput = {
+    decision: "ready";
+    proposal: TaskCompileProposal;
+} | {
+    decision: "needs_human";
+    clarification_request_payload: ClarificationRequestPayload;
+};
+export type TaskCompilePromptInput = {
+    scratchpad: {
+        topic: string;
+        background_summary: string;
+        current_consensus: string[];
+        open_questions: string[];
+        task_changes: string[];
+    };
+    worklist: {
+        modules: Array<{
+            id: TaskModuleId;
+            name: string;
+            summary?: string;
+            archived: boolean;
+            tasks: Array<{
+                title: string;
+                summary: string;
+                status: WorklistProjection["modules"][number]["tasks"][number]["status"];
+            }>;
+        }>;
+    };
+    clarification?: {
+        request: {
+            title?: string;
+            summary: string;
+            request: string;
+        };
+        answer_messages: TaskCompilePromptClarificationMessage[];
+    };
+};
+export type TaskCompilePromptClarificationMessage = {
+    role: "human" | "tutti";
+    author_display_name?: string;
+    text: string;
+};
+export type TaskCompileStructuredOutput = {
+    result: {
+        proposal: TaskCompileStructuredProposal;
+    } | {
+        clarification_request_payload: ClarificationRequestPayload;
+    };
+};
+export type TaskCompileStructuredProposal = {
+    modules: TaskCompileProposalModule[];
+    tasks: TaskCompileStructuredProposalTask[];
+};
+export type TaskCompileStructuredProposalTask = {
+    module_ref: {
+        kind: "new";
+        key: string;
+    } | {
+        kind: "existing";
+        key: TaskModuleId;
+    };
+    title: string;
+    goal: string;
+    scope: string[];
+};
+export type ProjectContextBootstrapWorkflowInput = {
+    project_name: string;
+    missing_docs?: ProjectContextBootstrapMissingDoc[];
+    scratchpad?: {
+        topic: string;
+        background_summary: string;
+        current_consensus: string[];
+        open_questions: string[];
+        task_changes: string[];
+    };
+};
+export type ProjectContextBootstrapMissingDoc = {
+    doc_key: ProjectDocKey;
+    path: string;
+};
+export type ProjectContextBootstrapDocument = {
+    doc_key: ProjectDocKey;
+    content: string;
+};
+export type ProjectContextBootstrapWorkflowOutput = {
+    documents: ProjectContextBootstrapDocument[];
+};
+export type ContextSyncDocumentUpdate = {
+    path: string;
+    content: string;
+};
+export type ContextSyncWorkflowTrigger = {
+    kind: "manual";
+} | {
+    kind: "worklist_all_tasks_completed";
+    completed_task_count: number;
+    module_count: number;
+};
+export type ContextSyncWorkflowInput = {
+    workflow_ref: WorkflowInvocationRef;
+    activity_ref: ActivityRef;
+    trigger: ContextSyncWorkflowTrigger;
+};
+export type ContextSyncWorkflowOutput = {
+    summary: string;
+    updates: ContextSyncDocumentUpdate[];
+};
+export type ProjectBriefRefreshWorkflowInput = {
+    docs: ProjectBriefSourceDocument[];
+};
+export type ProjectBriefRefreshWorkflowOutput = ProjectBriefSnapshot;
+export type ReferenceFileSummaryWorkflowInput = {
+    workflow_ref: WorkflowInvocationRef;
+    activity_ref: ActivityRef;
+    file: {
+        path: string;
+        name: string;
+        category: "file" | "image";
+        size_bytes: number;
+        blob_oid: string;
+        media_type?: string;
+    };
+};
+export type ReferenceFileSummaryWorkflowOutput = {
+    decision: "summarized";
+    summary: string;
+    unavailable_reason: "";
+    read_paths: string[];
+} | {
+    decision: "unavailable";
+    summary: string;
+    unavailable_reason: string;
+    read_paths: string[];
+};
+export type ReferenceFileSummaryStructuredOutput = {
+    result: {
+        summarized: {
+            summary: string;
+        };
+    } | {
+        unavailable: {
+            reason: string;
+        };
+    };
+};
+export type FollowUpCheckWorkflowInput = {
+    workflow_ref: WorkflowInvocationRef;
+    task_id: TaskId;
+    task_detail: TaskDetailProjection;
+    clarification_thread_ref: ClarificationThreadRef;
+    clarification_round_ref: ClarificationRoundRef;
+    clarification_request_payload: ClarificationRequestPayload;
+    submitted_message_refs: MessageId[];
+    round_messages: MessageProjection[];
+    latest_run_result: RunResultProjection;
+    run_lineage: RunLineage;
+};
+export type FollowUpCheckWorkflowOutput = {
+    decision: "resume";
+    summary: string;
+} | {
+    decision: "needs_more_input";
+    summary: string;
+    clarification_request_payload: ClarificationRequestPayload;
+} | {
+    decision: "requires_retasking";
+    summary: string;
+};
+export type FollowUpCheckStructuredOutput = {
+    result: {
+        resume: {
+            summary: string;
+        };
+    } | {
+        needs_more_input: ClarificationRequestPayload;
+    } | {
+        requires_retasking: {
+            summary: string;
+        };
+    };
+};
+export type ProcedureWorkflowRunner = {
+    runScratchpadRefresh: (input: ScratchpadRefreshWorkflowInput, context: ScratchpadRefreshWorkflowContext) => Promise<ScratchpadRefreshWorkflowOutput>;
+    runTaskCompile: (input: TaskCompileWorkflowInput, context?: ProcedureWorkflowRunContext) => Promise<TaskCompileWorkflowOutput>;
+    runProjectContextBootstrap?: (input: ProjectContextBootstrapWorkflowInput, context?: ProcedureWorkflowRunContext) => Promise<ProjectContextBootstrapWorkflowOutput>;
+    runContextSync?: (input: ContextSyncWorkflowInput, context?: ProcedureWorkflowRunContext) => Promise<ContextSyncWorkflowOutput>;
+    runReferenceFileSummary?: (input: ReferenceFileSummaryWorkflowInput, context?: ProcedureWorkflowRunContext) => Promise<ReferenceFileSummaryWorkflowOutput>;
+    runProjectBriefRefresh?: (input: ProjectBriefRefreshWorkflowInput, context?: ProcedureWorkflowRunContext) => Promise<ProjectBriefRefreshWorkflowOutput>;
+    runFollowUpCheck?: (input: FollowUpCheckWorkflowInput, context?: ProcedureWorkflowRunContext) => Promise<FollowUpCheckWorkflowOutput>;
+};
+export type ProcedureWorkflowRunnerResolution = {
+    kind: "ready";
+    runner: ProcedureWorkflowRunner;
+} | {
+    kind: "not_configured";
+} | {
+    kind: "unavailable";
+    reason: "provider_auth_invalid" | "provider_quota_or_billing_required" | "provider_rate_limited" | "provider_model_unavailable" | "provider_network_error";
+    retryable: boolean;
+};
+export type ProcedureWorkflowRunnerResolver = () => ProcedureWorkflowRunnerResolution;
+//# sourceMappingURL=types.d.ts.map

package/dist/control-plane/workflows/types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=types.js.map

package/dist/control-plane/worklist-terminal-feedback.d.ts

@@ -0,0 +1,15 @@
+import type { TaskId } from "@tutti/shared/ids";
+import type { MessageProjection } from "@tutti/shared/schemas/api";
+import type { HostProjectStore } from "../store/index.js";
+import type { WorkspaceEventBus } from "../server-shell/http/workspace-events.js";
+type EmitWorklistFeedbackInput = {
+    store: HostProjectStore;
+    events: WorkspaceEventBus;
+    now: () => Date;
+};
+export declare function emitWorklistCompletedFeedback(input: EmitWorklistFeedbackInput): MessageProjection | null;
+export declare function emitWorklistFailedFeedback(input: EmitWorklistFeedbackInput & {
+    taskId: TaskId;
+}): MessageProjection | null;
+export {};
+//# sourceMappingURL=worklist-terminal-feedback.d.ts.map

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

@@ -0,0 +1,135 @@
+import { createMainChatAgentMessage, hasMainChatWorklistFeedbackMessage, readCompletedWorklistFeedbackTaskIds, readTaskDetailProjection, readWorklistProjection, } from "../collaboration-state/index.js";
+import { mainChatInvalidates } from "./invalidations.js";
+const BODY_ITEM_LIMIT = 12;
+function summaryText(value, fallback) {
+    const trimmed = (value ?? "").trim();
+    return trimmed.length === 0 ? fallback : trimmed;
+}
+function readWorklistTaskEntries(store) {
+    const worklist = readWorklistProjection(store.db);
+    return worklist.modules.flatMap((entry) => entry.tasks.map((task) => ({
+        task,
+        moduleName: entry.module.name,
+        detail: readTaskDetailProjection(store.db, task.id),
+    })));
+}
+function feedbackItemFromEntry(entry) {
+    const result = entry.detail?.detail.result;
+    const item = {
+        task_id: entry.task.id,
+        title: entry.task.title,
+        status: entry.task.status === "done" ? "done" : "failed",
+        summary: summaryText(result?.summary, entry.task.summary),
+        module_name: entry.moduleName,
+    };
+    if (result?.latest_run_result_id !== undefined) {
+        item.latest_run_result_id = result.latest_run_result_id;
+    }
+    return item;
+}
+function feedbackCounters(entries) {
+    const completed = entries.filter((entry) => entry.task.status === "done").length;
+    const failed = entries.filter((entry) => entry.task.status === "failed").length;
+    return {
+        completed,
+        failed,
+        remaining: Math.max(0, entries.length - completed - failed),
+    };
+}
+function completedFeedbackKey(items) {
+    const runResultKeys = items.map((item) => item.latest_run_result_id ?? item.task_id).join(",");
+    return `worklist-completed:${items.length}:${runResultKeys}`;
+}
+function failedFeedbackKey(item) {
+    return `worklist-failed:${item.task_id}:${item.latest_run_result_id ?? "no-result"}`;
+}
+function hasExistingFeedback(store, feedbackKey) {
+    return hasMainChatWorklistFeedbackMessage(store.db, feedbackKey);
+}
+function taskCountLabel(count) {
+    return `${count} ${count === 1 ? "task" : "tasks"}`;
+}
+function markdownFallback(feedback) {
+    const lines = [feedback.title, ""];
+    const visibleItems = feedback.items.slice(0, BODY_ITEM_LIMIT);
+    for (const item of visibleItems) {
+        const prefix = item.status === "done" ? "- Done" : "- Failed";
+        const moduleText = item.module_name === undefined ? "" : ` (${item.module_name})`;
+        lines.push(`${prefix}: ${item.title}${moduleText}`);
+        if (item.summary.trim().length > 0) {
+            lines.push(`  ${item.summary}`);
+        }
+    }
+    if (feedback.items.length > visibleItems.length) {
+        lines.push(`- ${taskCountLabel(feedback.items.length - visibleItems.length)} hidden.`);
+    }
+    lines.push("");
+    if (feedback.status === "completed") {
+        lines.push("All Worklist tasks are done. Review the result or start the next discussion.");
+    }
+    else {
+        lines.push("This run has no reliable continuation path. Review the Worklist task detail and add the next step in chat.");
+    }
+    return lines.join("\n");
+}
+function publishFeedbackMessage(input, feedback) {
+    if (hasExistingFeedback(input.store, feedback.feedback_key)) {
+        return null;
+    }
+    const message = createMainChatAgentMessage(input.store.db, {
+        body: markdownFallback(feedback),
+        refs: {
+            scratchpad_source: "exclude",
+            worklist_feedback: feedback,
+        },
+        now: input.now,
+    });
+    input.events.publish({
+        event_type: "message.created",
+        payload: { message },
+        invalidates: mainChatInvalidates(),
+    });
+    return message;
+}
+export function emitWorklistCompletedFeedback(input) {
+    const entries = readWorklistTaskEntries(input.store);
+    if (entries.length === 0 || entries.some((entry) => entry.task.status !== "done")) {
+        return null;
+    }
+    const alreadyReportedTaskIds = readCompletedWorklistFeedbackTaskIds(input.store.db);
+    const newCompletedEntries = entries.filter((entry) => !alreadyReportedTaskIds.has(entry.task.id));
+    if (newCompletedEntries.length === 0) {
+        return null;
+    }
+    const items = newCompletedEntries.map(feedbackItemFromEntry);
+    const feedback = {
+        kind: "worklist_terminal",
+        status: "completed",
+        reason: "all_tasks_done",
+        title: `Completed ${taskCountLabel(items.length)}`,
+        feedback_key: completedFeedbackKey(items),
+        counters: feedbackCounters(newCompletedEntries),
+        items,
+    };
+    return publishFeedbackMessage(input, feedback);
+}
+export function emitWorklistFailedFeedback(input) {
+    const entries = readWorklistTaskEntries(input.store);
+    const failedEntry = entries.find((entry) => entry.task.id === input.taskId);
+    if (failedEntry === undefined || failedEntry.task.status !== "failed") {
+        return null;
+    }
+    const item = feedbackItemFromEntry(failedEntry);
+    const feedback = {
+        kind: "worklist_terminal",
+        status: "failed",
+        reason: "run_failed",
+        title: `"${failedEntry.task.title}" failed`,
+        feedback_key: failedFeedbackKey(item),
+        counters: feedbackCounters(entries),
+        items: [item],
+        primary_task_id: input.taskId,
+    };
+    return publishFeedbackMessage(input, feedback);
+}
+//# sourceMappingURL=worklist-terminal-feedback.js.map

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -0,0 +1,32 @@
+import { serializeRuntimeErrorLog, serializeRuntimeLogLine } from "@tutti/shared/utils";
+import { createHostServer } from "./server-shell/http/create-server.js";
+const DEFAULT_HOST = "127.0.0.1";
+const DEFAULT_PORT = 4371;
+function readPort(value, fallback) {
+    if (value === undefined || value.trim() === "") {
+        return fallback;
+    }
+    const parsed = Number(value);
+    if (!Number.isInteger(parsed) || parsed <= 0 || parsed > 65535) {
+        throw new Error(`Invalid TUTTI_HOST_ENDPOINT_PORT: ${value}`);
+    }
+    return parsed;
+}
+try {
+    const app = createHostServer();
+    const host = process.env.TUTTI_HOST_ENDPOINT_HOST ?? DEFAULT_HOST;
+    const port = readPort(process.env.TUTTI_HOST_ENDPOINT_PORT, DEFAULT_PORT);
+    await app.listen({ host, port });
+}
+catch (error) {
+    process.stderr.write(`${serializeRuntimeLogLine({
+        level: "error",
+        service: "tutti-host",
+        component: "runtime",
+        message: "Host server startup failed",
+        fields: { err: serializeRuntimeErrorLog(error) },
+        now: () => new Date(),
+    })}\n`);
+    process.exitCode = 1;
+}
+//# sourceMappingURL=index.js.map

package/dist/procedure-engine/index.d.ts

@@ -0,0 +1,56 @@
+import { type ActivityRef, type WorkflowInvocationRef } from "@tutti/shared/ids";
+import type { ResultAnchor, WorkflowKind } from "@tutti/shared/domain";
+import type { ActivityProjection, ExecutionStatusProjection, ProcedureLane } from "@tutti/shared/schemas/api";
+export type ProcedureTerminalConclusion = {
+    kind: "completed" | "failed" | "needs_human";
+    summary: string;
+    result_anchor?: ResultAnchor;
+};
+export type ProcedureExecutionContext = {
+    activity_ref: ActivityRef;
+    workflow_ref: WorkflowInvocationRef;
+    workflow_kind: WorkflowKind;
+    lane: ProcedureLane;
+};
+export type StartProcedureOptions = {
+    workflow_ref: WorkflowInvocationRef;
+    workflow_kind: WorkflowKind;
+    lane?: ProcedureLane;
+    title: string;
+    summary: string;
+    now?: () => Date;
+    execute: (context: ProcedureExecutionContext) => Promise<ProcedureTerminalConclusion>;
+    onError?: (input: {
+        context: ProcedureExecutionContext;
+        error: unknown;
+    }) => void;
+    onTransition?: (state: ProcedureEngineState) => void;
+};
+export type StartProcedureResult = {
+    kind: "accepted";
+    activity: ActivityProjection;
+} | {
+    kind: "already_running";
+    activity_ref: ActivityRef;
+};
+export type ProcedureEngineState = {
+    activity: ActivityProjection;
+    execution_status: ExecutionStatusProjection;
+};
+export declare class ProcedureEngine {
+    private readonly activeByLane;
+    private lastConclusion;
+    private readonly now;
+    constructor(options?: {
+        now?: () => Date;
+    });
+    startProcedure(options: StartProcedureOptions): StartProcedureResult;
+    getActiveProcedures(): ActivityProjection[];
+    getExecutionStatus(): ExecutionStatusProjection;
+    waitForIdle(): Promise<void>;
+    private stateForActivity;
+    private finishActive;
+    private primaryActiveProcedure;
+    private orderedActiveProcedures;
+}
+//# sourceMappingURL=index.d.ts.map

package/dist/procedure-engine/index.js

@@ -0,0 +1,163 @@
+import { createActivityRef } from "@tutti/shared/ids";
+const DEFAULT_PROCEDURE_LANE = "foreground";
+const PROCEDURE_LANE_ORDER = ["foreground", "scratchpad_background"];
+export class ProcedureEngine {
+    activeByLane = new Map();
+    lastConclusion = null;
+    now;
+    constructor(options = {}) {
+        this.now = options.now ?? (() => new Date());
+    }
+    startProcedure(options) {
+        const lane = options.lane ?? DEFAULT_PROCEDURE_LANE;
+        const activeInLane = this.activeByLane.get(lane);
+        if (activeInLane !== undefined) {
+            return {
+                kind: "already_running",
+                activity_ref: activeInLane.activity.activity_ref,
+            };
+        }
+        const startedAt = (options.now ?? this.now)().toISOString();
+        const activityRef = createActivityRef();
+        const activity = {
+            activity_ref: activityRef,
+            activity_kind: "procedure",
+            status: "running",
+            title: options.title,
+            summary: options.summary,
+            workflow_ref: options.workflow_ref,
+            workflow_kind: options.workflow_kind,
+            lane,
+            started_at: startedAt,
+            result_anchor: {
+                kind: "workflow",
+                workflow_ref: options.workflow_ref,
+            },
+        };
+        const context = {
+            activity_ref: activityRef,
+            workflow_ref: options.workflow_ref,
+            workflow_kind: options.workflow_kind,
+            lane,
+        };
+        const run = async () => {
+            try {
+                const conclusion = await options.execute(context);
+                this.finishActive(activityRef, lane, conclusion, options.onTransition);
+            }
+            catch (error) {
+                try {
+                    options.onError?.({ context, error });
+                }
+                catch {
+                    // Logging hooks must not change Procedure terminal semantics.
+                }
+                this.finishActive(activityRef, lane, {
+                    kind: "failed",
+                    summary: error instanceof Error ? error.message : "Procedure failed",
+                }, options.onTransition);
+            }
+        };
+        const promise = Promise.resolve().then(run);
+        this.activeByLane.set(lane, { activity, lane, promise });
+        options.onTransition?.(this.stateForActivity(activity));
+        return {
+            kind: "accepted",
+            activity,
+        };
+    }
+    getActiveProcedures() {
+        return this.orderedActiveProcedures().map((active) => active.activity);
+    }
+    getExecutionStatus() {
+        const active = this.primaryActiveProcedure();
+        if (active !== null) {
+            const activeActivities = this.orderedActiveProcedures().map((entry) => executionActivityFromProcedure(entry.activity));
+            return {
+                status: "running",
+                summary: active.activity.summary,
+                active_activity: executionActivityFromProcedure(active.activity),
+                active_activities: activeActivities,
+                updated_at: this.now().toISOString(),
+            };
+        }
+        const idle = {
+            status: "idle",
+            summary: "Idle",
+            updated_at: this.now().toISOString(),
+        };
+        if (this.lastConclusion !== null) {
+            idle.last_conclusion = this.lastConclusion;
+        }
+        return idle;
+    }
+    async waitForIdle() {
+        while (this.activeByLane.size > 0) {
+            await Promise.all(this.orderedActiveProcedures().map((active) => active.promise));
+        }
+    }
+    stateForActivity(activity) {
+        return {
+            activity,
+            execution_status: this.getExecutionStatus(),
+        };
+    }
+    finishActive(activityRef, lane, conclusion, onTransition) {
+        const active = this.activeByLane.get(lane);
+        if (active === undefined || active.activity.activity_ref !== activityRef) {
+            return;
+        }
+        const endedAt = this.now().toISOString();
+        const status = conclusion.kind === "completed"
+            ? "finished"
+            : conclusion.kind === "needs_human"
+                ? "needs_human"
+                : "failed";
+        active.activity.status = status;
+        active.activity.summary = conclusion.summary;
+        active.activity.ended_at = endedAt;
+        if (conclusion.result_anchor !== undefined) {
+            active.activity.result_anchor = conclusion.result_anchor;
+        }
+        this.lastConclusion = {
+            kind: conclusion.kind,
+            summary: conclusion.summary,
+            activity_ref: activityRef,
+            ...(active.activity.workflow_ref === undefined
+                ? {}
+                : { workflow_ref: active.activity.workflow_ref }),
+            occurred_at: endedAt,
+        };
+        this.activeByLane.delete(lane);
+        onTransition?.({
+            activity: active.activity,
+            execution_status: this.getExecutionStatus(),
+        });
+    }
+    primaryActiveProcedure() {
+        for (const lane of PROCEDURE_LANE_ORDER) {
+            const active = this.activeByLane.get(lane);
+            if (active !== undefined) {
+                return active;
+            }
+        }
+        return null;
+    }
+    orderedActiveProcedures() {
+        return PROCEDURE_LANE_ORDER.flatMap((lane) => {
+            const active = this.activeByLane.get(lane);
+            return active === undefined ? [] : [active];
+        });
+    }
+}
+function executionActivityFromProcedure(activity) {
+    return {
+        activity_ref: activity.activity_ref,
+        activity_kind: "procedure",
+        ...(activity.workflow_ref === undefined ? {} : { workflow_ref: activity.workflow_ref }),
+        ...(activity.workflow_kind === undefined ? {} : { workflow_kind: activity.workflow_kind }),
+        ...(activity.lane === undefined ? {} : { lane: activity.lane }),
+        ...(activity.started_at === undefined ? {} : { started_at: activity.started_at }),
+    };
+}
+//# sourceMappingURL=index.js.map

package/dist/project-brief/index.d.ts

@@ -0,0 +1,4 @@
+export { projectBriefSourceFingerprint, projectBriefSourceFingerprints, readProjectBriefSourceDocuments, } from "./source.js";
+export { readProjectBriefProjection, upsertProjectBriefProjection, } from "./repository.js";
+export type { ProjectBriefProjection, ProjectBriefRecord, ProjectBriefSnapshot, ProjectBriefSourceDocument, ProjectBriefSourceDocumentFingerprint, ProjectBriefSourceDocumentStatus, UpsertProjectBriefInput, } from "./types.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/project-brief/index.js

@@ -0,0 +1,3 @@
+export { projectBriefSourceFingerprint, projectBriefSourceFingerprints, readProjectBriefSourceDocuments, } from "./source.js";
+export { readProjectBriefProjection, upsertProjectBriefProjection, } from "./repository.js";
+//# sourceMappingURL=index.js.map