@thxgg/steward 0.1.18 → 0.1.19

package/.output/server/chunks/routes/renderer.mjs

@@ -1,5 +1,5 @@
 import { createRenderer, getRequestDependencies, getPreloadLinks, getPrefetchLinks } from 'vue-bundle-renderer/runtime';
-import { j as joinRelativeURL, u as useRuntimeConfig, b as getResponseStatusText, e as getResponseStatus, f as defineRenderHandler, g as getQuery, c as createError, h as destr, i as getRouteRules, k as joinURL, l as useNitroApp } from '../nitro/nitro.mjs';
+import { n as joinRelativeURL, u as useRuntimeConfig, o as getResponseStatusText, q as getResponseStatus, t as defineRenderHandler, g as getQuery, c as createError, v as destr, w as getRouteRules, x as joinURL, y as useNitroApp } from '../nitro/nitro.mjs';
 import { renderToString } from 'vue/server-renderer';
 import { createHead as createHead$1, propsToString, renderSSRHead } from 'unhead/server';
 import { stringify, uneval } from 'devalue';

package/.output/server/index.mjs

@@ -1,10 +1,12 @@
 import process from 'node:process';globalThis._importMeta_={url:import.meta.url,env:process.env};import 'node:http';
 import 'node:https';
-export { E as default } from './chunks/nitro/nitro.mjs';
+export { O as default } from './chunks/nitro/nitro.mjs';
 import 'node:events';
 import 'node:buffer';
 import 'node:fs';
 import 'node:path';
 import 'node:crypto';
+import 'node:os';
+import 'zod';
 import 'node:url';
 //# sourceMappingURL=index.mjs.map

package/.output/server/index.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"index.mjs","sources":[],"names":[],"mappings":";;;;;;;;"}
+{"version":3,"file":"index.mjs","sources":[],"names":[],"mappings":";;;;;;;;;;"}

package/.output/server/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@thxgg/steward-prod",
-  "version": "0.1.18",
+  "version": "0.1.19",
   "type": "module",
   "private": true,
   "dependencies": {

package/README.md

@@ -146,6 +146,9 @@ Steward reads local filesystem and git metadata by design.
 - UI/API accept loopback requests only
 - Non-loopback requests are rejected
 - Treat as a workstation tool, not a hosted multi-user service
+- `npm run dev` skips loopback enforcement because Nuxt dev proxying can mask loopback source addresses
+
+On startup, Steward also performs a one-time automatic state migration when legacy `progress_json` data is detected. During this migration, the UI shows a blocking progress overlay until migration completes.
 
 ## Storage
 

package/dist/server/utils/db.js

@@ -182,7 +182,22 @@ async function initializeDatabase() {
       FOREIGN KEY (repo_id) REFERENCES repos(id) ON DELETE CASCADE
     );
 
+    CREATE TABLE IF NOT EXISTS prd_archives (
+      repo_id TEXT NOT NULL,
+      slug TEXT NOT NULL,
+      archived_at TEXT NOT NULL,
+      PRIMARY KEY (repo_id, slug),
+      FOREIGN KEY (repo_id) REFERENCES repos(id) ON DELETE CASCADE
+    );
+
+    CREATE TABLE IF NOT EXISTS app_meta (
+      key TEXT PRIMARY KEY,
+      value TEXT NOT NULL,
+      updated_at TEXT NOT NULL
+    );
+
     CREATE INDEX IF NOT EXISTS idx_prd_states_repo_id ON prd_states(repo_id);
+    CREATE INDEX IF NOT EXISTS idx_prd_archives_repo_id ON prd_archives(repo_id);
   `);
     return adapter;
 }

package/dist/server/utils/prd-archive.js

@@ -0,0 +1,53 @@
+import { emitChange } from './change-events.js';
+import { dbAll, dbGet, dbRun } from './db.js';
+function toArchiveState(archivedAt) {
+    if (!archivedAt) {
+        return { archived: false };
+    }
+    return {
+        archived: true,
+        archivedAt
+    };
+}
+export async function getPrdArchiveMap(repoId) {
+    const rows = await dbAll('SELECT slug, archived_at FROM prd_archives WHERE repo_id = ?', [repoId]);
+    const archiveMap = new Map();
+    for (const row of rows) {
+        archiveMap.set(row.slug, row.archived_at);
+    }
+    return archiveMap;
+}
+export async function getPrdArchiveState(repoId, slug) {
+    const row = await dbGet('SELECT archived_at FROM prd_archives WHERE repo_id = ? AND slug = ?', [repoId, slug]);
+    return toArchiveState(row?.archived_at);
+}
+export async function setPrdArchived(repoId, slug, archived) {
+    if (archived) {
+        const archivedAt = new Date().toISOString();
+        const result = await dbRun(`
+        INSERT INTO prd_archives (repo_id, slug, archived_at)
+        VALUES (?, ?, ?)
+        ON CONFLICT(repo_id, slug) DO NOTHING
+      `, [repoId, slug, archivedAt]);
+        const row = await dbGet('SELECT archived_at FROM prd_archives WHERE repo_id = ? AND slug = ?', [repoId, slug]);
+        if (result.changes > 0) {
+            emitChange({
+                type: 'change',
+                path: `state://${repoId}/${slug}.archive`,
+                repoId,
+                category: 'prd'
+            });
+        }
+        return toArchiveState(row?.archived_at || archivedAt);
+    }
+    const result = await dbRun('DELETE FROM prd_archives WHERE repo_id = ? AND slug = ?', [repoId, slug]);
+    if (result.changes > 0) {
+        emitChange({
+            type: 'change',
+            path: `state://${repoId}/${slug}.archive`,
+            repoId,
+            category: 'prd'
+        });
+    }
+    return { archived: false };
+}

