@zq-silk/yui 0.14.1 → 0.15.0

package/dist/scheduler/roleTurnLiveness.js

@@ -29,7 +29,7 @@ export async function reconcileExitedRoleTurns(store, delivery, now, selection,
                     adapterId: run.effective.adapterId,
                     turnId: run.id,
                     progressAt: run.createdAt,
-                    ...(session?.launchId === undefined ? {} : { launchId: session.launchId }),
+                    ...(session?.runtimeGenerationId === undefined ? {} : { runtimeGenerationId: session.runtimeGenerationId }),
                     ...(session?.nativeSessionId === undefined
                         ? {}
                         : { nativeSessionId: session.nativeSessionId })
@@ -64,7 +64,7 @@ export async function reconcileExitedRoleTurns(store, delivery, now, selection,
                         ...(session?.nativeSessionId === undefined
                             ? {}
                             : { nativeSessionId: session.nativeSessionId }),
-                        ...(session?.launchId === undefined ? {} : { launchId: session.launchId })
+                        ...(session?.runtimeGenerationId === undefined ? {} : { runtimeGenerationId: session.runtimeGenerationId })
                     }]
                 : []))
             : [], targetedInventory);
@@ -94,7 +94,7 @@ export async function reconcileExitedRoleTurns(store, delivery, now, selection,
                 taskId: task.id,
                 roleName: role.name,
                 turnId: run.id,
-                ...(session?.launchId === undefined ? {} : { launchId: session.launchId }),
+                ...(session?.runtimeGenerationId === undefined ? {} : { runtimeGenerationId: session.runtimeGenerationId }),
                 ...(session?.nativeSessionId === undefined
                     ? {}
                     : { nativeSessionId: session.nativeSessionId }),
@@ -123,16 +123,16 @@ export async function reconcileExitedRoleTurns(store, delivery, now, selection,
                 mode: "resume",
                 turnId: run.id,
                 nativeSessionId: session.nativeSessionId,
-                ...(session.launchId === undefined
+                ...(session.runtimeGenerationId === undefined
                     ? {}
-                    : { hostActivationId: session.launchId })
+                    : { hostActivationId: session.runtimeGenerationId })
             });
             store.saveRoleTurnPrepared({
                 task,
                 role,
                 turn: run,
                 session: recovered.session ?? session,
-                ...(recovered.launchId === undefined ? {} : { launchId: recovered.launchId }),
+                ...(recovered.runtimeGenerationId === undefined ? {} : { runtimeGenerationId: recovered.runtimeGenerationId }),
                 now
             });
             liveStatuses?.set(`${task.id}\0${role.name}`, "present");

package/dist/scheduler/roleTurnStall.js

