@zq-silk/yui 0.6.1 → 0.6.3

package/dist/task/nextAction.js

@@ -1,4 +1,5 @@
 import { createHash } from "node:crypto";
+import { sameTaskFinalReviewContract, validateTaskFinalReviewContract } from "../review/taskFinalReviewContract.js";
 import { currentWorkItemCandidate } from "../workItem/workItem.js";
 const OPEN_WORK_ITEM_STATUSES = new Set(["pending", "running", "awaiting_acceptance"]);
 export function projectNextAction(facts) {
@@ -47,6 +48,17 @@ export function projectNextAction(facts) {
             ]
         });
     }
+    if (task.status === "draft") {
+        return buildAction(facts, {
+            kind: "implement-current-work-item",
+            reason: `Task ${task.id} is still a Draft; activate it before dispatching, integrating, reviewing, or completing work.`,
+            refs: [ref("task", task.id)],
+            preconditions: [
+                { fact: "Task is active", satisfied: false, ref: ref("task", task.id) }
+            ],
+            recommendedCommand: `yui task activate ${task.id}`
+        });
+    }
     const candidateReady = facts.workItems
         .find((item) => item.status === "awaiting_acceptance");
     if (candidateReady !== undefined) {
@@ -64,6 +76,70 @@ export function projectNextAction(facts) {
                 recommendedCommand: `yui task work reject ${task.id}/${candidateReady.id} --summary \"empty base==head candidate\"`
             });
         }
+        const activeReview = latestActiveWorkItemReview(facts.reviewRounds, candidateReady, candidate);
+        if (activeReview !== undefined) {
+            const reviewRef = ref("review-round", activeReview.id);
+            if (activeReview.status === "running") {
+                if (reviewGroupAwaitingResolution(activeReview)) {
+                    return buildResolveReviewGroupAction(facts, activeReview);
+                }
+                if (activeReview.reviewerRunId === undefined) {
+                    return buildAction(facts, {
+                        kind: "repair-protocol-inconsistency",
+                        reason: `ReviewRound ${activeReview.id} is running but has no Reviewer Run.`,
+                        refs: [reviewRef],
+                        conflicts: [reviewRef],
+                        preconditions: [
+                            { fact: "Running ReviewRound has an exact Reviewer Run", satisfied: false, ref: reviewRef }
+                        ]
+                    });
+                }
+                const reviewRun = activeReviewRoundRun(activeReview, facts.activeRuns);
+                if (reviewRun === undefined) {
+                    const runRef = ref("agent-run", activeReview.reviewerRunId);
+                    return buildAction(facts, {
+                        kind: "repair-protocol-inconsistency",
+                        reason: `ReviewRound ${activeReview.id} references Reviewer Run ${activeReview.reviewerRunId}, but that Run is not active.`,
+                        refs: [reviewRef, runRef],
+                        conflicts: [reviewRef, runRef],
+                        preconditions: [
+                            { fact: "Reviewer Run is active", satisfied: false, ref: runRef }
+                        ]
+                    });
+                }
+                return buildAction(facts, {
+                    kind: "wait-for-owned-execution",
+                    reason: `Reviewer Run ${reviewRun.id} is evaluating Candidate ${candidateReady.id}/${candidate?.id ?? "unknown"}.`,
+                    refs: [reviewRef, ref("agent-run", reviewRun.id)],
+                    preconditions: [
+                        { fact: "ReviewRound is running", satisfied: true, ref: reviewRef },
+                        { fact: "Reviewer Run is active", satisfied: true, ref: ref("agent-run", reviewRun.id) }
+                    ]
+                });
+            }
+            if (activeReview.reviewerRunId !== undefined) {
+                const runRef = ref("agent-run", activeReview.reviewerRunId);
+                return buildAction(facts, {
+                    kind: "repair-protocol-inconsistency",
+                    reason: `Pending ReviewRound ${activeReview.id} already references Reviewer Run ${activeReview.reviewerRunId}.`,
+                    refs: [reviewRef, runRef],
+                    conflicts: [reviewRef, runRef],
+                    preconditions: [
+                        { fact: "Pending ReviewRound has no Reviewer Run", satisfied: false, ref: runRef }
+                    ]
+                });
+            }
+            return buildAction(facts, {
+                kind: "resume-review",
+                reason: `ReviewRound ${activeReview.id} is pending and never launched; resume it before accepting or rejecting the Candidate.`,
+                refs: [reviewRef],
+                preconditions: [
+                    { fact: "ReviewRound is pending", satisfied: true, ref: reviewRef },
+                    { fact: "Reviewer Run exists", satisfied: false }
+                ],
+                recommendedCommand: `yui task work review ${task.id}/${candidateReady.id}`
+            });
+        }
         const refs = [
             ref("work-item", candidateReady.id),
             ...(candidate === undefined ? [] : [ref("candidate", `${candidateReady.id}/${candidate.id}`)])
@@ -78,7 +154,25 @@ export function projectNextAction(facts) {
                     ? [{ fact: "Candidate record exists", satisfied: false }]
                     : [{ fact: "Candidate record exists", satisfied: true, ref: refs[1] }])
             ],
