@xfey/tutti 0.1.96 → 0.1.97

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/migrations/0015_control_plane_intents.sql

@@ -0,0 +1,115 @@
+CREATE TABLE control_plane_intents (
+  intent_id TEXT PRIMARY KEY CHECK (
+    intent_id GLOB 'intent_[0-7][0-9A-HJKMNP-TV-Z][0-9A-HJKMNP-TV-Z][0-9A-HJKMNP-TV-Z]*'
+    AND length(intent_id) = 33
+  ),
+  kind TEXT NOT NULL CHECK (
+    kind IN (
+      'task_compile_start',
+      'task_compile_continuation',
+      'task_bound_follow_up',
+      'scratchpad_refresh',
+      'reference_summary_refresh',
+      'run_dispatch'
+    )
+  ),
+  owner_kind TEXT NOT NULL CHECK (
+    owner_kind IN (
+      'task_compile',
+      'clarification_round',
+      'scratchpad',
+      'reference_summary',
+      'task_run'
+    )
+  ),
+  owner_ref TEXT NOT NULL CHECK (length(owner_ref) BETWEEN 1 AND 512),
+  dedupe_key TEXT NOT NULL UNIQUE CHECK (length(dedupe_key) BETWEEN 1 AND 512),
+  lane TEXT NOT NULL CHECK (lane IN ('foreground', 'scratchpad_background', 'run')),
+  priority INTEGER NOT NULL DEFAULT 100 CHECK (priority >= 0),
+  state TEXT NOT NULL DEFAULT 'pending' CHECK (
+    state IN ('pending', 'claimed', 'running', 'completed', 'failed', 'cancelled')
+  ),
+  available_at TEXT NOT NULL,
+  claim_token TEXT CHECK (claim_token IS NULL OR length(claim_token) BETWEEN 1 AND 256),
+  lease_expires_at TEXT,
+  attempt_count INTEGER NOT NULL DEFAULT 0 CHECK (attempt_count >= 0),
+  last_error_code TEXT CHECK (
+    last_error_code IS NULL OR length(last_error_code) BETWEEN 1 AND 128
+  ),
+  created_at TEXT NOT NULL,
+  updated_at TEXT NOT NULL,
+  completed_at TEXT,
+  CHECK (
+    (
+      state = 'pending'
+      AND claim_token IS NULL
+      AND lease_expires_at IS NULL
+      AND completed_at IS NULL
+    )
+    OR (
+      state IN ('claimed', 'running')
+      AND claim_token IS NOT NULL
+      AND lease_expires_at IS NOT NULL
+      AND completed_at IS NULL
+    )
+    OR (
+      state IN ('completed', 'failed', 'cancelled')
+      AND claim_token IS NULL
+      AND lease_expires_at IS NULL
+      AND completed_at IS NOT NULL
+    )
+  )
+);
+
+CREATE INDEX idx_control_plane_intents_dispatch
+  ON control_plane_intents (state, available_at ASC, priority ASC, created_at ASC, intent_id ASC);
+
+CREATE INDEX idx_control_plane_intents_expired_claim
+  ON control_plane_intents (state, lease_expires_at ASC)
+  WHERE state IN ('claimed', 'running');
+
+CREATE INDEX idx_control_plane_intents_owner
+  ON control_plane_intents (owner_kind, owner_ref, created_at ASC);
+
+CREATE TABLE pending_task_compile_submissions (
+  id TEXT PRIMARY KEY CHECK (id = 'current'),
+  workflow_ref TEXT NOT NULL UNIQUE,
+  accepted_activity_ref TEXT NOT NULL,
+  requested_at TEXT NOT NULL,
+  source_window_after_created_at TEXT,
+  source_window_after_message_id TEXT,
+  source_window_through_created_at TEXT,
+  source_window_through_message_id TEXT,
+  CHECK (
+    (source_window_after_created_at IS NULL AND source_window_after_message_id IS NULL)
+    OR (
+      source_window_after_created_at IS NOT NULL
+      AND source_window_after_message_id IS NOT NULL
+    )
+  ),
+  CHECK (
+    (source_window_through_created_at IS NULL AND source_window_through_message_id IS NULL)
+    OR (
+      source_window_through_created_at IS NOT NULL
+      AND source_window_through_message_id IS NOT NULL
+    )
+  ),
+  CHECK (
+    source_window_after_created_at IS NULL
+    OR source_window_through_created_at IS NULL
+    OR source_window_through_created_at > source_window_after_created_at
+    OR (
+      source_window_through_created_at = source_window_after_created_at
+      AND source_window_through_message_id >= source_window_after_message_id
+    )
+  )
+);
+
+CREATE TRIGGER pending_task_compile_submissions_immutable
+BEFORE UPDATE ON pending_task_compile_submissions
+BEGIN
+  SELECT RAISE(ABORT, 'pending Task Compile submission is immutable');
+END;
+
+ALTER TABLE scratchpad_source_state
+  ADD COLUMN in_flight_intent_id TEXT REFERENCES control_plane_intents(intent_id);

package/migrations/README.md

@@ -27,10 +27,11 @@
 - `0012_scratchpad_receipts.sql`：为当前 Scratchpad 增加 `submitted` 状态字段，并新增已提交 Scratchpad 小票历史表。
 - `0013_scratchpad_receipt_sources.sql`：新增当前 Scratchpad snapshot 与 submitted receipt 的 source message id 引用表，供 Timeline Task Accepted 追溯原始聊天依据。
 - `0014_scratchpad_task_compile_context.sql`：把 Scratchpad source state 收敛为纯主群聊周期 cursor，新增 durable active Task Compile Context 与完整 source refs，并把 Current Scratchpad / receipt sources 限定为主群聊。该开发阶段 migration 不迁移旧调试数据，已有本地开发数据库需要 reset / recreate。
