@xfey/tutti 0.1.127 → 0.1.129

package/dist/collaboration-state/clarification-snapshot.d.ts

@@ -13,8 +13,9 @@ export declare function readSubmittedClarificationMessages(db: SqliteDatabase, r
         is_current_round: boolean;
     };
     refs?: {
-        task_id?: string;
         activity_ref?: string;
+        workflow_ref?: string;
+        task_id?: string;
         artifact_feedback?: {
             summary?: string;
             kind: "artifact_feedback";
@@ -106,15 +107,14 @@ export declare function readSubmittedClarificationMessages(db: SqliteDatabase, r
             blob_oid?: string;
             path: string;
             name: string;
-            source: "human_upload" | "tutti_output";
             category: "file" | "image";
+            source: "human_upload" | "tutti_output";
             size_bytes: number;
             text_read: {
                 blocked_reason?: "unknown" | "binary" | "too_large" | "unsupported_encoding" | "restricted_path" | "secret_like";
                 can_read: boolean;
             };
         };
-        workflow_ref?: string;
         clarification_round_ref?: string;
         clarification_thread_ref?: string;
         task_result?: {
@@ -141,10 +141,10 @@ export declare function readSubmittedClarificationMessages(db: SqliteDatabase, r
         };
         worklist_compile?: {
             kind: "worklist_compile";
-            title: string;
             workflow_ref: string;
+            title: string;
             tasks: {
-                status: "failed" | "pending" | "done" | "todo" | "running";
+                status: "failed" | "pending" | "running" | "done" | "todo";
                 task_id: string;
                 title: string;
                 summary: string;

package/dist/collaboration-state/context-sync-attempts.d.ts

@@ -0,0 +1,9 @@
+import type { SqliteDatabase } from "../store/index.js";
+export declare function hasContextSyncCompletionAttempt(db: SqliteDatabase, batchKey: string): boolean;
+/** Persist before invoking the provider; failure/unknown outcome is not a retry permit. */
+export declare function recordContextSyncCompletionAttempt(db: SqliteDatabase, input: {
+    batchKey: string;
+    workflowRef: string;
+    startedAt: string;
+}): boolean;
+//# sourceMappingURL=context-sync-attempts.d.ts.map

package/dist/collaboration-state/context-sync-attempts.js

@@ -0,0 +1,13 @@
+export function hasContextSyncCompletionAttempt(db, batchKey) {
+    return (db
+        .prepare("SELECT 1 AS present FROM context_sync_completion_attempts WHERE batch_key = ?")
+        .get(batchKey) !== undefined);
+}
+/** Persist before invoking the provider; failure/unknown outcome is not a retry permit. */
+export function recordContextSyncCompletionAttempt(db, input) {
+    return (db
+        .prepare(`INSERT OR IGNORE INTO context_sync_completion_attempts(batch_key, workflow_ref, started_at)
+     VALUES (?, ?, ?)`)
+        .run(input.batchKey, input.workflowRef, input.startedAt).changes === 1);
+}
+//# sourceMappingURL=context-sync-attempts.js.map

package/dist/collaboration-state/task-compile-context.d.ts

@@ -24,7 +24,7 @@ export declare function completeTaskCompileContext(db: SqliteDatabase, input: Co
     task_changes: string[];
     receipts: {
         compiled_tasks?: {
-            status: "failed" | "pending" | "done" | "todo" | "running";
+            status: "failed" | "pending" | "running" | "done" | "todo";
             task_id: string;
             title: string;
             summary: string;

package/dist/collaboration-state/task-compile-context.js

@@ -3,6 +3,7 @@ import { readScratchpadProjection } from "./scratchpad.js";
 import { readCommunicationLanguage, copyCommunicationLanguage } from "./communication-language.js";
 import { readScratchpadSourceState } from "./scratchpad-source-state.js";
 import { nowIso, stringifyJson } from "./serialization.js";
+import { registerTaskCompileRequest, closeFailedTaskCompileRequest, } from "./task-compile-requests.js";
 function cursorIsAfter(left, right) {
     if (left === undefined) {
         return false;
@@ -145,6 +146,7 @@ export function recordTaskCompileSubmission(db, input) {
     if (readActiveTaskCompileContext(db) !== null) {
         throw new Error("An active Task Compile Context already exists");
     }
+    registerTaskCompileRequest(db, input.workflow_ref, input.accepted_activity_ref, nowIso(input.now));
     db.prepare(`
       INSERT INTO pending_task_compile_submissions (
         id,
@@ -226,6 +228,7 @@ export function captureTaskCompileContext(db, input) {
                 : { created_at: lastSource.created_at, message_id: lastSource.message_id });
         const after = submission?.source_window.after ?? sourceState.cycle_start_cursor;
         const submittedAt = nowIso(input.now);
+        registerTaskCompileRequest(tx, input.workflow_ref, input.captured_by_activity_ref, submittedAt);
         tx.prepare(`
         INSERT INTO active_task_compile_context (
           id,
@@ -337,9 +340,16 @@ export function rollbackTaskCompileContext(db, input) {
     return withHostStoreTransaction(db, (tx) => {
         const context = readActiveTaskCompileContext(tx, input.workflow_ref);
         if (context === null) {
-            return false;
+            const pending = readPendingTaskCompileSubmission(tx, input.workflow_ref);
+            if (pending === null)
+                return false;
+            // Before capture the source cursor has not moved: release only this admission.
+            closeFailedTaskCompileRequest(tx, input.workflow_ref, nowIso(input.now));
+            tx.prepare("DELETE FROM pending_task_compile_submissions WHERE workflow_ref = ?").run(input.workflow_ref);
+            return true;
         }
         const rolledBackAt = nowIso(input.now);
+        closeFailedTaskCompileRequest(tx, input.workflow_ref, rolledBackAt);
         const sourceState = readScratchpadSourceState(tx);
         const after = context.source_window.after;
         const through = context.source_window.through;

package/dist/collaboration-state/task-compile-requests.d.ts

@@ -0,0 +1,6 @@
+import type { SqliteDatabase } from "../store/index.js";
+/** Persistence only: callers own acceptance, stage selection and rollback. */
+export declare function registerTaskCompileRequest(db: SqliteDatabase, workflowRef: string, activityRef: string, createdAt: string): void;
+export declare function linkTaskCompileActivity(db: SqliteDatabase, workflowRef: string, activityRef: string): void;
+export declare function closeFailedTaskCompileRequest(db: SqliteDatabase, workflowRef: string, now: string, code?: "task_compile_failed" | "scratchpad_empty_after_refresh"): void;
+//# sourceMappingURL=task-compile-requests.d.ts.map

package/dist/collaboration-state/task-compile-requests.js

@@ -0,0 +1,16 @@
+/** Persistence only: callers own acceptance, stage selection and rollback. */
+export function registerTaskCompileRequest(db, workflowRef, activityRef, createdAt) {
+    db.prepare(`INSERT OR IGNORE INTO task_compile_requests
+    (workflow_ref, accepted_activity_ref, current_activity_ref, created_at)
+    VALUES (?, ?, ?, ?)`).run(workflowRef, activityRef, activityRef, createdAt);
+}
+export function linkTaskCompileActivity(db, workflowRef, activityRef) {
+    db.prepare(`UPDATE task_compile_requests SET current_activity_ref = ?
+    WHERE workflow_ref = ? AND closed_at IS NULL`).run(activityRef, workflowRef);
+}
+export function closeFailedTaskCompileRequest(db, workflowRef, now, code = "task_compile_failed") {
+    db.prepare(`UPDATE task_compile_requests SET failure_code = ?, closed_at = ?
+    WHERE workflow_ref = ? AND closed_at IS NULL
+      AND NOT EXISTS (SELECT 1 FROM scratchpad_receipts WHERE workflow_ref = ?)`).run(code, now, workflowRef, workflowRef);
+}
+//# sourceMappingURL=task-compile-requests.js.map

package/dist/communication-language/notice-locale.d.ts

@@ -0,0 +1,4 @@
+/** Small static notice catalog, not language detection or a UI locale setting. */
+export type NoticeLocale = "en" | "zh-Hans" | "zh-Hant";
+export declare function noticeLocale(locale?: string | null): NoticeLocale;
+//# sourceMappingURL=notice-locale.d.ts.map

package/dist/communication-language/notice-locale.js

@@ -0,0 +1,14 @@
+export function noticeLocale(locale) {
+    if (locale === undefined || locale === null)
+        return "en";
+    try {
+        const parsed = new Intl.Locale(locale);
+        if (parsed.language !== "zh")
+            return "en";
+        return parsed.maximize().script === "Hant" ? "zh-Hant" : "zh-Hans";
+    }
+    catch {
+        return "en";
+    }
+}
+//# sourceMappingURL=notice-locale.js.map

package/dist/control-plane/context-sync-completion.d.ts

@@ -0,0 +1,7 @@
+import type { SqliteDatabase } from "../store/index.js";
+import type { ContextSyncWorkflowTrigger } from "./workflows/index.js";
+export declare function pendingContextSyncCompletion(db: SqliteDatabase): {
+    key: string;
+    trigger: ContextSyncWorkflowTrigger;
+} | undefined;
+//# sourceMappingURL=context-sync-completion.d.ts.map

package/dist/control-plane/context-sync-completion.js

@@ -0,0 +1,27 @@
+import { createHash } from "node:crypto";
+import { hasContextSyncCompletionAttempt } from "../collaboration-state/context-sync-attempts.js";
+import { readWorklistProjection } from "../collaboration-state/index.js";
+export function pendingContextSyncCompletion(db) {
+    const worklist = readWorklistProjection(db);
+    const tasks = worklist.modules
+        .flatMap((entry) => entry.tasks)
+        .sort((a, b) => (a.id < b.id ? -1 : 1));
+    if (tasks.length === 0 || tasks.some((task) => task.status !== "done"))
+        return undefined;
+    // A changed result on the same task is a new completion. Source messages,
+    // ordering, labels and context_sync's own Git commit are deliberately absent.
+    const key = createHash("sha256")
+        .update(JSON.stringify(tasks.map((task) => [task.id, task.latest_run_result_id])))
+        .digest("hex");
+    if (hasContextSyncCompletionAttempt(db, key))
+        return undefined;
+    return {
+        key,
+        trigger: {
+            kind: "worklist_all_tasks_completed",
+            completed_task_count: tasks.length,
+            module_count: worklist.modules.length,
+        },
+    };
+}
+//# sourceMappingURL=context-sync-completion.js.map

package/dist/control-plane/context-sync.d.ts

@@ -10,6 +10,7 @@ export declare function startContextSyncAnalysisProcedure(input: {
     store: HostProjectStore;
     events: WorkspaceEventBus;
     trigger: ContextSyncWorkflowTrigger;
+    completionBatchKey?: string;
     resolveWorkflowRunner: ProcedureWorkflowRunnerResolver;
     readActiveActivity: () => {
         activity_ref: ActivityRef;

package/dist/control-plane/context-sync.js

@@ -3,6 +3,7 @@ import { projectLanguageContext, logLanguageContext } from "./communication-lang
 import { recordProjectTimelineEvent } from "../project-timeline/index.js";
 import { syncProjectDocs } from "../workspace-ops/index.js";
 import { logProcedureExecutionError } from "./procedure-logging.js";
+import { recordContextSyncCompletionAttempt } from "../collaboration-state/context-sync-attempts.js";
 import { projectBriefShouldRefreshForUpdatedPaths, refreshProjectBriefProjection, } from "./project-brief-refresh.js";
 function publishContextSyncTimelineChanged(input) {
     input.events.publish({
@@ -63,6 +64,28 @@ export function startContextSyncAnalysisProcedure(input) {
             error,
         }),
         execute: async (context) => {
+            if (input.completionBatchKey !== undefined) {
+                const recorded = recordContextSyncCompletionAttempt(input.store.db, {
+                    batchKey: input.completionBatchKey,
+                    workflowRef,
+                    startedAt: input.now().toISOString(),
+                });
+                if (!recorded)
+                    return {
+                        kind: "completed",
+                        summary: "These task results were already checked for document maintenance.",
+                    };
+                try {
+                    input.logger?.info({
+                        workflow_ref: workflowRef,
+                        activity_ref: context.activity_ref,
+                        trigger: "worklist_all_tasks_completed",
+                    }, "Automatic context sync attempt recorded");
+                }
+                catch {
+                    /* Logging must not prevent the recorded maintenance attempt. */
+                }
+            }
             const language = projectLanguageContext(input.store.db, "documents");
             logLanguageContext(input.logger, language, {
                 workflow_ref: workflowRef,

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

@@ -1,9 +1,16 @@
 import { type ActivityRef, type ClarificationRoundRef, type IdempotencyKey, type TaskId, type WorkflowInvocationRef } from "@tutti/shared/ids";
 import type { TrustedCollaborationAuthor } from "../collaboration-ingestion/types.js";
+import type { WorkflowKind } from "@tutti/shared/domain";
 import type { ExecutionStatusProjection, MessageProjection, ContextSyncDisposition, ContextSyncResult, RefreshScratchpadDisposition, RefreshScratchpadResult, RunSchedulerNowDisposition, RunSchedulerNowPayload, RetryTaskDisposition, RetryTaskPayload, RefreshReferenceSummariesDisposition, RefreshReferenceSummariesPayload, RefreshReferenceSummariesResult, SendClarificationRoundMessageDisposition, SendClarificationRoundMessagePayload, SendClarificationRoundMessageResult, SubmitClarificationRoundDisposition, SubmitClarificationRoundPayload, SubmitClarificationRoundResult, SubmitWorklistDisposition, SubmitWorklistPayload, SubmitWorklistResult, ProcedureLane } from "@tutti/shared/schemas/api";
-import type { ContextSyncWorkflowTrigger } from "./workflows/index.js";
 import type { ControlPlaneCommandResult, Phase5ControlPlaneOptions, StartupRecoveryOptions, StartupRecoveryResult } from "./types.js";
 import { type ProjectBriefRefreshReason, type RefreshProjectBriefProjectionResult } from "./project-brief-refresh.js";
+type ActiveActivity = {
+    activity_ref: ActivityRef;
+    activity_kind: "run" | "procedure";
+    lane?: ProcedureLane;
+    workflow_kind?: WorkflowKind;
+    workflow_ref?: WorkflowInvocationRef;
+};
 export type { ControlPlaneCommandResult, ControlPlaneLogger, Phase5ControlPlaneOptions, RunCorrectionContext, RunContinuationContext, RunDispatchContext, RunDispatchTrigger, RunPipelineInput, RunPipelineResolution, RunPipelineResolver, RunPipelineResult, RunPipelineRunner, StartupRecoveryOptions, StartupRecoveryResult, TrustedHumanAuthor, } from "./types.js";
 export declare class Phase5ControlPlane {
     private readonly engine;
@@ -14,6 +21,7 @@ export declare class Phase5ControlPlane {
     private readonly resolveRunPipeline;
     private readonly readMainlineStatus;
     private readonly readActiveApproval;
+    private readonly hasPendingChatRequests;
     private readonly logger;
     private readonly projectContext;
     private readonly runLifecycle;
@@ -46,9 +54,10 @@ export declare class Phase5ControlPlane {
     }): Promise<RefreshProjectBriefProjectionResult>;
     beginShutdown(): void;
     dispose(): Promise<void>;
-    waitForRepoInspectionIdle(): Promise<void>;
+    waitForRepoInspectionIdle(onBlocked?: (blocker: ActiveActivity) => void): Promise<void>;
     startTaskCompile(payload: SubmitWorklistPayload): ControlPlaneCommandResult<SubmitWorklistDisposition, SubmitWorklistResult>;
-    startContextSyncAnalysis(trigger?: ContextSyncWorkflowTrigger): ControlPlaneCommandResult<ContextSyncDisposition, ContextSyncResult>;
+    startContextSyncAnalysis(): ControlPlaneCommandResult<ContextSyncDisposition, ContextSyncResult>;
+    private startContextSync;
     startReferenceSummaryRefresh(payload?: RefreshReferenceSummariesPayload): ControlPlaneCommandResult<RefreshReferenceSummariesDisposition, RefreshReferenceSummariesResult>;
     private tryStartPendingReferenceSummaryRefresh;
     sendClarificationRoundMessage(roundId: ClarificationRoundRef, payload: SendClarificationRoundMessagePayload, author: TrustedCollaborationAuthor): ControlPlaneCommandResult<SendClarificationRoundMessageDisposition, SendClarificationRoundMessageResult>;
@@ -71,7 +80,7 @@ export declare class Phase5ControlPlane {
     private handleRunTerminalTransition;
     private tryRunTaskArrivalScheduler;
     private maybeScheduleAfterRunCompletion;
-    private worklistCompletionContextSyncTrigger;
+    notifyChatRequestsChanged(): void;
     private scheduleContextSyncAfterWorklistCompletion;
     private attemptContextSyncAfterWorklistCompletion;
     private cancelPendingWorklistCompletionContextSync;

package/dist/control-plane/index.js

@@ -1,9 +1,10 @@
-import { readActiveClarificationProjection, readActiveTaskCompileContext, markScratchpadRefreshSucceeded, readPendingTaskCompileSubmission, readTaskDetailProjection, readTaskProjectionByActivityRef, readScratchpadSourceState, readWorklistProjection, } from "../collaboration-state/index.js";
+import { readActiveClarificationProjection, readActiveTaskCompileContext, markScratchpadRefreshSucceeded, readPendingTaskCompileSubmission, readTaskDetailProjection, readTaskProjectionByActivityRef, readScratchpadSourceState, } from "../collaboration-state/index.js";
 import { ProcedureEngine } from "../procedure-engine/index.js";
 import { RunEngine } from "../run-engine/index.js";
 import { WorkspaceOpsError, isReferenceFilePath, readReferenceSummaryTargets, } from "../workspace-ops/index.js";
 import { publishProcedureTransition as publishProcedureTransitionEvent, publishRunResultRecorded as publishRunResultRecordedEvent, publishRunTransition as publishRunTransitionEvent, publishTaskRunStarted as publishTaskRunStartedEvent, } from "./event-publishers.js";
 import { startContextSyncAnalysisProcedure } from "./context-sync.js";
+import { pendingContextSyncCompletion } from "./context-sync-completion.js";
 import { refreshProjectBriefProjection, } from "./project-brief-refresh.js";
 import { startReferenceSummaryRefreshProcedure } from "./reference-summary-refresh.js";
 import { runControlPlaneStartupRecovery } from "./startup-recovery.js";
@@ -30,6 +31,7 @@ export class Phase5ControlPlane {
     resolveRunPipeline;
     readMainlineStatus;
     readActiveApproval;
+    hasPendingChatRequests;
     logger;
     projectContext;
     runLifecycle;
@@ -53,6 +55,7 @@ export class Phase5ControlPlane {
         this.resolveRunPipeline = options.resolveRunPipeline;
         this.readMainlineStatus = options.readMainlineStatus;
         this.readActiveApproval = options.readActiveApproval;
+        this.hasPendingChatRequests = options.hasPendingChatRequests ?? (() => false);
         this.logger = options.logger;
         this.projectContext = options.projectContext;
         this.runLifecycle = options.runLifecycle;
@@ -177,13 +180,17 @@ export class Phase5ControlPlane {
         this.beginShutdown();
         return this.waitForIdle();
     }
-    async waitForRepoInspectionIdle() {
+    async waitForRepoInspectionIdle(onBlocked) {
         for (;;) {
             const waits = [];
-            if (this.readActiveRun() !== null) {
+            const run = this.readActiveRun();
+            const procedure = this.readActiveForegroundProcedure();
+            if (run !== null) {
+                onBlocked?.(run);
                 waits.push(this.runEngine.waitForIdle());
             }
-            if (this.readActiveForegroundProcedure() !== null) {
+            if (procedure !== null) {
+                onBlocked?.(procedure);
                 waits.push(this.engine.waitForLaneIdle("foreground"));
             }
             if (waits.length === 0) {
@@ -233,15 +240,17 @@ export class Phase5ControlPlane {
             shouldContinue: () => !this.closing,
         });
     }
-    startContextSyncAnalysis(trigger = { kind: "manual" }) {
-        if (trigger.kind === "manual") {
-            this.cancelPendingWorklistCompletionContextSync();
-        }
+    startContextSyncAnalysis() {
+        this.cancelPendingWorklistCompletionContextSync();
+        return this.startContextSync({ kind: "manual" });
+    }
+    startContextSync(trigger, completionBatchKey) {
         return startContextSyncAnalysisProcedure({
             engine: this.engine,
             store: this.store,
             events: this.events,
             trigger,
+            ...(completionBatchKey === undefined ? {} : { completionBatchKey }),
             resolveWorkflowRunner: this.resolveWorkflowRunner,
             readActiveActivity: () => this.readSchedulerBlocker(),
             projectContext: this.projectContext,
@@ -544,17 +553,13 @@ export class Phase5ControlPlane {
         }
         this.scheduleContextSyncAfterWorklistCompletion();
     }
-    worklistCompletionContextSyncTrigger() {
-        const worklist = readWorklistProjection(this.store.db);
-        const tasks = worklist.modules.flatMap((entry) => entry.tasks);
-        if (tasks.length === 0 || tasks.some((task) => task.status !== "done")) {
-            return undefined;
-        }
-        return {
-            kind: "worklist_all_tasks_completed",
-            completed_task_count: tasks.length,
-            module_count: worklist.modules.length,
-        };
+    notifyChatRequestsChanged() {
+        if (this.closing || !this.store.db.open)
+            return;
+        if (this.hasPendingChatRequests())
+            this.cancelPendingWorklistCompletionContextSync();
+        else
+            this.scheduleContextSyncAfterWorklistCompletion();
     }
     scheduleContextSyncAfterWorklistCompletion() {
         if (this.closing ||
@@ -563,7 +568,8 @@ export class Phase5ControlPlane {
             return;
         }
         const sourceState = readScratchpadSourceState(this.store.db);
-        if (this.worklistCompletionContextSyncTrigger() === undefined ||
+        if (pendingContextSyncCompletion(this.store.db) === undefined ||
+            this.hasPendingChatRequests() ||
             sourceState.dirty_since !== undefined ||
             sourceState.in_flight !== undefined ||
             this.readSchedulerBlocker() !== null) {
@@ -579,15 +585,16 @@ export class Phase5ControlPlane {
         if (this.closing || !this.store.db.open) {
             return;
         }
-        const trigger = this.worklistCompletionContextSyncTrigger();
+        const completion = pendingContextSyncCompletion(this.store.db);
         const sourceState = readScratchpadSourceState(this.store.db);
-        if (trigger === undefined ||
+        if (completion === undefined ||
+            this.hasPendingChatRequests() ||
             sourceState.dirty_since !== undefined ||
             sourceState.in_flight !== undefined ||
             this.readSchedulerBlocker() !== null) {
             return;
         }
-        void this.startContextSyncAnalysis(trigger);
+        void this.startContextSync(completion.trigger, completion.key);
     }
     cancelPendingWorklistCompletionContextSync() {
         if (this.pendingWorklistCompletionContextSyncTimer === null) {

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

@@ -1,5 +1,6 @@
 import { materializeClarificationSuccessor, readActiveTaskCompileContext, readClarificationRoundProjection, readWorklistProjection, rollbackTaskCompileContext, } from "../collaboration-state/index.js";
 import { withHostStoreTransaction } from "../store/index.js";
+import { linkTaskCompileActivity } from "../collaboration-state/task-compile-requests.js";
 import { clarificationInvalidates } from "./invalidations.js";
 import { applyTaskCompileProcedureOutput } from "./task-compile-output.js";
 import { readTaskCompileClarificationRounds } from "./task-compile-clarification-context.js";
@@ -27,6 +28,7 @@ export function startControlPlaneTaskCompileContinuation(options) {
         summary: "Continuing task_compile from clarification input.",
         now: options.now,
         onTransition: (state) => {
+            linkTaskCompileActivity(options.store.db, workflowRef, state.activity.activity_ref);
             options.publishProcedureTransition(state);
             if (state.transition_kind === "terminal") {
                 options.onTerminal?.(state.activity.status === "failed"

package/dist/control-plane/task-compile-request-status.d.ts

@@ -0,0 +1,6 @@
+import type { ExecutionStatusProjection, WorklistSubmissionStatus } from "@tutti/shared/schemas/api";
+import type { SqliteDatabase } from "../store/index.js";
+/** Pure projection of owned records. A missing receipt is never proof of failure. */
+export declare function readTaskCompileRequestStatus(db: SqliteDatabase, execution: ExecutionStatusProjection, workflowRef?: string): WorklistSubmissionStatus | null;
+export declare function readTaskCompileCommandRef(db: SqliteDatabase, commandId: string): string | undefined;
+//# sourceMappingURL=task-compile-request-status.d.ts.map

package/dist/control-plane/task-compile-request-status.js

@@ -0,0 +1,70 @@
+import { readActiveClarificationProjection, readActiveTaskCompileContext, readPendingTaskCompileSubmission, } from "../collaboration-state/index.js";
+/** Pure projection of owned records. A missing receipt is never proof of failure. */
+export function readTaskCompileRequestStatus(db, execution, workflowRef) {
+    const row = workflowRef === undefined
+        ? db
+            .prepare("SELECT * FROM task_compile_requests ORDER BY rowid DESC LIMIT 1")
+            .get()
+        : db
+            .prepare("SELECT * FROM task_compile_requests WHERE workflow_ref = ?")
+            .get(workflowRef);
+    if (row === undefined)
+        return null;
+    const common = {
+        operation: { kind: "worklist_submit", ref: row.workflow_ref },
+        created_at: row.created_at,
+        activity_ref: row.current_activity_ref,
+    };
+    if (db.prepare("SELECT 1 FROM scratchpad_receipts WHERE workflow_ref = ?").get(row.workflow_ref)) {
+        return { ...common, status: "succeeded", phase: "settled" };
+    }
+    if (row.failure_code !== null) {
+        return {
+            ...common,
+            status: "failed",
+            phase: "settled",
+            failure: {
+                code: row.failure_code,
+                category: "internal",
+                recovery: "none",
+                diagnostic_id: row.workflow_ref,
+            },
+        };
+    }
+    const clarification = readActiveClarificationProjection(db);
+    if (clarification.state === "active" &&
+        clarification.thread.owner.kind === "task_compile" &&
+        clarification.thread.owner.workflow_ref === row.workflow_ref &&
+        clarification.round.status === "writable") {
+        return {
+            ...common,
+            status: "waiting_input",
+            phase: "clarification",
+            round_id: clarification.round.id,
+        };
+    }
+    const activities = execution.active_activities ?? (execution.active_activity ? [execution.active_activity] : []);
+    const active = activities.find((entry) => entry.activity_ref === row.current_activity_ref || entry.workflow_ref === row.workflow_ref);
+    if (active !== undefined) {
+        const kind = active.workflow_kind;
+        const phase = kind === "scratchpad_refresh" ||
+            kind === "reference_summary_refresh" ||
+            kind === "project_context_bootstrap" ||
+            kind === "task_compile"
+            ? kind
+            : "preparing";
+        return { ...common, activity_ref: active.activity_ref, status: "running", phase };
+    }
+    const ref = row.workflow_ref;
+    if (readPendingTaskCompileSubmission(db, ref) !== null ||
+        readActiveTaskCompileContext(db, ref) !== null) {
+        return { ...common, status: "running", phase: "preparing" };
+    }
+    return { ...common, status: "unknown", phase: "unconfirmed" };
+}
+export function readTaskCompileCommandRef(db, commandId) {
+    return db
+        .prepare("SELECT workflow_ref FROM task_compile_request_commands WHERE command_id = ?")
+        .get(commandId)?.workflow_ref;
+}
+//# sourceMappingURL=task-compile-request-status.js.map

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

@@ -12,10 +12,15 @@ 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";
+import { linkTaskCompileActivity, closeFailedTaskCompileRequest, } from "../collaboration-state/task-compile-requests.js";
 export function startControlPlaneTaskCompile(options) {
     const activeContext = readActiveTaskCompileContext(options.store.db);
     if (activeContext !== null) {
         return {
+            result: {
+                submission_ref: activeContext.workflow_ref,
+                activity_ref: activeContext.captured_by_activity_ref,
+            },
             disposition: {
                 kind: "already_running",
                 activity_ref: activeContext.captured_by_activity_ref,
@@ -25,6 +30,10 @@ export function startControlPlaneTaskCompile(options) {
     const pendingSubmission = readPendingTaskCompileSubmission(options.store.db);
     if (pendingSubmission !== null) {
         return {
+            result: {
+                submission_ref: pendingSubmission.workflow_ref,
+                activity_ref: pendingSubmission.accepted_activity_ref,
+            },
             disposition: {
                 kind: "already_running",
                 activity_ref: pendingSubmission.accepted_activity_ref,
@@ -72,7 +81,7 @@ export function startControlPlaneTaskCompile(options) {
                 },
             };
         }
-        return startScratchpadRefreshBeforeTaskCompileActivity({
+        const started = startScratchpadRefreshBeforeTaskCompileActivity({
             ...options,
             runner: runnerResolution.runner,
             sourceBatch,
@@ -86,6 +95,7 @@ export function startControlPlaneTaskCompile(options) {
                 now: options.now,
             }),
         });
+        return withSubmissionRef(started, taskCompileWorkflowRef);
     }
     if (!scratchpadHasSubmittableContent(scratchpad)) {
         return { disposition: { kind: "scratchpad_empty" } };
@@ -108,7 +118,12 @@ export function startControlPlaneTaskCompile(options) {
             now: options.now,
         });
     }
-    return started;
+    return withSubmissionRef(started, taskCompileWorkflowRef);
+}
+function withSubmissionRef(result, submissionRef) {
+    return result.disposition.kind === "accepted"
+        ? { ...result, result: { ...result.result, submission_ref: submissionRef } }
+        : result;
 }
 function recordTaskCompileSubmissionIntent(options) {
     return withHostStoreTransaction(options.store.db, (tx) => {
@@ -152,6 +167,7 @@ function startControlPlaneTaskCompileActivity(options) {
         summary: "Compiling Scratchpad into Worklist tasks.",
         now: options.now,
         onTransition: (state) => {
+            linkTaskCompileActivity(options.store.db, options.taskCompileWorkflowRef, state.activity.activity_ref);
             options.publishProcedureTransition(state);
             if (state.transition_kind === "terminal") {
                 options.onChainTerminal?.(state.activity.status === "failed"
@@ -206,11 +222,16 @@ function startScratchpadRefreshBeforeTaskCompileActivity(options) {
         summary: "Refreshing Scratchpad before submitting to Worklist.",
         now: options.now,
         onTransition: (state) => {
+            linkTaskCompileActivity(options.store.db, options.taskCompileWorkflowRef, state.activity.activity_ref);
             options.publishProcedureTransition(state);
             if (state.transition_kind !== "terminal") {
                 return;
             }
             if (state.activity.status !== "finished") {
+                rollbackTaskCompileContext(options.store.db, {
+                    workflow_ref: options.taskCompileWorkflowRef,
+                    now: options.now,
+                });
                 options.onChainTerminal?.({
                     state: "failed",
                     errorCode: "scratchpad_refresh_failed",
@@ -222,6 +243,10 @@ function startScratchpadRefreshBeforeTaskCompileActivity(options) {
             }
             const scratchpad = readScratchpadProjection(options.store.db);
             if (!scratchpadHasSubmittableContent(scratchpad)) {
+                withHostStoreTransaction(options.store.db, (tx) => {
+                    closeFailedTaskCompileRequest(tx, options.taskCompileWorkflowRef, options.now().toISOString(), "scratchpad_empty_after_refresh");
+                    tx.prepare("DELETE FROM pending_task_compile_submissions WHERE workflow_ref = ?").run(options.taskCompileWorkflowRef);
+                });
                 options.onChainTerminal?.({
                     state: "failed",
                     errorCode: "scratchpad_empty_after_refresh",
@@ -230,6 +255,10 @@ function startScratchpadRefreshBeforeTaskCompileActivity(options) {
             }
             const next = startReferenceSummaryGateOrNextStage(options);
             if (next.disposition.kind !== "accepted" && next.disposition.kind !== "already_running") {
+                rollbackTaskCompileContext(options.store.db, {
+                    workflow_ref: options.taskCompileWorkflowRef,
+                    now: options.now,
+                });
                 options.onChainTerminal?.({
                     state: "failed",
                     errorCode: "task_compile_stage_unavailable",
@@ -413,6 +442,10 @@ function startReferenceSummaryGateOrNextStage(options) {
         });
         registerReferenceSummaryGateWaiter(options, activeReferenceSummary.activity_ref);
         return {
+            result: {
+                submission_ref: options.taskCompileWorkflowRef,
+                activity_ref: activeReferenceSummary.activity_ref,
+            },
             disposition: {
                 kind: "already_running",
                 activity_ref: activeReferenceSummary.activity_ref,
@@ -514,6 +547,10 @@ function startProjectContextBootstrapActivity(options) {
                 return;
             }
             if (state.activity.status !== "finished") {
+                rollbackTaskCompileContext(options.store.db, {
+                    workflow_ref: options.taskCompileWorkflowRef,
+                    now: options.now,
+                });
                 options.onChainTerminal?.({ state: "failed", errorCode: "project_context_failed" });
                 return;
             }
@@ -697,6 +734,7 @@ function readOrCaptureTaskCompileContext(input) {
                 captured_by_activity_ref: input.activityRef,
                 now: input.now,
             });
+        linkTaskCompileActivity(tx, input.workflowRef, input.activityRef);
         enqueueControlPlaneIntent(tx, {
             kind: "task_compile_start",
             ownerKind: "task_compile",