@oss-autopilot/core 1.17.4 → 3.0.0

package/dist/commands/daily-render.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Rendering functions for the daily digest.
+ *
+ * Extracted from src/core/daily-logic.ts under #1117 so that
+ * core/daily-logic.ts can be a pure-aggregations module with no console
+ * or markdown output mixed in. The aggregations live in core because
+ * other surfaces (dashboard, MCP) consume them too.
+ *
+ *   - formatActionHint — human-readable maintainer action hint label
+ *   - formatBriefSummary — single-line status string
+ *   - formatSummary — multi-line markdown summary
+ *   - printDigest — console.log-based plain-text rendering
+ *
+ * Tests for these renderers live alongside the aggregations test
+ * (daily-logic.test.ts) — pure rendering, easy to assert on string output.
+ */
+import type { CapacityAssessment, CommentedIssue, CommentedIssueWithResponse, DailyDigest, MaintainerActionHint } from '../core/types.js';
+/**
+ * Format a maintainer action hint as a human-readable label.
+ */
+export declare function formatActionHint(hint: MaintainerActionHint): string;
+/**
+ * Format a brief one-liner summary for the action-first flow.
+ *
+ * @returns One-line status string (e.g., "3 Active PRs | 1 needs attention | 2 issue replies")
+ */
+export declare function formatBriefSummary(digest: DailyDigest, issueCount: number, issueResponseCount?: number): string;
+/**
+ * Format the full dashboard summary as markdown.
+ * Used in JSON output for Claude to display verbatim — includes all PR sections,
+ * issue replies, and capacity status.
+ */
+export declare function formatSummary(digest: DailyDigest, capacity: CapacityAssessment, issueResponses?: CommentedIssueWithResponse[]): string;
+/**
+ * Print digest to console as plain text. Unified renderer: uses the same
+ * section ordering as {@link formatSummary} but outputs plain text with
+ * console.log instead of markdown links.
+ */
+export declare function printDigest(digest: DailyDigest, capacity: CapacityAssessment, commentedIssues?: CommentedIssue[]): void;

package/dist/commands/daily-render.js

