agent-afk 5.1.0 → 5.2.0

package/dist/config/env.d.ts

@@ -0,0 +1,136 @@
+export type EnvVarType = 'string' | 'number' | 'boolean' | 'json';
+export type EnvVarCategory = 'model' | 'auth' | 'telegram' | 'paths' | 'debug' | 'daemon' | 'worktree' | 'mcp' | 'routing' | 'browser' | 'process' | 'misc';
+export interface EnvVarMeta {
+    readonly name: string;
+    readonly description: string;
+    readonly type: EnvVarType;
+    readonly required: boolean;
+    readonly default?: string;
+    readonly example?: string;
+    readonly category: EnvVarCategory;
+    readonly describedTodo?: boolean;
+    readonly secret?: boolean;
+}
+export declare const ENV_REGISTRY: readonly EnvVarMeta[];
+export declare const env: {
+    readonly AFK_COMPACT_KEEP_LAST_TURNS: string | undefined;
+    readonly AFK_COMPACT_MODEL: string | undefined;
+    readonly AFK_DEFAULT_SUBAGENT_MODEL: string | undefined;
+    readonly AFK_DIAGNOSE_BASELINE: string | undefined;
+    readonly AFK_DISABLE_BASH_INTERPRETER_GUARD: string | undefined;
+    readonly AFK_DISABLE_PATH_APPROVAL: string | undefined;
+    readonly AFK_DISABLE_PROMPT_CACHE: string | undefined;
+    readonly AFK_EFFORT: string | undefined;
+    readonly AFK_FORCE_BASH_INTERPRETER_GUARD: string | undefined;
+    readonly AFK_MAX_BUDGET_USD: string | undefined;
+    readonly AFK_MAX_OUTPUT_TOKENS: string | undefined;
+    readonly AFK_MAX_TOKENS: string | undefined;
+    readonly AFK_MEMORY_EVIDENCE_GATE: string | undefined;
+    readonly AFK_MODEL: string | undefined;
+    readonly AFK_MODEL_LARGE: string | undefined;
+    readonly AFK_MODEL_LARGE_API_KEY: string | undefined;
+    readonly AFK_MODEL_LARGE_BASE_URL: string | undefined;
+    readonly AFK_MODEL_LOCAL: string | undefined;
+    readonly AFK_MODEL_LOCAL_API_KEY: string | undefined;
+    readonly AFK_MODEL_LOCAL_BASE_URL: string | undefined;
+    readonly AFK_MODEL_MEDIUM: string | undefined;
+    readonly AFK_MODEL_MEDIUM_API_KEY: string | undefined;
+    readonly AFK_MODEL_MEDIUM_BASE_URL: string | undefined;
+    readonly AFK_MODEL_SMALL: string | undefined;
+    readonly AFK_MODEL_SMALL_API_KEY: string | undefined;
+    readonly AFK_MODEL_SMALL_BASE_URL: string | undefined;
+    readonly AFK_VISION_MODELS: string | undefined;
+    readonly AFK_PROMPT_CACHE_TTL: string | undefined;
+    readonly AFK_SUGGEST_ENABLED: string | undefined;
+    readonly AFK_SUGGEST_GHOST: string | undefined;
+    readonly AFK_SUGGEST_MODEL: string | undefined;
+    readonly AFK_TASK_BUDGET: string | undefined;
+    readonly AFK_TEMPERATURE: string | undefined;
+    readonly AFK_THINKING: string | undefined;
+    readonly AFK_TIMEOUT_MS: string | undefined;
+    readonly CLAUDE_MODEL: string | undefined;
+    readonly AFK_SYSTEM_PROMPT: string | undefined;
+    readonly AFK_DUMP_PROMPT: string | undefined;
+    readonly ANTHROPIC_API_KEY: string | undefined;
+    readonly CLAUDE_CODE_OAUTH_TOKEN: string | undefined;
+    readonly OPENAI_API_KEY: string | undefined;
+    readonly CODEX_API_KEY: string | undefined;
+    readonly AFK_LOCAL_API_KEY: string | undefined;
+    readonly AFK_LOCAL_BASE_URL: string | undefined;
+    readonly AFK_OPENAI_BASE_URL: string | undefined;
+    readonly AFK_OPENAI_USE_RESPONSES: string | undefined;
+    readonly AFK_OPENAI_CHATGPT_OAUTH: string | undefined;
+    readonly AFK_PROVIDER: string | undefined;
+    readonly EXA_API_KEY: string | undefined;
+    readonly TELEGRAM_BOT_TOKEN: string | undefined;
+    readonly AFK_TELEGRAM_BOT_TOKEN: string | undefined;
+    readonly AFK_TELEGRAM_ALLOWED_CHAT_IDS: string | undefined;
+    readonly AFK_TELEGRAM_PRIMARY_CHAT_ID: string | undefined;
+    readonly AFK_TELEGRAM_NOTIFY_MODE: string | undefined;
+    readonly TELEGRAM_DATA_DIR: string | undefined;
+    readonly TELEGRAM_VERBOSE: string | undefined;
+    readonly AFK_TELEGRAM_TRACE: string | undefined;
+    readonly AFK_TELEGRAM_CWD: string | undefined;
+    readonly AFK_HOME: string | undefined;
+    readonly AFK_STATE_DIR: string | undefined;
+    readonly AFK_FRAMEWORK_DIR: string | undefined;
+    readonly HOME: string | undefined;
+    readonly PATH: string | undefined;
+    readonly AFK_DAEMON_CWD: string | undefined;
+    readonly AFK_DAEMON_TASK: string | undefined;
+    readonly AFK_DAEMON_TASK_ID: string | undefined;
+    readonly AFK_DAEMON_HOST: string | undefined;
+    readonly AFK_SESSIONSTART_COOLDOWN_MS: string | undefined;
+    readonly AFK_WORKTREE_AUTONAME: string | undefined;
+    readonly AFK_WORKTREE_BRANCH_PREFIX: string | undefined;
+    readonly AFK_WORKTREE_BASE: string | undefined;
+    readonly AFK_WORKTREE_BOOT_PRUNE: string | undefined;
+    readonly AFK_WORKTREE_PRUNE_DISABLE: string | undefined;
+    readonly AFK_WORKTREE_MAX_AGE_CLEAN: string | undefined;
+    readonly AFK_WORKTREE_MAX_AGE_DIRTY: string | undefined;
+    readonly AFK_WORKTREE_SWEEP_ROOT: string | undefined;
+    readonly AFK_ALLOW_PROJECT_MCP: string | undefined;
+    readonly AFK_AUTO_ROUTING: string | undefined;
+    readonly AFK_INTERNAL: string | undefined;
+    readonly AFK_SHELL_PASSTHROUGH: string | undefined;
+    readonly AFK_BANNER_PLAIN: string | undefined;
+    readonly AFK_SPINNER_TIPS: string | undefined;
+    readonly AFK_SHOW_DIFFS: string | undefined;
+    readonly AFK_SKILL_STREAM_VERBOSE: string | undefined;
+    readonly FORCE_COLOR: string | undefined;
+    readonly NO_COLOR: string | undefined;
+    readonly AFK_DEBUG: string | undefined;
+    readonly AFK_DEBUG_CLIPBOARD: string | undefined;
+    readonly AFK_DEBUG_COMPOSITOR: string | undefined;
+    readonly AFK_TRACE_DISABLED: string | undefined;
+    readonly AFK_SESSION_LEDGER_DISABLED: string | undefined;
+    readonly AFK_RUN_RECEIPT_DISABLED: string | undefined;
+    readonly DEBUG: string | undefined;
+    readonly AGENT_AFK_ASCII: string | undefined;
+    readonly AGENT_SURFACE: string | undefined;
+    readonly CI: string | undefined;
+    readonly NODE_ENV: string | undefined;
+    readonly VITEST: string | undefined;
+    readonly NO_UPDATE_NOTIFIER: string | undefined;
+    readonly AFK_SESSION_ID: string | undefined;
+    readonly AFK_BROWSER_HEADLESS: string | undefined;
+    readonly AFK_BROWSER_ALLOWED_DOMAINS: string | undefined;
+    readonly AFK_BROWSER_BLOCKED_DOMAINS: string | undefined;
+    readonly AFK_BROWSER_DOM_SNAPSHOTS: string | undefined;
+    readonly AFK_BROWSER_BACKEND: string | undefined;
+    readonly AFK_BROWSER_CONFIG: string | undefined;
+    readonly AFK_WRITE_DENYLIST: string | undefined;
+    readonly AFK_WRITE_DIFF: string | undefined;
+    readonly AFK_DEMO_CLEAN: string | undefined;
+    readonly SCRIPT: string | undefined;
+    readonly ASCIINEMA_REC: string | undefined;
+    readonly SHELL: string | undefined;
+    readonly PAGER: string | undefined;
+    readonly AFK_DIFF_LINES: string | undefined;
+    readonly AFK_SHELL_WRAPPER: string | undefined;
+    readonly AFK_USER_CARD_MAX_ROWS: string | undefined;
+};
+export type EnvVarName = keyof typeof env;
+export declare function getEnvVarMeta(name: string): EnvVarMeta | undefined;
+export declare function getMissingRequiredEnvVars(category?: EnvVarCategory): EnvVarMeta[];
+export declare function isEnvVarSet(name: string): boolean;

