@oss-autopilot/core 3.1.0 → 3.3.0

package/dist/commands/check-integration.js

@@ -2,8 +2,8 @@
  * Check integration command (#83)
  * Detects new files in the current branch that aren't referenced elsewhere
  */
-import * as path from 'path';
-import { execFileSync } from 'child_process';
+import * as path from 'node:path';
+import { execFileSync } from 'node:child_process';
 import { debug } from '../core/index.js';
 import { errorMessage } from '../core/errors.js';
 /** File extensions we consider "code" that should be imported/referenced */
@@ -71,8 +71,8 @@ export async function runCheckIntegration(options) {
     let newFiles;
     try {
         const output = execFileSync('git', ['diff', '--name-only', '--diff-filter=A', `${base}...HEAD`], {
-            encoding: 'utf-8',
-            timeout: 10000,
+            encoding: 'utf8',
+            timeout: 10_000,
         }).trim();
         newFiles = output ? output.split('\n').filter(Boolean) : [];
     }
@@ -94,8 +94,8 @@ export async function runCheckIntegration(options) {
     let allFiles;
     try {
         allFiles = execFileSync('git', ['ls-files'], {
-            encoding: 'utf-8',
-            timeout: 10000,
+            encoding: 'utf8',
+            timeout: 10_000,
         })
             .trim()
             .split('\n')
@@ -124,8 +124,8 @@ export async function runCheckIntegration(options) {
         for (const pattern of patterns) {
             try {
                 const grepOutput = execFileSync('git', ['grep', '-l', '--', pattern], {
-                    encoding: 'utf-8',
-                    timeout: 10000,
+                    encoding: 'utf8',
+                    timeout: 10_000,
                 }).trim();
                 if (grepOutput) {
                     const matches = grepOutput.split('\n').filter((f) => f !== newFile);

package/dist/commands/comments.js

@@ -7,6 +7,7 @@ import { ValidationError } from '../core/errors.js';
 import { warn } from '../core/logger.js';
 const MODULE = 'comments';
 import { paginateAll } from '../core/pagination.js';
+import { buildStalenessWarning } from '../formatters/json.js';
 import { validateUrl, validateMessage, validateGitHubUrl, PR_URL_PATTERN, ISSUE_OR_PR_URL_PATTERN, ISSUE_URL_PATTERN, } from './validation.js';
 /**
  * Fetch all comments, reviews, and inline review comments for a PR.
@@ -76,6 +77,7 @@ export async function runComments(options) {
     const relevantReviews = reviews
         .filter((r) => filterComment(r) && r.body && r.body.trim())
         .sort((a, b) => new Date(b.submitted_at || 0).getTime() - new Date(a.submitted_at || 0).getTime());
+    const staleness = stateManager.getStateStaleness();
     return {
         pr: {
             title: pr.title,
@@ -107,6 +109,7 @@ export async function runComments(options) {
             inlineCommentCount: relevantReviewComments.length,
             discussionCommentCount: relevantIssueComments.length,
         },
+        ...(staleness ? { warnings: [buildStalenessWarning(staleness)] } : {}),
     };
 }
 /**

package/dist/commands/config.js

@@ -44,25 +44,29 @@ export async function runConfig(options) {
     const value = options.value;
     // Handle specific config keys
     switch (options.key) {
-        case 'username':
+        case 'username': {
             stateManager.updateConfig({ githubUsername: validateGitHubUsername(value) });
             break;
-        case 'add-language':
+        }
+        case 'add-language': {
             if (!currentConfig.languages.includes(value)) {
                 stateManager.updateConfig({ languages: [...currentConfig.languages, value] });
             }
             break;
-        case 'add-label':
+        }
+        case 'add-label': {
             if (!currentConfig.labels.includes(value)) {
                 stateManager.updateConfig({ labels: [...currentConfig.labels, value] });
             }
             break;
-        case 'remove-label':
+        }
+        case 'remove-label': {
             if (!currentConfig.labels.includes(value)) {
                 throw new Error(`Label "${value}" is not currently configured. Current labels: ${currentConfig.labels.join(', ')}`);
             }
             stateManager.updateConfig({ labels: currentConfig.labels.filter((l) => l !== value) });
             break;
+        }
         case 'add-scope': {
             const scope = validateScope(value);
             const currentScopes = currentConfig.scope ?? [];
@@ -111,9 +115,10 @@ export async function runConfig(options) {
             }
             break;
         }
-        case 'issueListPath':
+        case 'issueListPath': {
             stateManager.updateConfig({ issueListPath: value || undefined });
             break;
+        }
         case 'diffTool': {
             if (!DIFF_TOOLS.includes(value)) {
                 throw new Error(`Invalid diffTool "${value}". Valid options: ${DIFF_TOOLS.join(', ')}`);
@@ -121,13 +126,15 @@ export async function runConfig(options) {
             stateManager.updateConfig({ diffTool: value });
             break;
         }
-        case 'diffToolCustomCommand':
+        case 'diffToolCustomCommand': {
             stateManager.updateConfig({
                 diffToolCustomCommand: value || undefined,
             });
             break;
-        default:
+        }
+        default: {
             throw new ValidationError(formatUnknownKeyError(options.key, 'config'));
+        }
     }
     return { success: true, key: options.key, value };
 }

package/dist/commands/daily-render.js

@@ -20,16 +20,21 @@ import { formatRelativeTime } from '../core/dates.js';
  */
 export function formatActionHint(hint) {
     switch (hint) {
-        case 'demo_requested':
+        case 'demo_requested': {
             return 'demo/screenshot requested';
-        case 'tests_requested':
+        }
+        case 'tests_requested': {
             return 'tests requested';
-        case 'changes_requested':
+        }
+        case 'changes_requested': {
             return 'code changes requested';
-        case 'docs_requested':
+        }
+        case 'docs_requested': {
             return 'documentation requested';
-        case 'rebase_requested':
+        }
+        case 'rebase_requested': {
             return 'rebase requested';
+        }
     }
 }
 /**

package/dist/commands/daily.js

@@ -12,7 +12,7 @@ import { warn } from '../core/logger.js';
 import { emptyPRCountsResult } from '../core/github-stats.js';
 import { createAutopilotScout } from './scout-bridge.js';
 import { updateMonthlyAnalytics } from './dashboard-data.js';
-import { deduplicateDigest, compactActionableIssues, compactRepoGroups, } from '../formatters/json.js';
+import { deduplicateDigest, compactActionableIssues, compactRepoGroups, buildStalenessWarning, } from '../formatters/json.js';
 const MODULE = 'daily';
 /**
  * Record a non-fatal failure: push a structured entry into the run's warnings
@@ -504,6 +504,11 @@ async function executeDailyCheckInternal(token) {
     // One collector shared by every phase — threaded through explicitly so the
     // callgraph documents which phases can produce non-fatal warnings. See #1042.
     const warnings = [];
+    // Surface Gist staleness up-front so consumers see it even if Phase 1 fails (#1193).
+    const staleness = getStateManager().getStateStaleness();
+    if (staleness) {
+        warnings.push(buildStalenessWarning(staleness));
+    }
     // Phase 1: Fetch all PR data from GitHub
     const { prs, failures, mergedCounts, closedCounts, monthlyCounts, monthlyClosedCounts, openedFromMerged, openedFromClosed, recentlyClosedPRs, recentlyMergedPRs, commentedIssues, } = await fetchPRData(prMonitor, token, warnings);
     // Phase 2: Update repo scores (signals, star counts, trust sync)

package/dist/commands/dashboard-lifecycle.js

@@ -3,7 +3,7 @@
  * Handles launching the interactive SPA dashboard as a background process
  * and detecting whether a server is already running.
  */
-import { spawn } from 'child_process';
+import { spawn } from 'node:child_process';
 import { findRunningDashboardServer, isDashboardServerRunning, readDashboardServerInfo, removeDashboardServerInfo, } from './dashboard-process.js';
 import { resolveAssetsDir } from './dashboard.js';
 import { getCLIVersion } from '../core/index.js';

package/dist/commands/dashboard-process.js

@@ -2,9 +2,9 @@
  * Dashboard server process management.
  * PID file operations, health probes, and running server detection.
  */
-import * as http from 'http';
-import * as fs from 'fs';
-import * as path from 'path';
+import * as http from 'node:http';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
 import { getDataDir } from '../core/index.js';
 import { warn } from '../core/logger.js';
 const MODULE = 'dashboard-server';
@@ -17,7 +17,7 @@ export function writeDashboardServerInfo(info) {
 }
 export function readDashboardServerInfo() {
     try {
-        const content = fs.readFileSync(getDashboardPidPath(), 'utf-8');
+        const content = fs.readFileSync(getDashboardPidPath(), 'utf8');
         const parsed = JSON.parse(content);
         if (typeof parsed !== 'object' ||
             parsed === null ||

package/dist/commands/dashboard-server.js

@@ -5,10 +5,10 @@
  *
  * Uses Node's built-in http module — no Express/Fastify.
  */
-import * as http from 'http';
-import * as fs from 'fs';
-import * as path from 'path';
-import * as crypto from 'crypto';
+import * as http from 'node:http';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import * as crypto from 'node:crypto';
 import { getStateManager, getGitHubToken, getCLIVersion, applyStatusOverrides } from '../core/index.js';
 import { errorMessage, ValidationError } from '../core/errors.js';
 import { warn } from '../core/logger.js';
@@ -44,7 +44,7 @@ function readVettedIssues() {
         const info = detectIssueList();
         if (!info)
             return null;
-        const content = fs.readFileSync(info.path, 'utf-8');
+        const content = fs.readFileSync(info.path, 'utf8');
         return parseIssueList(content);
     }
     catch (error) {
@@ -148,7 +148,7 @@ function readBody(req, maxBytes = MAX_BODY_BYTES) {
         });
         req.on('end', () => {
             if (!aborted)
-                resolve(Buffer.concat(chunks).toString('utf-8'));
+                resolve(Buffer.concat(chunks).toString('utf8'));
         });
         req.on('error', (err) => {
             if (!aborted)
@@ -599,6 +599,7 @@ export async function startDashboardServer(options) {
             cachedJsonData = buildDashboardJson(cachedDigest, stateManager.getState(), cachedCommentedIssues, result.allMergedPRs, result.allClosedPRs, cachedPartialFailures);
             cachedIssueListMtimeMs = getIssueListMtimeMs();
             warn(MODULE, 'Background data refresh complete');
+            return;
         })
             .catch((error) => {
             warn(MODULE, `Background data refresh failed (serving cached data): ${errorMessage(error)}`);

package/dist/commands/dashboard.js

@@ -1,8 +1,8 @@
 /**
  * Dashboard command — serves the interactive Preact SPA dashboard.
  */
-import * as fs from 'fs';
-import * as path from 'path';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
 import { getGitHubToken } from '../core/index.js';
 /**
  * Resolve the SPA assets directory from packages/dashboard/dist/.

package/dist/commands/detect-formatters.js

@@ -3,8 +3,8 @@
  * Scans a local repository for configured formatters/linters.
  * Optionally diagnoses CI log output for formatting failures.
  */
-import * as fs from 'fs';
-import * as path from 'path';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
 import { detectFormatters, diagnoseCIFormatterFailure } from '../core/formatter-detection.js';
 import { errorMessage } from '../core/errors.js';
 export async function runDetectFormatters(options) {
@@ -13,7 +13,7 @@ export async function runDetectFormatters(options) {
     if (options.ciLog) {
         let logContent;
         try {
-            logContent = fs.readFileSync(path.resolve(options.ciLog), 'utf-8');
+            logContent = fs.readFileSync(path.resolve(options.ciLog), 'utf8');
         }
         catch (err) {
             throw new Error(`Failed to read CI log file: ${errorMessage(err)}`, { cause: err });

package/dist/commands/doctor.js

@@ -9,10 +9,10 @@
  * Each `check*` function is exported individually so tests can mock its
  * external dependencies in isolation.
  */
-import * as fs from 'fs';
-import * as path from 'path';
-import { execFile } from 'child_process';
-import { promisify } from 'util';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
 import { getGitHubTokenAsync, getOctokit, getStatePath } from '../core/index.js';
 import { AgentStateSchema } from '../core/state-schema.js';
 import { errorMessage } from '../core/errors.js';
@@ -195,7 +195,7 @@ export function checkStateFile(options) {
         };
     }
     try {
-        const raw = fs.readFileSync(statePath, 'utf-8');
+        const raw = fs.readFileSync(statePath, 'utf8');
         const parsed = JSON.parse(raw);
         const result = AgentStateSchema.safeParse(parsed);
         if (!result.success) {

package/dist/commands/guidelines.d.ts

@@ -0,0 +1,67 @@
+import { type PRCommentBundle } from '../core/pr-comments-fetcher.js';
+export interface GuidelinesViewOutput {
+    repo: string;
+    /** Markdown content, or null when the repo has no guidelines stored. */
+    content: string | null;
+    /** UTF-8 byte size of `content`, or 0 when content is null. */
+    byteSize: number;
+    /** Whether a guidelines file exists for this repo. */
+    exists: boolean;
+    /** Where the guidelines would be persisted if a write happened now. */
+    storageMode: 'gist' | 'local-unavailable';
+}
+export interface GuidelinesStoreOutput {
+    repo: string;
+    byteSize: number;
+    stored: boolean;
+}
+export interface GuidelinesResetOutput {
+    repo: string;
+    /** True when an existing file was tombstoned, false when no file existed. */
+    deleted: boolean;
+}
+export interface FetchCorpusOutput {
+    repo: string;
+    bundles: PRCommentBundle[];
+    /** How many PRs were considered after recency + already-fetched filtering. */
+    prCount: number;
+    /** PRs skipped because `commentsFetchedAt` is already set (without --force). */
+    skipped: number;
+}
+interface RepoOption {
+    repo: string;
+}
+interface FetchCorpusOptions extends RepoOption {
+    /** Cap on PRs to process. Defaults to 5; capped at 10 to bound prompt size. */
+    limit?: number;
+    /** Re-fetch even when commentsFetchedAt is already set. */
+    forceRefetch?: boolean;
+}
+interface StoreOptions extends RepoOption {
+    content: string;
+}
+/** Read the per-repo guidelines for `repo`. Returns a `local-unavailable` envelope in non-Gist mode. */
+export declare function runGuidelinesView(options: RepoOption): Promise<GuidelinesViewOutput>;
+/**
+ * Persist per-repo guidelines for `repo`. Throws when not in Gist mode or
+ * when content exceeds the byte budget — the CLI surface relies on the
+ * outputJson error envelope to surface that to the host cleanly.
+ */
+export declare function runGuidelinesStore(options: StoreOptions): Promise<GuidelinesStoreOutput>;
+/** Tombstone the guidelines file for `repo`. */
+export declare function runGuidelinesReset(options: RepoOption): Promise<GuidelinesResetOutput>;
+/**
+ * Fetch raw PR comment bundles for the most recent merged/closed PRs in `repo`
+ * that haven't already been processed. Returns a serializable corpus for the
+ * host's extract-learnings prompt.
+ *
+ * Filters applied at the CLI layer (not the fetcher):
+ * - Only PRs in the requested `repo`
+ * - PRs older than 12 months are dropped (recency cliff)
+ * - PRs with `commentsFetchedAt` already set are skipped unless `forceRefetch`
+ * - Capped at `limit` (default 5, max 10)
+ *
+ * Stamps `commentsFetchedAt` on every PR that was successfully fetched.
+ */
+export declare function runFetchCorpus(options: FetchCorpusOptions): Promise<FetchCorpusOutput>;
+export {};

package/dist/commands/guidelines.js

@@ -0,0 +1,159 @@
+/**
+ * Guidelines CLI commands (#867 PR 4).
+ *
+ * `guidelines view`        — read the per-repo guidelines file from the Gist.
+ * `guidelines store`       — overwrite the per-repo guidelines file.
+ * `guidelines reset`       — tombstone the file so subsequent reads return null.
+ * `guidelines fetch-corpus` — pull raw PR comment bundles for the host's
+ *                              extract-learnings prompt to consume.
+ *
+ * The CLI layer is pure data plumbing — extraction is the host's job.
+ * Standalone-mode users see "not available" on store/reset/fetch-corpus
+ * because per-repo guidelines require Gist persistence to be useful.
+ */
+import { getStateManager, requireGitHubToken, getOctokit, GuidelinesNotAvailableError, maybeCheckpoint, } from '../core/index.js';
+import { fetchPRCommentBundlesBatch } from '../core/pr-comments-fetcher.js';
+import { warn } from '../core/logger.js';
+const MODULE = 'guidelines';
+const REPO_ID_PATTERN = /^[^/]+\/[^/]+$/;
+const DEFAULT_FETCH_LIMIT = 5;
+const MAX_FETCH_LIMIT = 10;
+/**
+ * Cliff at 12 months: PRs older than this are excluded from corpus fetches
+ * (#867 design decision §5). Computed at call time, not module load.
+ */
+const RECENCY_CLIFF_MS = 365 * 24 * 60 * 60 * 1000;
+function validateRepo(repo) {
+    if (!REPO_ID_PATTERN.test(repo)) {
+        throw new Error(`Invalid repo identifier "${repo}". Expected "owner/repo" format.`);
+    }
+}
+/** Read the per-repo guidelines for `repo`. Returns a `local-unavailable` envelope in non-Gist mode. */
+export async function runGuidelinesView(options) {
+    validateRepo(options.repo);
+    const sm = getStateManager();
+    const content = sm.getGuidelines(options.repo);
+    return {
+        repo: options.repo,
+        content,
+        byteSize: content === null ? 0 : Buffer.byteLength(content, 'utf8'),
+        exists: content !== null,
+        storageMode: sm.isGuidelinesAvailable() ? 'gist' : 'local-unavailable',
+    };
+}
+/**
+ * Persist per-repo guidelines for `repo`. Throws when not in Gist mode or
+ * when content exceeds the byte budget — the CLI surface relies on the
+ * outputJson error envelope to surface that to the host cleanly.
+ */
+export async function runGuidelinesStore(options) {
+    validateRepo(options.repo);
+    if (!options.content || options.content.length === 0) {
+        throw new Error('Cannot store empty content. Use `guidelines reset` to delete a guidelines file.');
+    }
+    const sm = getStateManager();
+    // Throws GuidelinesNotAvailableError or GuidelinesTooLargeError on failure.
+    sm.setGuidelines(options.repo, options.content);
+    // Push to Gist — autoSave only writes the local state-cache mirror in Gist
+    // mode, so without this checkpoint the change never propagates across
+    // machines (#1200).
+    await maybeCheckpoint(sm, MODULE);
+    return {
+        repo: options.repo,
+        byteSize: Buffer.byteLength(options.content, 'utf8'),
+        stored: true,
+    };
+}
+/** Tombstone the guidelines file for `repo`. */
+export async function runGuidelinesReset(options) {
+    validateRepo(options.repo);
+    const sm = getStateManager();
+    if (!sm.isGuidelinesAvailable()) {
+        throw new GuidelinesNotAvailableError();
+    }
+    const existed = sm.getGuidelines(options.repo) !== null;
+    if (existed) {
+        sm.deleteGuidelines(options.repo);
+        // Push to Gist — see runGuidelinesStore note (#1200).
+        await maybeCheckpoint(sm, MODULE);
+    }
+    return { repo: options.repo, deleted: existed };
+}
+/**
+ * Fetch raw PR comment bundles for the most recent merged/closed PRs in `repo`
+ * that haven't already been processed. Returns a serializable corpus for the
+ * host's extract-learnings prompt.
+ *
+ * Filters applied at the CLI layer (not the fetcher):
+ * - Only PRs in the requested `repo`
+ * - PRs older than 12 months are dropped (recency cliff)
+ * - PRs with `commentsFetchedAt` already set are skipped unless `forceRefetch`
+ * - Capped at `limit` (default 5, max 10)
+ *
+ * Stamps `commentsFetchedAt` on every PR that was successfully fetched.
+ */
+export async function runFetchCorpus(options) {
+    validateRepo(options.repo);
+    const limit = clampLimit(options.limit);
+    const sm = getStateManager();
+    const merged = sm.getMergedPRs() ?? [];
+    const closed = sm.getClosedPRs() ?? [];
+    const cutoffMs = Date.now() - RECENCY_CLIFF_MS;
+    /** Treat both merged and closed-without-merge PRs as candidates. */
+    const candidates = [
+        ...merged.map((pr) => ({ url: pr.url, timestamp: pr.mergedAt, alreadyFetched: !!pr.commentsFetchedAt })),
+        ...closed.map((pr) => ({ url: pr.url, timestamp: pr.closedAt, alreadyFetched: !!pr.commentsFetchedAt })),
+    ];
+    const repoUrlPrefix = `https://github.com/${options.repo}/`;
+    const eligible = candidates.filter((c) => {
+        if (!c.url.startsWith(repoUrlPrefix))
+            return false;
+        if (Date.parse(c.timestamp || '') < cutoffMs)
+            return false;
+        return true;
+    });
+    // Skipped count tracks ONLY the eligibility-passing PRs that were excluded
+    // for already-fetched. PRs filtered by repo/recency aren't "skipped" — they
+    // just don't apply to this repo or cutoff.
+    const skipped = options.forceRefetch ? 0 : eligible.filter((c) => c.alreadyFetched).length;
+    const toFetch = (options.forceRefetch ? eligible : eligible.filter((c) => !c.alreadyFetched))
+        // Most-recent first so the host always sees the freshest signal in its corpus window.
+        .sort((a, b) => Date.parse(b.timestamp || '') - Date.parse(a.timestamp || ''))
+        .slice(0, limit);
+    if (toFetch.length === 0) {
+        return { repo: options.repo, bundles: [], prCount: 0, skipped };
+    }
+    const token = requireGitHubToken();
+    const octokit = getOctokit(token);
+    const username = sm.getState().config.githubUsername;
+    if (!username) {
+        warn(MODULE, 'githubUsername is not set; bot/own-comment filtering will be incomplete');
+    }
+    const bundles = await fetchPRCommentBundlesBatch(octokit, toFetch.map((c) => c.url), username);
+    // Stamp commentsFetchedAt on each PR we successfully fetched — the bundle
+    // list mirrors the input order until paginateAll fan-out, so we mark on
+    // a per-bundle basis to be safe.
+    const now = new Date().toISOString();
+    for (const bundle of bundles) {
+        sm.markPRCommentsFetched(bundle.prUrl, now);
+    }
+    // Push commentsFetchedAt stamps to Gist so other machines don't re-fetch
+    // the same PRs forever. autoSave only writes the local mirror in Gist
+    // mode (#1200).
+    if (bundles.length > 0) {
+        await maybeCheckpoint(sm, MODULE);
+    }
+    return {
+        repo: options.repo,
+        bundles,
+        prCount: bundles.length,
+        skipped,
+    };
+}
+function clampLimit(limit) {
+    if (limit === undefined)
+        return DEFAULT_FETCH_LIMIT;
+    if (!Number.isFinite(limit) || limit < 1)
+        return DEFAULT_FETCH_LIMIT;
+    return Math.min(limit, MAX_FETCH_LIMIT);
+}

package/dist/commands/index.d.ts

@@ -53,6 +53,14 @@ export { runInit } from './init.js';
 export { runSetup } from './setup.js';
 /** Check whether setup has been completed. */
 export { runCheckSetup } from './setup.js';
+/** Read the guidelines file for a repo. */
+export { runGuidelinesView } from './guidelines.js';
+/** Persist a guidelines file for a repo (overwrites on subsequent calls). */
+export { runGuidelinesStore } from './guidelines.js';
+/** Tombstone a guidelines file so subsequent reads return null. */
+export { runGuidelinesReset } from './guidelines.js';
+/** Fetch raw PR comment bundles for the host's extract-learnings prompt. */
+export { runFetchCorpus } from './guidelines.js';
 /** Show current persistence mode, Gist ID, and sync status. */
 export { runStateShow } from './state-cmd.js';
 /** Force push state to the backing Gist (no-op in local mode). */
@@ -78,6 +86,7 @@ export type { VetOutput, CommentsOutput, PostOutput, ClaimOutput, VetListOutput,
 export type { ConfigOutput, DetectFormattersOutput, ParseIssueListOutput, ParsedIssueItem, CheckIntegrationOutput, LocalReposOutput, } from '../formatters/json.js';
 export type { ShelveOutput, UnshelveOutput } from './shelve.js';
 export type { MoveOutput, MoveTarget } from './move.js';
+export type { GuidelinesViewOutput, GuidelinesStoreOutput, GuidelinesResetOutput, FetchCorpusOutput, } from './guidelines.js';
 export type { DismissOutput, UndismissOutput } from './dismiss.js';
 export type { InitOutput } from './init.js';
 export type { ConfigSetOutput, ConfigCommandOutput } from './config.js';

package/dist/commands/index.js

@@ -57,6 +57,15 @@ export { runInit } from './init.js';
 export { runSetup } from './setup.js';
 /** Check whether setup has been completed. */
 export { runCheckSetup } from './setup.js';
+// ── Per-Repo Guidelines (#867) ──────────────────────────────────────────────
+/** Read the guidelines file for a repo. */
+export { runGuidelinesView } from './guidelines.js';
+/** Persist a guidelines file for a repo (overwrites on subsequent calls). */
+export { runGuidelinesStore } from './guidelines.js';
+/** Tombstone a guidelines file so subsequent reads return null. */
+export { runGuidelinesReset } from './guidelines.js';
+/** Fetch raw PR comment bundles for the host's extract-learnings prompt. */
+export { runFetchCorpus } from './guidelines.js';
 // ── State Persistence ────────────────────────────────────────────────────────
 /** Show current persistence mode, Gist ID, and sync status. */
 export { runStateShow } from './state-cmd.js';

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

@@ -10,8 +10,8 @@
  *
  * No GitHub calls — pure read/transform/write of a local file.
  */
-import * as fs from 'fs';
-import * as path from 'path';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
 import { errorMessage } from '../core/errors.js';
 const TIER_HEADERS = {
     pursue: '## Pursue',
@@ -47,7 +47,7 @@ function findIssueBlocks(lines, issueUrl) {
     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);
+        const isTopLevelListItem = /^[*+-]\s|^\d+\.\s/.test(line);
         if (!isTopLevelListItem || !line.includes(issueUrl))
             continue;
         // Capture indented sub-bullets that follow this line.
@@ -166,7 +166,7 @@ export async function runListMoveTier(options) {
     }
     let content;
     try {
-        content = fs.readFileSync(filePath, 'utf-8');
+        content = fs.readFileSync(filePath, 'utf8');
     }
     catch (error) {
         throw new Error(`Failed to read file: ${errorMessage(error)}`, { cause: error });
@@ -174,7 +174,7 @@ export async function runListMoveTier(options) {
     const result = moveIssueToTier(content, options.issueUrl, options.tier);
     if (result.moved) {
         try {
-            fs.writeFileSync(filePath, result.content, 'utf-8');
+            fs.writeFileSync(filePath, result.content, 'utf8');
         }
         catch (error) {
             throw new Error(`Failed to write file: ${errorMessage(error)}`, { cause: error });