@@ -0,0 +1,189 @@
+/**
+ * Rendering functions for the daily digest.
+ *
+ * Extracted from src/core/daily-logic.ts under #1117 so that
+ * core/daily-logic.ts can be a pure-aggregations module with no console
+ * or markdown output mixed in. The aggregations live in core because
+ * other surfaces (dashboard, MCP) consume them too.
+ *
+ *   - formatActionHint — human-readable maintainer action hint label
+ *   - formatBriefSummary — single-line status string
+ *   - formatSummary — multi-line markdown summary
+ *   - printDigest — console.log-based plain-text rendering
+ *
+ * Tests for these renderers live alongside the aggregations test
+ * (daily-logic.test.ts) — pure rendering, easy to assert on string output.
+ */
+import { formatRelativeTime } from '../core/dates.js';
+/**
+ * Format a maintainer action hint as a human-readable label.
+ */
+export function formatActionHint(hint) {
+    switch (hint) {
+        case 'demo_requested':
+            return 'demo/screenshot requested';
+        case 'tests_requested':
+            return 'tests requested';
+        case 'changes_requested':
+            return 'code changes requested';
+        case 'docs_requested':
+            return 'documentation requested';
+        case 'rebase_requested':
+            return 'rebase requested';
+    }
+}
+/**
+ * Format a brief one-liner summary for the action-first flow.
+ *
+ * @returns One-line status string (e.g., "3 Active PRs | 1 needs attention | 2 issue replies")
+ */
+export function formatBriefSummary(digest, issueCount, issueResponseCount = 0) {
+    const attentionText = issueCount > 0 ? `${issueCount} need${issueCount === 1 ? 's' : ''} attention` : 'all on track';
+    const issueReplyText = issueResponseCount > 0 ? ` | ${issueResponseCount} issue repl${issueResponseCount === 1 ? 'y' : 'ies'}` : '';
+    return `\u{1F4CA} ${digest.summary.totalActivePRs} Active PRs | ${attentionText}${issueReplyText}`;
+}
+/**
+ * Format the full dashboard summary as markdown.
+ * Used in JSON output for Claude to display verbatim — includes all PR sections,
+ * issue replies, and capacity status.
+ */
+export function formatSummary(digest, capacity, issueResponses = []) {
+    const lines = [];
+    lines.push('## OSS Dashboard');
+    lines.push('');
+    lines.push(`\u{1F4CA} **${digest.summary.totalActivePRs} Active PRs** | ${digest.summary.totalMergedAllTime} Merged | ${digest.summary.mergeRate}% Merge Rate`);
+    lines.push('✓ Dashboard generated — say "open dashboard" to view in browser');
+    lines.push('');
+    if (digest.needsAddressingPRs.length > 0) {
+        lines.push('### ❌ Needs Addressing');
+        for (const pr of digest.needsAddressingPRs) {
+            lines.push(`- [${pr.repo}#${pr.number}](${pr.url}): ${pr.title}`);
+            lines.push(`  └─ ${pr.displayLabel} ${pr.displayDescription}`);
+        }
+        lines.push('');
+    }
+    if (digest.waitingOnMaintainerPRs.length > 0) {
+        lines.push('### ⏳ Waiting on Maintainer');
+        for (const pr of digest.waitingOnMaintainerPRs) {
+            lines.push(`- [${pr.repo}#${pr.number}](${pr.url}): ${pr.title}`);
+            lines.push(`  └─ ${pr.displayDescription}`);
+        }
+        lines.push('');
+    }
+    if (digest.recentlyMergedPRs.length > 0) {
+        lines.push('### \u{1F389} Recently Merged');
+        for (const pr of digest.recentlyMergedPRs) {
+            const mergedDate = pr.mergedAt ? new Date(pr.mergedAt).toLocaleDateString() : '';
+            lines.push(`- [${pr.repo}#${pr.number}](${pr.url}): ${pr.title}${mergedDate ? ` (merged ${mergedDate})` : ''}`);
+        }
+        lines.push('');
+    }
+    if (digest.recentlyClosedPRs.length > 0) {
+        lines.push('### \u{1F6AB} Recently Closed');
+        for (const pr of digest.recentlyClosedPRs) {
+            const closedDate = pr.closedAt ? new Date(pr.closedAt).toLocaleDateString() : '';
+            lines.push(`- [${pr.repo}#${pr.number}](${pr.url}): ${pr.title}${closedDate ? ` (closed ${closedDate})` : ''}`);
+        }
+        lines.push('');
+    }
+    if (digest.autoUnshelvedPRs.length > 0) {
+        lines.push('### \u{1F514} Auto-Unshelved');
+        lines.push('> These PRs were shelved but a maintainer engaged — moved back to active.');
+        for (const pr of digest.autoUnshelvedPRs) {
+            lines.push(`- [${pr.repo}#${pr.number}](${pr.url}): ${pr.title} (${pr.status.replace(/_/g, ' ')})`);
+        }
+        lines.push('');
+    }
+    if (digest.shelvedPRs.length > 0) {
+        lines.push('### \u{1F4E6} Shelved');
+        for (const pr of digest.shelvedPRs) {
+            lines.push(`- [${pr.repo}#${pr.number}](${pr.url}): ${pr.title}`);
+        }
+        lines.push('');
+    }
+    if (issueResponses.length > 0) {
+        lines.push('### \u{1F4AC} Issue Replies');
+        for (const issue of issueResponses) {
+            lines.push(`- [${issue.repo}#${issue.number}](${issue.url}): ${issue.title}`);
+            const timeAgo = formatRelativeTime(issue.lastResponseAt);
+            lines.push(`  └─ @${issue.lastResponseAuthor}: "${issue.lastResponseBody.slice(0, 80)}${issue.lastResponseBody.length > 80 ? '...' : ''}"${timeAgo ? ` (${timeAgo})` : ''}`);
+        }
+        lines.push('');
+    }
+    const capacityIcon = capacity.hasCapacity ? '✅' : '⚠️';
+    const capacityLabel = capacity.hasCapacity ? 'Ready for new work' : 'Focus on existing PRs';
+    const shelvedNote = capacity.shelvedPRCount > 0 ? ` + ${capacity.shelvedPRCount} shelved` : '';
+    lines.push(`**Capacity:** ${capacityIcon} ${capacityLabel} (${capacity.activePRCount}/${capacity.maxActivePRs} PRs${shelvedNote})`);
+    return lines.join('\n');
+}
+/**
+ * Print digest to console as plain text. Unified renderer: uses the same
+ * section ordering as {@link formatSummary} but outputs plain text with
+ * console.log instead of markdown links.
+ */
+export function printDigest(digest, capacity, commentedIssues = []) {
+    console.log('\n\u{1F4CA} OSS Daily Check\n');
+    console.log(`Active PRs: ${digest.summary.totalActivePRs}`);
+    console.log(`Needing Attention: ${digest.summary.totalNeedingAttention}`);
+    console.log(`Merged (all time): ${digest.summary.totalMergedAllTime}`);
+    console.log(`Merge Rate: ${digest.summary.mergeRate}%`);
+    console.log(`\nCapacity: ${capacity.hasCapacity ? '✅ Ready for new work' : '⚠️  Focus on existing work'}`);
+    console.log(`  ${capacity.reason}\n`);
+    if (digest.needsAddressingPRs.length > 0) {
+        console.log('❌ Needs Addressing:');
+        for (const pr of digest.needsAddressingPRs) {
+            console.log(`  - ${pr.repo}#${pr.number}: ${pr.title}`);
+            console.log(`    ${pr.displayLabel} ${pr.displayDescription}`);
+        }
+        console.log('');
+    }
+    if (digest.waitingOnMaintainerPRs.length > 0) {
+        console.log('⏳ Waiting on Maintainer:');
+        for (const pr of digest.waitingOnMaintainerPRs) {
+            console.log(`  - ${pr.repo}#${pr.number}: ${pr.title}`);
+            console.log(`    ${pr.displayDescription}`);
+        }
+        console.log('');
+    }
+    if (digest.recentlyMergedPRs.length > 0) {
+        console.log('\u{1F389} Recently Merged:');
+        for (const pr of digest.recentlyMergedPRs) {
+            const mergedDate = pr.mergedAt ? new Date(pr.mergedAt).toLocaleDateString() : '';
+            console.log(`  - ${pr.repo}#${pr.number}: ${pr.title}${mergedDate ? ` (merged ${mergedDate})` : ''}`);
+        }
+        console.log('');
+    }
+    if (digest.recentlyClosedPRs.length > 0) {
+        console.log('\u{1F6AB} Recently Closed:');
+        for (const pr of digest.recentlyClosedPRs) {
+            const closedDate = pr.closedAt ? new Date(pr.closedAt).toLocaleDateString() : '';
+            console.log(`  - ${pr.repo}#${pr.number}: ${pr.title}${closedDate ? ` (closed ${closedDate})` : ''}`);
+        }
+        console.log('');
+    }
+    if (digest.autoUnshelvedPRs.length > 0) {
+        console.log('\u{1F514} Auto-Unshelved:');
+        for (const pr of digest.autoUnshelvedPRs) {
+            console.log(`  - ${pr.repo}#${pr.number}: ${pr.title} (${pr.status.replace(/_/g, ' ')})`);
+        }
+        console.log('');
+    }
+    if (digest.shelvedPRs.length > 0) {
+        console.log('\u{1F4E6} Shelved:');
+        for (const pr of digest.shelvedPRs) {
+            console.log(`  - ${pr.repo}#${pr.number}: ${pr.title}`);
+        }
+        console.log('');
+    }
+    const issueResponses = commentedIssues.filter((i) => i.status === 'new_response');
+    if (issueResponses.length > 0) {
+        console.log('\u{1F4AC} Issue Replies:');
+        for (const issue of issueResponses) {
+            console.log(`  - ${issue.repo}#${issue.number}: ${issue.title}`);
+            console.log(`    @${issue.lastResponseAuthor}: ${issue.lastResponseBody.slice(0, 80)}${issue.lastResponseBody.length > 80 ? '...' : ''}`);
+        }
+        console.log('');
+    }
+    console.log('Run with --json for structured output');
+    console.log('Run "dashboard serve" for browser view');
+}