package/dist/config/import-sources.d.ts

@@ -0,0 +1,46 @@
+export type ImportSourceBinary = 'claude-code' | 'codex';
+export declare const KNOWN_IMPORT_BINARIES: readonly ImportSourceBinary[];
+export interface ImportAssetToggles {
+    plugins: boolean;
+    skills: boolean;
+    mcp: boolean;
+}
+export type ImportFromConfig = Partial<Record<ImportSourceBinary, ImportAssetToggles>>;
+export type ImportedSkillOrigin = `imported:${ImportSourceBinary}`;
+export type McpConfigFormat = 'json' | 'toml';
+export declare const KNOWN_SOURCE_LABELS: Record<ImportSourceBinary, string>;
+export declare function parseImportFromConfig(raw: unknown): ImportFromConfig | undefined;
+export declare function importFromConfigPaths(): string[];
+export declare function loadImportFromConfig(configPaths?: readonly string[]): ImportFromConfig | undefined;
+export interface ResolvedImportRoots {
+    pluginRoots: string[];
+    skillRoots: Array<{
+        dir: string;
+        origin: ImportedSkillOrigin;
+    }>;
+    mcpConfigs: Array<{
+        source: string;
+        format: McpConfigFormat;
+    }>;
+}
+export declare function resolveImportedRoots(config: ImportFromConfig | undefined, home?: string): ResolvedImportRoots;
+export interface DetectedAsset {
+    name: string;
+    path: string;
+}
+export interface DetectedMcpServer {
+    name: string;
+    command: string;
+}
+export interface DetectedSource {
+    binary: ImportSourceBinary;
+    label: string;
+    present: boolean;
+    plugins: DetectedAsset[];
+    skills: DetectedAsset[];
+    mcpServers: DetectedMcpServer[];
+    mcpConfigPath: string | null;
+    mcpFormat: McpConfigFormat;
+}
+export declare function detectSources(home?: string): DetectedSource[];
+export declare function readMcpServers(path: string, format: McpConfigFormat): DetectedMcpServer[];