-            recommendedCommand: `yui task work accept ${task.id}/${candidateReady.id} --summary \"<decision>\"`
+            recommendedCommand: `yui task work accept ${task.id}/${candidateReady.id} --summary \"<decision>\"`,
+            alternatives: [
+                {
+                    kind: "reject-candidate",
+                    reason: "Reject when the Candidate does not satisfy the Task objective or acceptance criteria.",
+                    recommendedCommand: `yui task work reject ${task.id}/${candidateReady.id} --summary \"<reason>\"`,
+                    refs
+                },
+                ...(candidate?.reviewPolicy === undefined
+                    || candidate.reviewPolicy.trigger === "final"
+                    ? []
+                    : [{
+                            kind: "re-review-candidate",
+                            reason: "Request another WorkItem Review when the Leader needs independent evidence before disposition.",
+                            recommendedCommand: `yui task work review ${task.id}/${candidateReady.id}`,
+                            refs
+                        }])
+            ],
+            judgmentRequired: `Leader must judge Candidate ${candidateReady.id}/${candidate?.id ?? "unknown"} against the Task objective, acceptance criteria, and delivery risk.`
         });
     }
     const activeWorkers = facts.activeRuns.filter((run) => run.roleName !== "leader");
@@ -101,7 +195,8 @@ export function projectNextAction(facts) {
                 preconditions: [
                     { fact: "Work Item is failed", satisfied: true, ref: ref("work-item", failedWork.id) },
                     { fact: "Review Round is failed", satisfied: true, ref: ref("review-round", failedReview.id) }
-                ]
+                ],
+                recommendedCommand: `yui task review finding repair-wave ${task.id} --create`
             });
         }
         return buildAction(facts, {
@@ -114,17 +209,46 @@ export function projectNextAction(facts) {
             recommendedCommand: `yui task work update ${task.id}/${failedWork.id} running`
         });
     }
