@zq-silk/yui 0.10.0 → 0.11.0

package/dist/scheduler/taskExecutionProjection.js

@@ -1,14 +1,16 @@
 import { operationalTaskRecords } from "../task/taskRecordRetirement.js";
 import { currentWorkItemExecutionGroup } from "../workItem/workItem.js";
 import { mailboxBatches } from "../coordination/workMailbox.js";
-import { summarizeExecutionGroup } from "../execution/executionGroup.js";
+import { actionableExecutionLaneRecoveries, summarizeExecutionGroupHealth } from "../execution/executionHealth.js";
+import { buildTaskObservabilityProjection } from "./taskObservabilityProjection.js";
 import { isRoleRunStalled, latestStallProgressAt } from "./roleRunStall.js";
+import { resolveRuntimeHealth } from "../config/yuiConfig.js";
 /**
  * Build one consistent Task-first projection from the existing durable
  * aggregate. This function only reads; it never starts a Controller, queues a
  * wake, writes a Message, or mutates any record.
  */
-export function buildTaskExecutionProjection(store, taskId, taskOverride) {
+export function buildTaskExecutionProjection(store, taskId, taskOverride, now = new Date()) {
     const task = store.getTask?.(taskId) ?? taskOverride ?? null;
     if (task === null)
         return null;
@@ -34,6 +36,9 @@ export function buildTaskExecutionProjection(store, taskId, taskOverride) {
             ? []
             : collectExecutionGroups(store.listWorkItems?.(taskId) ?? [], store.listReviewRounds?.(taskId) ?? []),
         workItems: store.listWorkItems?.(taskId) ?? [],
+        ...(store.listContextSnapshots === undefined
+            ? {}
+            : { contextSnapshots: store.listContextSnapshots(taskId) }),
         inputRequests: store.listInputRequests?.(taskId) ?? [],
         ...(store.listReviewRounds === undefined
             ? {}
@@ -50,7 +55,9 @@ export function buildTaskExecutionProjection(store, taskId, taskOverride) {
         leaderMailbox,
         leaderFailure: store.getLeaderFailure?.(taskId) ?? null,
         operatorNotification: store.getOperatorNotification?.(taskId) ?? null,
-        roleSessions
+        roleSessions,
+        now,
+        runtimeHealthPolicy: resolveRuntimeHealth(store.getConfig?.().runtimeHealth)
     });
 }
 /**
@@ -72,10 +79,37 @@ export function projectTaskExecutionFromFacts(facts) {
 export const deriveTaskExecutionProjection = projectTaskExecution;
 export function projectTaskExecution(facts) {
     const { task, roles, runs, workItems = [], inputRequests = [], reviewRounds = [], integrations = [], events = [], pendingWakeup = null, leaderMailbox = null, leaderFailure = null, operatorNotification = null, roleSessions = [], executionGroups = [] } = facts;
-    const groupSummaries = executionGroups.map((group) => summarizeExecutionGroup(group));
+    const now = facts.now ?? new Date();
+    const groupSummaries = executionGroups.map((group) => {
+        const stageGroups = workItems.find((item) => (item.executionGroups.some(({ id }) => id === group.id)))?.executionGroups;
+        return summarizeExecutionGroupHealth({
+            group,
+            ...(stageGroups === undefined ? {} : { stageGroups }),
+            runs,
+            sessions: roleSessions,
+            events,
+            now,
+            policy: facts.runtimeHealthPolicy
+        });
+    });
+    const observabilityGroups = uniqueExecutionGroups([
+        ...executionGroups,
+        ...workItems.flatMap((item) => item.executionGroups)
+    ]);
+    const observability = buildTaskObservabilityProjection({
+        workItems,
+        executionGroups: observabilityGroups,
+        groupSummaries,
+        runs,
+        events,
+        contextSnapshots: facts.contextSnapshots,
+        now
+    });
+    const laneRecovery = actionableExecutionLaneRecoveries(groupSummaries)[0];
     const render = (input) => projection({
         ...input,
-        executionGroups: groupSummaries
+        executionGroups: groupSummaries,
+        observability
     });
     const activeRuns = runs.filter((run) => run.status === "active");
     const activeRunViews = activeRuns.map((run) => ({
@@ -138,8 +172,10 @@ export function projectTaskExecution(facts) {
         || attempt.status === "validating"
         || attempt.status === "blocked"));
     const hasLeaderMismatch = attention.some((item) => item.kind === "identity-mismatch");
-    if (attention.length > 0) {
+    const renderAttention = () => {
         const first = attention[0];
+        if (first === undefined)
+            throw new Error("Task execution attention disappeared.");
         const progressingWithAttention = first.kind === "checkpoint-overdue"
             && healthyExecutionCarriers.length > 0;
         return render({
@@ -159,6 +195,9 @@ export function projectTaskExecution(facts) {
             blockers,
             pendingWakeup
         });
+    };
+    if (attention.length > 0 && hasLeaderMismatch) {
+        return renderAttention();
     }
     if (openInputs.length > 0) {
         return render({
@@ -177,6 +216,30 @@ export function projectTaskExecution(facts) {
             pendingWakeup
         });
     }
+    if (laneRecovery !== undefined) {
+        return render({
+            task,
+            status: laneRecovery.runtimeHealth === "confirmed-dead"
+                ? "attention"
+                : "needs-leader-action",
+            owner: "leader",
+            action: "recover-execution",
+            summary: `Execution Lane ${laneRecovery.laneId} in ${laneRecovery.groupId}`
+                + ` requires ${laneRecovery.recovery}`
+                + (laneRecovery.runId === undefined ? "." : ` for exact Run ${laneRecovery.runId}.`),
+            reason: `execution-lane-${laneRecovery.recovery}`,
+            monitoring,
+            failClosed: false,
+            activeRuns: activeRunViews,
+            activeExecutorCount: activeExecutors.length,
+            attention,
+            blockers,
+            pendingWakeup
+        });
+    }
+    if (attention.length > 0) {
+        return renderAttention();
+    }
     if (blockedIntegration || failedWork || hasLeaderMismatch) {
         return render({
             task,
@@ -335,19 +398,53 @@ function projection(input) {
         activeExecutorCount: input.activeExecutorCount,
         activeRuns: input.activeRuns,
         executionGroups: input.executionGroups ?? [],
+        observability: input.observability,
         attention: input.attention,
         blockers: input.blockers,
         pendingWakeup: input.pendingWakeup,
         next: { owner: input.owner, action: input.action }
     };
 }
+function uniqueExecutionGroups(groups) {
+    const seen = new Set();
+    return groups.filter((group) => {
+        if (seen.has(group.id))
+            return false;
+        seen.add(group.id);
+        return true;
+    });
+}
 function collectExecutionGroups(workItems, reviewRounds) {
+    const workItemsById = new Map(workItems.map((item) => [item.id, item]));
+    const orderedRounds = [...reviewRounds].sort((left, right) => (left.id.localeCompare(right.id, undefined, { numeric: true })));
+    const latestTaskRound = orderedRounds
+        .filter((round) => (round.scope ?? "work-item") === "task")
+        .at(-1);
+    const latestWorkItemRounds = new Map();
+    for (const round of orderedRounds) {
+        if ((round.scope ?? "work-item") === "task"
+            || round.workItemId === undefined
+            || round.candidateId === undefined)
+            continue;
+        const item = workItemsById.get(round.workItemId);
+        if (item === undefined
+            || item.status === "retired"
+            || item.candidates.at(-1)?.id !== round.candidateId)
+            continue;
+        latestWorkItemRounds.set(`${round.workItemId}\0${round.candidateId}`, round);
+    }
+    const operationalReviewRoundIds = new Set([
+        ...(latestTaskRound === undefined ? [] : [latestTaskRound.id]),
+        ...[...latestWorkItemRounds.values()].map(({ id }) => id)
+    ]);
     const groups = [
-        ...workItems.flatMap((item) => {
+        ...workItems.filter(({ status }) => status !== "retired").flatMap((item) => {
             const group = currentWorkItemExecutionGroup(item);
             return group === undefined ? [] : [group];
         }),
-        ...reviewRounds.flatMap((round) => round.executionGroup === undefined ? [] : [round.executionGroup])
+        ...reviewRounds.flatMap((round) => (!operationalReviewRoundIds.has(round.id) || round.executionGroup === undefined
+            ? []
+            : [round.executionGroup]))
     ];
     const seen = new Set();
     return groups.filter((group) => {

package/dist/scheduler/taskObservabilityProjection.js

@@ -0,0 +1,282 @@
+import { isDeepStrictEqual } from "node:util";
+import { observedExecutionResourceUsage } from "../execution/resourceBroker.js";
+import { runtimeObservationFromTaskEvent } from "../runtime/runtimeObservation.js";
+/**
+ * Build the read-only DAG, execution, cost, and context view consumed by CLI
+ * and Web. It deliberately derives every value from existing Task records and
+ * never persists or repairs a second graph/status authority.
+ */
+export function buildTaskObservabilityProjection(input) {
+    const now = input.now ?? new Date();
+    const summariesById = new Map((input.groupSummaries ?? []).map((summary) => [summary.groupId, summary]));
+    const dag = projectDag(input.workItems);
+    const workItems = input.workItems.map((item) => {
+        const groups = item.executionGroups;
+        const executionGroups = groups.flatMap((group) => {
+            const summary = summariesById.get(group.id);
+            return summary === undefined ? [] : [summary];
+        });
+        const stages = groups.map((group) => {
+            const summary = summariesById.get(group.id);
+            return Object.freeze({
+                groupId: group.id,
+                ...(group.stage === undefined ? {} : {
+                    mode: group.stage.mode,
+                    stage: group.stage.stage,
+                    round: group.stage.round,
+                    stageAttempt: group.stage.stageAttempt
+                }),
+                laneCount: group.lanes.length,
+                activeLaneCount: group.lanes.filter(({ status }) => status === "pending" || status === "running").length,
+                terminalLaneCount: group.lanes.filter(({ status }) => isTerminalLane(status)).length,
+                ...(group.resolution === undefined ? {} : { resolution: group.resolution.decision }),
+                ...(summary?.resources === undefined ? {} : { resources: summary.resources })
+            });
+        });
+        const itemCost = projectCost(groups, input.runs, input.events, now);
+        const itemContext = projectContext(groups, input.runs, input.events, input.contextSnapshots);
+        const evidence = groups.flatMap((group) => group.lanes.flatMap((lane) => (lane.result?.evidence ?? [])));
+        const openFindingCount = groups.reduce((count, group) => count + group.lanes.reduce((laneCount, lane) => laneCount + (lane.result?.findings ?? [])
+            .filter(({ status }) => status === "open").length, 0), 0);
+        return Object.freeze({
+            workItemId: item.id,
+            title: item.title,
+            status: item.status,
+            ...(item.currentExecutionGroupId === undefined ? {} : { currentGroupId: item.currentExecutionGroupId }),
+            groupIds: groups.map(({ id }) => id),
+            executionGroups,
+            stages,
+            cost: itemCost,
+            context: itemContext,
+            evidenceCount: evidence.length,
+            openFindingCount
+        });
+    });
+    const cost = projectCost(input.executionGroups, input.runs, input.events, now);
+    const context = projectContext(input.executionGroups, input.runs, input.events, input.contextSnapshots);
+    return Object.freeze({ dag, workItems, cost, context });
+}
+function projectDag(workItems) {
+    const byId = new Map(workItems.map((item) => [item.id, item]));
+    const dependents = new Map();
+    for (const item of workItems)
+        dependents.set(item.id, []);
+    const edges = [];
+    for (const item of workItems) {
+        for (const dependency of item.dependsOn) {
+            const target = byId.get(dependency);
+            const status = dependencyEdgeStatus(dependency, byId);
+            edges.push({ from: dependency, to: item.id, status });
+            dependents.get(dependency)?.push(item.id);
+        }
+    }
+    const nodes = workItems.map((item) => {
+        const unresolved = item.dependsOn.filter((dependency) => {
+            return !dependencySatisfied(dependency, byId);
+        });
+        const projectedStatus = item.status === "pending"
+            ? unresolved.length === 0 ? "ready" : "blocked"
+            : item.status;
+        return Object.freeze({
+            id: item.id,
+            title: item.title,
+            status: item.status,
+            projectedStatus,
+            dependsOn: item.dependsOn,
+            dependentIds: Object.freeze([...(dependents.get(item.id) ?? [])]),
+            rootCauseIds: Object.freeze(rootCauses(item.id, byId)),
+            ...(item.disposition?.replacementWorkItemId === undefined
+                ? {}
+                : { replacementWorkItemId: item.disposition.replacementWorkItemId })
+        });
+    });
+    return Object.freeze({
+        nodes,
+        edges: Object.freeze(edges),
+        readyIds: Object.freeze(nodes.filter(({ projectedStatus }) => projectedStatus === "ready").map(({ id }) => id)),
+        blockedIds: Object.freeze(nodes.filter(({ projectedStatus }) => projectedStatus === "blocked").map(({ id }) => id))
+    });
+}
+function rootCauses(id, byId) {
+    const result = [];
+    const visited = new Set();
+    const visit = (currentId) => {
+        if (visited.has(currentId))
+            return;
+        visited.add(currentId);
+        const item = byId.get(currentId);
+        if (item === undefined) {
+            result.push(currentId);
+            return;
+        }
+        const unresolved = item.dependsOn.filter((dependency) => !dependencySatisfied(dependency, byId));
+        if (unresolved.length === 0) {
+            if (item.status === "failed" || item.status === "awaiting_acceptance")
+                result.push(item.id);
+            return;
+        }
+        for (const dependency of unresolved) {
+            const target = resolveDependency(dependency, byId);
+            if (target?.status === "failed" || target?.status === "awaiting_acceptance")
+                result.push(target.id);
+            else
+                visit(dependency);
+        }
+    };
+    visit(id);
+    return [...new Set(result)];
+}
+function dependencySatisfied(id, byId) {
+    const target = resolveDependency(id, byId);
+    return target !== undefined && (target.status === "completed" || (target.status === "retired" && target.disposition?.replacementWorkItemId === undefined));
+}
+function dependencyEdgeStatus(id, byId) {
+    const target = byId.get(id);
+    if (target === undefined)
+        return "dead";
+    if (dependencySatisfied(id, byId))
+        return "satisfied";
+    const resolved = resolveDependency(id, byId);
+    if (resolved === undefined)
+        return "dead";
+    if (resolved.status === "failed" || resolved.status === "awaiting_acceptance")
+        return "failed-open";
+    return "active";
+}
+function resolveDependency(id, byId) {
+    const visited = new Set();
+    let current = byId.get(id);
+    while (current?.status === "retired" && current.disposition?.replacementWorkItemId !== undefined) {
+        if (visited.has(current.id))
+            return undefined;
+        visited.add(current.id);
+        current = byId.get(current.disposition.replacementWorkItemId);
+    }
+    return current;
+}
+function projectCost(groups, runs, events, now) {
+    const stageGroups = latestStageGroups(groups);
+    let tokens = 0;
+    let toolCalls = 0;
+    let wallClockSeconds = 0;
+    let tokensObservable = true;
+    let toolCallsObservable = true;
+    let laneCount = 0;
+    let retryCount = 0;
+    for (const group of stageGroups) {
+        const lineage = groups.filter((candidate) => sameStage(candidate, group));
+        const usage = observedExecutionResourceUsage({ group, stageGroups: lineage, runs, events });
+        tokens += usage.tokens;
+        toolCalls += usage.toolCalls;
+        tokensObservable = tokensObservable && (usage.tokensObservable ?? true);
+        toolCallsObservable = toolCallsObservable && (usage.toolCallsObservable ?? true);
+        wallClockSeconds += stageDurationSeconds(lineage, now);
+        laneCount += group.lanes.length;
+        retryCount += Math.max(0, lineage.length - 1);
+    }
+    return Object.freeze({
+        tokens,
+        toolCalls,
+        wallClockSeconds,
+        tokensObservable,
+        toolCallsObservable,
+        laneCount,
+        groupCount: stageGroups.length,
+        retryCount,
+        marginalValuePercent: null,
+        marginalValueStatus: "unavailable"
+    });
+}
+function projectContext(groups, runs, events, snapshots) {
+    const refs = new Map();
+    for (const group of groups) {
+        const ref = group.stage?.contextSnapshotRef;
+        if (ref !== undefined)
+            refs.set(ref.id, ref);
+    }
+    for (const run of runs) {
+        const ref = run.assignment.contextSnapshotRef;
+        if (ref !== undefined)
+            refs.set(ref.id, ref);
+    }
+    const snapshotById = new Map((snapshots ?? []).map((snapshot) => [snapshot.id, snapshot]));
+    const metrics = [...refs.values()].sort((left, right) => left.sequence - right.sequence || left.id.localeCompare(right.id))
+        .map((ref) => {
+        const snapshot = snapshotById.get(ref.id);
+        const byteSize = snapshot === undefined ? null : Buffer.byteLength(JSON.stringify(snapshot), "utf8");
+        return Object.freeze({
+            id: ref.id,
+            scope: ref.scope,
+            sequence: ref.sequence,
+            digest: ref.digest,
+            refCount: snapshot?.refs.length ?? null,
+            resourceCount: snapshot?.resources.length ?? null,
+            byteSize,
+            ...(snapshot?.parentRef === undefined ? {} : { parentId: snapshot.parentRef.id })
+        });
+    });
+    const sizes = metrics.flatMap(({ byteSize }) => byteSize === null ? [] : [byteSize]);
+    const observedInputPeakTokens = events.flatMap((event) => {
+        const observation = runtimeObservationFromTaskEvent(event);
+        const inputTokens = observation?.payload.usage?.inputTokens;
+        return inputTokens === undefined ? [] : [inputTokens];
+    }).reduce((peak, value) => Math.max(peak, value), 0);
+    return Object.freeze({
+        snapshotCount: metrics.length,
+        snapshots: Object.freeze(metrics),
+        totalBytes: sizes.length === metrics.length ? sizes.reduce((sum, size) => sum + size, 0) : null,
+        largestBytes: sizes.length === 0 ? null : Math.max(...sizes),
+        observedInputPeakTokens,
+        compressionEvents: null,
+        compressionRatio: null,
+        compressionStatus: "unavailable"
+    });
+}
+function latestStageGroups(groups) {
+    const latest = new Map();
+    for (const group of groups) {
+        const key = group.stage === undefined ? `group:${group.id}` : stageKey(group);
+        const existing = latest.get(key);
+        if (existing === undefined || compareStageGroup(existing, group) < 0)
+            latest.set(key, group);
+    }
+    return [...latest.values()].sort((left, right) => left.createdAt.localeCompare(right.createdAt));
+}
+function sameStage(left, right) {
+    if (left.stage === undefined || right.stage === undefined)
+        return left.id === right.id;
+    return left.taskId === right.taskId
+        && executionTargetKey(left) === executionTargetKey(right)
+        && left.stage.mode === right.stage.mode
+        && left.stage.stage === right.stage.stage
+        && left.stage.round === right.stage.round
+        && isDeepStrictEqual(left.stage.budget, right.stage.budget)
+        && isDeepStrictEqual(left.stage.resources, right.stage.resources);
+}
+function stageKey(group) {
+    const stage = group.stage;
+    return `${executionTargetKey(group)}\0${stage.mode}\0${stage.stage}\0${stage.round}`;
+}
+function executionTargetKey(group) {
+    const target = group.target;
+    return `${target.kind}\0${target.workItemId ?? ""}\0${target.candidateId ?? ""}`;
+}
+function compareStageGroup(left, right) {
+    return (left.stage?.stageAttempt ?? 1) - (right.stage?.stageAttempt ?? 1)
+        || left.updatedAt.localeCompare(right.updatedAt)
+        || left.id.localeCompare(right.id);
+}
+function stageDurationSeconds(groups, now) {
+    const started = groups.map(({ createdAt }) => Date.parse(createdAt)).filter(Number.isFinite);
+    const ended = groups.map((group) => Date.parse(group.updatedAt)).filter(Number.isFinite);
+    if (started.length === 0)
+        return 0;
+    const hasOpenWork = groups.some((group) => group.lanes.some(({ status }) => (status === "pending" || status === "running")));
+    const end = hasOpenWork || ended.length === 0
+        ? now.getTime()
+        : Math.max(...ended);
+    return Math.max(0, Math.floor((end - Math.min(...started)) / 1_000));
+}
+function isTerminalLane(status) {
+    return status === "yielded" || status === "completed" || status === "failed" || status === "skipped";
+}

package/dist/storage/migration/productionRegistry.js

@@ -28,6 +28,12 @@ const WORK_ITEM_GIT_SNAPSHOT_FROM_VERSION = 7;
 const WORK_ITEM_GIT_SNAPSHOT_TO_VERSION = 8;
 const WORK_ITEM_GROUP_HISTORY_FROM_VERSION = 8;
 const WORK_ITEM_GROUP_HISTORY_TO_VERSION = 9;
+const WORK_ITEM_EXPLORATION_STAGE_FROM_VERSION = 9;
+const WORK_ITEM_EXPLORATION_STAGE_TO_VERSION = 10;
+const WORK_ITEM_CANDIDATE_CONVERGENCE_FROM_VERSION = 10;
+const WORK_ITEM_CANDIDATE_CONVERGENCE_TO_VERSION = 11;
+const WORK_ITEM_RESOURCE_SCHEDULING_FROM_VERSION = 11;
+const WORK_ITEM_RESOURCE_SCHEDULING_TO_VERSION = 12;
 const AGENT_RUN_FROM_VERSION = 5;
 const AGENT_RUN_TO_VERSION = 6;
 /**
@@ -144,6 +150,14 @@ export function createProductionStorageRegistry() {
         .registerOfflineMigration(recordFamilyStep("workItem", WORK_ITEM_FROM_VERSION, WORK_ITEM_TO_VERSION, "workItems"))
         .registerOfflineMigration(recordFamilyStep("workItem", WORK_ITEM_GIT_SNAPSHOT_FROM_VERSION, WORK_ITEM_GIT_SNAPSHOT_TO_VERSION, "workItems"))
         .registerOfflineMigration(workItemExecutionGroupHistoryStep())
+        .registerOfflineMigration(recordFamilyStep("workItem", WORK_ITEM_EXPLORATION_STAGE_FROM_VERSION, WORK_ITEM_EXPLORATION_STAGE_TO_VERSION, "workItems"))
+        // Candidate convergence is frozen only on newly created exploration
+        // histories. Existing valid T4 histories remain byte-for-byte evidence,
+        // so this adjacent persistent transition advances only the family version.
+        .registerOfflineMigration(recordFamilyStep("workItem", WORK_ITEM_CANDIDATE_CONVERGENCE_FROM_VERSION, WORK_ITEM_CANDIDATE_CONVERGENCE_TO_VERSION, "workItems"))
+        // Existing v11 histories remain valid immutable evidence without a T6
+        // resource policy. Newly planned stages always freeze the full policy.
+        .registerOfflineMigration(recordFamilyStep("workItem", WORK_ITEM_RESOURCE_SCHEDULING_FROM_VERSION, WORK_ITEM_RESOURCE_SCHEDULING_TO_VERSION, "workItems"))
         .registerOfflineMigration(recordFamilyStep("agentRun", AGENT_RUN_FROM_VERSION, AGENT_RUN_TO_VERSION, "agentRuns"))
         .registerOfflineMigration(recordFamilyStep("agentRun", AGENT_RUN_OPTIONAL_FIELDS_FROM_VERSION, AGENT_RUN_OPTIONAL_FIELDS_TO_VERSION, "agentRuns"))
         .registerOfflineMigration(agentRunContextProtocolStep())

package/dist/storage/sqliteStore.js

@@ -1480,6 +1480,18 @@ export class SqliteTaskStore {
     saveAgentRun(run) {
         if (run.taskId !== undefined)
             this.#requireTask(run.taskId);
+        if (run.reviewRoundId !== undefined) {
+            const round = this.getReviewRound(run.taskId, run.reviewRoundId);
+            if (round === null) {
+                throw new StorageRecordError(`Agent run ReviewRound not found: ${run.reviewRoundId}.`);
+            }
+            const laneRole = round.executionGroup?.lanes
+                .find(({ id }) => id === run.executionLaneId)?.roleName;
+            if (round.workItemId !== run.workItemId
+                || (round.reviewerRoleName !== run.roleName && laneRole !== run.roleName)) {
+                throw new StorageRecordError(`Agent run does not match ReviewRound: ${run.id}.`);
+            }
+        }
         this.#mutate(() => {
             this.#db.prepare(`INSERT INTO agent_runs (task_id, run_id, role_name, status, payload, updated_at) VALUES (?, ?, ?, ?, ?, ?)
          ON CONFLICT(task_id, run_id) DO UPDATE SET role_name = excluded.role_name, status = excluded.status,

package/dist/storage/taskStore.js

@@ -67,7 +67,7 @@ export const CURRENT_TASK_BRIEF_SCHEMA_VERSION = 2;
 export const CURRENT_CONTEXT_SNAPSHOT_SCHEMA_VERSION = 1;
 export const CURRENT_TASK_ROLE_SCHEMA_VERSION = 3;
 export const CURRENT_MANAGED_WORKSPACE_SCHEMA_VERSION = 2;
-export const CURRENT_WORK_ITEM_SCHEMA_VERSION = 9;
+export const CURRENT_WORK_ITEM_SCHEMA_VERSION = 12;
 export const CURRENT_REVIEW_ROUND_SCHEMA_VERSION = 5;
 export const CURRENT_CHANGE_SET_SCHEMA_VERSION = 3;
 export const CURRENT_INTEGRATION_ATTEMPT_SCHEMA_VERSION = 4;

package/dist/task/completionReadiness.js

@@ -16,7 +16,7 @@ const UNRESOLVED_INTEGRATION_STATUSES = new Set([
     "validating"
 ]);
 const TERMINAL_REVIEW_STATUSES = new Set(["completed", "failed"]);
-const TERMINAL_LANE_STATUSES = new Set(["completed", "failed", "yielded"]);
+const TERMINAL_LANE_STATUSES = new Set(["completed", "failed", "yielded", "skipped"]);
 export function projectCompletionReadiness(facts, options = {}) {
     const blockers = [];
     const advisories = [];