package/dist/config/mutate.d.ts

@@ -0,0 +1,78 @@
+import { type EnvKeyClass, type ConfigKeyClass } from './settable-keys.js';
+export declare const RESTART_NOTE = "effective on the next session/daemon restart; the current session is unchanged";
+export declare class UnknownKeyError extends Error {
+    constructor(key: string);
+}
+export declare class NonConfigKeyError extends Error {
+    constructor(key: string);
+}
+export declare class SecretWriteRefused extends Error {
+    constructor(key: string);
+}
+export declare class ProtectedEnvKeyRefused extends Error {
+    constructor(key: string);
+}
+export declare class HumanOnlyKeyRefused extends Error {
+    constructor(key: string);
+}
+export declare class ConfigValidationError extends Error {
+    constructor(message: string);
+}
+export declare class MalformedConfigError extends Error {
+    constructor(path: string);
+}
+export declare function maskSecret(value: string | undefined): string;
+export interface EnvOptions {
+    allowSecret?: boolean;
+    allowProtected?: boolean;
+    filePath?: string;
+}
+export interface EnvVarView {
+    key: string;
+    class: EnvKeyClass;
+    persisted: string | undefined;
+    activeInProcess: boolean;
+}
+export interface EnvWriteResult {
+    key: string;
+    class: EnvKeyClass;
+    persistedTo: string;
+    display: string;
+}
+export declare function setEnvVar(key: string, rawValue: string, opts?: EnvOptions): EnvWriteResult;
+export interface EnvRemoveResult {
+    key: string;
+    class: EnvKeyClass;
+    removed: boolean;
+    persistedTo: string;
+}
+export declare function unsetEnvVar(key: string, opts?: EnvOptions): EnvRemoveResult;
+export declare function getEnvVar(key: string, opts?: EnvOptions): EnvVarView;
+export declare function listEnv(opts?: EnvOptions & {
+    all?: boolean;
+}): EnvVarView[];
+export interface ConfigOptions {
+    allowHumanOnly?: boolean;
+    filePath?: string;
+}
+export interface ConfigWriteResult {
+    path: string;
+    class: ConfigKeyClass;
+    value: string | number | boolean | number[];
+    persistedTo: string;
+}
+export declare function setConfigValue(path: string, rawValue: unknown, opts?: ConfigOptions): ConfigWriteResult;
+export interface ConfigRemoveResult {
+    path: string;
+    class: ConfigKeyClass;
+    removed: boolean;
+    persistedTo: string;
+}
+export declare function unsetConfigValue(path: string, opts?: ConfigOptions): ConfigRemoveResult;
+export interface ConfigValueView {
+    path: string;
+    class: ConfigKeyClass;
+    value: unknown;
+}
+export declare function getConfigValue(path: string, opts?: ConfigOptions): ConfigValueView;
+export declare function listConfig(opts?: ConfigOptions): Record<string, unknown>;

