@wrongstack/core 0.305.1 → 0.306.0

package/dist/plugins/auto-review-plugin.d.ts

@@ -2,6 +2,7 @@ import type { ProviderModelStatusTracker } from '../coordination/provider-status
 import type { Config } from '../types/config.js';
 import type { Plugin } from '../types/plugin.js';
 import type { CascadeAgentKind } from './chimera-plugin.js';
+import type { ChimeraFinding } from './review-finding-types.js';
 export interface AutoReviewConfig {
     enabled?: boolean | undefined;
     /** Provider for review subagents. Falls back to session provider. */
@@ -108,20 +109,26 @@ export interface ParsedSeverities {
     high: number;
     medium: number;
 }
+/**
+ * Count verified findings into the severity shape `shouldCascade` expects.
+ * Used by the P0-2 cascade gate: only disk-verified findings count toward
+ * the cascade threshold when a parsed report is available.
+ */
+export declare function severitiesFromFindings(findings: readonly ChimeraFinding[]): ParsedSeverities;
 /** Parse report counts for clean-vs-actionable classification. */
 export declare function parseReviewSeverity(text: string): ParsedSeverities;
 /**
- * Decide which follow-up cascade agents to spawn based on the review text.
+ * Decide which follow-up cascade agents to spawn based on the review.
  *
- * - `security-scanner` is selected when any Critical/High finding mentions
- *   a security keyword (injection, secret, XSS, etc.).
- * - `bug-hunter` is selected whenever the threshold is crossed at all —
- *   any High+ finding warrants a focused bug hunt.
+ * When structured, disk-verified findings are supplied (P0-1/P0-2), routing
+ * uses the finding's `category` tag: `security` selects security-scanner,
+ * and any High+ finding selects bug-hunter. The legacy keyword scan on the
+ * report text remains the fallback for reports without structured findings.
  *
- * Both may be returned in parallel when a finding is both severe and
+ * Both agents may be returned in parallel when a finding is both severe and
  * security-related.
  */
-export declare function decideCascadeAgents(text: string, severities: ParsedSeverities): CascadeAgentKind[];
+export declare function decideCascadeAgents(text: string, severities: ParsedSeverities, findings?: readonly ChimeraFinding[] | undefined): CascadeAgentKind[];
 /**
  * Determine whether a review result should trigger a cascade, given the
  * configured threshold and parsed severities. Returns the crossed

package/dist/plugins/chimera-plugin.d.ts

@@ -1,6 +1,6 @@
 import type { Plugin } from '../types/plugin.js';
 import type { ResolvedChimeraConfig } from './review-types.js';
-export type { CascadeAgentKind, ChimeraCascadeNeededPayload, ChimeraReviewCompletePayload, ChimeraReviewNeededPayload, ResolvedChimeraConfig, ReviewContextBundle, ReviewFileEntry, } from './review-types.js';
+export type { CascadeAgentKind, CascadeEvidenceCheckResult, CascadeEvidenceStatus, ChimeraCascadeNeededPayload, ChimeraReviewCompletePayload, ChimeraReviewNeededPayload, ResolvedChimeraConfig, ReviewContextBundle, ReviewFileEntry, } from './review-types.js';
 interface ChimeraConfig {
     enabled?: boolean | undefined;
     provider?: string | undefined;
@@ -26,6 +26,20 @@ interface ChimeraConfig {
      * re-check). Mirrors the auto-review plugin's maxCascadeDepth.
      */
     maxCascadeDepth?: number | undefined;
+    /**
+     * Chimera-specific fallback model chain (`provider/model` refs). When set,
+     * the reviewer subagent uses these models as its in-request fallback chain
+     * instead of inheriting the session-level fallback profile. Example:
+     * `["openai/gpt-4o", "anthropic/claude-sonnet-4-20250514"]`.
+     */
+    fallbackModels?: string[] | undefined;
+    /**
+     * Named fallback profile to use for Chimera reviews. When set, the reviewer
+     * spawn resolves this profile's chain from config and uses it as the
+     * fallback ladder. Takes precedence over the session-level fallback profile
+     * for Chimera spawns only.
+     */
+    fallbackProfile?: string | undefined;
     /**
      * @deprecated Removed. The subagent's `Request.maxTokens` now defaults to
      * the provider's `capabilities.maxOutput`, so Chimera reports can run up

package/dist/plugins/review-finding-integration.d.ts

@@ -6,7 +6,17 @@
  *
  * @module review-finding-integration
  */
-import type { ChimeraReviewCompletePayload } from './review-types.js';
+import type { ChimeraReviewCompletePayload, ReviewContextBundle } from './review-types.js';
+import type { FindingSource } from './review-finding-types.js';
+/**
+ * Classify the review source from the payload bundle.
+ *
+ * Shared by finding integration and report integration so the two stores
+ * always agree on how a review is labeled. Mirrors the historical logic:
+ * cascadeDepth > 0 → 'cascade'; cascadeOn configured (not 'off') → 'auto';
+ * otherwise the post-session/manual Chimera plugin → 'chimera'.
+ */
+export declare function classifyChimeraReviewSource(bundle: ReviewContextBundle): FindingSource;
 /**
  * Result of a findings integration run.
  */
@@ -28,8 +38,10 @@ export interface FindingsIntegrationResult {
  * Integrate findings from a completed Chimera review into the
  * project's finding store.
  *
- * Parses the review report text, upserts all findings, and
- * returns a summary.
+ * Uses the execution owner's pre-parsed findings (P0-1) when present so the
+ * report is never re-parsed with a divergent context; falls back to parsing
+ * `payload.reviewText` for legacy emitters. Upserts all findings and returns
+ * a summary.
  */
 export declare function integrateFindings(payload: ChimeraReviewCompletePayload, projectDir: string, reportId: string): Promise<FindingsIntegrationResult>;
 //# sourceMappingURL=review-finding-integration.d.ts.map

package/dist/plugins/review-finding-parser.d.ts

@@ -26,7 +26,43 @@ export interface ParsedReviewReport {
     unparseableCount: number;
     /** Total time for the review, extracted from "Duration: Xs" line. */
     durationSeconds?: number | undefined;
+    /**
+     * True when the findings came from the structured JSON contract (P0-1)
+     * rather than the legacy markdown heuristics. When false, findings are
+     * recovered from `### Severity (N)` headings + numbered list items and
+     * carry no `category`/`confidence`.
+     */
+    structured?: boolean | undefined;
 }
+/**
+ * One finding item from the structured JSON contract appended by the
+ * reviewer to the end of the markdown report (P0-1).
+ */
+export interface StructuredFindingItem {
+    severity: string;
+    file?: string | undefined;
+    line?: number | undefined;
+    category?: string | undefined;
+    confidence?: string | undefined;
+    title: string;
+    description?: string | undefined;
+    suggestedFix?: string | undefined;
+}
+/**
+ * The parsed fenced JSON block: a `findings` array plus optional metadata.
+ */
+export interface StructuredFindingsBlock {
+    findings: StructuredFindingItem[];
+    durationSeconds?: number | undefined;
+}
+/**
+ * Extract the structured findings JSON block from a report. Returns the
+ * LAST fenced block that parses as JSON and carries a `findings` array —
+ * the reviewer is instructed to append exactly one such block, so the last
+ * one wins when earlier blocks are examples or stray prose. Returns `null`
+ * when no parseable block exists (legacy markdown-only reports).
+ */
+export declare function extractStructuredFindingsBlock(reportText: string): StructuredFindingsBlock | null;
 /**
  * Parse a Chimera review report text into structured findings.
  *

package/dist/plugins/review-finding-types.d.ts

@@ -26,6 +26,36 @@ export type ResolutionOutcome = 'fixed' | 'wontfix' | 'duplicate' | 'false_posit
 export type FindingSource = 'auto' | 'chimera' | 'cascade' | 'security-scanner';
 /** What kind of actor performed a lifecycle transition. */
 export type ActorKind = 'agent' | 'operator' | 'system';
+/**
+ * What kind of defect a finding describes. The reviewer tags every finding
+ * with one of these in the structured JSON contract (P0-1); cascade routing
+ * prefers the tag over keyword heuristics (P1-6).
+ */
+export type FindingCategory = 'bug' | 'security' | 'performance' | 'type' | 'contract' | 'test' | 'other';
+/** How confident the reviewer is that the finding is real. */
+export type FindingConfidence = 'high' | 'medium' | 'low';
+/** Whether the deterministic disk-verification pass confirmed the finding. */
+export type FindingVerificationStatus = 'verified' | 'failed' | 'unverified';
+/**
+ * Result of the P0-2 disk-verification pass. Attached by the execution owner
+ * AFTER parsing, BEFORE persistence and cascade gating:
+ *
+ * - `verified` — the cited file exists, the cited line is in range, and a
+ *   code anchor extracted from the finding appears at/near that line.
+ * - `failed`   — the citation is provably wrong (file missing, line out of
+ *   range, or the path escapes the workspace).
+ * - `unverified` — could not confirm either way (no location, no line, or
+ *   no anchor found near the cited line).
+ *
+ * Only `verified` findings are actionable: they are counted in the mailbox
+ * message and may trigger a cascade.
+ */
+export interface FindingVerification {
+    status: FindingVerificationStatus;
+    reason: 'no_line' | 'file_missing' | 'unreadable' | 'outside_workspace' | 'line_out_of_range' | 'anchor_found' | 'no_anchor' | 'anchor_not_found';
+    /** The matched source line (trimmed), when the anchor was found. */
+    evidence?: string | undefined;
+}
 export interface ChimeraFindingLocation {
     /** Project-relative file path. */
     file: string;
@@ -62,6 +92,22 @@ export interface ChimeraFinding {
     source: FindingSource;
     /** Where the issue was found. */
     location?: ChimeraFindingLocation | undefined;
+    /**
+     * Defect category from the structured JSON contract. Absent for findings
+     * recovered from the legacy markdown path (no JSON block in the report).
+     */
+    category?: FindingCategory | undefined;
+    /**
+     * Reviewer confidence, from the structured JSON contract. Absent for
+     * findings recovered from the legacy markdown path.
+     */
+    confidence?: FindingConfidence | undefined;
+    /**
+     * Result of the P0-2 disk-verification pass. Absent when the execution
+     * owner did not verify the report (legacy emitters) or for findings
+     * without any citation.
+     */
+    verification?: FindingVerification | undefined;
     /** One-line title extracted from the report item. */
     title: string;
     /** Full description paragraphs. */

package/dist/plugins/review-finding-verification.d.ts

@@ -0,0 +1,53 @@
+/**
+ * Chimera finding disk-verification pass (P0-2).
+ *
+ * A review finding is only as good as its citation. Before a finding is
+ * persisted and before it can gate a cascade, the execution owner runs this
+ * deterministic pass against the actual working tree:
+ *
+ *   1. the cited file must exist inside the workspace;
+ *   2. the cited line must be in range for that file;
+ *   3. a code anchor extracted from the finding's title/description must
+ *      appear at or near the cited line.
+ *
+ * This is deliberately NOT semantic verification — it does not judge whether
+ * the claim is correct, only whether the citation is real. It catches the
+ * gross phantom-finding classes cheaply: files that do not exist, line
+ * numbers past EOF, and lines that have nothing to do with the claim.
+ *
+ * @module review-finding-verification
+ */
+import type { ChimeraFinding } from './review-finding-types.js';
+export interface VerifyFindingsOptions {
+    /** Workspace root the reviewer cited against. */
+    cwd: string;
+    /**
+     * Lines around the cited line to search for the code anchor.
+     * Default 2 (i.e. the cited line plus 2 above and 2 below).
+     */
+    anchorWindow?: number | undefined;
+}
+/**
+ * Extract the most distinctive code identifier from a finding's
+ * title + description. Prefers camelCase / snake_case / `$`-suffixed
+ * identifiers (code-like), then falls back to the first non-stopword
+ * token of length >= 3. Exported for unit tests.
+ */
+export declare function extractFindingAnchor(title: string, description: string): string | undefined;
+/**
+ * Resolve a finding's cited path against the workspace, normalizing
+ * backslashes, leading `./`, absolute POSIX paths, and (on win32) absolute
+ * Windows paths. Returns the absolute path when the citation resolves
+ * INSIDE the workspace, or `null` when it escapes it. Exported for tests.
+ */
+export declare function resolveFindingPath(raw: string, cwd: string): string | null;
+/**
+ * Verify findings against the working tree. Each finding that carries a
+ * `location` gets a `verification` result attached; findings without a
+ * location are left untouched (there is nothing to verify). Files are read
+ * once per unique path. Never throws — read failures degrade to a
+ * `failed`/`unverified` verdict so one unreadable file cannot abort the
+ * whole review pipeline.
+ */
+export declare function verifyFindingsAgainstDisk(findings: ChimeraFinding[], opts: VerifyFindingsOptions): Promise<ChimeraFinding[]>;
+//# sourceMappingURL=review-finding-verification.d.ts.map

package/dist/plugins/review-report-integration.d.ts

@@ -37,6 +37,7 @@ export interface ReportIntegrationResult {
  * @param projectDir - Project root (~/.wrongstack/projects/<slug>).
  * @returns Integration result summary.
  */
+export declare function updateReviewReportEvidence(reportId: string, projectDir: string, evidenceStatus: import('./review-types.js').CascadeEvidenceStatus, evidenceChecks: import('./review-types.js').CascadeEvidenceCheckResult[]): Promise<void>;
 export declare function persistReviewReport(payload: ChimeraReviewCompletePayload, reportId: string, projectDir: string): Promise<ReportIntegrationResult>;
 /**
  * Result of a report-completion sync check.

package/dist/plugins/review-report-store.d.ts

@@ -12,6 +12,7 @@
  *
  * @module review-report-store
  */
+import type { CascadeEvidenceCheckResult, CascadeEvidenceStatus } from './review-types.js';
 import type { ReviewReport, ReviewReportCounts, ReviewReportEvent, ReviewReportFile } from './review-report-types.js';
 import { type ReportActorKind, type ReportLifecycleStatus } from './review-report-types.js';
 /** Default retention for completed/skipped reports (90 days in ms). */
@@ -38,6 +39,10 @@ export interface PersistReportInput {
     durationSeconds?: number | undefined;
     rawText: string;
     cascadeDepth?: number | undefined;
+    /** P0-3: cascade fix evidence status (verified/failed/missing). */
+    evidenceStatus?: CascadeEvidenceStatus | undefined;
+    /** P0-3: per-check claimed-vs-observed exit-code comparisons. */
+    evidenceChecks?: CascadeEvidenceCheckResult[] | undefined;
 }
 /** Context for who is creating/transitioning a report. */
 export interface ReportActor {
@@ -55,6 +60,7 @@ export interface ReportStore {
         reason?: string;
     }): Promise<ReviewReport>;
     addNote(reportId: string, actor: ReportActor, note: string): Promise<ReviewReport>;
+    updateEvidence(reportId: string, evidenceStatus: CascadeEvidenceStatus, evidenceChecks: CascadeEvidenceCheckResult[]): Promise<ReviewReport>;
     list(opts?: ListReportsOptions): Promise<ReviewReport[]>;
     get(id: string): Promise<ReviewReport | null>;
     getEvents(reportId: string): Promise<ReviewReportEvent[]>;
@@ -73,6 +79,7 @@ export declare class JsonlReportStore implements ReportStore {
     transition(reportId: string, to: ReportLifecycleStatus, actor: ReportActor, opts?: {
         reason?: string;
     }): Promise<ReviewReport>;
+    updateEvidence(reportId: string, status: CascadeEvidenceStatus, checks: CascadeEvidenceCheckResult[]): Promise<ReviewReport>;
     addNote(reportId: string, actor: ReportActor, note: string): Promise<ReviewReport>;
     list(opts?: ListReportsOptions): Promise<ReviewReport[]>;
     get(id: string): Promise<ReviewReport | null>;

package/dist/plugins/review-report-types.d.ts

@@ -13,6 +13,7 @@
  *
  * @module review-report-types
  */
+import type { CascadeEvidenceCheckResult, CascadeEvidenceStatus } from './review-types.js';
 import type { FindingSource } from './review-finding-types.js';
 /**
  * Lifecycle status of a review report.
@@ -79,6 +80,19 @@ export interface ReviewReport {
     rawText: string;
     /** Cascade iteration depth (0 for initial review). */
     cascadeDepth?: number | undefined;
+    /**
+     * P0-3: machine-evidence verification status of the cascade fix step that
+     * preceded this report's review. `verified` / `failed` / `missing` mirror
+     * the bundle's evidenceStatus; absent when no cascade step ran.
+     */
+    evidenceStatus?: CascadeEvidenceStatus | undefined;
+    /**
+     * Per-check comparison results (claimed vs. observed exit codes) from the
+     * cascade evidence verification. Recorded so a report is auditable: exactly
+     * which commands the fix agent claimed, what the orchestrator observed, and
+     * which checks matched.
+     */
+    evidenceChecks?: CascadeEvidenceCheckResult[] | undefined;
 }
 export type ReportEventType = 'created' | 'actioned' | 'completed' | 'skipped' | 'reopened' | 'note_added';
 /** A single state-transition or annotation event in a report's lifecycle. */

package/dist/plugins/review-types.d.ts

@@ -1,3 +1,5 @@
+import type { ParsedReviewReport } from './review-finding-parser.js';
+import type { ChimeraFinding } from './review-finding-types.js';
 export interface ResolvedChimeraConfig {
     enabled: boolean;
     provider: string;
@@ -6,6 +8,19 @@ export interface ResolvedChimeraConfig {
     autoFix: 'off' | 'ask' | 'auto';
     cascadeOn: 'off' | 'critical' | 'high';
     maxCascadeDepth: number;
+    /**
+     * Chimera-specific fallback model chain (`provider/model` refs), resolved
+     * from `extensions["wstack-chimera"].fallbackModels`. Empty when unset —
+     * the reviewer then inherits the session-level fallback profile chain.
+     */
+    fallbackModels: string[];
+    /**
+     * Named fallback profile to use for Chimera reviews, resolved from
+     * `extensions["wstack-chimera"].fallbackProfile`. When set, the reviewer
+     * spawn resolves the profile chain from config and prepends it to
+     * `fallbackModels`.
+     */
+    fallbackProfile: string | undefined;
 }
 /**
  * A single changed file with its content and, for modified files, a
@@ -119,6 +134,47 @@ export interface ReviewContextBundle {
         eventType?: string | undefined;
         observedAt?: string | undefined;
     }> | undefined;
+    /**
+     * P0-3: machine-evidence verification status of the cascade fix step that
+     * preceded this (re-)review. Set by the cascade handler after re-running
+     * the fix agents' claimed verification commands against the working tree:
+     * - `verified` — every claimed typecheck/lint/test check re-ran and passed.
+     * - `failed`   — at least one check failed, mismatched, timed out, or was
+     *                refused (unsafe command).
+     * - `missing`  — the fix agent returned no evidence block at all.
+     * Absent on initial reviews (no cascade step yet).
+     */
+    evidenceStatus?: CascadeEvidenceStatus | undefined;
+    /**
+     * Per-check comparison results from the cascade evidence verification.
+     * Carried so the persisted report can record exactly which commands were
+     * claimed, what the orchestrator observed, and which checks matched.
+     */
+    evidenceChecks?: CascadeEvidenceCheckResult[] | undefined;
+}
+/**
+ * Aggregate verdict on a cascade fix agent's machine evidence (P0-3).
+ * See {@link ReviewContextBundle.evidenceStatus} for the semantics of each
+ * value. Shared across the cli cascade handler (which produces it), the
+ * core bundle type, and the report store (which persists it) so the shape
+ * cannot drift between producer and consumers.
+ */
+export type CascadeEvidenceStatus = 'verified' | 'failed' | 'missing';
+/**
+ * One check's comparison: the command a cascade fix agent claimed to run,
+ * the exit code it claimed, the exit code the orchestrator observed when it
+ * re-ran the command against the working tree, and whether the check counts
+ * as passed (observed exit code 0 matching a claimed 0).
+ */
+export interface CascadeEvidenceCheckResult {
+    name: 'typecheck' | 'lint' | 'tests';
+    command: string;
+    /** Exit code the agent claimed (null when the block omitted the key). */
+    claimedExitCode: number | null;
+    /** Exit code observed by the orchestrator's re-run. */
+    actualExitCode: number | null;
+    /** True when the check ran and actual matches a passing (0) claim. */
+    ok: boolean;
 }
 /** Legacy alias for the bundle emitted when a Chimera review is requested. */
 export type ChimeraReviewNeededPayload = ReviewContextBundle;
@@ -140,10 +196,21 @@ export interface ChimeraReviewCompletePayload {
      * directory path (which was the previous broken behaviour).
      */
     sessionId?: string | undefined;
+    /**
+     * Findings parsed ONCE by the execution owner (P0-1) and verified against
+     * the working tree (P0-2) before persistence. Threaded through so
+     * `persistReviewReport`, `integrateFindings`, and the cascade gate never
+     * re-parse the report with divergent contexts. Absent for failed reviews
+     * and legacy emitters that do not pre-parse — consumers fall back to
+     * parsing `reviewText` themselves in that case.
+     */
+    parsedReport?: ParsedReviewReport | undefined;
 }
 export type CascadeAgentKind = 'security-scanner' | 'bug-hunter';
 export interface ChimeraCascadeNeededPayload {
     bundle: ReviewContextBundle;
+    /** Source review whose findings triggered this cascade. */
+    reportId?: string | undefined;
     reviewText: string;
     severities: {
         critical: number;
@@ -152,5 +219,12 @@ export interface ChimeraCascadeNeededPayload {
     };
     threshold: 'high' | 'critical';
     agents: CascadeAgentKind[];
+    /**
+     * Findings that passed the P0-2 disk-verification pass (file exists, line
+     * in range, code anchor present). Only these findings may gate a cascade
+     * when the execution owner threaded a parsed report. Absent for legacy
+     * emitters that skip pre-parsing.
+     */
+    verifiedFindings?: ChimeraFinding[] | undefined;
 }
 //# sourceMappingURL=review-types.d.ts.map

package/dist/replay/replay-provider-runner.d.ts

@@ -30,10 +30,11 @@ import type { Response } from '../types/provider.js';
  * ## What a hit requires
  *
  * The lookup key is `hashRequest`, which covers everything the provider is
- * actually sent — including `system`. The agent loop appends volatile blocks
- * to the system prompt on every request (the continuity ledger, the live
- * next-steps gate, memory evidence; see `agent-response.ts`), and those blocks
- * describe the state of *this* run. A re-run whose ledger or retrieved memory
+ * actually sent — including `system`. The agent loop carries a live-context
+ * tail on every request (the continuity ledger, the live next-steps gate,
+ * memory evidence, epoch-volatile prompt blocks — appended after the last
+ * message; see `agent-response.ts`), and those blocks describe the state of
+ * *this* run. A re-run whose ledger or retrieved memory
  * differs therefore produces a different request, and correctly misses: the
  * recorded response answered a different prompt.
  *

package/dist/tools/fallback-manage-tool-options.d.ts

@@ -10,6 +10,15 @@ export interface FallbackManageToolOptions {
     updateConfig: (mutate: (cfg: Record<string, unknown>) => void) => Promise<void>;
     /** Optional secure interactive input callback for secrets such as API keys. */
     requestInput?: ((prompt: string) => Promise<string>) | undefined;
+    /**
+     * Optional live provider/model switch (the host's switchProviderAndModel).
+     * When present, `leader_model_set` routes leader changes through it so the
+     * live agent context (provider instance, model, context caps) follows the
+     * config write. Returns an error string on failure, null on success —
+     * mirroring cli-main's switch callback. When absent, the tool persists the
+     * config and reports that the live session keeps its current model.
+     */
+    switchProviderAndModel?: ((providerId: string, modelId: string) => Promise<string | null>) | undefined;
     /** Optional logger for internal warnings. */
     logger?: Logger | undefined;
 }