@oss-autopilot/core 3.4.1 → 3.6.0

package/dist/core/pr-monitor.js

@@ -18,11 +18,11 @@ import { daysBetween } from './dates.js';
 import { parseGitHubUrl, extractOwnerRepo, isOwnRepo } from './urls.js';
 import { DEFAULT_CONCURRENCY, runWorkerPool } from './concurrency.js';
 import { determineStatus } from './status-determination.js';
-import { ConfigurationError, ValidationError, errorMessage, getHttpStatusCode, isRateLimitOrAuthError, } from './errors.js';
+import { ConfigurationError, ValidationError, errorMessage, getHttpStatusCode, isInvalidUserSearchError, isRateLimitOrAuthError, } from './errors.js';
 import { paginateAll } from './pagination.js';
 import { debug, warn, timed } from './logger.js';
 import { getHttpCache, cachedRequest } from './http-cache.js';
-import { classifyFailingChecks, getCIStatus } from './ci-analysis.js';
+import { categorizeCIStatus, classifyFailingChecks, getCIStatus } from './ci-analysis.js';
 import { determineReviewDecision, getLatestChangesRequestedDate, checkUnrespondedComments, } from './review-analysis.js';
 import { analyzeChecklist } from './checklist-analysis.js';
 import { extractMaintainerActionHints } from './maintainer-analysis.js';