package/dist/config/settable-keys.d.ts

@@ -0,0 +1,44 @@
+import { type EnvVarMeta } from './env.js';
+export declare const INHERITED_ENV_KEYS: ReadonlySet<string>;
+export declare const PROTECTED_ENV_KEYS: ReadonlySet<string>;
+export type EnvKeyClass = 'settable' | 'secret' | 'protected' | 'non-config' | 'unknown';
+export declare function classifyEnvKey(name: string): EnvKeyClass;
+export type CoerceResult = {
+    ok: true;
+    value: string;
+} | {
+    ok: false;
+    error: string;
+};
+export declare function coerceEnvValue(meta: EnvVarMeta, raw: string): CoerceResult;
+export type ConfigKeyTier = 'agent' | 'human';
+export type ConfigKeyType = 'string' | 'number' | 'boolean' | 'enum' | 'number-array';
+export interface ConfigKeySpec {
+    readonly path: string;
+    readonly tier: ConfigKeyTier;
+    readonly type: ConfigKeyType;
+    readonly enumValues?: readonly string[];
+    readonly clamp?: {
+        readonly min: number;
+        readonly max: number;
+        readonly integer?: boolean;
+    };
+    readonly description: string;
+}
+export declare const CONFIG_KEY_SPECS: readonly ConfigKeySpec[];
+export declare function getConfigKeySpec(path: string): ConfigKeySpec | undefined;
+export type ConfigKeyClass = 'agent' | 'human' | 'unknown';
+export declare function classifyConfigKey(path: string): ConfigKeyClass;
+export type ConfigCoerceResult = {
+    ok: true;
+    value: string | number | boolean | number[];
+} | {
+    ok: false;
+    error: string;
+};
+export declare function coerceConfigValue(spec: ConfigKeySpec, raw: unknown): ConfigCoerceResult;
+type Json = Record<string, unknown>;
+export declare function getAtPath(obj: Json, path: string): unknown;
+export declare function setAtPath(obj: Json, path: string, value: unknown): void;
+export declare function unsetAtPath(obj: Json, path: string): boolean;
+export {};

