@oss-autopilot/core 3.5.0 → 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/state-schema.d.ts

@@ -459,6 +459,7 @@ export declare const AgentStateSchema: z.ZodObject<{
     }, 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>;

package/dist/core/state-schema.js

@@ -285,6 +285,15 @@ export const AgentStateSchema = z.object({
     config: AgentConfigSchema.default(() => AgentConfigSchema.parse({})),
     lastRunAt: z.string().default(() => new Date().toISOString()),
     lastDigestAt: z.string().optional(),
+    /**
+     * ISO timestamp of the most recent {@link computeStrategy} invocation
+     * embedded in a daily run output (#1270). The cadence gate in
+     * `daily.ts` consults this — strategy snapshots fire every 30 days OR
+     * when 5+ PRs have merged since the last snapshot, whichever comes
+     * first. Below {@link STRATEGY_MIN_PRS} merged PRs the gate stays
+     * silent regardless of cadence.
+     */
+    lastStrategyAt: z.string().optional(),
     lastDigest: DailyDigestSchema.optional(),
     monthlyMergedCounts: z.record(z.string(), z.number()).optional(),
     monthlyClosedCounts: z.record(z.string(), z.number()).optional(),

package/dist/core/state.d.ts

@@ -174,6 +174,13 @@ export declare class StateManager {
      * @param digest - The daily digest to store
      */
     setLastDigest(digest: DailyDigest): void;
+    /**
+     * Persist the timestamp of the most recent strategy snapshot embedded
+     * in a daily run output (#1270). Called from the daily pipeline after
+     * `computeStrategy()` succeeds; the cadence gate in
+     * {@link shouldComputeStrategy} reads this on the next run.
+     */
+    setLastStrategyAt(iso: string): void;
     /**
      * Update monthly merged PR counts for dashboard display.
      * @param counts - Monthly merged PR counts keyed by YYYY-MM

package/dist/core/state.js

@@ -416,6 +416,16 @@ export class StateManager {
         this.state.lastDigestAt = digest.generatedAt;
         this.autoSave();
     }
+    /**
+     * Persist the timestamp of the most recent strategy snapshot embedded
+     * in a daily run output (#1270). Called from the daily pipeline after
+     * `computeStrategy()` succeeds; the cadence gate in
+     * {@link shouldComputeStrategy} reads this on the next run.
+     */
+    setLastStrategyAt(iso) {
+        this.state.lastStrategyAt = iso;
+        this.autoSave();
+    }
     /**
      * Update monthly merged PR counts for dashboard display.
      * @param counts - Monthly merged PR counts keyed by YYYY-MM

package/dist/core/strategy.d.ts

@@ -32,9 +32,15 @@ export interface StrategyProfile {
 export interface StrategyCapacity {
     openPRCount: number;
     dormantPRCount: number;
+    /** Distinct repos hosting at least one dormant PR. Surfaces alongside
+     * `dormantPRCount` so consumers can render "N PRs across M repos"
+     * without re-deriving from `openPRs` themselves. */
+    dormantRepoCount: number;
     /** True when dormant PRs span >=2 distinct repos (a signal that the
      * contributor is awaiting reviews from multiple maintainers, not just
-     * one slow project). */
+     * one slow project). Equivalent to `dormantPRCount >= 2 &&
+     * dormantRepoCount >= 2` — exposed as a separate boolean so callers
+     * with a strict yes/no presentation don't have to recompute. */
     overExtended: boolean;
     /** The single highest-priority next action — null when state is too
      * thin to recommend anything. */
@@ -73,3 +79,17 @@ export declare const STRATEGY_MIN_PRS = 10;
  * minimum-data gate (#1243).
  */
 export declare function computeStrategy(state: AgentState): StrategyResult | null;
+/** Cadence trigger thresholds for the auto-display in `/oss` (#1270). */
+export declare const STRATEGY_CADENCE_DAYS = 30;
+export declare const STRATEGY_CADENCE_MERGED_DELTA = 5;
+/**
+ * Decide whether a strategy snapshot should be embedded in this daily run.
+ * Returns true when EITHER 30 days have elapsed since the last snapshot OR
+ * 5+ PRs have merged since then, AND the merge floor in
+ * {@link STRATEGY_MIN_PRS} is met. The caller is responsible for calling
+ * {@link computeStrategy} when this returns true and for persisting
+ * `state.lastStrategyAt` after a successful compute.
+ *
+ * `nowIso` is injected so tests can pin time without mocking `Date`.
+ */
+export declare function shouldComputeStrategy(state: AgentState, nowIso: string): boolean;

package/dist/core/strategy.js

@@ -182,6 +182,7 @@ export function computeStrategy(state) {
     const capacity = {
         openPRCount,
         dormantPRCount,
+        dormantRepoCount: dormantRepos.size,
         overExtended,
         suggestedAction: recommendForOverExtension(openPRCount, dormantPRCount, overExtended),
     };
@@ -204,6 +205,49 @@ export function computeStrategy(state) {
     };
     return { profile, capacity, patterns, recommendations };
 }
+/** Cadence trigger thresholds for the auto-display in `/oss` (#1270). */
+export const STRATEGY_CADENCE_DAYS = 30;
+export const STRATEGY_CADENCE_MERGED_DELTA = 5;
+/**
+ * Decide whether a strategy snapshot should be embedded in this daily run.
+ * Returns true when EITHER 30 days have elapsed since the last snapshot OR
+ * 5+ PRs have merged since then, AND the merge floor in
+ * {@link STRATEGY_MIN_PRS} is met. The caller is responsible for calling
+ * {@link computeStrategy} when this returns true and for persisting
+ * `state.lastStrategyAt` after a successful compute.
+ *
+ * `nowIso` is injected so tests can pin time without mocking `Date`.
+ */
+export function shouldComputeStrategy(state, nowIso) {
+    const merged = state.mergedPRs ?? [];
+    if (merged.length < STRATEGY_MIN_PRS)
+        return false;
+    const lastIso = state.lastStrategyAt;
+    if (!lastIso)
+        return true;
+    // Time-based trigger: 30+ days since last snapshot.
+    const lastMs = Date.parse(lastIso);
+    const nowMs = Date.parse(nowIso);
+    if (Number.isFinite(lastMs) && Number.isFinite(nowMs)) {
+        const daysSince = (nowMs - lastMs) / (1000 * 60 * 60 * 24);
+        if (daysSince >= STRATEGY_CADENCE_DAYS)
+            return true;
+    }
+    else {
+        // Unparseable timestamps — fail open and recompute rather than
+        // silently never re-firing. The lastStrategyAt write below will
+        // refresh to a valid ISO string.
+        return true;
+    }
+    // Merge-count trigger: count PRs merged after `lastStrategyAt`.
+    // `mergedAt` is required on StoredMergedPRSchema; `Date.parse` returns
+    // NaN for malformed-but-stored data and Number.isFinite excludes those.
+    const mergedSince = merged.filter((pr) => {
+        const mergedMs = Date.parse(pr.mergedAt);
+        return Number.isFinite(mergedMs) && mergedMs > lastMs;
+    }).length;
+    return mergedSince >= STRATEGY_CADENCE_MERGED_DELTA;
+}
 function deriveIssueTypePreferences(distribution) {
     // Recommend the user's two strongest PR types — they have a track
     // record there, so issues in those buckets are higher-yield.

package/dist/core/types.d.ts

@@ -19,6 +19,46 @@ export interface ClassifiedCheck {
     category: CIFailureCategory;
     conclusion?: string;
 }
+/**
+ * Mutually exclusive overall-CI categories produced by
+ * {@link categorizeCIStatus} (#1272). The 5-row truth table that lived
+ * as prose in `agents/pr-health-checker.md` — extracted so any consumer
+ * (the agent, the dashboard, future MCP surfaces) reads one typed field
+ * instead of re-deriving the table.
+ *
+ * - `all_passing` — every reported check is green
+ * - `failing` — at least one actionable failure (real test/lint/build
+ *   issue), OR ciStatus reported failing without per-check detail (the
+ *   honest answer when the legacy combined-status endpoint can't tell
+ *   us what failed)
+ * - `fork_limitation` — failures exist but ALL of them are
+ *   `fork_limitation` / `auth_gate` (Vercel preview, internal CI) — purely
+ *   informational
+ * - `blocked` — checks are pending (awaiting trigger / completion), OR
+ *   non-actionable failures include `infrastructure` (cancelled /
+ *   timed-out runner — re-running often resolves)
+ * - `not_running` — no checks reported
+ */
+export type CIStatusCategory = 'all_passing' | 'failing' | 'fork_limitation' | 'blocked' | 'not_running';
+/**
+ * Suggested action for the {@link CIStatusCategorization}. Hint, not
+ * enforcement — the consuming agent may still escalate or skip based on
+ * other PR context.
+ */
+export type CIStatusAction = 'none' | 'investigate' | 'request_rerun' | 'check_workflows' | 'informational';
+/**
+ * Aggregate CI status produced by {@link categorizeCIStatus} (#1272).
+ * Derived from `ciStatus + failingCheckNames + classifiedChecks` —
+ * exposed on {@link FetchedPR} so agents read a single field instead
+ * of re-implementing the truth table.
+ */
+export interface CIStatusCategorization {
+    category: CIStatusCategory;
+    /** Short human-readable summary suitable for inline display. */
+    summary: string;
+    /** Suggested next action (hint, not enforcement). */
+    action: CIStatusAction;
+}
 /** CI status result returned by getCIStatus(). */
 export interface CIStatusResult {
     status: CIStatus;
@@ -115,6 +155,15 @@ export interface FetchedPR {
     failingCheckNames: string[];
     /** Failing checks with category classification (#81). Separates actionable failures from fork limitations and auth gates. */
     classifiedChecks: ClassifiedCheck[];
+    /**
+     * Aggregate 5-state CI categorization (#1272). Derived from `ciStatus`,
+     * `failingCheckNames`, and `classifiedChecks` via `categorizeCIStatus()`
+     * — agents read this directly instead of re-deriving the truth table.
+     * Always populated on a fresh fetch (v2 architecture has no cached
+     * `FetchedPR` to migrate); pr-monitor's `fetchPRDetails` sets it on
+     * every PR before construction.
+     */
+    ciCategorization: CIStatusCategorization;
     hasMergeConflict: boolean;
     reviewDecision: ReviewDecision;
     /** How many commits the PR branch is behind the base branch. */

package/dist/formatters/json.d.ts

@@ -97,6 +97,13 @@ export interface DailyOutput {
      * on clean runs. See #1042.
      */
     warnings: DailyWarning[];
+    /**
+     * Periodic contribution-strategy snapshot (#1270). Populated when the
+     * cadence trigger fires AND the user has crossed the merge floor. The
+     * `/oss` action menu renders this inline ahead of the action options;
+     * absent or null on runs where the gate stays silent.
+     */
+    strategySummary?: import('../core/strategy.js').StrategyResult | null;
 }
 /**
  * Compact version of DailyOutput for reduced JSON payload size (#763).
@@ -122,6 +129,8 @@ export interface CompactDailyOutput {
      * the `--compact` payload. See #1042.
      */
     warnings: DailyWarning[];
+    /** Periodic strategy snapshot, threaded through compact mode for parity. See {@link DailyOutput.strategySummary}. */
+    strategySummary?: import('../core/strategy.js').StrategyResult | null;
 }
 /**
  * Strip a full DailyOutput down to the compact subset (#763).
@@ -275,6 +284,50 @@ export declare const DailyOutputSchema: z.ZodObject<{
         timestamp: z.ZodOptional<z.ZodString>;
         details: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
     }, z.core.$strip>>;
+    strategySummary: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+        profile: z.ZodObject<{
+            style: z.ZodEnum<{
+                maintainer: "maintainer";
+                explorer: "explorer";
+                specialist: "specialist";
+                generalist: "generalist";
+            }>;
+            totalPRs: z.ZodNumber;
+            mergedCount: z.ZodNumber;
+            mergeRate: z.ZodNumber;
+            primaryLanguages: z.ZodArray<z.ZodString>;
+            favoriteRepos: z.ZodArray<z.ZodString>;
+        }, z.core.$loose>;
+        capacity: z.ZodObject<{
+            openPRCount: z.ZodNumber;
+            dormantPRCount: z.ZodNumber;
+            dormantRepoCount: z.ZodNumber;
+            overExtended: z.ZodBoolean;
+            suggestedAction: z.ZodUnion<readonly [z.ZodLiteral<"open_more">, z.ZodLiteral<"follow_up_dormant">, z.ZodLiteral<"wait_on_maintainers">, z.ZodNull]>;
+        }, z.core.$loose>;
+        patterns: z.ZodObject<{
+            prTypeDistribution: z.ZodObject<{
+                docs: z.ZodNumber;
+                fixes: z.ZodNumber;
+                features: z.ZodNumber;
+                refactors: z.ZodNumber;
+                tests: z.ZodNumber;
+                other: z.ZodNumber;
+            }, z.core.$loose>;
+            trajectoryDirection: z.ZodEnum<{
+                growing: "growing";
+                steady: "steady";
+                declining: "declining";
+            }>;
+            averagePRSize: z.ZodNumber;
+        }, z.core.$loose>;
+        recommendations: z.ZodObject<{
+            languages: z.ZodArray<z.ZodString>;
+            repos: z.ZodArray<z.ZodString>;
+            issueTypes: z.ZodArray<z.ZodString>;
+            avoidPatterns: z.ZodArray<z.ZodString>;
+        }, z.core.$loose>;
+    }, z.core.$loose>>>;
 }, z.core.$strip>;
 export declare const CompactDailyOutputSchema: z.ZodObject<{
     digest: z.ZodObject<{
@@ -371,6 +424,50 @@ export declare const CompactDailyOutputSchema: z.ZodObject<{
         timestamp: z.ZodOptional<z.ZodString>;
         details: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
     }, z.core.$strip>>;
+    strategySummary: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+        profile: z.ZodObject<{
+            style: z.ZodEnum<{
+                maintainer: "maintainer";
+                explorer: "explorer";
+                specialist: "specialist";
+                generalist: "generalist";
+            }>;
+            totalPRs: z.ZodNumber;
+            mergedCount: z.ZodNumber;
+            mergeRate: z.ZodNumber;
+            primaryLanguages: z.ZodArray<z.ZodString>;
+            favoriteRepos: z.ZodArray<z.ZodString>;
+        }, z.core.$loose>;
+        capacity: z.ZodObject<{
+            openPRCount: z.ZodNumber;
+            dormantPRCount: z.ZodNumber;
+            dormantRepoCount: z.ZodNumber;
+            overExtended: z.ZodBoolean;
+            suggestedAction: z.ZodUnion<readonly [z.ZodLiteral<"open_more">, z.ZodLiteral<"follow_up_dormant">, z.ZodLiteral<"wait_on_maintainers">, z.ZodNull]>;
+        }, z.core.$loose>;
+        patterns: z.ZodObject<{
+            prTypeDistribution: z.ZodObject<{
+                docs: z.ZodNumber;
+                fixes: z.ZodNumber;
+                features: z.ZodNumber;
+                refactors: z.ZodNumber;
+                tests: z.ZodNumber;
+                other: z.ZodNumber;
+            }, z.core.$loose>;
+            trajectoryDirection: z.ZodEnum<{
+                growing: "growing";
+                steady: "steady";
+                declining: "declining";
+            }>;
+            averagePRSize: z.ZodNumber;
+        }, z.core.$loose>;
+        recommendations: z.ZodObject<{
+            languages: z.ZodArray<z.ZodString>;
+            repos: z.ZodArray<z.ZodString>;
+            issueTypes: z.ZodArray<z.ZodString>;
+            avoidPatterns: z.ZodArray<z.ZodString>;
+        }, z.core.$loose>;
+    }, z.core.$loose>>>;
 }, z.core.$strip>;
 export declare const SearchOutputSchema: z.ZodObject<{
     candidates: z.ZodArray<z.ZodObject<{
@@ -454,6 +551,14 @@ export declare const ListMoveTierOutputSchema: z.ZodObject<{
     count: z.ZodNumber;
     reason: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
+export declare const ListMarkDoneOutputSchema: z.ZodObject<{
+    marked: z.ZodBoolean;
+    filePath: z.ZodString;
+    url: z.ZodString;
+    repoHeadingStruck: z.ZodBoolean;
+    remainingUnderRepo: z.ZodNumber;
+    reason: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
 export declare const PostOutputSchema: z.ZodObject<{
     commentUrl: z.ZodString;
     url: z.ZodString;

package/dist/formatters/json.js

@@ -30,6 +30,7 @@ export function toCompactDailyOutput(output) {
         commentedIssues: output.commentedIssues,
         failureCount: output.failures.length,
         warnings: output.warnings,
+        strategySummary: output.strategySummary,
     };
 }
 /**
@@ -198,6 +199,65 @@ const CompactRepoGroupSchema = z.object({
 });
 // DailyWarning schemas were hoisted above StatusOutputSchema (#1193) so the
 // status output can reference them without `z.lazy()`.
+// Mirrors {@link StrategyResult} in core/strategy.ts. Kept passthrough on the
+// inner objects so additive shape changes there don't break Zod validation
+// before the schema catches up — drift on required keys still fails.
+const StrategyResultSchema = z
+    .object({
+    profile: z
+        .object({
+        style: z.enum(['maintainer', 'explorer', 'specialist', 'generalist']),
+        totalPRs: z.number().int().nonnegative(),
+        mergedCount: z.number().int().nonnegative(),
+        mergeRate: z.number(),
+        primaryLanguages: z.array(z.string()),
+        favoriteRepos: z.array(z.string()),
+    })
+        .passthrough(),
+    capacity: z
+        .object({
+        openPRCount: z.number().int().nonnegative(),
+        dormantPRCount: z.number().int().nonnegative(),
+        dormantRepoCount: z.number().int().nonnegative(),
+        overExtended: z.boolean(),
+        suggestedAction: z.union([
+            z.literal('open_more'),
+            z.literal('follow_up_dormant'),
+            z.literal('wait_on_maintainers'),
+            z.null(),
+        ]),
+    })
+        .passthrough(),
+    patterns: z
+        .object({
+        // Closed set on the six required PR-type buckets — drift on any
+        // of these breaks the snapshot rendering. `.passthrough()` allows
+        // additive growth (e.g., a future 'security' bucket) without a
+        // schema bump, but a typo on `features` → `feauters` fails here.
+        prTypeDistribution: z
+            .object({
+            docs: z.number(),
+            fixes: z.number(),
+            features: z.number(),
+            refactors: z.number(),
+            tests: z.number(),
+            other: z.number(),
+        })
+            .passthrough(),
+        trajectoryDirection: z.enum(['growing', 'steady', 'declining']),
+        averagePRSize: z.number(),
+    })
+        .passthrough(),
+    recommendations: z
+        .object({
+        languages: z.array(z.string()),
+        repos: z.array(z.string()),
+        issueTypes: z.array(z.string()),
+        avoidPatterns: z.array(z.string()),
+    })
+        .passthrough(),
+})
+    .passthrough();
 export const DailyOutputSchema = z.object({
     digest: DailyDigestCompactSchema,
     capacity: CapacityAssessmentSchema,
@@ -209,6 +269,7 @@ export const DailyOutputSchema = z.object({
     repoGroups: z.array(CompactRepoGroupSchema),
     failures: z.array(PRCheckFailurePassthroughSchema),
     warnings: z.array(DailyWarningSchema),
+    strategySummary: StrategyResultSchema.nullable().optional(),
 });
 export const CompactDailyOutputSchema = z.object({
     digest: DailyDigestCompactSchema,
@@ -219,6 +280,7 @@ export const CompactDailyOutputSchema = z.object({
     commentedIssues: z.array(CommentedIssuePassthroughSchema),
     failureCount: z.number().int().nonnegative(),
     warnings: z.array(DailyWarningSchema),
+    strategySummary: StrategyResultSchema.nullable().optional(),
 });
 // ── Search output schema (#1147) ─────────────────────────────────────
 const SearchPrioritySchema = z.enum(['merged_pr', 'preferred_org', 'starred', 'normal']);
@@ -287,6 +349,18 @@ export const ListMoveTierOutputSchema = z.object({
     count: z.number().int().nonnegative(),
     reason: z.string().optional(),
 });
+// list-mark-done (#1299): mirrors {@link MarkDoneOutput} from the command
+// module. Strict shape — additional keys must be added here AND in the
+// command output, otherwise the validator's `parse()` rejects the response
+// before it reaches consumers.
+export const ListMarkDoneOutputSchema = z.object({
+    marked: z.boolean(),
+    filePath: z.string(),
+    url: z.string(),
+    repoHeadingStruck: z.boolean(),
+    remainingUnderRepo: z.number().int().nonnegative(),
+    reason: z.string().optional(),
+});
 // ── #1155: Zod coverage for remaining CLI commands ───────────────────
 export const PostOutputSchema = z.object({
     commentUrl: z.string(),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@oss-autopilot/core",
-  "version": "3.5.0",
+  "version": "3.6.0",
   "description": "CLI and core library for managing open source contributions",
   "type": "module",
   "bin": {