-    const openWork = facts.workItems
-        .find((item) => OPEN_WORK_ITEM_STATUSES.has(item.status));
-    if (openWork !== undefined) {
+    const openWork = selectOpenWorkItem(facts.workItems);
+    if (openWork?.kind === "blocked") {
+        const refs = [
+            ref("work-item", openWork.itemId),
+            ref("work-item", openWork.blockedBy)
+        ];
+        return buildAction(facts, {
+            kind: "repair-protocol-inconsistency",
+            reason: `Work Item ${openWork.itemId} depends on ${openWork.blockedBy}, which is not completed or available.`,
+            refs,
+            conflicts: refs,
+            preconditions: [
+                { fact: `Dependency ${openWork.blockedBy} is completed`, satisfied: false, ref: refs[1] }
+            ]
+        });
+    }
+    if (openWork?.kind === "ready") {
+        const item = openWork.item;
+        const refs = [ref("work-item", item.id)];
         return buildAction(facts, {
             kind: "implement-current-work-item",
-            reason: `Work Item ${openWork.id} is ${openWork.status}; dispatch or continue its implementation.`,
-            refs: [ref("work-item", openWork.id)],
+            reason: `Work Item ${item.id} is ${item.status}; dispatch or continue its implementation.`,
+            refs,
             preconditions: [
-                { fact: `Work Item is ${openWork.status}`, satisfied: true, ref: ref("work-item", openWork.id) }
+                { fact: `Work Item is ${item.status}`, satisfied: true, ref: refs[0] }
+            ],
+            recommendedCommand: `yui task work dispatch ${task.id}/${item.id}`,
+            alternatives: [
+                {
+                    kind: "execute-directly",
+                    reason: "Execute the bounded Work Item directly when the Leader's current context and authority are sufficient.",
+                    refs
+                },
+                {
+                    kind: "native-subagent",
+                    reason: "Use one native implementer subagent when one bounded implementation pass benefits from parallel attention.",
+                    refs
+                }
             ],
-            recommendedCommand: `yui task work dispatch ${task.id}/${openWork.id}`
+            judgmentRequired: "Leader must choose the execution path: direct execution, a native subagent, or managed Task Role dispatch."
         });
     }
     if (facts.workItems.length === 0) {
@@ -136,9 +260,7 @@ export function projectNextAction(facts) {
                 { fact: "At least one Work Item exists", satisfied: false },
                 { fact: "Task is active", satisfied: task.status === "active" }
             ],
-            recommendedCommand: task.status === "draft"
-                ? `yui task activate ${task.id}`
-                : `yui task work create ${task.id} \"<objective>\"`
+            recommendedCommand: `yui task work create ${task.id} \"<objective>\"`
         });
     }
     const uncaptured = facts.workItems.find((item) => needsChangeSetCapture(facts, item));
@@ -176,10 +298,80 @@ export function projectNextAction(facts) {
             refs: [ref("review-round", failedFinal.id)],
             preconditions: [
                 { fact: "Task-final Review is failed", satisfied: true, ref: ref("review-round", failedFinal.id) }
-            ]
+            ],
+            recommendedCommand: `yui task review finding repair-wave ${task.id} --create`
+        });
+    }
+    const activeFinal = latestTaskFinalReview(facts.reviewRounds);
+    if (activeFinal !== undefined
+        && (activeFinal.status === "pending" || activeFinal.status === "running")) {
+        const reviewRef = ref("review-round", activeFinal.id);
+        if (activeFinal.status === "running") {
+            if (reviewGroupAwaitingResolution(activeFinal)) {
+                return buildResolveReviewGroupAction(facts, activeFinal);
+            }
+            if (activeFinal.reviewerRunId === undefined) {
+                return buildAction(facts, {
+                    kind: "repair-protocol-inconsistency",
+                    reason: `Task-final ReviewRound ${activeFinal.id} is running but has no Reviewer Run.`,
+                    refs: [reviewRef],
+                    conflicts: [reviewRef],
+                    preconditions: [
+                        { fact: "Running Task-final ReviewRound has an exact Reviewer Run", satisfied: false, ref: reviewRef }
+                    ]
+                });
+            }
+            const reviewRun = activeReviewRoundRun(activeFinal, facts.activeRuns);
+            if (reviewRun === undefined) {
+                const runRef = ref("agent-run", activeFinal.reviewerRunId);
+                return buildAction(facts, {
+                    kind: "repair-protocol-inconsistency",
+                    reason: `Task-final ReviewRound ${activeFinal.id} references Reviewer Run ${activeFinal.reviewerRunId}, but that Run is not active.`,
+                    refs: [reviewRef, runRef],
+                    conflicts: [reviewRef, runRef],
+                    preconditions: [
+                        { fact: "Reviewer Run is active", satisfied: false, ref: runRef }
+                    ]
+                });
+            }
+            return buildAction(facts, {
+                kind: "wait-for-owned-execution",
+                reason: `Reviewer Run ${reviewRun.id} is executing Task-final Review ${activeFinal.id}.`,
+                refs: [reviewRef, ref("agent-run", reviewRun.id)],
+                preconditions: [
+                    { fact: "Task-final ReviewRound is running", satisfied: true, ref: reviewRef },
+                    { fact: "Reviewer Run is active", satisfied: true, ref: ref("agent-run", reviewRun.id) }
+                ]
+            });
+        }
+        if (activeFinal.reviewerRunId !== undefined) {
+            const runRef = ref("agent-run", activeFinal.reviewerRunId);
+            return buildAction(facts, {
+                kind: "repair-protocol-inconsistency",
+                reason: `Pending Task-final ReviewRound ${activeFinal.id} already references Reviewer Run ${activeFinal.reviewerRunId}.`,
+                refs: [reviewRef, runRef],
+                conflicts: [reviewRef, runRef],
+                preconditions: [
+                    { fact: "Pending Task-final ReviewRound has no Reviewer Run", satisfied: false, ref: runRef }
+                ]
+            });
+        }
+        return buildAction(facts, {
+            kind: "resume-review",
+            reason: `Task-final ReviewRound ${activeFinal.id} is pending and never launched; retry it under the same semantic Round.`,
+            refs: [reviewRef],
+            preconditions: [
+                { fact: "Task-final ReviewRound is pending", satisfied: true, ref: reviewRef },
+                { fact: "Reviewer Run exists", satisfied: false }
+            ],
+            recommendedCommand: `yui task review retry ${task.id}/${activeFinal.id}`
         });
     }