package/dist/improve/eval-gen/replay-fixture.d.ts

@@ -0,0 +1,19 @@
+export type EvalGenErrorCode = 'source-not-found' | 'source-empty' | 'seq-not-found' | 'unsupported-window' | 'fixture-mismatch' | 'card-not-found' | 'card-pattern-unknown' | 'evidence-row-out-of-range' | 'proposal-not-found';
+export declare class EvalGenError extends Error {
+    readonly code: EvalGenErrorCode;
+    constructor(message: string, code: EvalGenErrorCode);
+}
+export interface SliceTraceOptions {
+    endSeq: number;
+    startLine?: number;
+}
+export interface SliceTraceResult {
+    bytes: Buffer;
+    startLine: number;
+    endLine: number;
+    sliceLineCount: number;
+    sliceSha256: string;
+    sourceLineCount: number;
+}
+export declare function sliceTracePrefix(sourceAbsPath: string, options: SliceTraceOptions): SliceTraceResult;
+export declare function sha256Bytes(bytes: Buffer): string;

package/dist/improve/eval-gen/writer.d.ts

@@ -0,0 +1,41 @@
+import { type EvalCase, type FailureCard } from '../schemas.js';
+export interface IdContext {
+    now?: () => Date;
+    randomSuffix?: () => string;
+}
+export declare function generateEvalCaseId(cardSlug: string, ctx?: IdContext): string;
+export interface BuildEvalCaseContext {
+    evalCaseId: string;
+    evidenceRowIndex: number;
+    proposalId?: string | null;
+    now?: () => Date;
+    resolveTraceAbsPath?: (relativeTracePath: string) => string;
+}
+export interface BuildEvalCaseResult {
+    evalCase: EvalCase;
+    sliceBytes: Buffer;
+}
+export declare function buildEvalCase(card: FailureCard, ctx: BuildEvalCaseContext): BuildEvalCaseResult;
+export interface WriteEvalCaseOutcome {
+    evalCaseId: string;
+    jsonPath: string;
+    fixturePath: string;
+    markdownPath: string;
+}
+export declare function writeEvalCase(evalCase: EvalCase, sliceBytes: Buffer): WriteEvalCaseOutcome;
+export declare function renderEvalCaseMarkdown(ec: EvalCase): string;
+export interface EvalCaseListEntry {
+    evalCaseId: string;
+    cardSlug: string;
+    proposalId: string | null;
+    title: string;
+    kind: EvalCase['kind'];
+    status: EvalCase['status'];
+    patternId: EvalCase['assertion']['patternId'];
+    createdAt: string;
+    sliceSha256: string;
+}
+export declare function listEvalCases(): EvalCaseListEntry[];
+export declare function getEvalCase(evalCaseId: string): EvalCase | undefined;
+export declare function getEvalCasesForCard(cardSlug: string): EvalCase[];
+export declare function getEvalCasesForProposal(proposalId: string): EvalCase[];

package/dist/improve/eval-run/contracts.d.ts

@@ -0,0 +1,25 @@
+import { type SessionRead } from '../scan/reader.js';
+import type { EvalCheck, EvalCheckStatus, EvalRunEvidenceRef, FailurePattern } from '../schemas.js';
+export interface ContractProbeResult {
+    checks: EvalCheck[];
+    evidence: EvalRunEvidenceRef[];
+}
+export interface EvalContract {
+    id: string;
+    patternId: FailurePattern;
+    title: string;
+    run: () => Promise<ContractProbeResult>;
+}
+export declare function snapshot(value: unknown): string;
+export declare function makeCheck(args: {
+    name: string;
+    description: string;
+    pass: boolean;
+    expected: string;
+    actual: string;
+    status?: EvalCheckStatus;
+}): EvalCheck;
+export declare function buildToolFailureClassificationCorpus(): SessionRead[];
+export declare function resolveContract(patternId: FailurePattern): EvalContract | undefined;
+export declare function supportedContractPatterns(): readonly FailurePattern[];
+export declare function knownContractIds(): readonly string[];

package/dist/improve/eval-run/replay.d.ts