package/dist/commands/dashboard-data.js

@@ -7,7 +7,7 @@ import { getStateManager, PRMonitor, IssueConversationMonitor, getOctokit } from
 import { errorMessage, isRateLimitOrAuthError } from '../core/errors.js';
 import { warn } from '../core/logger.js';
 import { emptyPRCountsResult, fetchMergedPRsSince, fetchClosedPRsSince } from '../core/github-stats.js';
-import { parseGitHubUrl } from '../core/utils.js';
+import { parseGitHubUrl } from '../core/urls.js';
 import { isBelowMinStars, } from '../core/types.js';
 import { toShelvedPRRef, buildStarFilter } from './daily.js';
 const MODULE = 'dashboard-data';
@@ -182,14 +182,20 @@ export async function fetchDashboardData(token) {
         stateManager.batch(() => {
             // Store new merged PRs incrementally (dedupes by URL)
             try {
-                stateManager.addMergedPRs(newMergedPRs);
+                const { dropped } = stateManager.addMergedPRs(newMergedPRs);
+                if (dropped > 0) {
+                    partialFailures.push(`Dropped ${dropped} merged PR(s) with invalid URLs before persistence`);
+                }
             }
             catch (error) {
                 warn(MODULE, `Failed to store merged PRs: ${errorMessage(error)}`);
             }
             // Store new closed PRs incrementally (dedupes by URL)
             try {
-                stateManager.addClosedPRs(newClosedPRs);
+                const { dropped } = stateManager.addClosedPRs(newClosedPRs);
+                if (dropped > 0) {
+                    partialFailures.push(`Dropped ${dropped} closed PR(s) with invalid URLs before persistence`);
+                }
             }
             catch (error) {
                 warn(MODULE, `Failed to store closed PRs: ${errorMessage(error)}`);

package/dist/commands/index.d.ts

@@ -27,12 +27,8 @@ export { runSearch, MAX_SEARCH_RESULTS } from './search.js';
 export { runVet } from './vet.js';
 /** Re-vet all available issues in a curated issue list for freshness. */
 export { runVetList } from './vet-list.js';
-/** Add a PR to tracking state. */
+/** Fetch PR metadata from GitHub (informational; nothing is persisted). */
 export { runTrack } from './track.js';
-/** Remove a PR from tracking state. */
-export { runUntrack } from './track.js';
-/** Mark PR comments as read. */
-export { runRead } from './read.js';
 /** Temporarily hide a PR from the daily digest. */
 export { runShelve } from './shelve.js';
 /** Restore a shelved PR to the daily digest. */
@@ -65,6 +61,8 @@ export { runStateSync } from './state-cmd.js';
 export { runStateUnlink } from './state-cmd.js';
 /** Parse a curated markdown issue list file into structured issue items. */
 export { runParseList, pruneIssueList } from './parse-list.js';
+/** Move an issue between Pursue / Maybe / Skip sections of a curated list (#1107). */
+export { runListMoveTier, moveIssueToTier, type Tier, type ListMoveTierOptions, type ListMoveTierOutput, } from './list-move-tier.js';
 /** Check if new files are properly referenced/integrated. */
 export { runCheckIntegration } from './check-integration.js';
 /** System-health diagnostic — verifies tokens, bundle, state, scout, rate limit. */
@@ -78,13 +76,11 @@ export type { ErrorCode } from '../formatters/json.js';
 export type { DailyOutput, SearchOutput, StartupOutput, StatusOutput, TrackOutput } from '../formatters/json.js';
 export type { VetOutput, CommentsOutput, PostOutput, ClaimOutput, VetListOutput, VetListItemStatus, } from '../formatters/json.js';
 export type { ConfigOutput, DetectFormattersOutput, ParseIssueListOutput, ParsedIssueItem, CheckIntegrationOutput, LocalReposOutput, } from '../formatters/json.js';
-export type { ReadOutput } from './read.js';
 export type { ShelveOutput, UnshelveOutput } from './shelve.js';
 export type { MoveOutput, MoveTarget } from './move.js';
 export type { DismissOutput, UndismissOutput } from './dismiss.js';
-export type { UntrackOutput } from './track.js';
 export type { InitOutput } from './init.js';
 export type { ConfigSetOutput, ConfigCommandOutput } from './config.js';
 export type { SetupSetOutput, SetupCompleteOutput, SetupRequiredOutput, SetupOutput, CheckSetupOutput, } from './setup.js';
 export type { DailyCheckResult } from './daily.js';
-export type { StateShowOutput, StateSyncOutput, StateUnlinkOutput } from './state-cmd.js';
+export type { StateShowOutput, StateSyncOutput, StateUnlinkOutput, InvalidUrlEntry } from './state-cmd.js';

package/dist/commands/index.js

@@ -29,12 +29,8 @@ export { runVet } from './vet.js';
 /** Re-vet all available issues in a curated issue list for freshness. */
 export { runVetList } from './vet-list.js';
 // ── PR Management ───────────────────────────────────────────────────────────
-/** Add a PR to tracking state. */
+/** Fetch PR metadata from GitHub (informational; nothing is persisted). */
 export { runTrack } from './track.js';
-/** Remove a PR from tracking state. */
-export { runUntrack } from './track.js';
-/** Mark PR comments as read. */
-export { runRead } from './read.js';
 /** Temporarily hide a PR from the daily digest. */
 export { runShelve } from './shelve.js';
 /** Restore a shelved PR to the daily digest. */
@@ -71,6 +67,8 @@ export { runStateUnlink } from './state-cmd.js';
 // ── Utilities ───────────────────────────────────────────────────────────────
 /** Parse a curated markdown issue list file into structured issue items. */
 export { runParseList, pruneIssueList } from './parse-list.js';
+/** Move an issue between Pursue / Maybe / Skip sections of a curated list (#1107). */
+export { runListMoveTier, moveIssueToTier, } from './list-move-tier.js';
 /** Check if new files are properly referenced/integrated. */
 export { runCheckIntegration } from './check-integration.js';
 /** System-health diagnostic — verifies tokens, bundle, state, scout, rate limit. */

package/dist/commands/list-move-tier.d.ts

@@ -0,0 +1,46 @@
+/**
+ * list-move-tier command (#1107).
+ *
+ * Move an issue line — and any indented sub-bullets that belong to it —
+ * between the `## Pursue`, `## Maybe`, and `## Skip` sections of a curated
+ * issue-list markdown file. Replaces the model-driven prose rewrite that
+ * lived in /oss-search with a deterministic file manipulation.
+ *
+ * Idempotent: re-running with the same target tier is a no-op.
+ *
+ * No GitHub calls — pure read/transform/write of a local file.
+ */
+export type Tier = 'pursue' | 'maybe' | 'skip';
+export interface ListMoveTierOptions {
+    issueUrl: string;
+    tier: Tier;
+    listPath: string;
+}
+export interface ListMoveTierOutput {
+    /** Whether anything moved (false when the URL isn't in the list, or it was already in the target tier). */
+    moved: boolean;
+    /** Fully-resolved file path that was inspected. */
+    filePath: string;
+    /** The issue URL that was searched for. */
+    url: string;
+    /** The target tier (always normalized to one of pursue/maybe/skip). */
+    toTier: Tier;
+    /** The tier the issue was moved out of, if it had one. Absent when not found or already in target. */
+    fromTier?: string;
+    /** Number of matching entries moved. Should normally be 1; >1 means the list contained duplicate entries (all moved). */
+    count: number;
+    /** Human-readable explanation when `moved` is false. */
+    reason?: string;
+}
+/**
+ * Pure transform — accepts the file content and returns the rewritten content
+ * plus a summary of what changed. Exported for unit testing.
+ */
+export declare function moveIssueToTier(content: string, issueUrl: string, targetTier: Tier): {
+    content: string;
+    moved: boolean;
+    fromTier?: string;
+    count: number;
+    reason?: string;
+};
+export declare function runListMoveTier(options: ListMoveTierOptions): Promise<ListMoveTierOutput>;

package/dist/commands/list-move-tier.js

@@ -0,0 +1,192 @@
+/**
+ * list-move-tier command (#1107).
+ *
+ * Move an issue line — and any indented sub-bullets that belong to it —
+ * between the `## Pursue`, `## Maybe`, and `## Skip` sections of a curated
+ * issue-list markdown file. Replaces the model-driven prose rewrite that
+ * lived in /oss-search with a deterministic file manipulation.
+ *
+ * Idempotent: re-running with the same target tier is a no-op.
+ *
+ * No GitHub calls — pure read/transform/write of a local file.
+ */
+import * as fs from 'fs';
+import * as path from 'path';
+import { errorMessage } from '../core/errors.js';
+const TIER_HEADERS = {
+    pursue: '## Pursue',
+    maybe: '## Maybe',
+    skip: '## Skip',
+};
+/** Extract the heading text from a line that starts with `## ` (returns undefined otherwise).
+ * Avoids regex on the heading body so a long whitespace prefix can't trigger
+ * backtracking in static analyzers (CodeQL js/polynomial-redos).
+ */
+function parseLevel2Heading(line) {
+    if (line.startsWith('## '))
+        return line.slice(3).trim();
+    return undefined;
+}
+/** Identify which "## Pursue|Maybe|Skip" section a line index sits under, if any. */
+function tierForLine(lines, lineIndex) {
+    for (let i = lineIndex - 1; i >= 0; i--) {
+        const heading = parseLevel2Heading(lines[i]);
+        if (heading !== undefined)
+            return heading;
+        // A higher-level heading also resets — we don't reach back across `# Foo`.
+        if (lines[i].startsWith('# '))
+            return undefined;
+    }
+    return undefined;
+}
+/** Locate every issue block (issue line + any sub-bullets) that mentions the URL. */
+function findIssueBlocks(lines, issueUrl) {
+    const blocks = [];
+    // Use exact substring match on the URL — no regex escaping pitfalls and
+    // the URL itself contains no markdown delimiters that would split a line.
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        // Top-level list item — `- `, `* `, `+ `, or `1.` at the start (with no leading whitespace).
+        const isTopLevelListItem = /^[-*+]\s|^\d+\.\s/.test(line);
+        if (!isTopLevelListItem || !line.includes(issueUrl))
+            continue;
+        // Capture indented sub-bullets that follow this line.
+        let end = i + 1;
+        while (end < lines.length && /^\s{2,}/.test(lines[end])) {
+            end++;
+        }
+        blocks.push({ start: i, end, tier: tierForLine(lines, i) });
+        i = end - 1; // continue past the captured sub-bullets
+    }
+    return blocks;
+}
+/** Find the line index of the target tier's `## ...` header, or undefined if absent. */
+function findTierHeaderIndex(lines, tier) {
+    const expected = TIER_HEADERS[tier].toLowerCase();
+    for (let i = 0; i < lines.length; i++) {
+        const heading = parseLevel2Heading(lines[i]);
+        if (heading !== undefined && `## ${heading}`.toLowerCase() === expected) {
+            return i;
+        }
+    }
+    return undefined;
+}
+/** Find the insertion point for a new entry under a tier's header — the first
+ * blank line or next-section boundary after the header. Returns an index where
+ * splice() can insert. */
+function findTierInsertionIndex(lines, headerIndex) {
+    for (let i = headerIndex + 1; i < lines.length; i++) {
+        // Stop at the next heading of the same or shallower depth.
+        if (/^#{1,2}\s+/.test(lines[i]))
+            return i;
+    }
+    return lines.length;
+}
+/**
+ * Pure transform — accepts the file content and returns the rewritten content
+ * plus a summary of what changed. Exported for unit testing.
+ */
+export function moveIssueToTier(content, issueUrl, targetTier) {
+    // Preserve the trailing newline if present so we don't accidentally strip it.
+    const hadTrailingNewline = content.endsWith('\n');
+    const lines = (hadTrailingNewline ? content.slice(0, -1) : content).split('\n');
+    const blocks = findIssueBlocks(lines, issueUrl);
+    if (blocks.length === 0) {
+        return { content, moved: false, count: 0, reason: 'issue URL not found in the list' };
+    }
+    const targetHeader = TIER_HEADERS[targetTier];
+    // If every match is already in the target tier, no-op (idempotent).
+    if (blocks.every((b) => b.tier !== undefined && `## ${b.tier}`.toLowerCase() === targetHeader.toLowerCase())) {
+        return {
+            content,
+            moved: false,
+            fromTier: blocks[0].tier,
+            count: blocks.length,
+            reason: 'already in target tier',
+        };
+    }
+    // Extract the blocks (highest start index first so earlier indices stay
+    // valid as we splice). Capture the original tier for reporting.
+    const sortedBlocks = [...blocks].sort((a, b) => b.start - a.start);
+    const extracted = [];
+    for (const block of sortedBlocks) {
+        extracted.push({ tier: block.tier, lines: lines.slice(block.start, block.end) });
+        lines.splice(block.start, block.end - block.start);
+    }
+    // We popped in reverse order; reverse to restore source order.
+    extracted.reverse();
+    // Ensure the target section exists. If not, append a new header at the end
+    // of the document.
+    let headerIndex = findTierHeaderIndex(lines, targetTier);
+    if (headerIndex === undefined) {
+        // Append a blank line (if none precedes) and the new header.
+        if (lines.length > 0 && lines[lines.length - 1].trim() !== '') {
+            lines.push('');
+        }
+        lines.push(targetHeader);
+        headerIndex = lines.length - 1;
+        // Add a blank line after the header so insertion below stays clean.
+        lines.push('');
+    }
+    // Insert the extracted blocks at the top of the target section (just after
+    // the header, after any leading blank line).
+    let insertAt = headerIndex + 1;
+    // Skip a single immediate blank line so entries land before the blank that
+    // already separates the section header from its first item, not before the
+    // header.
+    if (insertAt < lines.length && lines[insertAt].trim() === '') {
+        insertAt += 1;
+    }
+    // Don't cross into a different section.
+    const sectionBoundary = findTierInsertionIndex(lines, headerIndex);
+    if (insertAt > sectionBoundary)
+        insertAt = sectionBoundary;
+    const flattened = [];
+    for (const e of extracted) {
+        flattened.push(...e.lines);
+    }
+    lines.splice(insertAt, 0, ...flattened);
+    let next = lines.join('\n');
+    if (hadTrailingNewline)
+        next += '\n';
+    // Report fromTier as the original tier of the first match. (Multi-match
+    // moves across multiple source tiers are uncommon enough that one label is
+    // fine; the count surfaces the multiplicity if needed.)
+    return {
+        content: next,
+        moved: true,
+        fromTier: extracted[0].tier,
+        count: extracted.length,
+    };
+}
+export async function runListMoveTier(options) {
+    const filePath = path.resolve(options.listPath);
+    if (!fs.existsSync(filePath)) {
+        throw new Error(`File not found: ${filePath}`);
+    }
+    let content;
+    try {
+        content = fs.readFileSync(filePath, 'utf-8');
+    }
+    catch (error) {
+        throw new Error(`Failed to read file: ${errorMessage(error)}`, { cause: error });
+    }
+    const result = moveIssueToTier(content, options.issueUrl, options.tier);
+    if (result.moved) {
+        try {
+            fs.writeFileSync(filePath, result.content, 'utf-8');
+        }
+        catch (error) {
+            throw new Error(`Failed to write file: ${errorMessage(error)}`, { cause: error });
+        }
+    }
+    return {
+        moved: result.moved,
+        filePath,
+        url: options.issueUrl,
+        toTier: options.tier,
+        fromTier: result.fromTier,
+        count: result.count,
+        reason: result.reason,
+    };
+}

package/dist/commands/pr-template.js

@@ -4,7 +4,8 @@
  * Usage: oss-autopilot pr-template owner/repo --json
  */
 import { getOctokit } from '../core/github.js';
-import { requireGitHubToken, splitRepo } from '../core/utils.js';
+import { requireGitHubToken } from '../core/auth.js';
+import { splitRepo } from '../core/urls.js';
 import { fetchPRTemplate } from '../core/pr-template.js';
 export async function runPRTemplate(opts) {
     const { owner, repo } = splitRepo(opts.repo);

package/dist/commands/state-cmd.d.ts

@@ -2,11 +2,18 @@
  * State persistence management commands.
  * Provides --show, --sync, and --unlink subcommands for the Gist persistence layer.
  */
+export interface InvalidUrlEntry {
+    kind: 'merged' | 'closed';
+    url: string;
+    title: string;
+}
 export interface StateShowOutput {
     persistence: 'local' | 'gist';
     gistId: string | null;
     gistDegraded: boolean;
     lastRunAt: string | undefined;
+    /** Present only when validate=true. Existing entries with unparseable URLs. */
+    invalidEntries?: InvalidUrlEntry[];
 }
 export interface StateSyncOutput {
     pushed: boolean;
@@ -17,6 +24,8 @@ export interface StateUnlinkOutput {
     localStatePath: string;
     previousGistId: string | null;
 }
-export declare function runStateShow(): Promise<StateShowOutput>;
+export declare function runStateShow(options?: {
+    validate?: boolean;
+}): Promise<StateShowOutput>;
 export declare function runStateSync(): Promise<StateSyncOutput>;
 export declare function runStateUnlink(): Promise<StateUnlinkOutput>;

package/dist/commands/state-cmd.js

@@ -5,18 +5,37 @@
 import * as fs from 'fs';
 import { getStateManager, resetStateManager } from '../core/state.js';
 import { atomicWriteFileSync } from '../core/state-persistence.js';
-import { getStatePath, getGistIdPath } from '../core/utils.js';
+import { getStatePath, getGistIdPath } from '../core/paths.js';
+import { parseGitHubUrl } from '../core/urls.js';
 import { warn } from '../core/logger.js';
 const MODULE = 'state-cmd';
-export async function runStateShow() {
+export async function runStateShow(options = {}) {
     const sm = getStateManager();
     const state = sm.getState();
-    return {
+    const output = {
         persistence: state.config.persistence ?? 'local',
         gistId: state.gistId ?? null,
         gistDegraded: sm.isGistDegraded(),
         lastRunAt: state.lastRunAt,
     };
+    if (options.validate) {
+        output.invalidEntries = collectInvalidUrlEntries(sm);
+    }
+    return output;
+}
+function collectInvalidUrlEntries(sm) {
+    const invalid = [];
+    for (const pr of sm.getMergedPRs()) {
+        if (parseGitHubUrl(pr.url) === null) {
+            invalid.push({ kind: 'merged', url: pr.url, title: pr.title });
+        }
+    }
+    for (const pr of sm.getClosedPRs()) {
+        if (parseGitHubUrl(pr.url) === null) {
+            invalid.push({ kind: 'closed', url: pr.url, title: pr.title });
+        }
+    }
+    return invalid;
 }
 export async function runStateSync() {
     const sm = getStateManager();