-    if (task.projectBindings.length > 0 && !hasValidFinalReview(facts)) {
+    const finalReviewRequired = taskFinalReviewRequired(facts);
+    if (task.projectBindings.length > 0
+        && finalReviewRequired
+        && !hasValidFinalReview(facts)) {
+        const reviewerRole = taskFinalReviewRole(facts);
         return buildAction(facts, {
             kind: "request-final-review",
             reason: "All Work Items are delivered but no valid Task-final Review attests the integrated head.",
@@ -189,9 +381,20 @@ export function projectNextAction(facts) {
                 { fact: "Every ChangeSet is committed", satisfied: true },
                 { fact: "Valid Task-final Review at the integrated head", satisfied: false }
             ],
-            recommendedCommand: `yui task review request ${task.id} --role <global-reviewer>`
+            recommendedCommand: `yui task review request ${task.id} --role ${reviewerRole ?? "<reviewer-role>"}`
         });
     }
+    const finalReviewOptional = task.projectBindings.length > 0
+        && !finalReviewRequired
+        && !hasValidFinalReview(facts);
+    const finalReviewAlternative = finalReviewOptional && facts.reviewConfig !== null
+        ? [{
+                kind: "request-final-review",
+                reason: "Request an independent Task-final Review when the Leader wants extra assurance before completion.",
+                recommendedCommand: `yui task review request ${task.id} --role ${facts.reviewConfig.roleName}`,
+                refs: [ref("task", task.id)]
+            }]
+        : [];
     return buildAction(facts, {
         kind: "complete-task",
         reason: "The delivery chain is complete; converge the Task instead of creating successor work.",
@@ -202,9 +405,18 @@ export function projectNextAction(facts) {
                 ? []
                 : [
                     { fact: "Every ChangeSet is committed", satisfied: true },
-                    { fact: "Valid Task-final Review at the integrated head", satisfied: true }
+                    {
+                        fact: "Valid Task-final Review at the integrated head",
+                        satisfied: hasValidFinalReview(facts)
+                    }
                 ])
         ],
+        ...(finalReviewAlternative.length === 0 ? {} : { alternatives: finalReviewAlternative }),
+        ...(!finalReviewOptional
+            ? {}
+            : {
+                judgmentRequired: "Leader must decide whether the integrated delivery is safe to complete directly or needs an optional Task-final Review."
+            }),
         recommendedCommand: `yui task complete ${task.id} --summary-file -`
     });
 }
@@ -237,10 +449,174 @@ function buildAction(facts, input) {
         ...(input.recommendedCommand === undefined
             ? {}
             : { recommendedCommand: input.recommendedCommand }),
+        ...(input.alternatives === undefined || input.alternatives.length === 0
+            ? {}
+            : { alternatives: input.alternatives }),
+        ...(input.judgmentRequired === undefined
+            ? {}
+            : { judgmentRequired: input.judgmentRequired }),
         ...(input.conflicts === undefined ? {} : { conflicts: input.conflicts }),
         fingerprint: createHash("sha256").update(fingerprintSource).digest("hex")
     };
 }