@@ -0,0 +1,25 @@
+import type { ClosureReason } from '../../agent/trace/index.js';
+import type { EvalCase, FailurePattern } from '../schemas.js';
+import { type ContractProbeResult } from './contracts.js';
+export declare const REPLAY_CHECK_PREFIX = "replay:";
+export declare const REPLAY_CHECK_REPRODUCES = "replay:fixture-reproduces-pattern";
+export declare const REPLAY_CHECK_NEUTRALIZED = "replay:guardrail-neutralizes-recorded-loop";
+export declare const REPLAY_CHECK_CLOSURE_REPRODUCES = "replay:fixture-reproduces-closure-anomaly";
+export declare const REPLAY_CHECK_CLOSURE_GUIDED = "replay:guardrail-guides-recorded-closure";
+export interface LoopDriveResult {
+    trippedAtCall: number | null;
+    callsDriven: number;
+}
+export type LoopDriver = (toolName: string, count: number) => Promise<LoopDriveResult>;
+export declare const liveCircuitBreakerDriver: LoopDriver;
+export interface ReplayContext {
+    driveLoop?: LoopDriver;
+    buildGuidance?: (reason: ClosureReason) => string | null;
+}
+export interface ReplayHandler {
+    patternId: FailurePattern;
+    run: (evalCase: EvalCase, fixtureBytes: Buffer, ctx: ReplayContext) => Promise<ContractProbeResult>;
+}
+export declare function isReplayNeutralizeCheck(name: string): boolean;
+export declare function resolveReplayHandler(patternId: FailurePattern): ReplayHandler | undefined;
+export declare function replaySupportedPatterns(): readonly FailurePattern[];

package/dist/improve/eval-run/runner.d.ts

@@ -0,0 +1,37 @@
+import { type EvalCase, type EvalCheck, type EvalRun, type EvalRunStatus } from '../schemas.js';
+import type { IdContext } from '../eval-gen/writer.js';
+import { type LoopDriver } from './replay.js';
+export declare const EVAL_RUN_RUNNER_VERSION = "eval-run@v1";
+export declare function generateEvalRunId(cardSlug: string, ctx?: IdContext): string;
+export interface RunEvalCaseContext {
+    evalRunId: string;
+    now?: () => Date;
+    clockMs?: () => number;
+    resolveFixtureAbsPath?: (relativeFixturePath: string) => string;
+    driveLoop?: LoopDriver;
+}
+export declare function runEvalCase(evalCase: EvalCase, ctx: RunEvalCaseContext): Promise<EvalRun>;
+export declare function decideStatus(args: {
+    hasContract: boolean;
+    contractThrew: boolean;
+    checks: EvalCheck[];
+    replayInconclusive?: boolean;
+}): EvalRunStatus;
+export interface WriteEvalRunOutcome {
+    evalRunId: string;
+    jsonPath: string;
+    markdownPath: string;
+}
+export declare function writeEvalRun(evalRun: EvalRun): WriteEvalRunOutcome;
+export declare function renderEvalRunMarkdown(run: EvalRun): string;
+export interface EvalRunListEntry {
+    evalRunId: string;
+    evalCaseId: string;
+    cardSlug: string;
+    patternId: EvalRun['patternId'];
+    contract: string | null;
+    status: EvalRunStatus;
+    createdAt: string;
+}
+export declare function listEvalRuns(): EvalRunListEntry[];
+export declare function getEvalRun(evalRunId: string): EvalRun | undefined;

package/dist/improve/paths.d.ts

@@ -0,0 +1,19 @@
+export declare function getImproveRoot(): string;
+export declare function getFailureCardsDir(): string;
+export declare function getFailureCardsIndexPath(): string;
+export declare function getFailureCardJsonPath(slug: string): string;
+export declare function getFailureCardMarkdownPath(slug: string): string;
+export declare function getWitnessRoot(): string;
+export declare function getProposalsDir(): string;
+export declare function getProposalsIndexPath(): string;
+export declare function getProposalJsonPath(proposalId: string): string;
+export declare function getProposalMarkdownPath(proposalId: string): string;
+export declare function getEvalCasesDir(): string;
+export declare function getEvalCasesIndexPath(): string;
+export declare function getEvalCaseJsonPath(evalCaseId: string): string;
+export declare function getEvalCaseFixturePath(evalCaseId: string): string;
+export declare function getEvalCaseMarkdownPath(evalCaseId: string): string;
+export declare function getEvalRunsDir(): string;
+export declare function getEvalRunsIndexPath(): string;
+export declare function getEvalRunJsonPath(evalRunId: string): string;
+export declare function getEvalRunMarkdownPath(evalRunId: string): string;

