@zq-silk/yui 0.6.13 → 0.6.14

package/dist/task/completionReadiness.js

@@ -0,0 +1,282 @@
+import { isReviewFindingBlocking } from "../review/reviewFinding.js";
+import { deltaRecheckBlocksAcceptance } from "../review/reviewRound.js";
+import { reviewFindingLedgerWriteFailedFromEvents } from "../review/reviewFindingLedger.js";
+import { blockingProviderContinuations } from "../runtime/runtimeContinuationProjection.js";
+const ACTIVE_JOB_STATUSES = new Set([
+    "queued",
+    "running",
+    "unknown-needs-attention"
+]);
+const UNRESOLVED_INTEGRATION_STATUSES = new Set([
+    "running",
+    "blocked",
+    "validating"
+]);
+const TERMINAL_REVIEW_STATUSES = new Set(["completed", "failed"]);
+const TERMINAL_LANE_STATUSES = new Set(["completed", "failed", "yielded"]);
+export function projectCompletionReadiness(facts, options = {}) {
+    const blockers = [];
+    const { task } = facts;
+    const findingsGate = options.findingsGate ?? true;
+    // A pending/running Task-final Review must be resumed or blocked first.
+    for (const round of facts.reviewRounds) {
+        if ((round.scope ?? "work-item") !== "task")
+            continue;
+        if (round.status !== "pending" && round.status !== "running")
+            continue;
+        blockers.push({
+            code: "active-task-review",
+            ref: ref("review-round", round.id),
+            reason: `Task-final ReviewRound ${round.id} is ${round.status}.`,
+            fix: round.status === "pending"
+                ? `yui task review retry ${task.id}/${round.id}`
+                : `wait for Reviewer Run on ${round.id} to finish`
+        });
+    }
+    // Issue 07: a completed delta-recheck that did not accept the head keeps the
+    // completion gate closed.  `requires-full-review` escalates to a full Review;
+    // `finding` stays a blocker for the Leader to repair.
+    for (const round of facts.reviewRounds) {
+        if (!deltaRecheckBlocksAcceptance(round))
+            continue;
+        const disposition = round.deltaRecheck.disposition;
+        blockers.push({
+            code: "delta-recheck-not-accepted",
+            ref: ref("review-round", round.id),
+            reason: `Delta-recheck ${round.id} disposition is ${disposition}; the head is not accepted.`,
+            fix: disposition === "requires-full-review"
+                ? `yui task review request ${task.id} --role <global-role>`
+                : `repair the finding and request a new Task-final Review`
+        });
+    }
+    // Open Input requests block protocol convergence.
+    for (const request of facts.openInputRequests) {
+        blockers.push({
+            code: "open-input-request",
+            ref: ref("input-request", request.id),
+            reason: `Input request ${request.id} is open.`,
+            fix: `yui task input answer ${task.id}/${request.id}`
+        });
+    }
+    // Every Work Item must be terminal (completed or retired).
+    for (const item of facts.workItems) {
+        if (item.status === "completed" || item.status === "retired")
+            continue;
+        blockers.push({
+            code: "incomplete-work-item",
+            ref: ref("work-item", item.id),
+            reason: `Work Item ${item.id} is ${item.status}.`,
+            fix: item.status === "failed"
+                ? `yui task work update ${task.id}/${item.id} running`
+                : `complete or retire Work Item ${item.id}`
+        });
+    }
+    // Active DurableJobs (integration checks, etc.) must settle.
+    for (const job of facts.durableJobs) {
+        if (!ACTIVE_JOB_STATUSES.has(job.status))
+            continue;
+        if (job.status === "unknown-needs-attention" && job.acknowledgedAt !== undefined)
+            continue;
+        blockers.push({
+            code: "active-durable-job",
+            ref: ref("durable-job", job.id),
+            reason: `DurableJob ${job.id} is ${job.status}.`,
+            fix: `wait for DurableJob ${job.id} to finish, or cancel it`
+        });
+    }
+    // requireIntegration Tasks need the full evidence chain.
+    if (task.requireIntegration === true) {
+        if (facts.workItems.length === 0) {
+            blockers.push({
+                code: "integration-evidence-missing",
+                ref: ref("task", task.id),
+                reason: `Task ${task.id} requires at least one WorkItem before completion.`,
+                fix: `yui task work create ${task.id} "<objective>"`
+            });
+        }
+        if (facts.changeSets.length === 0) {
+            blockers.push({
+                code: "integration-evidence-missing",
+                ref: ref("task", task.id),
+                reason: `Task ${task.id} requires at least one ChangeSet before completion.`,
+                fix: `yui task work capture ${task.id}/<work-item>`
+            });
+        }
+        if (!facts.integrations.some(({ status }) => status === "committed")) {
+            blockers.push({
+                code: "integration-evidence-missing",
+                ref: ref("task", task.id),
+                reason: `Task ${task.id} requires a committed Integration Attempt before completion.`,
+                fix: `yui task integration start ${task.id} --project <project> --change-set <change-set>`
+            });
+        }
+    }
+    // Unresolved Integration Attempts must settle.
+    for (const integration of facts.integrations) {
+        if (!UNRESOLVED_INTEGRATION_STATUSES.has(integration.status))
+            continue;
+        blockers.push({
+            code: "unresolved-integration",
+            ref: ref("integration-attempt", integration.id),
+            reason: `Integration Attempt ${integration.id} is ${integration.status}.`,
+            fix: `yui task integration continue ${task.id}/${integration.id}`
+        });
+    }
+    // Unsettled integration queue entries must commit or be superseded.
+    for (const entry of facts.integrationQueueEntries) {
+        if (entry.status === "committed" || entry.status === "superseded")
+            continue;
+        blockers.push({
+            code: "unsettled-integration-queue-entry",
+            ref: ref("integration-queue-entry", entry.id),
+            reason: `Integration queue entry ${entry.id} is ${entry.status}.`,
+            fix: `settle integration queue entry ${entry.id} (continue or supersede)`
+        });
+    }
+    // Provider continuations that may still write the Workspace.
+    for (const continuation of blockingProviderContinuations(facts.events)) {
+        const identity = continuation.identity;
+        blockers.push({
+            code: "blocking-provider-continuation",
+            ref: ref("provider-continuation", identity.continuationId),
+            reason: `Provider continuation ${identity.continuationId} (run ${continuation.runId}) `
+                + "may still write the Workspace or has an identity conflict.",
+            fix: `wait for or recover the Provider turn on run ${continuation.runId}`
+        });
+    }
+    // Undisposed managed workspaces.  The Task-owned main workspace is excluded
+    // (it is cleaned at archive, not at completion).
+    for (const workspace of facts.managedWorkspaces) {
+        const blocker = workspaceBlocker(facts, task.id, workspace);
+        if (blocker !== null)
+            blockers.push(blocker);
+    }
+    // Active non-Leader Runs must finish.  The Leader's own Run is terminalized
+    // by the completion transaction itself, so it is not a readiness blocker.
+    for (const run of facts.activeRuns) {
+        if (run.roleName === "leader")
+            continue;
+        blockers.push({
+            code: "active-run",
+            ref: ref("agent-run", run.id),
+            reason: `Role ${run.roleName} has an active Run ${run.id}.`,
+            fix: `wait for Run ${run.id} to yield or fail`
+        });
+    }
+    // Review finding ledger gate (enforce mode only).
+    // The transactional completion path runs this gate after final-review
+    // preparation: a pending/running Task-final Review is expected to resolve
+    // `fixed-pending-review` findings, so the gate only blocks when no Review
+    // is active.  Mirror that timing here so the projection never blocks a
+    // completion attempt that is about to request the resolving Review.
+    const activeTaskReview = facts.reviewRounds.some((round) => ((round.scope ?? "work-item") === "task"
+        && (round.status === "pending" || round.status === "running")));
+    if (findingsGate && facts.reviewFindingLedgerMode === "enforce" && !activeTaskReview) {
+        if (reviewFindingLedgerWriteFailedFromEvents(facts.events)) {
+            blockers.push({
+                code: "finding-ledger-unavailable",
+                ref: ref("task", task.id),
+                reason: "The Review finding ledger was unavailable while reconciling a semantic Review.",
+                fix: "recover the ledger and reconcile the Round before completing the Task"
+            });
+        }
+        for (const finding of facts.reviewFindings) {
+            if (!isReviewFindingBlocking(finding))
+                continue;
+            blockers.push({
+                code: "open-review-finding",
+                ref: ref("review-finding", finding.id),
+                reason: `Open ${finding.severity.toUpperCase()} finding ${finding.id} is undispositioned.`,
+                fix: `yui task review finding dispose ${task.id}/${finding.id}`
+            });
+        }
+    }
+    const sorted = [...blockers].sort((left, right) => {
+        const codeOrder = left.code.localeCompare(right.code);
+        if (codeOrder !== 0)
+            return codeOrder;
+        const kindOrder = left.ref.kind.localeCompare(right.ref.kind);
+        if (kindOrder !== 0)
+            return kindOrder;
+        return left.ref.id.localeCompare(right.ref.id, undefined, { numeric: true });
+    });
+    return { taskId: task.id, ready: sorted.length === 0, blockers: sorted };
+}
+function workspaceBlocker(facts, taskId, workspace) {
+    const owner = workspace.owner;
+    switch (owner.type) {
+        case "task":
+            // The Task main workspace is cleaned at archive, not completion.
+            return null;
+        case "work-item": {
+            // The preflight has always blocked on WorkItem workspaces.  Project the
+            // blocker regardless of the Work Item status: if the item is still open
+            // the incomplete-work-item blocker fires too, and once it is terminal
+            // the workspace is the exact cleanup target.
+            return {
+                code: "work-item-workspace-undisposed",
+                ref: ref("work-item", owner.workItemId),
+                reason: `Work Item ${owner.workItemId} has an isolated workspace that is not disposed.`,
+                fix: `yui task work cleanup ${taskId}/${owner.workItemId} --integrated|--abandon`
+            };
+        }
+        case "review-round": {
+            const round = facts.reviewRounds.find((entry) => entry.id === owner.reviewRoundId);
+            // A workspace for a still-active Review is covered by the
+            // active-task-review / wait-for-owned-execution path; only project the
+            // cleanup blocker once the Round is terminal.
+            if (round !== undefined && !TERMINAL_REVIEW_STATUSES.has(round.status))
+                return null;
+            return {
+                code: "review-workspace-undisposed",
+                ref: ref("review-round", owner.reviewRoundId),
+                reason: `ReviewRound ${owner.reviewRoundId} is terminal but its workspace is not cleaned up.`,
+                fix: `yui task work review cleanup ${taskId}/${owner.reviewRoundId}`
+            };
+        }
+        case "integration-attempt": {
+            const integration = facts.integrations.find((entry) => entry.id === owner.integrationAttemptId);
+            if (integration !== undefined && UNRESOLVED_INTEGRATION_STATUSES.has(integration.status)) {
+                return null;
+            }
+            return {
+                code: "integration-workspace-undisposed",
+                ref: ref("integration-attempt", owner.integrationAttemptId),
+                reason: `Integration Attempt ${owner.integrationAttemptId} is terminal but its workspace is not cleaned up.`,
+                fix: `retry or continue Integration ${owner.integrationAttemptId} so its workspace is reclaimed`
+            };
+        }
+        case "execution-lane": {
+            const lane = findExecutionLane(facts, owner.executionGroupId, owner.executionLaneId);
+            if (lane !== undefined && !TERMINAL_LANE_STATUSES.has(lane.status))
+                return null;
+            return {
+                code: "execution-lane-workspace-undisposed",
+                ref: ref("execution-lane", `${owner.executionGroupId}/${owner.executionLaneId}`),
+                reason: `Execution Lane ${owner.executionGroupId}/${owner.executionLaneId} `
+                    + "is terminal but its workspace is not cleaned up.",
+                fix: `clean up Execution Lane ${owner.executionGroupId}/${owner.executionLaneId}`
+            };
+        }
+    }
+}
+function findExecutionLane(facts, groupId, laneId) {
+    for (const item of facts.workItems) {
+        const group = item.executionGroups?.find((entry) => entry.id === groupId);
+        const lane = group?.lanes.find((entry) => entry.id === laneId);
+        if (lane !== undefined)
+            return lane;
+    }
+    for (const round of facts.reviewRounds) {
+        const group = round.executionGroup;
+        if (group?.id !== groupId)
+            continue;
+        const lane = group.lanes.find((entry) => entry.id === laneId);
+        if (lane !== undefined)
+            return lane;
+    }
+    return undefined;
+}
+function ref(kind, id) {
+    return { kind, id };
+}