+function latestActiveWorkItemReview(rounds, item, candidate) {
+    if (candidate === undefined)
+        return undefined;
+    return [...rounds]
+        .reverse()
+        .find((round) => (round.workItemId === item.id
+        && round.candidateId === candidate.id
+        && (round.status === "pending" || round.status === "running")));
+}
+function activeReviewRoundRun(round, activeRuns) {
+    if (round.executionGroup !== undefined) {
+        for (const lane of round.executionGroup.lanes) {
+            if (lane.status !== "running"
+                || lane.reviewRoundId !== round.id
+                || lane.runId === undefined) {
+                continue;
+            }
+            const run = activeRuns.find((candidate) => (candidate.id === lane.runId && candidate.roleName === lane.roleName));
+            if (run !== undefined)
+                return run;
+        }
+        return undefined;
+    }
+    if (round.reviewerRunId === undefined)
+        return undefined;
+    return activeRuns.find((run) => (run.id === round.reviewerRunId && run.roleName === round.reviewerRoleName));
+}
+const TERMINAL_REVIEW_LANE_STATUSES = new Set(["yielded", "completed", "failed"]);
+function isPanelReviewRound(round) {
+    return round.executionGroup !== undefined
+        && (round.executionGroup.lanes.length > 1
+            || round.executionGroup.strategy.mode === "adaptive");
+}
+function reviewGroupAwaitingResolution(round) {
+    return round.status === "running"
+        && round.executionGroup !== undefined
+        && round.executionGroup.resolution === undefined
+        && isPanelReviewRound(round)
+        && round.executionGroup.lanes.every((lane) => TERMINAL_REVIEW_LANE_STATUSES.has(lane.status));
+}
+function buildResolveReviewGroupAction(facts, round) {
+    const group = round.executionGroup;
+    const refs = [
+        ref("review-round", round.id),
+        ref("execution-group", group.id)
+    ];
+    const resolveCommand = (decision) => `yui task review group resolve ${facts.task.id}/${round.id}`
+        + ` --decision ${decision} --summary \"<decision>\"`;
+    return buildAction(facts, {
+        kind: "resolve-review-group",
+        reason: `Reviewer panel ${group.id} has finished every Lane; the Leader must resolve ReviewRound ${round.id}.`,
+        refs,
+        preconditions: [
+            { fact: "ReviewRound is running", satisfied: true, ref: refs[0] },
+            { fact: "Every Reviewer Lane is terminal", satisfied: true, ref: refs[1] },
+            { fact: "Leader has resolved the Review ExecutionGroup", satisfied: false, ref: refs[1] }
+        ],
+        recommendedCommand: resolveCommand("<accept|reject|blocked>"),
+        alternatives: [
+            {
+                kind: "accept-review-group",
+                reason: "Accept the usable Lane outputs when their evidence satisfies the Task objective.",
+                recommendedCommand: resolveCommand("accept"),
+                refs
+            },
+            {
+                kind: "reject-review-group",
+                reason: "Reject the panel evidence when it does not support the delivery.",
+                recommendedCommand: resolveCommand("reject"),
+                refs
+            },
+            {
+                kind: "block-review-group",
+                reason: "Block the Review when a material dependency or external fact prevents a sound decision.",
+                recommendedCommand: resolveCommand("blocked"),
+                refs
+            }
+        ],
+        judgmentRequired: `Leader must judge Review panel ${group.id} against the Task objective, acceptance criteria, and delivery risk.`
+    });
+}
+function reviewRoundConflict(round, activeRuns) {
+    const reviewRef = ref("review-round", round.id);
+    if (round.status === "running") {
+        if (reviewGroupAwaitingResolution(round)) {
+            return null;
+        }
+        if (round.reviewerRunId === undefined) {
+            return {
+                reason: `ReviewRound ${round.id} is running but has no Reviewer Run.`,
+                conflicts: [reviewRef]
+            };
+        }
+        if (activeReviewRoundRun(round, activeRuns) === undefined) {
+            const runRef = ref("agent-run", round.reviewerRunId);
+            return {
+                reason: `ReviewRound ${round.id} references Reviewer Run ${round.reviewerRunId}, but that Run is not active.`,
+                conflicts: [reviewRef, runRef]
+            };
+        }
+    }
+    if (round.status === "pending") {
+        const launchedRunId = round.reviewerRunId
+            ?? round.executionGroup?.lanes.find((lane) => lane.runId !== undefined)?.runId;
+        if (launchedRunId !== undefined) {
+            const runRef = ref("agent-run", launchedRunId);
+            return {
+                reason: `Pending ReviewRound ${round.id} already references Reviewer Run ${launchedRunId}.`,
+                conflicts: [reviewRef, runRef]
+            };
+        }
+    }
+    return null;
+}
+function selectOpenWorkItem(workItems) {
+    const byId = new Map(workItems.map((item) => [item.id, item]));
+    const openItems = workItems.filter((item) => OPEN_WORK_ITEM_STATUSES.has(item.status));
+    if (openItems.length === 0)
+        return { kind: "none" };
+    const eligible = openItems.find((item) => (item.dependsOn.every((dependencyId) => byId.get(dependencyId)?.status === "completed")));
+    if (eligible !== undefined)
+        return { kind: "ready", item: eligible };
+    let current = openItems[0];
+    const visited = new Set();
+    while (current !== undefined) {
+        if (visited.has(current.id)) {
+            return { kind: "blocked", itemId: current.id, blockedBy: current.id };
+        }
+        visited.add(current.id);
+        const blockedBy = current.dependsOn
+            .find((dependencyId) => byId.get(dependencyId)?.status !== "completed");
+        if (blockedBy === undefined)
+            return { kind: "ready", item: current };
+        const dependency = byId.get(blockedBy);
+        if (dependency === undefined || !OPEN_WORK_ITEM_STATUSES.has(dependency.status)) {
+            return { kind: "blocked", itemId: current.id, blockedBy };
+        }
+        current = dependency;
+    }
+    return { kind: "none" };
+}
+function taskFinalReviewContract(facts) {
+    const contract = facts.workItems
+        .flatMap((item) => item.candidates)
+        .map((candidate) => candidate.taskFinalReviewContract)
+        .find((contract) => contract !== undefined);
+    return contract === undefined ? undefined : validateTaskFinalReviewContract(contract);
+}
+function taskFinalReviewRequired(facts) {
+    return taskFinalReviewContract(facts) !== undefined
+        || latestTaskFinalReview(facts.reviewRounds) !== undefined
+        || facts.reviewConfig?.trigger === "final";
+}
+function taskFinalReviewRole(facts) {
+    return taskFinalReviewContract(facts)?.reviewerRoleName
+        ?? latestTaskFinalReview(facts.reviewRounds)?.reviewerRoleName
+        ?? (facts.reviewConfig?.trigger === "final" ? facts.reviewConfig.roleName : undefined);
+}
 function ref(kind, id) {
     return { kind, id };
 }