@@ -31,7 +31,7 @@ import { fetchUserMergedPRCounts as fetchUserMergedPRCountsImpl, fetchUserClosed
 import { isPlaceholderUsername } from './placeholder-usernames.js';
 // Re-export so existing consumers can still import from pr-monitor
 export { computeDisplayLabel } from './display-utils.js';
-export { classifyCICheck, classifyFailingChecks, getCIStatus } from './ci-analysis.js';
+export { categorizeCIStatus, classifyCICheck, classifyFailingChecks, getCIStatus } from './ci-analysis.js';
 export { isConditionalChecklistItem } from './checklist-analysis.js';
 export { determineStatus } from './status-determination.js';
 /**
@@ -140,16 +140,31 @@ export class PRMonitor {
         }
         debug('pr-monitor', `Fetching open PRs for @${searchUsername}...`);
         // Search for all open PRs authored by the user with pagination
-        const allItems = [];
         let page = 1;
         const perPage = 100;
-        const firstPage = await this.octokit.search.issuesAndPullRequests({
-            q: `is:pr is:open is:public author:${searchUsername}`,
-            sort: 'updated',
-            order: 'desc',
-            per_page: perPage,
-            page: 1,
-        });
+        let firstPage;
+        try {
+            firstPage = await this.octokit.search.issuesAndPullRequests({
+                q: `is:pr is:open is:public author:${searchUsername}`,
+                sort: 'updated',
+                order: 'desc',
+                per_page: perPage,
+                page: 1,
+            });
+        }
+        catch (err) {
+            // Rewrite the Search API's "users do not exist" 422 into an actionable
+            // ConfigurationError naming the configured username (#1323). The raw
+            // Octokit message ("Validation Failed: ...") gives the user no signal
+            // that the cause is local config rather than a transient GitHub issue.
+            if (isInvalidUserSearchError(err)) {
+                throw new ConfigurationError(`Configured GitHub username "${searchUsername}" was not found on GitHub. ` +
+                    `Run \`/setup-oss\` to reconfigure, or edit \`config.githubUsername\` in ` +
+                    `\`~/.oss-autopilot/state.json\` directly.`);
+            }
+            throw err;
+        }
+        const allItems = [];
         allItems.push(...firstPage.data.items);
         const totalCount = firstPage.data.total_count;
         debug(MODULE, `Found ${totalCount} open PRs`);
@@ -341,6 +356,10 @@ export class PRMonitor {
         const latestChangesRequestedDate = getLatestChangesRequestedDate(reviews);
         // Classify failing checks (delegated to ci-analysis module)
         const classifiedChecks = classifyFailingChecks(failingCheckNames, failingCheckConclusions);
+        // Aggregate 5-state CI categorization (#1272). Computed once here so
+        // agents read pr.ciCategorization rather than re-deriving the truth
+        // table in three separate prose forms.
+        const ciCategorization = categorizeCIStatus({ ciStatus, failingCheckNames, classifiedChecks });
         // Determine status
         const hasActionableCIFailure = ciStatus === 'failing' && classifiedChecks.some((c) => c.category === 'actionable');
         const { status, actionReason, waitReason, stalenessTier, actionReasons } = determineStatus({
@@ -376,6 +395,7 @@ export class PRMonitor {
             ciStatus,
             failingCheckNames,
             classifiedChecks,
+            ciCategorization,
             hasMergeConflict: mergeConflict,
             reviewDecision,
             hasUnrespondedComment,

package/dist/core/pr-quality-rubric.d.ts

@@ -0,0 +1,70 @@
+/**
+ * Canonical PR quality rubric (#1252).
+ *
+ * Single source of truth for the PR-quality checks shared between
+ * `skills/pr-etiquette/SKILL.md` (human-facing checklist) and
+ * `agents/pr-compliance-checker.md` (agent-facing scoring via
+ * `computeComplianceScore` in compliance-score.ts).
+ *
+ * Both surfaces had the same checks listed independently, with the
+ * "< 10 files, < 400 lines ideal" threshold duplicated. Drift was
+ * inevitable as either surface evolved. This module exports the
+ * rubric as structured data so the two consumers cannot drift
+ * silently — `compliance-score.ts` re-exports its WEIGHTS /
+ * FOCUSED_CHANGES from here, and the skill prose references this
+ * file as the canonical definition.
+ *
+ * Same architectural shape as the typed-core extractions in
+ * #858 / #910 / #911 / #1245 / #1242 / #1243 — pull the rubric out
+ * of prose into typed code so it's testable and tunable.
+ */
+export type PRQualityTier = 'required' | 'conditional' | 'optional';
+export interface PRQualityCheck {
+    /** Stable identifier referenced by the agent's scoring code. */
+    id: 'issueReference' | 'description' | 'title' | 'focusedChanges' | 'minimalDiff' | 'tests' | 'docs' | 'branch' | 'screenshots';
+    /** Human-facing label as it appears in the skill checklist. */
+    label: string;
+    /** One-line description for both the skill checklist and the
+     * agent's recommendation prose. */
+    description: string;
+    tier: PRQualityTier;
+    /**
+     * Percent weight in the agent's compliance score, when the check
+     * is part of the scored set. `null` for checks the skill lists but
+     * the agent doesn't currently score (Minimal Diff, Docs, Screenshots).
+     */
+    weight: number | null;
+}
+/**
+ * Canonical "focused changes" thresholds. Mirrored by
+ * compliance-score.ts's `FOCUSED_CHANGES` constant — that file
+ * imports these values.
+ */
+export declare const FOCUSED_CHANGES_THRESHOLDS: {
+    readonly passFiles: 10;
+    readonly passLines: 400;
+    readonly warnFiles: 20;
+    readonly warnLines: 800;
+};
+/**
+ * Title byte budget. Mirrored by compliance-score.ts's
+ * `TITLE_LENGTH_BUDGET` — that file imports this value.
+ */
+export declare const TITLE_LENGTH_BUDGET = 72;
+/**
+ * The full rubric. The order is the order the skill renders the
+ * checklist in; the weights total 100 across the scored entries.
+ */
+export declare const PR_QUALITY_RUBRIC: readonly PRQualityCheck[];
+/**
+ * Look up a check by id. Used by `compliance-score.ts` to wire the
+ * scored checks to their canonical weight without hardcoding the
+ * value in two places.
+ */
+export declare function getRubricCheck(id: PRQualityCheck['id']): PRQualityCheck | undefined;
+/**
+ * Sum of the weights for scored checks. Should equal 100. Tests pin
+ * this so a future edit that fails to balance the weights surfaces
+ * at CI time rather than silently shipping a < 100 rubric.
+ */
+export declare function totalScoredWeight(): number;

package/dist/core/pr-quality-rubric.js

@@ -0,0 +1,121 @@
+/**
+ * Canonical PR quality rubric (#1252).
+ *
+ * Single source of truth for the PR-quality checks shared between
+ * `skills/pr-etiquette/SKILL.md` (human-facing checklist) and
+ * `agents/pr-compliance-checker.md` (agent-facing scoring via
+ * `computeComplianceScore` in compliance-score.ts).
+ *
+ * Both surfaces had the same checks listed independently, with the
+ * "< 10 files, < 400 lines ideal" threshold duplicated. Drift was
+ * inevitable as either surface evolved. This module exports the
+ * rubric as structured data so the two consumers cannot drift
+ * silently — `compliance-score.ts` re-exports its WEIGHTS /
+ * FOCUSED_CHANGES from here, and the skill prose references this
+ * file as the canonical definition.
+ *
+ * Same architectural shape as the typed-core extractions in
+ * #858 / #910 / #911 / #1245 / #1242 / #1243 — pull the rubric out
+ * of prose into typed code so it's testable and tunable.
+ */
+/**
+ * Canonical "focused changes" thresholds. Mirrored by
+ * compliance-score.ts's `FOCUSED_CHANGES` constant — that file
+ * imports these values.
+ */
+export const FOCUSED_CHANGES_THRESHOLDS = {
+    passFiles: 10,
+    passLines: 400,
+    warnFiles: 20,
+    warnLines: 800,
+};
+/**
+ * Title byte budget. Mirrored by compliance-score.ts's
+ * `TITLE_LENGTH_BUDGET` — that file imports this value.
+ */
+export const TITLE_LENGTH_BUDGET = 72;
+/**
+ * The full rubric. The order is the order the skill renders the
+ * checklist in; the weights total 100 across the scored entries.
+ */
+export const PR_QUALITY_RUBRIC = [
+    {
+        id: 'issueReference',
+        label: 'Issue Reference',
+        description: 'PR links to issue (`Closes #X` or `Fixes #X`)',
+        tier: 'required',
+        weight: 25,
+    },
+    {
+        id: 'description',
+        label: 'Description Quality',
+        description: 'Explains what changed and why',
+        tier: 'required',
+        weight: 25,
+    },
+    {
+        id: 'title',
+        label: 'Title Quality',
+        description: 'Descriptive, properly formatted (e.g., `fix: resolve login timeout`)',
+        tier: 'required',
+        weight: 10,
+    },
+    {
+        id: 'focusedChanges',
+        label: 'Focused Changes',
+        description: `One logical change per PR (< ${FOCUSED_CHANGES_THRESHOLDS.passFiles} files, < ${FOCUSED_CHANGES_THRESHOLDS.passLines} lines ideal)`,
+        tier: 'required',
+        weight: 20,
+    },
+    {
+        id: 'minimalDiff',
+        label: 'Minimal Diff',
+        description: 'No unrelated formatting changes (whitespace, quotes, imports, trailing commas)',
+        tier: 'required',
+        weight: null,
+    },
+    {
+        id: 'tests',
+        label: 'Tests Included',
+        description: 'If project requires tests, add them',
+        tier: 'conditional',
+        weight: 15,
+    },
+    {
+        id: 'docs',
+        label: 'Docs Updated',
+        description: 'If behavior changed, update docs',
+        tier: 'conditional',
+        weight: null,
+    },
+    {
+        id: 'branch',
+        label: 'Branch Naming',
+        description: 'Follows convention (`feature/`, `fix/`, `docs/`)',
+        tier: 'optional',
+        weight: 5,
+    },
+    {
+        id: 'screenshots',
+        label: 'Screenshots',
+        description: 'Included for UI changes',
+        tier: 'optional',
+        weight: null,
+    },
+];
+/**
+ * Look up a check by id. Used by `compliance-score.ts` to wire the
+ * scored checks to their canonical weight without hardcoding the
+ * value in two places.
+ */
+export function getRubricCheck(id) {
+    return PR_QUALITY_RUBRIC.find((c) => c.id === id);
+}
+/**
+ * Sum of the weights for scored checks. Should equal 100. Tests pin
+ * this so a future edit that fails to balance the weights surfaces
+ * at CI time rather than silently shipping a < 100 rubric.
+ */
+export function totalScoredWeight() {
+    return PR_QUALITY_RUBRIC.reduce((sum, c) => sum + (c.weight ?? 0), 0);
+}

package/dist/core/repo-vet.d.ts

@@ -0,0 +1,90 @@
+/**
+ * Repo health scoring (#1242).
+ *
+ * Extracted from `agents/repo-evaluator.md`'s in-prompt assembly logic
+ * so the rubric weights, sub-factor thresholds, and verdict cutoffs
+ * are deterministic, unit-testable, and tunable without editing
+ * markdown. Same architectural shape as success-grade (#858),
+ * compliance-score (#1245), and strategy (#1243).
+ *
+ * The function is pure — callers (the MCP tool, the CLI command)
+ * supply pre-fetched repo signals so the score is reproducible
+ * against fixture data and offline replays.
+ *
+ * Rubric reference: docs/repo-rubric.md.
+ */
+export interface RepoVetInput {
+    /** Star count from the GitHub repo metadata. */
+    stars: number;
+    forks: number;
+    openIssues: number;
+    watchers: number;
+    isArchived: boolean;
+    /** ISO-8601 timestamp of the last push. */
+    lastPushed: string;
+    /** ISO-8601 timestamp of repo creation. */
+    createdAt: string;
+    /** Number of commits to the default branch in the last 30 days. */
+    commitsLast30Days: number;
+    /** Per-PR `createdAt → mergedAt` durations in days, for the last 90
+     * days of merged PRs. Used to derive avg / median merge time. */
+    prMergeTimesDays: number[];
+    /** Count of merges in the last 90 days. */
+    mergedCount90Days: number;
+    /** Count of opened PRs in the last 90 days. Used for merge rate. */
+    openedCount90Days: number;
+    /** ISO-8601 timestamp of the most recent commit on the default branch. */
+    lastCommitISO: string | null;
+    /** Distinct authors who committed in the last 90 days. */
+    contributorsLast90d: number;
+    /** ISO-8601 timestamp of the most recent published release. */
+    lastReleaseISO: string | null;
+    hasContributing: boolean;
+    hasIssueTemplates: boolean;
+    hasPRTemplate: boolean;
+    hasCodeOfConduct: boolean;
+}
+export type RepoVetVerdict = 'recommended' | 'proceed_with_caution' | 'avoid';
+export interface RepoVetResult {
+    repo: {
+        stars: number;
+        forks: number;
+        openIssues: number;
+        watchers: number;
+        isArchived: boolean;
+        lastPushed: string;
+        createdAt: string;
+    };
+    prMergeTime: {
+        avgDays: number | null;
+        medianDays: number | null;
+        sampleSize: number;
+        sourceWindowDays: 90;
+    };
+    mergeRate: {
+        merged: number;
+        opened: number;
+        percent: number | null;
+        windowDays: 90;
+    };
+    maintainerActivity: {
+        lastCommitISO: string | null;
+        contributorsLast90d: number;
+        lastReleaseISO: string | null;
+    };
+    communityHealth: {
+        contributing: boolean;
+        issueTemplates: boolean;
+        prTemplate: boolean;
+        codeOfConduct: boolean;
+    };
+    /** Weighted 1-10 score per docs/repo-rubric.md. */
+    rubricScore: number;
+    /** Top-line verdict derived from the score and red-flag overrides. */
+    rubricVerdict: RepoVetVerdict;
+}
+/**
+ * Compute repo-health metrics and an overall rubric score from
+ * pre-fetched signals (#1242). Pure function — no I/O, no global state.
+ */
+export declare function computeRepoVet(input: RepoVetInput): RepoVetResult;

package/dist/core/repo-vet.js

@@ -0,0 +1,178 @@
+/**
+ * Repo health scoring (#1242).
+ *
+ * Extracted from `agents/repo-evaluator.md`'s in-prompt assembly logic
+ * so the rubric weights, sub-factor thresholds, and verdict cutoffs
+ * are deterministic, unit-testable, and tunable without editing
+ * markdown. Same architectural shape as success-grade (#858),
+ * compliance-score (#1245), and strategy (#1243).
+ *
+ * The function is pure — callers (the MCP tool, the CLI command)
+ * supply pre-fetched repo signals so the score is reproducible
+ * against fixture data and offline replays.
+ *
+ * Rubric reference: docs/repo-rubric.md.
+ */
+const WEIGHTS = {
+    activity: 0.25,
+    prSpeed: 0.25,
+    mergeRate: 0.2,
+    guidelines: 0.1,
+    stability: 0.05,
+    /** Responsiveness (15%) is documented in the rubric but the input
+     * shape doesn't surface it — `gh pr list --json` doesn't expose
+     * "time to first review". Per the rubric note, omit it rather than
+     * fabricate it. The remaining weights total 0.85 and are normalized
+     * to a 10-point ceiling at the end. */
+};
+const SUM_OF_AVAILABLE_WEIGHTS = WEIGHTS.activity + WEIGHTS.prSpeed + WEIGHTS.mergeRate + WEIGHTS.guidelines + WEIGHTS.stability;
+const VERDICT_CUTOFFS = {
+    recommended: 7.5,
+    cautious: 5,
+};
+function median(nums) {
+    if (nums.length === 0)
+        return 0;
+    const sorted = [...nums].sort((a, b) => a - b);
+    const mid = Math.floor(sorted.length / 2);
+    return sorted.length % 2 === 0 ? (sorted[mid - 1] + sorted[mid]) / 2 : sorted[mid];
+}
+function activitySubScore(input) {
+    // 1.0 when commits/30d ≥ 30 (one per day), 0 when 0, linear in between.
+    if (input.isArchived)
+        return 0;
+    return Math.min(1, input.commitsLast30Days / 30);
+}
+function prSpeedSubScore(input) {
+    // Rubric: avg PR merge time < 7 days = healthy. Linear: 0d → 1.0,
+    // 14d+ → 0.0. Sample of zero merges = 0 score (no signal of speed).
+    if (input.prMergeTimesDays.length === 0)
+        return 0;
+    const avg = input.prMergeTimesDays.reduce((sum, d) => sum + d, 0) / input.prMergeTimesDays.length;
+    if (avg <= 0)
+        return 1;
+    if (avg >= 14)
+        return 0;
+    return Math.max(0, Math.min(1, (14 - avg) / 14));
+}
+function mergeRateSubScore(input) {
+    // Rubric: >70% merged in last 90 days. Linear: 100% → 1.0, 0% → 0.
+    if (input.openedCount90Days === 0)
+        return 0;
+    const rate = input.mergedCount90Days / input.openedCount90Days;
+    return Math.max(0, Math.min(1, rate));
+}
+function guidelinesSubScore(input) {
+    // Each of the four community-health flags contributes equally.
+    let score = 0;
+    if (input.hasContributing)
+        score += 0.4;
+    if (input.hasIssueTemplates)
+        score += 0.25;
+    if (input.hasPRTemplate)
+        score += 0.25;
+    if (input.hasCodeOfConduct)
+        score += 0.1;
+    return Math.min(1, score);
+}
+function stabilitySubScore(input) {
+    // Rubric: not archived, regular releases. Half-credit for not-archived,
+    // half for a release within the last 6 months.
+    if (input.isArchived)
+        return 0;
+    let score = 0.5;
+    if (input.lastReleaseISO) {
+        const since = Date.now() - new Date(input.lastReleaseISO).getTime();
+        const sixMonths = 1000 * 60 * 60 * 24 * 30 * 6;
+        if (since <= sixMonths)
+            score += 0.5;
+    }
+    return score;
+}
+/**
+ * Hard red-flag overrides — when one fires, verdict drops to `avoid`
+ * regardless of the weighted score. Sourced verbatim from the rubric.
+ */
+function hasRedFlags(input) {
+    if (input.isArchived)
+        return true;
+    if (input.lastCommitISO) {
+        const sinceCommit = Date.now() - new Date(input.lastCommitISO).getTime();
+        const sixtyDays = 60 * 24 * 60 * 60 * 1000;
+        if (sinceCommit > sixtyDays)
+            return true;
+    }
+    if (input.openedCount90Days > 0 && input.mergedCount90Days === 0)
+        return true;
+    return false;
+}
+function deriveVerdict(score, redFlags) {
+    if (redFlags)
+        return 'avoid';
+    if (score >= VERDICT_CUTOFFS.recommended)
+        return 'recommended';
+    if (score >= VERDICT_CUTOFFS.cautious)
+        return 'proceed_with_caution';
+    return 'avoid';
+}
+/**
+ * Compute repo-health metrics and an overall rubric score from
+ * pre-fetched signals (#1242). Pure function — no I/O, no global state.
+ */
+export function computeRepoVet(input) {
+    const subScores = {
+        activity: activitySubScore(input),
+        prSpeed: prSpeedSubScore(input),
+        mergeRate: mergeRateSubScore(input),
+        guidelines: guidelinesSubScore(input),
+        stability: stabilitySubScore(input),
+    };
+    // Weighted average normalized to the 10-point ceiling.
+    const weightedSum = subScores.activity * WEIGHTS.activity +
+        subScores.prSpeed * WEIGHTS.prSpeed +
+        subScores.mergeRate * WEIGHTS.mergeRate +
+        subScores.guidelines * WEIGHTS.guidelines +
+        subScores.stability * WEIGHTS.stability;
+    const rubricScore = Math.round((weightedSum / SUM_OF_AVAILABLE_WEIGHTS) * 100) / 10;
+    const sampleSize = input.prMergeTimesDays.length;
+    const avgDays = sampleSize === 0 ? null : input.prMergeTimesDays.reduce((s, d) => s + d, 0) / sampleSize;
+    const medianDays = sampleSize === 0 ? null : median(input.prMergeTimesDays);
+    // Cap at 100. A repo clearing a backlog can have mergedCount > openedCount
+    // because PRs opened before the window can merge inside it — without the
+    // cap, the surfaced text would read "Merge rate (90d): 160% (8/5)" which
+    // looks like a tool bug. The score itself is fine (mergeRateSubScore
+    // clamps separately); this just keeps the display sensible.
+    const mergeRatePercent = input.openedCount90Days === 0 ? null : Math.min(100, (input.mergedCount90Days / input.openedCount90Days) * 100);
+    const verdict = deriveVerdict(rubricScore, hasRedFlags(input));
+    return {
+        repo: {
+            stars: input.stars,
+            forks: input.forks,
+            openIssues: input.openIssues,
+            watchers: input.watchers,
+            isArchived: input.isArchived,
+            lastPushed: input.lastPushed,
+            createdAt: input.createdAt,
+        },
+        prMergeTime: { avgDays, medianDays, sampleSize, sourceWindowDays: 90 },
+        mergeRate: {
+            merged: input.mergedCount90Days,
+            opened: input.openedCount90Days,
+            percent: mergeRatePercent,
+            windowDays: 90,
+        },
+        maintainerActivity: {
+            lastCommitISO: input.lastCommitISO,
+            contributorsLast90d: input.contributorsLast90d,
+            lastReleaseISO: input.lastReleaseISO,
+        },
+        communityHealth: {
+            contributing: input.hasContributing,
+            issueTemplates: input.hasIssueTemplates,
+            prTemplate: input.hasPRTemplate,
+            codeOfConduct: input.hasCodeOfConduct,
+        },
+        rubricScore,
+        rubricVerdict: verdict,
+    };
+}

package/dist/core/state-schema.d.ts

@@ -78,6 +78,53 @@ export declare const AnalyzedIssueConversationSchema: z.ZodObject<{
     repo: z.ZodString;
     analyzedAt: z.ZodString;
 }, z.core.$strip>;
+/**
+ * One entry in a PR's follow-up history (#1277). Tier matches the
+ * cadence labels in `skills/pr-etiquette/SKILL.md` (light_check_in
+ * for 7-13 days, direct_check_in for 14-29 days, final_check_in for
+ * 30+ days). The `draftPath` is optional so an entry recorded from a
+ * direct `gh pr comment` (no draft) still validates.
+ */
+export declare const FollowUpEntrySchema: z.ZodObject<{
+    tier: z.ZodEnum<{
+        light_check_in: "light_check_in";
+        direct_check_in: "direct_check_in";
+        final_check_in: "final_check_in";
+    }>;
+    timestamp: z.ZodString;
+    draftPath: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type FollowUpEntry = z.infer<typeof FollowUpEntrySchema>;
+/**
+ * Pause-point snapshot for resumable workflows (#1280). When the user
+ * picks "Done for now" inside `draft-first-workflow.md`,
+ * `work-through-issues.md`, or `pre-commit-review.md`, the workflow
+ * records its position here. The next `/oss` run consults this state
+ * and offers "Resume / Restart / Discard" instead of restarting from
+ * the beginning.
+ *
+ * `stepData` is intentionally typed as `Record<string, unknown>` so
+ * each workflow can persist whatever per-step context it needs to
+ * resume cleanly (compliance-gap skip list, last review pass count,
+ * etc.) without forcing a tagged-union schema in shared state.
+ */
+export declare const WorkflowStateSchema: z.ZodObject<{
+    workflowName: z.ZodEnum<{
+        "draft-first": "draft-first";
+        "work-through-issues": "work-through-issues";
+        "pre-commit-review": "pre-commit-review";
+    }>;
+    currentStep: z.ZodString;
+    branchName: z.ZodOptional<z.ZodString>;
+    issueContext: z.ZodOptional<z.ZodObject<{
+        title: z.ZodString;
+        url: z.ZodString;
+    }, z.core.$strip>>;
+    completedSteps: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    stepData: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    lastUpdatedAt: z.ZodString;
+}, z.core.$strip>;
+export type WorkflowState = z.infer<typeof WorkflowStateSchema>;
 export declare const ContributionGuidelinesSchema: z.ZodObject<{
     branchNamingConvention: z.ZodOptional<z.ZodString>;
     commitMessageFormat: z.ZodOptional<z.ZodString>;
@@ -243,6 +290,8 @@ export declare const AgentConfigSchema: z.ZodObject<{
     }>>;
     diffToolCustomCommand: z.ZodOptional<z.ZodString>;
     autoFormatBeforePush: z.ZodDefault<z.ZodBoolean>;
+    healthCheckFreshnessMinutes: z.ZodDefault<z.ZodNumber>;
+    reviewMaxPasses: z.ZodOptional<z.ZodNumber>;
     slmTriageModel: z.ZodDefault<z.ZodString>;
     slmTriageHost: z.ZodDefault<z.ZodString>;
 }, z.core.$strip>;
@@ -403,11 +452,14 @@ export declare const AgentStateSchema: z.ZodObject<{
         }>>;
         diffToolCustomCommand: z.ZodOptional<z.ZodString>;
         autoFormatBeforePush: z.ZodDefault<z.ZodBoolean>;
+        healthCheckFreshnessMinutes: z.ZodDefault<z.ZodNumber>;
+        reviewMaxPasses: z.ZodOptional<z.ZodNumber>;
         slmTriageModel: z.ZodDefault<z.ZodString>;
         slmTriageHost: z.ZodDefault<z.ZodString>;
     }, z.core.$strip>>;
     lastRunAt: z.ZodDefault<z.ZodString>;
     lastDigestAt: z.ZodOptional<z.ZodString>;
+    lastStrategyAt: z.ZodOptional<z.ZodString>;
     lastDigest: z.ZodOptional<z.ZodObject<{
         generatedAt: z.ZodString;
         openPRs: z.ZodArray<z.ZodAny>;
@@ -532,6 +584,31 @@ export declare const AgentStateSchema: z.ZodObject<{
             notes: z.ZodArray<z.ZodString>;
         }, z.core.$strip>>;
     }, z.core.$strip>>>;
+    prFollowUpHistory: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodArray<z.ZodObject<{
+        tier: z.ZodEnum<{
+            light_check_in: "light_check_in";
+            direct_check_in: "direct_check_in";
+            final_check_in: "final_check_in";
+        }>;
+        timestamp: z.ZodString;
+        draftPath: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>>;
+    workflowState: z.ZodOptional<z.ZodObject<{
+        workflowName: z.ZodEnum<{
+            "draft-first": "draft-first";
+            "work-through-issues": "work-through-issues";
+            "pre-commit-review": "pre-commit-review";
+        }>;
+        currentStep: z.ZodString;
+        branchName: z.ZodOptional<z.ZodString>;
+        issueContext: z.ZodOptional<z.ZodObject<{
+            title: z.ZodString;
+            url: z.ZodString;
+        }, z.core.$strip>>;
+        completedSteps: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        stepData: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        lastUpdatedAt: z.ZodString;
+    }, z.core.$strip>>;
 }, z.core.$strip>;
 export type IssueStatus = z.infer<typeof IssueStatusSchema>;
 export type FetchedPRStatus = z.infer<typeof FetchedPRStatusSchema>;