@thxgg/steward 0.1.17 → 0.1.19

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

@@ -1,11 +1,7 @@
-import { promises as fs } from 'node:fs';
-import { join } from 'node:path';
 import { emitChange } from './change-events.js';
 import { dbAll, dbGet, dbRun } from './db.js';
-import { parseProgressFile, parseTasksFile } from './state-schema.js';
-const LEGACY_STATE_STABLE_MS = 0;
-const migrationInFlight = new Map();
-const cleanupCompletedRepoIds = new Set();
+import { ensureStateMigrationReady } from './state-migration.js';
+import { parseProgressFile, parseStoredProgressFile, parseTasksFile } from './state-schema.js';
 function parseStoredJson(raw, fieldName, parseValue) {
     if (!raw) {
         return null;
@@ -28,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
@@ -37,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,
@@ -47,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) {
@@ -69,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));
@@ -124,118 +128,3 @@ export async function upsertPrdState(repoId, slug, update) {
         });
     }
 }
-async function readStableLegacyFile(filePath, minFileAgeMs) {
-    try {
-        const stats = await fs.stat(filePath);
-        if (!stats.isFile()) {
-            return null;
-        }
-        if (Date.now() - stats.mtimeMs < minFileAgeMs) {
-            return null;
-        }
-        return await fs.readFile(filePath, 'utf-8');
-    }
-    catch {
-        return null;
-    }
-}
-async function readLegacyJsonFile(filePath, label, minFileAgeMs) {
-    const content = await readStableLegacyFile(filePath, minFileAgeMs);
-    if (!content) {
-        return { value: null, imported: false };
-    }
-    try {
-        return { value: JSON.parse(content), imported: true };
-    }
-    catch (error) {
-        const message = error instanceof Error ? error.message : String(error);
-        console.warn(`[legacy-state] Skipping invalid ${label} at ${filePath}: ${message}`);
-        return { value: null, imported: false };
-    }
-}
-async function removeIfExists(filePath) {
-    try {
-        await fs.unlink(filePath);
-    }
-    catch {
-        // File may already be removed.
-    }
-}
-async function removeDirIfEmpty(dirPath) {
-    try {
-        const entries = await fs.readdir(dirPath);
-        if (entries.length === 0) {
-            await fs.rmdir(dirPath);
-        }
-    }
-    catch {
-        // Directory may not exist or may contain files.
-    }
-}
-async function runLegacyStateMigration(repo, cleanupLegacyFiles, minFileAgeMs) {
-    const legacyStateDir = join(repo.path, '.claude', 'state');
-    const entries = await fs.readdir(legacyStateDir, { withFileTypes: true, encoding: 'utf8' }).catch(() => null);
-    if (!entries) {
-        return;
-    }
-    for (const entry of entries) {
-        if (!entry.isDirectory()) {
-            continue;
-        }
-        const slug = entry.name;
-        const slugDir = join(legacyStateDir, slug);
-        const tasksPath = join(slugDir, 'tasks.json');
-        const progressPath = join(slugDir, 'progress.json');
-        const notesPath = join(slugDir, 'notes.md');
-        const [tasksResult, progressResult, notesContent] = await Promise.all([
-            readLegacyJsonFile(tasksPath, 'tasks.json', minFileAgeMs),
-            readLegacyJsonFile(progressPath, 'progress.json', minFileAgeMs),
-            readStableLegacyFile(notesPath, minFileAgeMs)
-        ]);
-        const shouldImportNotes = notesContent !== null;
-        const shouldImport = tasksResult.imported || progressResult.imported || shouldImportNotes;
-        if (!shouldImport) {
-            continue;
-        }
-        await upsertPrdState(repo.id, slug, {
-            ...(tasksResult.imported && { tasks: tasksResult.value }),
-            ...(progressResult.imported && { progress: progressResult.value }),
-            ...(shouldImportNotes && { notes: notesContent })
-        });
-        if (cleanupLegacyFiles) {
-            if (tasksResult.imported) {
-                await removeIfExists(tasksPath);
-            }
-            if (progressResult.imported) {
-                await removeIfExists(progressPath);
-            }
-            if (shouldImportNotes) {
-                await removeIfExists(notesPath);
-            }
-            await removeDirIfEmpty(slugDir);
-        }
-    }
-    if (cleanupLegacyFiles) {
-        await removeDirIfEmpty(legacyStateDir);
-    }
-}
-export async function migrateLegacyStateForRepo(repo, options = {}) {
-    const cleanupLegacyFiles = options.cleanupLegacyFiles
-        ?? !cleanupCompletedRepoIds.has(repo.id);
-    const minFileAgeMs = options.minFileAgeMs ?? LEGACY_STATE_STABLE_MS;
-    const inFlight = migrationInFlight.get(repo.id);
-    if (inFlight) {
-        return inFlight;
-    }
-    const migrationPromise = runLegacyStateMigration(repo, cleanupLegacyFiles, minFileAgeMs)
-        .then(() => {
-        if (cleanupLegacyFiles) {
-            cleanupCompletedRepoIds.add(repo.id);
-        }
-    })
-        .finally(() => {
-        migrationInFlight.delete(repo.id);
-    });
-    migrationInFlight.set(repo.id, migrationPromise);
-    return migrationPromise;
-}

