agent-afk 5.261.6 → 5.262.0

package/dist/agent/outcomes/artifacts.d.ts

@@ -0,0 +1,17 @@
+import type { Artifacts } from './schema.js';
+export interface ToolEvent {
+    toolName: string;
+    input?: string;
+    result?: string;
+    isError?: boolean;
+}
+export interface Turn {
+    user?: string;
+    assistant?: string;
+    toolEvents?: ToolEvent[];
+}
+export declare function recoverCommitSHAs(turns: Turn[]): string[];
+export declare function isPRCreateEvent(ev: ToolEvent): boolean;
+export declare function recoverPRURLs(turns: Turn[]): string[];
+export declare function inferRepo(turns: Turn[]): string | null;
+export declare function recoverArtifacts(turns: Turn[]): Artifacts;

package/dist/agent/outcomes/combine.d.ts

@@ -0,0 +1,13 @@
+import type { Vote, OutcomeLabel, SelfReport, Artifacts } from './schema.js';
+export interface CombinerInput {
+    votes: Vote[];
+    selfReport: SelfReport;
+    artifacts: Artifacts;
+    explicit_feedback?: 'good' | 'bad';
+}
+export interface CombinerResult {
+    label: OutcomeLabel;
+    confidence: number;
+}
+export declare function computeConfidence(label: OutcomeLabel, votes: Vote[]): number;
+export declare function combine(input: CombinerInput): CombinerResult;

package/dist/agent/outcomes/index.d.ts

@@ -0,0 +1,10 @@
+export type { VerifiedOutcome, OutcomeLabel, SelfReport, Vote, HistoryEntry, Artifacts } from './schema.js';
+export { VerifiedOutcomeSchema } from './schema.js';
+export type { ToolEvent, Turn } from './artifacts.js';
+export { recoverArtifacts, recoverCommitSHAs, recoverPRURLs, inferRepo } from './artifacts.js';
+export type { ClosureInfo, LoadClosure, ImmediateLFResult } from './lf-immediate.js';
+export { parseSelfReport, lfClosure, lfErrorTail, lfVerification, lfInSessionCorrection, lfSelfReport, runImmediateLFs, } from './lf-immediate.js';
+export type { PrState, FetchPrState, CheckAncestor, CheckRevert, GetDefaultBranch } from './lf-delayed.js';
+export { parsePrUrl, lfPrFate, lfCommitSurvival, lfFixOfFix, realFetchPrState, realCheckAncestor, realCheckRevert, } from './lf-delayed.js';
+export type { CombinerInput, CombinerResult } from './combine.js';
+export { combine, computeConfidence } from './combine.js';

package/dist/agent/outcomes/lf-delayed.d.ts

@@ -0,0 +1,19 @@
+import type { Vote } from './schema.js';
+export interface PrState {
+    state: 'OPEN' | 'CLOSED' | 'MERGED';
+    mergedAt: string | null;
+}
+export type FetchPrState = (prUrl: string) => Promise<PrState | null>;
+export type CheckAncestor = (sha: string, repoPath: string) => Promise<boolean>;
+export type CheckRevert = (sha: string, repoPath: string) => Promise<boolean>;
+export type GetDefaultBranch = (repoPath: string) => Promise<string>;
+export declare function parsePrUrl(url: string): {
+    repo: string;
+    number: number;
+} | null;
+export declare function lfPrFate(prUrls: string[], fetchPrState: FetchPrState, now: string): Promise<Vote[]>;
+export declare function lfCommitSurvival(commits: string[], repoPath: string | null, checkAncestor: CheckAncestor, checkRevert: CheckRevert, now: string): Promise<Vote[]>;
+export declare function lfFixOfFix(): Vote[];
+export declare const realFetchPrState: FetchPrState;
+export declare const realCheckAncestor: CheckAncestor;
+export declare const realCheckRevert: CheckRevert;

package/dist/agent/outcomes/lf-immediate.d.ts