@@ -303,6 +679,25 @@ function hasValidFinalReview(facts) {
 function detectProtocolInconsistency(facts) {
     const changeSetIds = new Set(facts.changeSets.map((changeSet) => changeSet.id));
     const workItemById = new Map(facts.workItems.map((item) => [item.id, item]));
+    const contractedCandidates = facts.workItems
+        .flatMap((item) => item.candidates.map((candidate) => ({ item, candidate })))
+        .filter(({ candidate }) => candidate.taskFinalReviewContract !== undefined);
+    if (contractedCandidates.length > 1) {
+        const first = validateTaskFinalReviewContract(contractedCandidates[0].candidate.taskFinalReviewContract);
+        const conflict = contractedCandidates.find(({ candidate }) => (!sameTaskFinalReviewContract(first, candidate.taskFinalReviewContract)));
+        if (conflict !== undefined) {
+            const refs = contractedCandidates.map(({ item, candidate }) => ref("candidate", `${item.id}/${candidate.id}`));
+            return {
+                reason: "Task-final Review contracts conflict across Candidates; the completion gate is ambiguous.",
+                conflicts: refs
+            };
+        }
+    }
+    for (const round of facts.reviewRounds) {
+        const reviewConflict = reviewRoundConflict(round, facts.activeRuns);
+        if (reviewConflict !== null)
+            return reviewConflict;
+    }
     for (const attempt of facts.integrations) {
         if (attempt.status !== "committed")
             continue;

package/dist/telemetry/sqliteTelemetryStore.js

@@ -163,34 +163,6 @@ export class SqliteTelemetryStore {
     revision() {
         return this.#applied;
     }
-    latestProgressEvents(taskId) {
-        const db = this.#ensureDb();
-        if (db === null)
-            return [];
-        const rows = db.prepare(`SELECT task_id, role_name, run_id, generation, progress_id, sequence, payload, received_at FROM (
-         SELECT *, ROW_NUMBER() OVER (
-           PARTITION BY run_id
-           ORDER BY COALESCE(sequence, -1) DESC, received_at DESC, progress_id ASC
-         ) AS rn FROM telemetry WHERE task_id = ?
-       ) WHERE rn = 1`).all(taskId);
-        return rows.map((row) => {
-            const entry = rowToEntry(row);
-            const payload = { ...entry.payload };
-            payload.runId = entry.runId;
-            payload.progressId = entry.progressId;
-            // The semantic progress event carries progressAt = observation time;
-            // mirror that so liveness folds see the same timestamp.
-            payload.progressAt = entry.receivedAt;
-            return {
-                schemaVersion: 2,
-                id: `telemetry-progress-${entry.runId}-${entry.progressId}`,
-                taskId: entry.taskId,
-                type: "runtime.provider-turn-progress",
-                payload,
-                createdAt: entry.receivedAt
-            };
-        });
-    }
     // -- retention -----------------------------------------------------------------
     pruneGeneration(taskId, roleName, runId, generation, keep = this.#terminalKeep) {
         const db = this.#ensureDb();

package/dist/telemetry/telemetryCompaction.js

@@ -15,6 +15,7 @@ import { DEFAULT_TERMINAL_KEEP } from "./telemetryConfig.js";
  * copy only after this module validates the result; a validation failure
  * throws and leaves the original history unchanged.
  */
+/** Historical pre-Driver event type accepted only by the offline migration. */
 export const PROGRESS_EVENT_TYPE = "runtime.provider-turn-progress";
 /**
  * Scan a store and build the compaction plan. Read-only: nothing is modified.

package/dist/telemetry/telemetryConfig.js

@@ -2,10 +2,9 @@
  * Issue 09 — telemetry retention & compaction configuration.
  *
  * Telemetry lives in the Home's authoritative `yui.db` (database-only
- * direction). Its activation is an explicit per-Home switch so the feature
- * can be rolled out (legacy → dual → bounded) and rolled back independently
- * of every other Issue. Retention defaults are the schema's own constants
- * (§4.4); the environment only overrides them.
+ * direction). Its activation is an explicit per-Home diagnostic switch and
+ * never changes canonical runtime-state persistence. Retention defaults are
+ * the schema's own constants (§4.4); the environment only overrides them.
  */
 import { TELEMETRY_KEEP_PER_GENERATION, TELEMETRY_RUN_CAP } from "../storage/sqliteSchema.js";
 export const DEFAULT_TELEMETRY_MODE = "legacy";
@@ -23,7 +22,7 @@ const TELEMETRY_MODES = ["legacy", "dual", "bounded"];
 /**
  * Resolve `YUI_TELEMETRY_MODE` (default `legacy`). Only the three exact
  * values (case-insensitive) are accepted; anything else fails closed at
- * startup instead of silently changing progress routing.
+ * startup instead of silently changing diagnostic retention.
  */
 export function resolveTelemetryMode(env = process.env) {
     const raw = env.YUI_TELEMETRY_MODE?.trim().toLowerCase();