package/dist/server/utils/repos.js

@@ -274,12 +274,22 @@ export async function discoverGitRepos(basePath, maxDepth = 4) {
     return discovered;
 }
 export async function validateRepoPath(path) {
-    // Normalize the path
-    const resolvedPath = resolve(path);
-    // Ensure path is absolute (starts with / on Unix or drive letter on Windows)
-    if (!resolvedPath.startsWith('/') && !/^[A-Za-z]:/.test(resolvedPath)) {
+    const trimmedPath = path.trim();
+    if (trimmedPath.length === 0) {
+        return { valid: false, error: 'Path is required' };
+    }
+    if (trimmedPath.length > 4096) {
+        return { valid: false, error: 'Path is too long' };
+    }
+    if (trimmedPath.includes('\u0000')) {
+        return { valid: false, error: 'Path contains invalid characters' };
+    }
+    const isWindowsAbsolutePath = /^[A-Za-z]:[\\/]/.test(trimmedPath);
+    if (!isAbsolute(trimmedPath) && !isWindowsAbsolutePath) {
         return { valid: false, error: 'Path must be absolute' };
     }
+    // Normalize the path
+    const resolvedPath = resolve(trimmedPath);
     try {
         const stats = await fs.stat(resolvedPath);
         if (!stats.isDirectory()) {

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);
 }

package/dist/server/utils/task-graph.js

@@ -1,5 +1,6 @@
 import { promises as fs } from 'node:fs';
-import { getPrdState, getPrdStateSummaries, migrateLegacyStateForRepo } from './prd-state.js';
+import { getPrdArchiveMap } from './prd-archive.js';
+import { getPrdState, getPrdStateSummaries } from './prd-state.js';
 import { resolvePrdMarkdownPath } from './prd-service.js';
 const NODE_SEPARATOR = '::';
 const MISSING_PREFIX = 'missing';
@@ -139,7 +140,6 @@ function buildGraphFromInputs(inputs) {
     };
 }
 export async function buildPrdGraph(repo, prdSlug) {
-    await migrateLegacyStateForRepo(repo);
     const [state, prdName] = await Promise.all([
         getPrdState(repo.id, prdSlug),
         resolvePrdName(repo, prdSlug)
@@ -161,23 +161,30 @@ export async function buildPrdGraph(repo, prdSlug) {
         stats: graph.stats
     };
 }
-export async function buildRepoGraph(repo) {
-    await migrateLegacyStateForRepo(repo);
-    const summaries = await getPrdStateSummaries(repo.id);
-    const slugs = [...summaries.keys()].sort((a, b) => a.localeCompare(b));
-    const inputs = [];
-    for (const slug of slugs) {
-        const state = await getPrdState(repo.id, slug);
+export async function buildRepoGraph(repo, options = {}) {
+    const includeArchived = options.includeArchived === true;
+    const [summaries, archiveMap] = await Promise.all([
+        getPrdStateSummaries(repo.id),
+        getPrdArchiveMap(repo.id)
+    ]);
+    const slugs = [...summaries.keys()]
+        .filter((slug) => includeArchived || !archiveMap.has(slug))
+        .sort((a, b) => a.localeCompare(b));
+    const inputs = (await Promise.all(slugs.map(async (slug) => {
+        const [state, prdName] = await Promise.all([
+            getPrdState(repo.id, slug),
+            resolvePrdName(repo, slug)
+        ]);
         const tasks = state?.tasks?.tasks;
         if (!Array.isArray(tasks)) {
-            continue;
+            return null;
         }
-        inputs.push({
+        return {
             prdSlug: slug,
-            prdName: await resolvePrdName(repo, slug),
+            prdName,
             tasks
-        });
-    }
+        };
+    }))).filter((input) => input !== null);
     const graph = buildGraphFromInputs(inputs);
     return {
         scope: 'repo',

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@thxgg/steward",
-  "version": "0.1.17",
+  "version": "0.1.19",
   "description": "Local-first PRD workflow steward with codemode MCP and web UI.",
   "type": "module",
   "author": "thxgg",