package/dist/server/utils/prd-service.js

@@ -1,6 +1,7 @@
 import { promises as fs } from 'node:fs';
 import { basename, isAbsolute, join, relative, resolve } from 'node:path';
 import { resolveCommitRepo } from './git.js';
+import { getPrdArchiveMap, getPrdArchiveState } from './prd-archive.js';
 import { getPrdState, getPrdStateSummaries } from './prd-state.js';
 import { discoverGitRepos, updateRepoGitRepos } from './repos.js';
 const PRD_SLUG_PATTERN = /^[A-Za-z0-9][A-Za-z0-9-]*$/;
@@ -83,14 +84,18 @@ export async function readPrdDocument(repo, prdSlug) {
     catch {
         throw new Error('PRD not found');
     }
+    const archiveState = await getPrdArchiveState(repo.id, prdSlug);
     return {
         slug: prdSlug,
         name: extractPrdTitle(content, prdSlug),
         content,
-        metadata: parseMetadata(content)
+        metadata: parseMetadata(content),
+        archived: archiveState.archived,
+        ...(archiveState.archivedAt && { archivedAt: archiveState.archivedAt })
     };
 }
-export async function listPrdDocuments(repo) {
+export async function listPrdDocuments(repo, options = {}) {
+    const includeArchived = options.includeArchived === true;
     const prdDir = join(repo.path, 'docs', 'prd');
     let prdFiles = [];
     try {
@@ -106,9 +111,17 @@ export async function listPrdDocuments(repo) {
     catch {
         return [];
     }
-    const stateSummaries = await getPrdStateSummaries(repo.id);
-    const items = await Promise.all(prdFiles.map(async (filename) => {
+    const [stateSummaries, archiveMap] = await Promise.all([
+        getPrdStateSummaries(repo.id),
+        getPrdArchiveMap(repo.id)
+    ]);
+    const items = (await Promise.all(prdFiles.map(async (filename) => {
         const slug = basename(filename, '.md');
+        const archivedAt = archiveMap.get(slug);
+        const archived = typeof archivedAt === 'string';
+        if (!includeArchived && archived) {
+            return null;
+        }
         const filePath = join(prdDir, filename);
         let name = slug;
         let modifiedAt = 0;
@@ -130,11 +143,18 @@ export async function listPrdDocuments(repo) {
             source: `docs/prd/${filename}`,
             hasState: !!stateSummary?.hasState,
             modifiedAt,
+            archived,
+            ...(archivedAt && { archivedAt }),
             ...(stateSummary?.taskCount !== undefined && { taskCount: stateSummary.taskCount }),
             ...(stateSummary?.completedCount !== undefined && { completedCount: stateSummary.completedCount })
         };
-    }));
-    items.sort((a, b) => b.modifiedAt - a.modifiedAt);
+    }))).filter((item) => item !== null);
+    items.sort((a, b) => {
+        if (a.archived !== b.archived) {
+            return a.archived ? 1 : -1;
+        }
+        return b.modifiedAt - a.modifiedAt;
+    });
     return items;
 }
 export async function readPrdTasks(repo, prdSlug) {

package/dist/server/utils/prd-state.js

@@ -1,6 +1,7 @@
 import { emitChange } from './change-events.js';
 import { dbAll, dbGet, dbRun } from './db.js';
-import { parseProgressFile, parseTasksFile } from './state-schema.js';
+import { ensureStateMigrationReady } from './state-migration.js';
+import { parseProgressFile, parseStoredProgressFile, parseTasksFile } from './state-schema.js';
 function parseStoredJson(raw, fieldName, parseValue) {
     if (!raw) {
         return null;
@@ -23,6 +24,7 @@ function getTaskCounts(tasksFile) {
     return { taskCount, completedCount };
 }
 export async function getPrdState(repoId, slug) {
+    await ensureStateMigrationReady();
     const row = await dbGet(`
       SELECT repo_id, slug, tasks_json, progress_json, notes_md, updated_at
       FROM prd_states
@@ -32,7 +34,12 @@ export async function getPrdState(repoId, slug) {
         return null;
     }
     const tasks = parseStoredJson(row.tasks_json, 'prd_states.tasks_json', parseTasksFile);
-    const progress = parseStoredJson(row.progress_json, 'prd_states.progress_json', parseProgressFile);
+    const tasksCountHint = Array.isArray(tasks?.tasks) ? tasks.tasks.length : undefined;
+    const prdNameFallback = tasks?.prd?.name || row.slug;
+    const progress = parseStoredJson(row.progress_json, 'prd_states.progress_json', (value) => parseStoredProgressFile(value, {
+        totalTasksHint: tasksCountHint,
+        prdNameFallback
+    }));
     return {
         slug: row.slug,
         tasks,
@@ -42,6 +49,7 @@ export async function getPrdState(repoId, slug) {
     };
 }
 export async function getPrdStateSummaries(repoId) {
+    await ensureStateMigrationReady();
     const rows = await dbAll('SELECT slug, tasks_json FROM prd_states WHERE repo_id = ?', [repoId]);
     const summaries = new Map();
     for (const row of rows) {
@@ -64,6 +72,7 @@ export async function getPrdStateSummaries(repoId) {
     return summaries;
 }
 export async function upsertPrdState(repoId, slug, update) {
+    await ensureStateMigrationReady();
     const validatedTasks = update.tasks === undefined
         ? undefined
         : (update.tasks === null ? null : parseTasksFile(update.tasks));

package/dist/server/utils/state-migration.js

@@ -0,0 +1,225 @@
+import { emitChange } from './change-events.js';
+import { dbAll, dbExec, dbGet, dbRun } from './db.js';
+import { needsProgressMigration, parseStoredProgressFile, parseTasksFile } from './state-schema.js';
+const MIGRATION_VERSION = 'progress-json-v2';
+const MIGRATION_META_KEY = `state-migration:${MIGRATION_VERSION}`;
+let status = {
+    state: 'idle',
+    version: MIGRATION_VERSION,
+    startedAt: null,
+    completedAt: null,
+    totalRows: 0,
+    processedRows: 0,
+    migratedRows: 0,
+    failedRows: 0,
+    currentSlug: null,
+    errorMessage: null,
+    percent: 0
+};
+let migrationPromise = null;
+function nowIso() {
+    return new Date().toISOString();
+}
+function toPercent(processedRows, totalRows) {
+    if (totalRows <= 0) {
+        return 100;
+    }
+    return Math.min(100, Math.floor((processedRows / totalRows) * 100));
+}
+function resetRunningStatus(totalRows) {
+    status = {
+        state: 'running',
+        version: MIGRATION_VERSION,
+        startedAt: nowIso(),
+        completedAt: null,
+        totalRows,
+        processedRows: 0,
+        migratedRows: 0,
+        failedRows: 0,
+        currentSlug: null,
+        errorMessage: null,
+        percent: totalRows === 0 ? 100 : 0
+    };
+}
+function markCompleted(marker) {
+    const completedAt = marker?.completedAt || nowIso();
+    const totalRows = marker?.totalRows ?? status.totalRows;
+    const migratedRows = marker?.migratedRows ?? status.migratedRows;
+    status = {
+        ...status,
+        state: 'completed',
+        completedAt,
+        totalRows,
+        processedRows: totalRows,
+        migratedRows,
+        failedRows: 0,
+        currentSlug: null,
+        errorMessage: null,
+        percent: 100
+    };
+}
+function markFailed(message) {
+    status = {
+        ...status,
+        state: 'failed',
+        completedAt: nowIso(),
+        currentSlug: null,
+        errorMessage: message,
+        percent: toPercent(status.processedRows, status.totalRows)
+    };
+}
+async function ensureMetaTable() {
+    await dbExec(`
+    CREATE TABLE IF NOT EXISTS app_meta (
+      key TEXT PRIMARY KEY,
+      value TEXT NOT NULL,
+      updated_at TEXT NOT NULL
+    );
+  `);
+}
+async function readMigrationMarker() {
+    const row = await dbGet('SELECT value FROM app_meta WHERE key = ?', [MIGRATION_META_KEY]);
+    if (!row?.value) {
+        return null;
+    }
+    try {
+        const parsed = JSON.parse(row.value);
+        if (!parsed || typeof parsed !== 'object') {
+            return null;
+        }
+        if (parsed.version !== MIGRATION_VERSION) {
+            return null;
+        }
+        if (typeof parsed.completedAt !== 'string') {
+            return null;
+        }
+        if (typeof parsed.totalRows !== 'number' || typeof parsed.migratedRows !== 'number') {
+            return null;
+        }
+        return parsed;
+    }
+    catch {
+        return null;
+    }
+}
+async function writeMigrationMarker(totalRows, migratedRows) {
+    const completedAt = nowIso();
+    const marker = {
+        version: MIGRATION_VERSION,
+        completedAt,
+        totalRows,
+        migratedRows
+    };
+    await dbRun(`
+      INSERT INTO app_meta (key, value, updated_at)
+      VALUES (?, ?, ?)
+      ON CONFLICT(key) DO UPDATE SET
+        value = excluded.value,
+        updated_at = excluded.updated_at
+    `, [MIGRATION_META_KEY, JSON.stringify(marker), completedAt]);
+}
+async function migrateProgressRows() {
+    await ensureMetaTable();
+    const marker = await readMigrationMarker();
+    if (marker) {
+        markCompleted(marker);
+        return;
+    }
+    const rows = await dbAll(`
+      SELECT repo_id, slug, tasks_json, progress_json
+      FROM prd_states
+      WHERE progress_json IS NOT NULL
+      ORDER BY repo_id ASC, slug ASC
+    `);
+    resetRunningStatus(rows.length);
+    for (let index = 0; index < rows.length; index += 1) {
+        const row = rows[index];
+        status.currentSlug = row.slug;
+        try {
+            const parsedProgress = row.progress_json
+                ? JSON.parse(row.progress_json)
+                : null;
+            let tasksCountHint;
+            let prdNameFallback;
+            if (row.tasks_json) {
+                try {
+                    const tasks = parseTasksFile(JSON.parse(row.tasks_json));
+                    tasksCountHint = tasks.tasks.length;
+                    prdNameFallback = tasks.prd.name;
+                }
+                catch {
+                    // Keep fallback below when tasks_json is malformed.
+                }
+            }
+            const shouldMigrate = needsProgressMigration(parsedProgress);
+            if (shouldMigrate) {
+                const normalized = parseStoredProgressFile(parsedProgress, {
+                    prdNameFallback: prdNameFallback || row.slug,
+                    totalTasksHint: tasksCountHint
+                });
+                const updatedAt = nowIso();
+                await dbRun(`
+            UPDATE prd_states
+            SET progress_json = ?, updated_at = ?
+            WHERE repo_id = ? AND slug = ?
+          `, [JSON.stringify(normalized), updatedAt, row.repo_id, row.slug]);
+                status.migratedRows += 1;
+                emitChange({
+                    type: 'change',
+                    path: `state://${row.repo_id}/${row.slug}/progress.json`,
+                    repoId: row.repo_id,
+                    category: 'progress'
+                });
+            }
+        }
+        catch {
+            status.failedRows += 1;
+        }
+        status.processedRows = index + 1;
+        status.percent = toPercent(status.processedRows, status.totalRows);
+    }
+    if (status.failedRows > 0) {
+        markFailed(`Failed to migrate ${status.failedRows} PRD progress row(s).`);
+        return;
+    }
+    await writeMigrationMarker(status.totalRows, status.migratedRows);
+    markCompleted();
+}
+async function runMigration() {
+    try {
+        await migrateProgressRows();
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        markFailed(message);
+    }
+}
+export function getStateMigrationStatus() {
+    return { ...status };
+}
+export function startStateMigration() {
+    if (!migrationPromise) {
+        if (status.state === 'idle') {
+            status = {
+                ...status,
+                state: 'running',
+                startedAt: nowIso(),
+                completedAt: null,
+                errorMessage: null,
+                percent: 0
+            };
+        }
+        migrationPromise = runMigration().finally(() => {
+            migrationPromise = null;
+        });
+    }
+    return migrationPromise;
+}
+export async function ensureStateMigrationReady() {
+    if (status.state !== 'completed') {
+        await startStateMigration();
+    }
+    if (status.state === 'failed') {
+        throw new Error(status.errorMessage || 'State migration failed');
+    }
+}

package/dist/server/utils/state-schema.js

@@ -6,6 +6,7 @@ const commitRefSchema = z.object({
     sha: z.string().min(1),
     repo: z.string()
 });
+const taskStatusValues = new Set(['pending', 'in_progress', 'completed']);
 const taskSchema = z.object({
     id: z.string().min(1),
     category: taskCategorySchema,
@@ -38,6 +39,19 @@ const taskLogSchema = z.object({
     learnings: z.string().optional(),
     commits: z.array(z.union([z.string().min(1), commitRefSchema])).optional()
 });
+const progressPatternSchema = z.union([
+    z.string().trim().min(1).transform((value) => ({
+        name: value,
+        description: value
+    })),
+    z.object({
+        name: z.string().trim().min(1),
+        description: z.string().trim().min(1).optional()
+    }).transform((value) => ({
+        name: value.name,
+        description: value.description ?? value.name
+    }))
+]);
 const progressFileSchema = z.object({
     prdName: z.string(),
     shortcutStory: z.string().optional(),
@@ -47,12 +61,175 @@ const progressFileSchema = z.object({
     blocked: z.number(),
     startedAt: z.string().nullable(),
     lastUpdated: z.string(),
-    patterns: z.array(z.object({
-        name: z.string(),
-        description: z.string()
-    })),
+    patterns: z.array(progressPatternSchema),
     taskLogs: z.array(taskLogSchema)
 });
+const progressInputSchema = z.object({
+    prdName: z.string().trim().min(1).optional(),
+    startedAt: z.union([z.string(), z.null()]).optional(),
+    started: z.union([z.string(), z.null()]).optional(),
+    totalTasks: z.number().optional(),
+    completed: z.union([z.number(), z.array(z.unknown())]).optional(),
+    inProgress: z.union([z.number(), z.null()]).optional(),
+    blocked: z.number().optional(),
+    lastUpdated: z.string().optional(),
+    patterns: z.array(z.unknown()).optional(),
+    taskLogs: z.array(z.unknown()).optional(),
+    taskProgress: z.record(z.object({
+        status: z.string().optional(),
+        startedAt: z.string().optional(),
+        completedAt: z.string().optional(),
+        implemented: z.string().optional(),
+        filesChanged: z.array(z.string()).optional(),
+        learnings: z.string().optional(),
+        commits: z.array(z.union([z.string().min(1), commitRefSchema])).optional()
+    })).optional()
+}).passthrough();
+function coerceNonNegativeNumber(value) {
+    if (typeof value !== 'number' || !Number.isFinite(value)) {
+        return undefined;
+    }
+    return Math.max(0, Math.floor(value));
+}
+function normalizeTaskLogStatus(value) {
+    if (typeof value === 'string' && taskStatusValues.has(value)) {
+        return value;
+    }
+    return 'pending';
+}
+function normalizeLegacyTaskProgress(taskProgress, now) {
+    if (!taskProgress) {
+        return [];
+    }
+    return Object.entries(taskProgress).map(([taskId, value]) => ({
+        taskId,
+        status: normalizeTaskLogStatus(value.status),
+        startedAt: typeof value.startedAt === 'string' ? value.startedAt : now,
+        ...(typeof value.completedAt === 'string' && { completedAt: value.completedAt }),
+        ...(typeof value.implemented === 'string' && { implemented: value.implemented }),
+        ...(Array.isArray(value.filesChanged) && { filesChanged: value.filesChanged }),
+        ...(typeof value.learnings === 'string' && { learnings: value.learnings }),
+        ...(Array.isArray(value.commits) && { commits: value.commits })
+    }));
+}
+function normalizePatterns(patterns) {
+    if (!patterns) {
+        return [];
+    }
+    const normalized = [];
+    for (const pattern of patterns) {
+        const parsed = progressPatternSchema.safeParse(pattern);
+        if (parsed.success) {
+            normalized.push(parsed.data);
+        }
+    }
+    return normalized;
+}
+function normalizeTaskLogs(taskLogs, now) {
+    if (!taskLogs) {
+        return [];
+    }
+    const normalized = [];
+    for (const taskLog of taskLogs) {
+        const parsed = taskLogSchema.safeParse(taskLog);
+        if (parsed.success) {
+            normalized.push(parsed.data);
+            continue;
+        }
+        if (!taskLog || typeof taskLog !== 'object' || Array.isArray(taskLog)) {
+            continue;
+        }
+        const raw = taskLog;
+        if (typeof raw.taskId !== 'string' || raw.taskId.trim().length === 0) {
+            continue;
+        }
+        const startedAt = typeof raw.startedAt === 'string' ? raw.startedAt : now;
+        const commits = Array.isArray(raw.commits)
+            ? raw.commits.filter((commit) => {
+                if (typeof commit === 'string' && commit.trim().length > 0) {
+                    return true;
+                }
+                if (!commit || typeof commit !== 'object' || Array.isArray(commit)) {
+                    return false;
+                }
+                const ref = commit;
+                return typeof ref.sha === 'string' && ref.sha.trim().length > 0 && typeof ref.repo === 'string';
+            })
+            : undefined;
+        normalized.push({
+            taskId: raw.taskId,
+            status: normalizeTaskLogStatus(raw.status),
+            startedAt,
+            ...(typeof raw.completedAt === 'string' && { completedAt: raw.completedAt }),
+            ...(typeof raw.implemented === 'string' && { implemented: raw.implemented }),
+            ...(Array.isArray(raw.filesChanged) && {
+                filesChanged: raw.filesChanged.filter((file) => typeof file === 'string')
+            }),
+            ...(typeof raw.learnings === 'string' && { learnings: raw.learnings }),
+            ...(commits && commits.length > 0 && { commits })
+        });
+    }
+    return normalized;
+}
+export function normalizeProgressFile(value, options = {}) {
+    const now = options.now || new Date().toISOString();
+    const parsed = progressInputSchema.safeParse(value);
+    const input = parsed.success ? parsed.data : {};
+    const prdName = input.prdName
+        || options.prdNameFallback
+        || 'Unknown PRD';
+    const patterns = normalizePatterns(input.patterns);
+    const taskLogs = input.taskLogs && input.taskLogs.length > 0
+        ? normalizeTaskLogs(input.taskLogs, now)
+        : normalizeLegacyTaskProgress(input.taskProgress, now);
+    const completed = typeof input.completed === 'number'
+        ? Math.max(0, Math.floor(input.completed))
+        : (Array.isArray(input.completed) ? input.completed.length : taskLogs.filter((log) => log.status === 'completed').length);
+    const inProgress = coerceNonNegativeNumber(input.inProgress)
+        ?? taskLogs.filter((log) => log.status === 'in_progress').length;
+    const blocked = coerceNonNegativeNumber(input.blocked) ?? 0;
+    const totalTasks = coerceNonNegativeNumber(input.totalTasks)
+        ?? coerceNonNegativeNumber(options.totalTasksHint)
+        ?? Math.max(completed + inProgress + blocked, taskLogs.length);
+    return progressFileSchema.parse({
+        prdName,
+        shortcutStory: undefined,
+        totalTasks,
+        completed,
+        inProgress,
+        blocked,
+        startedAt: input.startedAt ?? input.started ?? null,
+        lastUpdated: input.lastUpdated || now,
+        patterns,
+        taskLogs
+    });
+}
+export function parseStoredProgressFile(value, options = {}) {
+    return normalizeProgressFile(value, options);
+}
+export function needsProgressMigration(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value)) {
+        return true;
+    }
+    const record = value;
+    if (Object.prototype.hasOwnProperty.call(record, 'started')) {
+        return true;
+    }
+    if (Object.prototype.hasOwnProperty.call(record, 'taskProgress')) {
+        return true;
+    }
+    if (!Array.isArray(record.patterns) || !Array.isArray(record.taskLogs)) {
+        return true;
+    }
+    if (Array.isArray(record.completed)) {
+        return true;
+    }
+    if (record.inProgress === null) {
+        return true;
+    }
+    const result = progressFileSchema.safeParse(value);
+    return !result.success;
+}
 export function parseTasksFile(value) {
     return tasksFileSchema.parse(value);
 }