package/dist/improve/propose/template-engine.d.ts

@@ -0,0 +1,7 @@
+import { type FailureCard, type ImprovementProposal, type LikelyFile, type Severity } from '../schemas.js';
+export interface TemplateContext {
+    proposalId: string;
+    now?: () => Date;
+}
+export declare function proposeFromCard(card: FailureCard, ctx: TemplateContext): ImprovementProposal;
+export declare function deriveRiskLevel(floor: Severity, files: readonly LikelyFile[]): Severity;

package/dist/improve/propose/writer.d.ts

@@ -0,0 +1,26 @@
+import { type ImprovementProposal } from '../schemas.js';
+export interface WriteProposalOutcome {
+    proposalId: string;
+    jsonPath: string;
+    markdownPath: string;
+}
+export declare function writeProposal(proposal: ImprovementProposal): WriteProposalOutcome;
+export interface IdContext {
+    now?: () => Date;
+    randomSuffix?: () => string;
+}
+export declare function generateProposalId(cardSlug: string, ctx?: IdContext): string;
+export declare function renderProposalMarkdown(p: ImprovementProposal): string;
+export interface ProposalListEntry {
+    proposalId: string;
+    cardSlug: string;
+    title: string;
+    riskLevel: ImprovementProposal['riskLevel'];
+    status: ImprovementProposal['status'];
+    rootCauseClass: ImprovementProposal['rootCauseClass'];
+    generatedBy: ImprovementProposal['generatedBy'];
+    createdAt: string;
+}
+export declare function listProposals(): ProposalListEntry[];
+export declare function getProposal(proposalId: string): ImprovementProposal | undefined;
+export declare function getProposalsForCard(cardSlug: string): ImprovementProposal[];

package/dist/improve/scan/card-writer.d.ts

@@ -0,0 +1,38 @@
+import { type CardIndexEvent, type DetectorResult, type FailureCard } from '../schemas.js';
+export interface WriteCardOutcome {
+    slug: string;
+    event: CardIndexEvent['event'];
+    occurrenceCount: number;
+    evidenceAdded: number;
+    jsonPath: string;
+    markdownPath: string;
+}
+export declare function writeCard(detection: DetectorResult): WriteCardOutcome;
+export declare function readCardIfExists(jsonPath: string): FailureCard | undefined;
+export declare function mergeCard(existing: FailureCard | undefined, detection: DetectorResult): FailureCard;
+export declare function renderMarkdown(card: FailureCard): string;
+export interface CardListEntry {
+    slug: string;
+    title: string;
+    pattern: FailureCard['pattern'];
+    severity: FailureCard['severity'];
+    status: FailureCard['status'];
+    occurrenceCount: number;
+    firstSeen: string;
+    lastSeen: string;
+}
+export declare function listCards(): CardListEntry[];
+export declare function getCard(slug: string): FailureCard | undefined;
+export interface RegressedCardEntry {
+    slug: string;
+    pattern: FailureCard['pattern'];
+    severity: FailureCard['severity'];
+    status: FailureCard['status'];
+    occurrenceCount: number;
+    lastSeen: string;
+    latestNoteAt: string;
+}
+export declare function latestNoteAt(card: FailureCard): string | undefined;
+export declare function isRegressed(card: FailureCard): boolean;
+export declare function selectRegressed(cards: FailureCard[]): RegressedCardEntry[];
+export declare function listRegressedCards(): RegressedCardEntry[];

package/dist/improve/scan/detectors/closure-anomaly.d.ts