package/dist/task/publicationReference.js

@@ -0,0 +1,123 @@
+import { requireIdentity, requireText, requireTimestamp } from "../domain/validation.js";
+import { validateTaskRecordReference } from "./taskRecordReference.js";
+export const PUBLICATION_REFERENCE_SCHEMA_VERSION = 1;
+const PROVIDERS = new Set(["github", "gitlab"]);
+const EXTERNAL_KINDS = new Set(["pull-request", "merge-request"]);
+const STATES = new Set(["open", "merged", "closed"]);
+const VERIFICATIONS = new Set(["reported", "verified"]);
+const RECORDED_BY = new Set(["user", "operator", "leader"]);
+const SOURCES = new Set(["manual", "release-workflow", "integration"]);
+const GIT_SHA = /^[0-9a-f]{40}$/iu;
+export function createPublicationReference(id, taskId, input, now) {
+    const reference = validateTaskRecordReference({ taskId, localId: id }, "publicationReference");
+    return validatePublicationReference({
+        schemaVersion: PUBLICATION_REFERENCE_SCHEMA_VERSION,
+        id: reference.localId,
+        taskId: reference.taskId,
+        projectId: requireIdentity(input.projectId, "Publication Project id"),
+        provider: requireEnum(input.provider, PROVIDERS, "Publication provider"),
+        repository: requireText(input.repository, "Publication repository"),
+        externalKind: requireEnum(input.externalKind, EXTERNAL_KINDS, "Publication external kind"),
+        externalId: requireText(input.externalId, "Publication external id"),
+        ...(input.externalUrl === undefined ? {} : {
+            externalUrl: requireText(input.externalUrl, "Publication external URL")
+        }),
+        ...(input.title === undefined ? {} : {
+            title: requireText(input.title, "Publication title")
+        }),
+        ...(input.sourceBranch === undefined ? {} : {
+            sourceBranch: requireText(input.sourceBranch, "Publication source branch")
+        }),
+        ...(input.targetBranch === undefined ? {} : {
+            targetBranch: requireText(input.targetBranch, "Publication target branch")
+        }),
+        ...(input.localCommit === undefined ? {} : {
+            localCommit: requireCommit(input.localCommit, "Publication local commit")
+        }),
+        ...(input.remoteCommit === undefined ? {} : {
+            remoteCommit: requireCommit(input.remoteCommit, "Publication remote commit")
+        }),
+        state: requireEnum(input.state ?? "open", STATES, "Publication state"),
+        verification: requireEnum(input.verification ?? "reported", VERIFICATIONS, "Publication verification"),
+        ...(input.evidence === undefined ? {} : {
+            evidence: requireText(input.evidence, "Publication evidence")
+        }),
+        ...(input.supersedes === undefined ? {} : {
+            supersedes: requireText(input.supersedes, "Publication supersedes id")
+        }),
+        recordedBy: requireEnum(input.recordedBy ?? "user", RECORDED_BY, "Publication recordedBy"),
+        source: requireEnum(input.source ?? "manual", SOURCES, "Publication source"),
+        ...(input.mergedAt === undefined ? {} : {
+            mergedAt: requireTimestamp(input.mergedAt, "Publication mergedAt")
+        }),
+        createdAt: now.toISOString()
+    });
+}
+export function publicationExternalKey(reference) {
+    return `${reference.provider}/${reference.repository}/${reference.externalId}`;
+}
+export function validatePublicationReference(reference) {
+    if (reference.schemaVersion !== PUBLICATION_REFERENCE_SCHEMA_VERSION) {
+        throw new Error("Publication reference must use schemaVersion 1.");
+    }
+    validateTaskRecordReference({ taskId: reference.taskId, localId: reference.id }, "publicationReference");
+    requireIdentity(reference.projectId, "Publication Project id");
+    requireEnum(reference.provider, PROVIDERS, "Publication provider");
+    requireText(reference.repository, "Publication repository");
+    requireEnum(reference.externalKind, EXTERNAL_KINDS, "Publication external kind");
+    requireText(reference.externalId, "Publication external id");
+    if (reference.externalUrl !== undefined) {
+        requireText(reference.externalUrl, "Publication external URL");
+    }
+    if (reference.title !== undefined) {
+        requireText(reference.title, "Publication title");
+    }
+    if (reference.sourceBranch !== undefined) {
+        requireText(reference.sourceBranch, "Publication source branch");
+    }
+    if (reference.targetBranch !== undefined) {
+        requireText(reference.targetBranch, "Publication target branch");
+    }
+    if (reference.localCommit !== undefined) {
+        requireCommit(reference.localCommit, "Publication local commit");
+    }
+    if (reference.remoteCommit !== undefined) {
+        requireCommit(reference.remoteCommit, "Publication remote commit");
+    }
+    requireEnum(reference.state, STATES, "Publication state");
+    requireEnum(reference.verification, VERIFICATIONS, "Publication verification");
+    if (reference.verification === "verified"
+        && (reference.state !== "merged" || reference.remoteCommit === undefined)) {
+        throw new Error("Verified publication requires state merged and a remote commit.");
+    }
+    if (reference.mergedAt !== undefined && reference.state !== "merged") {
+        throw new Error("Publication mergedAt requires state merged.");
+    }
+    if (reference.evidence !== undefined) {
+        requireText(reference.evidence, "Publication evidence");
+    }
+    if (reference.supersedes !== undefined) {
+        requireText(reference.supersedes, "Publication supersedes id");
+        if (reference.supersedes === reference.id) {
+            throw new Error("Publication reference cannot supersede itself.");
+        }
+    }
+    requireEnum(reference.recordedBy, RECORDED_BY, "Publication recordedBy");
+    requireEnum(reference.source, SOURCES, "Publication source");
+    requireTimestamp(reference.createdAt, "Publication createdAt");
+    return reference;
+}
+function requireEnum(value, allowed, label) {
+    const normalized = requireText(value, label);
+    if (!allowed.has(normalized)) {
+        throw new Error(`${label} is invalid: ${normalized}.`);
+    }
+    return normalized;
+}
+function requireCommit(value, label) {
+    const commit = requireText(value, label);
+    if (!GIT_SHA.test(commit)) {
+        throw new Error(`${label} must be a full 40-character Git SHA.`);
+    }
+    return commit.toLowerCase();
+}