+- `0015_control_plane_intents.sql`：新增 Control Plane durable dispatch intent，保存 bounded kind / owner / dedupe / lane、pending-to-running claim lease 与 terminal 状态，为 Clarification、Task Compile、Scratchpad、Reference Summary 和 Run 提供可恢复的 runtime handoff；同时用 immutable pending Task Compile submission row 固化 context capture 前的 workflow / main-chat cursor boundary，不保存 prompt、消息正文、provider output、secret 或 host path。
 
 ## 当前实现状态
 
-- `0001_init.sql` 至 `0014_scratchpad_task_compile_context.sql` 已存在，代表当前 host project SQLite schema contract。`0014` 明确采用开发数据库重建策略，不提供旧 Scratchpad source/cursor 数据兼容。
+- `0001_init.sql` 至 `0015_control_plane_intents.sql` 已存在，代表当前 host project SQLite schema contract。`0014` 明确采用开发数据库重建策略，不提供旧 Scratchpad source/cursor 数据兼容。
 - SQLite adapter、migration runner、checksum 校验、store metadata 初始化、transaction helper 与 command recovery scan helper 已实现。
 - 协作 repository 与 Control Plane 已实现第一批业务读写；Phase 7 首批已复用 `0001_init.sql` 中的 `tasks.latest_run_result_id`、`task_details.result_json` 与 `run_results` 表完成 Run result / checks / promotion 摘要持久化。Control Plane recovery resolver 与 task-bound continuation / retry 复用现有 schema；新 Run 的 accepted checkpoint 业务 truth 继续写入最终 Run result / task detail result，Git tag / commit trailer 承担 crash recovery evidence。Timeline 默认从 `tasks`、`run_results` 与历史主群聊 `refs.worklist_feedback` 投影任务级审计节点，当前 task terminal Chat feedback 写入 `refs.task_result` 消息；`project_timeline_events` 只保留缺少稳定 record 的轻量可观测性事件和历史 reconcile 兼容记录。project workspace、working diff 与 ignored runtime state 都不进入 SQLite truth。`provider_usage_events` 只保存 token 计数、调用来源、模型名、记录时间和可空 anchor，不保存 provider secret、prompt 或 raw response。store 基础设施本身已经可以创建并迁移 `tutti.sqlite`。
 

package/node_modules/@tutti/shared/dist/ids/index.d.ts

@@ -25,6 +25,7 @@ export declare const ID_PREFIXES: {
     readonly hostConnection: "host_connection_";
     readonly joinToken: "join_token_";
     readonly notice: "notice_";
+    readonly controlPlaneIntent: "intent_";
 };
 export type IdPrefix = (typeof ID_PREFIXES)[keyof typeof ID_PREFIXES];
 export type PrefixedId<TPrefix extends string> = `${TPrefix}${string}`;
@@ -53,6 +54,7 @@ export type RelayDesktopEntryContinuationRef = PrefixedId<typeof ID_PREFIXES.rel
 export type HostConnectionRef = PrefixedId<typeof ID_PREFIXES.hostConnection>;
 export type JoinTokenRef = PrefixedId<typeof ID_PREFIXES.joinToken>;
 export type NoticeId = PrefixedId<typeof ID_PREFIXES.notice>;
+export type ControlPlaneIntentId = PrefixedId<typeof ID_PREFIXES.controlPlaneIntent>;
 export declare function createPrefixedId<const TPrefix extends IdPrefix>(prefix: TPrefix): PrefixedId<TPrefix>;
 export declare function isUlidBody(value: string): boolean;
 export declare function getPrefixedIdBody(value: string, prefix: IdPrefix): string | null;
@@ -85,4 +87,5 @@ export declare const createRelayDesktopEntryContinuationRef: () => RelayDesktopE
 export declare const createHostConnectionRef: () => HostConnectionRef;
 export declare const createJoinTokenRef: () => JoinTokenRef;
 export declare const createNoticeId: () => NoticeId;
+export declare const createControlPlaneIntentId: () => ControlPlaneIntentId;
 //# sourceMappingURL=index.d.ts.map

package/node_modules/@tutti/shared/dist/ids/index.js

@@ -27,6 +27,7 @@ export const ID_PREFIXES = {
     hostConnection: "host_connection_",
     joinToken: "join_token_",
     notice: "notice_",
+    controlPlaneIntent: "intent_",
 };
 export function createPrefixedId(prefix) {
     return `${prefix}${ulid()}`;
@@ -87,4 +88,5 @@ export const createRelayDesktopEntryContinuationRef = () => createPrefixedId(ID_
 export const createHostConnectionRef = () => createPrefixedId(ID_PREFIXES.hostConnection);
 export const createJoinTokenRef = () => createPrefixedId(ID_PREFIXES.joinToken);
 export const createNoticeId = () => createPrefixedId(ID_PREFIXES.notice);
+export const createControlPlaneIntentId = () => createPrefixedId(ID_PREFIXES.controlPlaneIntent);
 //# sourceMappingURL=index.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xfey/tutti",
-  "version": "0.1.96",
+  "version": "0.1.97",
   "type": "module",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",