@@ -58,7 +58,7 @@ export function projectRoleTurnHealth(input) {
         : session.status === "ended"
             ? session.endReason === "failed" ? "broken" : "stopped"
             : !hasResourceIdentityText(session.nativeSessionId)
-                && !hasResourceIdentityText(session.launchId)
+                && !hasResourceIdentityText(session.runtimeGenerationId)
                 ? "unknown"
                 : "matching";
     const resourceActivity = hostLiveness === "present"
@@ -212,9 +212,8 @@ export function latestTurnDurableProgressAt(store, taskId, roleName, turnId, pre
     const changeSets = store.listChangeSets?.(taskId)
         .filter(({ workItemId }) => workItemId === run.workItemId)
         ?? [];
-    const changeSetIds = new Set(changeSets.map(({ id }) => id));
     const integrations = store.listIntegrationAttempts?.(taskId)
-        .filter(({ changeSetIds: ids }) => ids.some((id) => changeSetIds.has(id)))
+        .filter(({ source }) => (source.kind === "work-item" && source.workItemId === run.workItemId))
         ?? [];
     const inputProgress = store.listInputRequests?.(taskId)
         .filter((request) => (request.requester.turnId === run.id
@@ -509,7 +508,7 @@ export async function reconcileStalledRoleTurns(store, delivery, now, selection,
                 progressAt: run.createdAt,
                 agentId: session?.agentId ?? run.effective.agentId,
                 adapterId: session?.adapterId ?? run.effective.adapterId,
-                ...(session?.launchId === undefined ? {} : { launchId: session.launchId }),
+                ...(session?.runtimeGenerationId === undefined ? {} : { runtimeGenerationId: session.runtimeGenerationId }),
                 ...(session?.nativeSessionId === undefined
                     ? {}
                     : { nativeSessionId: session.nativeSessionId })
@@ -520,7 +519,7 @@ export async function reconcileStalledRoleTurns(store, delivery, now, selection,
                 progressAt: currentRoleTurnProgressAt(store, task.id, role.name, run).progressAt,
                 agentId: session?.agentId ?? run.effective.agentId,
                 adapterId: session?.adapterId ?? run.effective.adapterId,
-                ...(session?.launchId === undefined ? {} : { launchId: session.launchId }),
+                ...(session?.runtimeGenerationId === undefined ? {} : { runtimeGenerationId: session.runtimeGenerationId }),
                 ...(session?.nativeSessionId === undefined
                     ? {}
                     : { nativeSessionId: session.nativeSessionId })
@@ -624,9 +623,9 @@ export async function reconcileStalledRoleTurns(store, delivery, now, selection,
                 ...(candidate.session.nativeSessionId === undefined
                     ? {}
                     : { nativeSessionId: candidate.session.nativeSessionId }),
-                ...(candidate.session.launchId === undefined
+                ...(candidate.session.runtimeGenerationId === undefined
                     ? {}
-                    : { launchId: candidate.session.launchId })
+                    : { runtimeGenerationId: candidate.session.runtimeGenerationId })
             };
         const resourceSnapshot = resourceForRun(resourceEvidence, candidate.task.id, candidate.role.name, candidate.run.id);
         const resourceIsCurrent = live === "present"
@@ -946,10 +945,10 @@ function resourceEvidenceMatchesCurrentRun(resource, expected, progressAt) {
         || identity.agentId !== expected.agentId
         || identity.adapterId !== expected.adapterId
         || identity.nativeSessionId !== expected.nativeSessionId
-        || identity.launchId !== expected.launchId)
+        || identity.runtimeGenerationId !== expected.runtimeGenerationId)
         return false;
     return hasResourceIdentityText(identity.nativeSessionId)
-        || hasResourceIdentityText(identity.launchId);
+        || hasResourceIdentityText(identity.runtimeGenerationId);
 }
 function hasResourceIdentityText(value) {
     return typeof value === "string" && value.trim().length > 0;

package/dist/scheduler/taskExecutionProjection.js

@@ -35,7 +35,7 @@ export function buildTaskExecutionProjection(store, taskId, taskOverride, now =
         turns,
         executionGroups: store.listWorkItems === undefined && store.listReviewRounds === undefined
             ? []
-            : collectExecutionGroups(store.listWorkItems?.(taskId) ?? [], store.listReviewRounds?.(taskId) ?? []),
+            : collectExecutionGroups(store.listWorkItems?.(taskId) ?? [], store.listReviewRounds?.(taskId) ?? [], turns),
         workItems: store.listWorkItems?.(taskId) ?? [],
         ...(store.listContextSnapshots === undefined
             ? {}
@@ -67,11 +67,12 @@ export function buildTaskExecutionProjection(store, taskId, taskOverride, now =
  * unchanged revision.
  */
 export function projectTaskExecutionFromFacts(facts) {
+    const turns = operationalTaskRecords(facts.turns, facts.events ?? [], "turn");
     const executionGroups = facts.executionGroups
-        ?? collectExecutionGroups(facts.workItems ?? [], facts.reviewRounds ?? []);
+        ?? collectExecutionGroups(facts.workItems ?? [], facts.reviewRounds ?? [], turns);
     return projectTaskExecution({
         ...facts,
-        turns: operationalTaskRecords(facts.turns, facts.events ?? [], "turn"),
+        turns,
         executionGroups
     });
 }
@@ -79,21 +80,18 @@ export function projectTaskExecution(facts) {
     const { task, roles, turns, workItems = [], inputRequests = [], reviewRounds = [], integrations = [], events = [], pendingWakeup = null, leaderMailbox = null, leaderFailure = null, roleSessions = [], executionGroups = [] } = facts;
     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 }),
             turns,
             sessions: roleSessions,
             events,
             now,
-            policy: facts.runtimeHealthPolicy
+            ...(facts.runtimeHealthPolicy === undefined
+                ? {}
+                : { policy: facts.runtimeHealthPolicy })
         });
     });
-    const observabilityGroups = uniqueExecutionGroups([
-        ...executionGroups,
-        ...workItems.flatMap((item) => item.executionGroups)
-    ]);
+    const observabilityGroups = uniqueExecutionGroups(executionGroups);
     const sessionTokens = roleSessions.map((session) => {
         const identity = resolveSessionTokenIdentity({ taskId: task.id, ...session });
         return Object.freeze({
@@ -105,7 +103,6 @@ export function projectTaskExecution(facts) {
     const observability = buildTaskObservabilityProjection({
         workItems,
         executionGroups: observabilityGroups,
-        groupSummaries,
         turns,
         events,
         contextSnapshots: facts.contextSnapshots,
@@ -474,37 +471,18 @@ function uniqueExecutionGroups(groups) {
         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)
-    ]);
+function collectExecutionGroups(workItems, reviewRounds, _turns) {
     const groups = [
-        ...workItems.filter(({ status }) => status !== "retired").flatMap((item) => {
-            const group = currentWorkItemExecutionGroup(item);
+        ...workItems.flatMap((item) => {
+            const group = item.status === "retired"
+                ? undefined
+                : currentWorkItemExecutionGroup(item);
             return group === undefined ? [] : [group];
         }),
-        ...reviewRounds.flatMap((round) => (!operationalReviewRoundIds.has(round.id) || round.executionGroup === undefined
-            ? []
-            : [round.executionGroup]))
+        ...reviewRounds.flatMap((round) => ((round.status === "pending" || round.status === "running")
+            && round.executionGroup !== undefined
+            ? [round.executionGroup]
+            : []))
     ];
     const seen = new Set();
     return groups.filter((group) => {
@@ -623,7 +601,7 @@ function collectBlockers(workItems, reviewRounds, integrations, openInputs, task
         }
         if (item.status === "pending" && (item.dependsOn ?? []).some((id) => {
             const status = byId.get(id)?.status;
-            return status !== "completed" && status !== "retired";
+            return status !== "completed";
         })) {
             blockers.push({
                 kind: "work",
@@ -638,7 +616,7 @@ function collectBlockers(workItems, reviewRounds, integrations, openInputs, task
             kind: "review",
             id: round.id,
             owner: "leader",
-            summary: round.summary ?? `ReviewRound ${round.id} failed.`
+            summary: round.failure?.message ?? `ReviewRound ${round.id} failed.`
         });
     }
     for (const attempt of integrations.filter(({ status }) => status === "blocked" || status === "failed")) {

package/dist/scheduler/taskObservabilityProjection.js

@@ -1,5 +1,3 @@
-import { isDeepStrictEqual } from "node:util";
-import { observedExecutionResourceUsage } from "../execution/resourceBroker.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
@@ -7,48 +5,20 @@ import { observedExecutionResourceUsage } from "../execution/resourceBroker.js";
  */
 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.turns, input.events, now);
+        const itemCost = projectWorkItemCost(groups, input.turns, now);
         const itemContext = projectContext(groups, input.turns, 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);
+        const producerObservability = projectWorkItemProducerObservability(item, input.turns);
         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
+            resultCount: producerObservability?.resultCount ?? null
         });
     });
     const cost = projectCost(input.executionGroups, input.turns, input.events, now);
@@ -61,6 +31,26 @@ export function buildTaskObservabilityProjection(input) {
         sessionTokens: Object.freeze([...(input.sessionTokens ?? [])])
     });
 }
+function projectWorkItemProducerObservability(item, turns) {
+    const successfulLanes = item.executionGroups.flatMap((group) => group.lanes.flatMap((lane) => (lane.disposition === "succeeded" ? [{ group, lane }] : [])));
+    let resultCount = 0;
+    for (const { group, lane } of successfulLanes) {
+        const turn = lane.successfulTurnId === undefined
+            ? undefined
+            : turns.find(({ id }) => id === lane.successfulTurnId);
+        if (turn === undefined
+            || turn.result === undefined
+            || turn.status !== "completed"
+            || turn.taskId !== item.taskId
+            || turn.workItemId !== item.id
+            || turn.executionGroupId !== group.id
+            || turn.executionLaneId !== lane.id
+            || turn.roleName !== lane.roleName)
+            return null;
+        resultCount += 1;
+    }
+    return { resultCount };
+}
 function projectDag(workItems) {
     const byId = new Map(workItems.map((item) => [item.id, item]));
     const dependents = new Map();
@@ -114,6 +104,10 @@ function rootCauses(id, byId) {
             result.push(currentId);
             return;
         }
+        if (item.status === "retired") {
+            result.push(item.id);
+            return;
+        }
         const unresolved = item.dependsOn.filter((dependency) => !dependencySatisfied(dependency, byId));
         if (unresolved.length === 0) {
             if (item.status === "failed" || item.status === "awaiting_acceptance")
@@ -121,7 +115,7 @@ function rootCauses(id, byId) {
             return;
         }
         for (const dependency of unresolved) {
-            const target = resolveDependency(dependency, byId);
+            const target = byId.get(dependency);
             if (target?.status === "failed" || target?.status === "awaiting_acceptance")
                 result.push(target.id);
             else
@@ -132,8 +126,7 @@ function rootCauses(id, byId) {
     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));
+    return byId.get(id)?.status === "completed";
 }
 function dependencyEdgeStatus(id, byId) {
     const target = byId.get(id);
@@ -141,53 +134,52 @@ function dependencyEdgeStatus(id, byId) {
         return "dead";
     if (dependencySatisfied(id, byId))
         return "satisfied";
-    const resolved = resolveDependency(id, byId);
-    if (resolved === undefined)
+    if (target.status === "retired")
         return "dead";
-    if (resolved.status === "failed" || resolved.status === "awaiting_acceptance")
+    if (target.status === "failed" || target.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, turns, _events, now) {
+    const uniqueGroups = [...new Map(groups.map((group) => [group.id, group])).values()];
+    const groupIds = new Set(uniqueGroups.map(({ id }) => id));
+    const attempts = turns.filter(({ executionGroupId }) => (executionGroupId !== undefined && groupIds.has(executionGroupId)));
+    const laneCount = uniqueGroups.reduce((total, group) => total + group.lanes.length, 0);
+    return Object.freeze({
+        tokens: 0,
+        toolCalls: 0,
+        wallClockSeconds: uniqueGroups.reduce((total, group) => total + groupDurationSeconds(group, now), 0),
+        tokensObservable: false,
+        toolCallsObservable: false,
+        laneCount,
+        groupCount: uniqueGroups.length,
+        retryCount: Math.max(0, attempts.length - laneCount),
+        marginalValuePercent: null,
+        marginalValueStatus: "unavailable"
+    });
 }
-function projectCost(groups, turns, 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, turns, 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);
-    }
+function projectWorkItemCost(groups, turns, now) {
+    const groupIds = new Set(groups.map(({ id }) => id));
+    const attempts = turns.filter(({ executionGroupId }) => (executionGroupId !== undefined && groupIds.has(executionGroupId)));
+    const wallClockSeconds = groups.reduce((total, group) => {
+        const started = Date.parse(group.createdAt);
+        const ended = group.lanes.some(({ disposition }) => disposition === "open")
+            ? now.getTime()
+            : Date.parse(group.updatedAt);
+        return total + (Number.isFinite(started) && Number.isFinite(ended)
+            ? Math.max(0, Math.floor((ended - started) / 1_000))
+            : 0);
+    }, 0);
+    const laneCount = groups.reduce((total, group) => total + group.lanes.length, 0);
     return Object.freeze({
-        tokens,
-        toolCalls,
+        tokens: 0,
+        toolCalls: 0,
         wallClockSeconds,
-        tokensObservable,
-        toolCallsObservable,
+        tokensObservable: false,
+        toolCallsObservable: false,
         laneCount,
-        groupCount: stageGroups.length,
-        retryCount,
+        groupCount: groups.length,
+        retryCount: Math.max(0, attempts.length - laneCount),
         marginalValuePercent: null,
         marginalValueStatus: "unavailable"
     });
@@ -195,7 +187,7 @@ function projectCost(groups, turns, events, now) {
 function projectContext(groups, turns, snapshots) {
     const refs = new Map();
     for (const group of groups) {
-        const ref = group.stage?.contextSnapshotRef;
+        const ref = group.assignment.contextSnapshotRef;
         if (ref !== undefined)
             refs.set(ref.id, ref);
     }
@@ -231,51 +223,12 @@ function projectContext(groups, turns, snapshots) {
         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
+function groupDurationSeconds(group, now) {
+    const started = Date.parse(group.createdAt);
+    const ended = group.lanes.some(({ disposition }) => disposition === "open")
         ? now.getTime()
-        : Math.max(...ended);
-    return Math.max(0, Math.floor((end - Math.min(...started)) / 1_000));
-}
-function isTerminalLane(status) {
-    return status === "completed" || status === "failed" || status === "skipped";
+        : Date.parse(group.updatedAt);
+    return Number.isFinite(started) && Number.isFinite(ended)
+        ? Math.max(0, Math.floor((ended - started) / 1_000))
+        : 0;
 }

package/dist/storage/currentTaskStore.js

@@ -2,12 +2,11 @@ import { existsSync } from "node:fs";
 import { join } from "node:path";
 import { StorageRecordError } from "./taskStore.js";
 import { readSqliteHomeIdentity, SqliteTaskStore } from "./sqliteStore.js";
-import { ensureStorageSchema, inspectStorageSchema } from "./storageSchema.js";
-export const CURRENT_DATABASE_FILENAME = "yui.db";
+import { CURRENT_DATABASE_FILENAME, inspectStorageSchema } from "./storageSchema.js";
+export { CURRENT_DATABASE_FILENAME } from "./storageSchema.js";
 /** Initialize a new Home, or open an existing Home at the exact current contract. */
 export function initializeCurrentTaskStore(home) {
     if (inspectStorageSchema(home).status === "uninitialized") {
-        ensureStorageSchema(home);
         return new SqliteTaskStore(home);
     }
     return openCurrentTaskStore(home);
@@ -16,7 +15,10 @@ export function initializeCurrentTaskStore(home) {
 export function openCurrentTaskStore(home) {
     const schema = inspectStorageSchema(home);
     if (schema.status !== "current") {
-        throw new StorageRecordError("This Home does not use the current storage contract. Preserve it for read-only history and initialize a new Home.");
+        throw new StorageRecordError(schema.status === "upgradeable"
+            ? `This Home uses storage version ${schema.currentVersion}; run \`yui upgrade\` `
+                + `to reach ${schema.latestVersion}.`
+            : "This Home does not use a supported storage contract.");
     }
     if (!existsSync(join(home, CURRENT_DATABASE_FILENAME))) {
         throw new StorageRecordError("The current Home is incomplete: yui.db is missing. Preserve it for diagnosis and initialize a new Home.");