package/dist/task/taskRecordReference.js

@@ -14,7 +14,9 @@ export const TASK_RECORD_ID_PREFIXES = {
     milestone: "milestone",
     event: "event",
     capabilityGrant: "capability-grant",
-    releaseWorkflow: "release-workflow"
+    releaseWorkflow: "release-workflow",
+    taskWake: "wake",
+    publicationReference: "publication"
 };
 export function formatTaskRecordReference(taskId, localId, kind) {
     const reference = validateTaskRecordReference({ taskId, localId }, kind);

package/dist/telemetry/telemetryConfig.js

@@ -20,42 +20,47 @@ export const DEFAULT_RUN_CAP = TELEMETRY_RUN_CAP;
 export const MAX_RUN_CAP = 10_000_000;
 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 diagnostic retention.
+ * Resolve the telemetry mode from the durable config value (default `legacy`).
+ * Only the three exact values (case-insensitive) are accepted; anything else
+ * fails closed at startup instead of silently changing diagnostic retention.
  */
-export function resolveTelemetryMode(env = process.env) {
-    const raw = env.YUI_TELEMETRY_MODE?.trim().toLowerCase();
+export function resolveTelemetryMode(value) {
+    if (typeof value !== "string")
+        return DEFAULT_TELEMETRY_MODE;
+    const raw = value.trim().toLowerCase();
     if (raw === undefined || raw === "")
         return DEFAULT_TELEMETRY_MODE;
     if (!TELEMETRY_MODES.includes(raw)) {
-        throw new TypeError(`YUI_TELEMETRY_MODE must be one of ${TELEMETRY_MODES.join(", ")}; got ${JSON.stringify(raw)}.`);
+        throw new TypeError(`telemetryMode must be one of ${TELEMETRY_MODES.join(", ")}; got ${JSON.stringify(raw)}.`);
     }
     return raw;
 }
 /**
- * Resolve the terminal-Run retention window (`YUI_TELEMETRY_TERMINAL_KEEP`,
- * default 200). Must be a positive integer.
+ * Resolve the terminal-Run retention window from the durable config value
+ * (default 200). Must be a positive integer.
  */
-export function resolveTerminalKeep(env = process.env) {
-    return resolvePositiveInteger(env.YUI_TELEMETRY_TERMINAL_KEEP, DEFAULT_TERMINAL_KEEP, "YUI_TELEMETRY_TERMINAL_KEEP");
+export function resolveTerminalKeep(value) {
+    return resolvePositiveInteger(value, DEFAULT_TERMINAL_KEEP, "telemetryTerminalKeep");
 }
 /**
- * Resolve the active-Run hard cap (`YUI_TELEMETRY_RUN_CAP`, default 50,000).
- * Must be a positive integer not exceeding {@link MAX_RUN_CAP}; the cap
- * cannot be disabled.
+ * Resolve the active-Run hard cap from the durable config value (default
+ * 50,000). Must be a positive integer not exceeding {@link MAX_RUN_CAP};
+ * the cap cannot be disabled.
  */
-export function resolveRunCap(env = process.env) {
-    const cap = resolvePositiveInteger(env.YUI_TELEMETRY_RUN_CAP, DEFAULT_RUN_CAP, "YUI_TELEMETRY_RUN_CAP");
+export function resolveRunCap(value) {
+    const cap = resolvePositiveInteger(value, DEFAULT_RUN_CAP, "telemetryRunCap");
     if (cap > MAX_RUN_CAP) {
-        throw new TypeError(`YUI_TELEMETRY_RUN_CAP must not exceed ${MAX_RUN_CAP.toLocaleString("en-US")} (retention cannot be disabled).`);
+        throw new TypeError(`telemetryRunCap must not exceed ${MAX_RUN_CAP.toLocaleString("en-US")} (retention cannot be disabled).`);
     }
     return cap;
 }
 function resolvePositiveInteger(raw, fallback, label) {
-    if (raw === undefined || raw.trim() === "")
+    if (raw === undefined || raw === null)
         return fallback;
-    const value = Number(raw);
+    if (typeof raw !== "string" && typeof raw !== "number") {
+        throw new TypeError(`${label} must be a positive integer; got ${JSON.stringify(raw)}.`);
+    }
+    const value = typeof raw === "string" ? Number(raw) : raw;
     if (!Number.isSafeInteger(value) || value < 1) {
         throw new TypeError(`${label} must be a positive integer; got ${JSON.stringify(raw)}.`);
     }

package/dist/telemetry/telemetryWiring.js

@@ -4,9 +4,9 @@ import { resolveRunCap, resolveTelemetryMode, resolveTerminalKeep } from "./tele
 import { SqliteTelemetryStore } from "./sqliteTelemetryStore.js";
 import { COMMITTED_DATABASE_FILENAME } from "../storage/upgrade/sqliteStateMigration.js";
 /**
- * Open the telemetry sidecar for a Home, resolved from the environment
- * (`YUI_TELEMETRY_MODE`, default `legacy`). Returns null in legacy mode so
- * callers keep the exact master behavior and never touch the database.
+ * Open the telemetry sidecar for a Home, resolved from the durable Yui
+ * config (default `legacy`). Returns null in legacy mode so callers keep the
+ * exact master behavior and never touch the database.
  *
  * Telemetry lives in the Home's authoritative `yui.db`. A Home without a
  * database has not reached SQLite storage yet, so dual/bounded mode fails
@@ -15,19 +15,19 @@ import { COMMITTED_DATABASE_FILENAME } from "../storage/upgrade/sqliteStateMigra
  * store fails isolated: a broken sidecar only increments its dropped counter
  * and never blocks the semantic lane.
  */
-export function openSchedulerTelemetry(home, env = process.env) {
-    const mode = resolveTelemetryMode(env);
+export function openSchedulerTelemetry(home, config) {
+    const mode = resolveTelemetryMode(config.telemetryMode);
     if (mode === "legacy")
         return null;
     const dbPath = join(home, COMMITTED_DATABASE_FILENAME);
     if (!existsSync(dbPath)) {
-        throw new Error(`YUI_TELEMETRY_MODE=${mode} requires SQLite storage, but ${dbPath} does not exist. `
+        throw new Error(`telemetryMode=${mode} requires SQLite storage, but ${dbPath} does not exist. `
             + "Migrate this Home to the database backend first (yui upgrade).");
     }
     const store = new SqliteTelemetryStore(home, {
         mode,
-        terminalKeep: resolveTerminalKeep(env),
-        runCap: resolveRunCap(env)
+        terminalKeep: resolveTerminalKeep(config.telemetryTerminalKeep),
+        runCap: resolveRunCap(config.telemetryRunCap)
     });
     return { mode, sink: store, reader: store };
 }