@@ -0,0 +1,8 @@
+import type { DetectorResult } from '../../schemas.js';
+import type { SessionRead } from '../reader.js';
+export declare const DEFAULT_CLOSURE_ANOMALY_MIN_OCCURRENCES = 1;
+export interface ClosureAnomalyOptions {
+    minOccurrences?: number;
+}
+export declare function detectClosureAnomaly(sessions: SessionRead[], options?: ClosureAnomalyOptions): DetectorResult[];
+export declare function makeSlug(reason: string): string;

package/dist/improve/scan/detectors/index.d.ts

@@ -0,0 +1,20 @@
+import type { DetectorResult } from '../../schemas.js';
+import type { SessionRead } from '../reader.js';
+export interface DetectorOptions {
+    minRepeats?: number;
+    closureAnomalyMinOccurrences?: number;
+    subagentBlockMinOccurrences?: number;
+    toolFailureMinFailures?: number;
+    toolFailureMinRate?: number;
+}
+export interface DetectorEntry {
+    name: string;
+    description: string;
+    enabledByDefault?: boolean;
+    run: (sessions: SessionRead[], options: DetectorOptions) => DetectorResult[];
+}
+export declare const DETECTOR_REGISTRY: readonly DetectorEntry[];
+export declare function runAllDetectors(sessions: SessionRead[], options: DetectorOptions, enabledNames?: ReadonlySet<string>, includeDisabled?: boolean): DetectorResult[];
+export declare function knownDetectorNames(): readonly string[];
+export declare function defaultEnabledDetectorNames(): readonly string[];
+export declare function disabledByDefaultDetectorNames(): readonly string[];

package/dist/improve/scan/detectors/repeated-tool-use.d.ts

@@ -0,0 +1,29 @@
+import type { DetectorResult } from '../../schemas.js';
+import type { ReaderEvent, SessionRead } from '../reader.js';
+export declare const DEFAULT_MIN_REPEATS = 4;
+export interface RepeatedToolUseOptions {
+    minRepeats?: number;
+}
+export declare function detectRepeatedToolUse(sessions: SessionRead[], options?: RepeatedToolUseOptions): DetectorResult[];
+export interface ToolCallPair {
+    toolUseId: string;
+    startedSeq: number;
+    completedSeq: number;
+    completedLineNumber: number;
+    name: string;
+    inputBytes: number;
+    resultBytes: number;
+    isError: boolean;
+    subagentId: string | undefined;
+    rawLine: string;
+    fingerprint: string;
+}
+export declare function pairToolCalls(events: ReaderEvent[]): ToolCallPair[];
+export declare function computeFingerprint(args: {
+    name: string;
+    inputBytes: number;
+    resultBytes: number;
+    isError: boolean;
+    subagentId: string | undefined;
+}): string;
+export declare function makeSlug(toolName: string, fingerprint: string): string;

package/dist/improve/scan/detectors/subagent-block.d.ts

@@ -0,0 +1,13 @@
+import type { DetectorResult } from '../../schemas.js';
+import type { SessionRead } from '../reader.js';
+export declare const DEFAULT_SUBAGENT_BLOCK_MIN_OCCURRENCES = 2;
+export interface SubagentBlockOptions {
+    minOccurrences?: number;
+}
+export declare function detectSubagentBlock(sessions: SessionRead[], options?: SubagentBlockOptions): DetectorResult[];
+export declare function computeFingerprint(args: {
+    hookEvent: string;
+    reason: string;
+    blockedTool: string | undefined;
+}): string;
+export declare function makeSlug(fingerprint: string): string;

package/dist/improve/scan/detectors/tool-failure-density.d.ts

@@ -0,0 +1,10 @@
+import type { DetectorResult } from '../../schemas.js';
+import type { SessionRead } from '../reader.js';
+export declare const DEFAULT_TOOL_FAILURE_MIN_FAILURES = 3;
+export declare const DEFAULT_TOOL_FAILURE_MIN_RATE = 0.25;
+export interface ToolFailureDensityOptions {
+    minFailures?: number;
+    minFailureRate?: number;
+}
+export declare function detectToolFailureDensity(sessions: SessionRead[], options?: ToolFailureDensityOptions): DetectorResult[];
+export declare function makeSlug(toolName: string): string;