@@ -0,0 +1,20 @@
+import type { Vote, SelfReport } from './schema.js';
+import type { Turn } from './artifacts.js';
+export interface ClosureInfo {
+    reason: 'abort' | 'iteration_cap' | 'normal' | 'unknown';
+}
+export type LoadClosure = (sessionId: string) => ClosureInfo | null;
+export declare function parseSelfReport(assistantText: string): SelfReport;
+export declare function lfClosure(sessionId: string, loadClosure: LoadClosure, now: string): Vote[];
+export declare function lfErrorTail(turns: Turn[], now: string): Vote | null;
+export declare function lfVerification(turns: Turn[], now: string): Vote | null;
+export declare function lfInSessionCorrection(turns: Turn[], now: string): Vote | null;
+export declare function lfSelfReport(turns: Turn[], now: string): {
+    selfReport: SelfReport;
+    vote: Vote;
+};
+export interface ImmediateLFResult {
+    votes: Vote[];
+    selfReport: SelfReport;
+}
+export declare function runImmediateLFs(sessionId: string, turns: Turn[], loadClosure: LoadClosure, now?: string): ImmediateLFResult;

package/dist/agent/outcomes/schema.d.ts

@@ -0,0 +1,75 @@
+import { z } from 'zod';
+export declare const VoteSchema: z.ZodObject<{
+    lf: z.ZodString;
+    vote: z.ZodUnion<readonly [z.ZodLiteral<1>, z.ZodLiteral<-1>, z.ZodLiteral<0>]>;
+    strength: z.ZodEnum<{
+        strong: "strong";
+        weak: "weak";
+    }>;
+    evidence: z.ZodString;
+    observed_at: z.ZodString;
+}, z.core.$strip>;
+export type Vote = z.infer<typeof VoteSchema>;
+export declare const HistoryEntrySchema: z.ZodObject<{
+    at: z.ZodString;
+    label: z.ZodString;
+    reason: z.ZodString;
+}, z.core.$strip>;
+export type HistoryEntry = z.infer<typeof HistoryEntrySchema>;
+export declare const ArtifactsSchema: z.ZodObject<{
+    commits: z.ZodArray<z.ZodString>;
+    prs: z.ZodArray<z.ZodString>;
+    repo: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+export type Artifacts = z.infer<typeof ArtifactsSchema>;
+export declare const VerifiedOutcomeSchema: z.ZodObject<{
+    schema_version: z.ZodLiteral<1>;
+    session_id: z.ZodString;
+    label: z.ZodEnum<{
+        failed: "failed";
+        succeeded: "succeeded";
+        unknown: "unknown";
+        blocked: "blocked";
+        interrupted: "interrupted";
+    }>;
+    confidence: z.ZodNumber;
+    state: z.ZodEnum<{
+        settled: "settled";
+        provisional: "provisional";
+    }>;
+    settles_after: z.ZodNullable<z.ZodString>;
+    session_kind: z.ZodEnum<{
+        text: "text";
+        mutating: "mutating";
+    }>;
+    self_report: z.ZodEnum<{
+        done: "done";
+        blocked: "blocked";
+        asking: "asking";
+        interrupted: "interrupted";
+        none: "none";
+    }>;
+    artifacts: z.ZodObject<{
+        commits: z.ZodArray<z.ZodString>;
+        prs: z.ZodArray<z.ZodString>;
+        repo: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>;
+    votes: z.ZodArray<z.ZodObject<{
+        lf: z.ZodString;
+        vote: z.ZodUnion<readonly [z.ZodLiteral<1>, z.ZodLiteral<-1>, z.ZodLiteral<0>]>;
+        strength: z.ZodEnum<{
+            strong: "strong";
+            weak: "weak";
+        }>;
+        evidence: z.ZodString;
+        observed_at: z.ZodString;
+    }, z.core.$strip>>;
+    history: z.ZodArray<z.ZodObject<{
+        at: z.ZodString;
+        label: z.ZodString;
+        reason: z.ZodString;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type VerifiedOutcome = z.infer<typeof VerifiedOutcomeSchema>;
+export type OutcomeLabel = VerifiedOutcome['label'];
+export type SelfReport = VerifiedOutcome['self_report'];

package/dist/agent/whatif-episode-gate.d.ts

@@ -1,5 +1,6 @@
 import type { HookContext, HookDecision } from './hooks.js';
 export declare function resetWhatifEpisodeGateForTests(): void;
 export declare function isWhatifEpisode(): boolean;
+export declare function keepContextHooksInEpisode(): boolean;
 export declare const EPISODE_BLOCK_REASON: string;
 export declare function createWhatifEpisodeGate(): (context: HookContext) => HookDecision;