gennady 0.6.0 → 0.7.0

package/dist/cli/cmd/_shared/prompt/logic/build-ai-verify-placeholders.logic.d.ts

@@ -1,16 +1,19 @@
 /**
- * @purpose Описать подстановки verify-блока для AI-шаблона.
+ * @purpose Describe verify-block substitutions for the AI template.
  * @consumer render-review-verify.xml, render-resolve-conflicts.xml
  */
 export type VerifyCommandPlaceholders = {
+    /** @purpose Hint for agent on which verification command to run. */
     axiomHint: string;
+    /** @purpose Example tool commands for the agent to reference. */
     toolsExample: string;
+    /** @purpose Step-by-step verification instruction for the agent. */
     verifyStep: string;
 };
 /**
- * @purpose Построить безопасные подстановки `<!--ai:verify-*-->` для шаблона.
+ * @purpose Build safe `<!--ai:verify-*-->` substitutions for the template.
+ * @param projectRoot Repository root for searching verification commands.
+ * @returns Set of strings for insertion into the template.
  * @consumer render-review-verify.xml, render-resolve-conflicts.xml
- * @param projectRoot Корень репозитория для поиска команд проверки.
- * @returns Набор строк для вставки в шаблон.
  */
 export declare function buildVerifyCommandPlaceholders(projectRoot: string): VerifyCommandPlaceholders;

package/dist/cli/cmd/_shared/prompt/logic/verify-commands/resolve-verify-commands.logic.d.ts

@@ -1 +1,6 @@
+/**
+ * @purpose Return safe code verification commands for the current project (tests, lint, types).
+ * @param projectRoot Repository root for searching markers and package.json.
+ * @returns List of commands in priority order; empty list if the detector did not find a safe set.
+ */
 export declare function resolveSafeVerifyCommands(projectRoot: string): string[];

package/dist/cli/cmd/_shared/update-check-worker.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/cli/cmd/_shared/update-check.d.ts

@@ -0,0 +1,38 @@
+import { spawn } from 'node:child_process';
+/** @purpose Serialized cache structure persisted by the update-check worker. */
+export type UpdateCheckCache = {
+    /** @purpose ISO8601 timestamp of the most recent registry check */
+    lastCheck: string;
+    /** @purpose Latest version string from npm registry response */
+    latestVersion: string;
+};
+/** @purpose Configuration driving the update-check service behaviour. */
+export type UpdateCheckOptions = {
+    /** @purpose Package identity — name and semver version */
+    pkg: {
+        name: string;
+        version: string;
+    };
+    /** @purpose Minimum interval between checks in ms | @invariant Default 24h (86_400_000 ms) */
+    interval?: number;
+    /** @purpose Suppress stderr notification when stderr is not a TTY | @invariant Default true — suppresses display only, never the check */
+    skipNotificationIfNoTty?: boolean;
+    /** @purpose Directory for the update-check cache file | @invariant Must exist before worker spawn */
+    cacheDir?: string;
+    /** @purpose Inject a custom spawn implementation for testing | @invariant Test seam only — not used in production */
+    _spawnFn?: typeof spawn;
+};
+/**
+ * @purpose Orchestrate a non-blocking update check — read cache, spawn worker if stale, register deferred notification.
+ * @implements {UpdateCheck} in specs/cli/update-check/update-check.spec.md#updatecheck
+ * @invariant Never throws — all failure paths are silent.
+ * @invariant Never blocks process.exit — spawn uses unref().
+ * @param pkg Package identity with name and semver version.
+ * @param [opts] Optional configuration overrides.
+ * @post Returns synchronously without blocking; if stale/missing cache: detached worker spawned via unref(); if fresh cache with newer version: beforeExit hook registered.
+ * @sideEffect FS: reads and writes cache directory. Subprocess: may spawn UpdateCheckWorker.
+ */
+export declare function checkForUpdates(pkg: {
+    name: string;
+    version: string;
+}, opts?: Partial<UpdateCheckOptions>): void;

package/dist/cli/cmd/agent-mon/cmd/create-providers.d.ts

@@ -0,0 +1,15 @@
+import { AgentMonitor } from '../../../../services/agent-mon/monitor/index.js';
+/** @purpose Options controlling which providers are registered. */
+export type CreateProvidersOpts = {
+    /** @purpose Register Claude provider | @invariant Default true when absent */
+    claude?: boolean;
+    /** @purpose Register OpenCode provider | @invariant Default true when absent */
+    opencode?: boolean;
+};
+/**
+ * @purpose Create an AgentMonitor and register Claude and OpenCode providers according to options.
+ * @invariant Stateless — each call creates a fresh monitor instance.
+ * @param [opts] Provider selection — both enabled by default.
+ * @returns AgentMonitor with selected providers registered and ready for scanning.
+ */
+export declare function createProviders(opts?: CreateProvidersOpts): AgentMonitor;

package/dist/cli/cmd/agent-mon/cmd/index.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/cli/cmd/agent-mon/cmd/run.d.ts

@@ -0,0 +1,12 @@
+/**
+ * @purpose CLI entry point for `gennady agent-mon` — parse flags, wire providers, render the dashboard.
+ * @invariant --once mode: single scan → build ViewModel → render + exit.
+ * @invariant Live mode: observe → state manager → render, process kept alive by ink.
+ * @pre argv contains CLI flags per the agent-mon subcommand contract.
+ * @param argv Argument vector (excluding the command name 'agent-mon').
+ * @throws Never — on invalid input, prints usage and exits with code 1.
+ * @returns void (process is kept alive by ink in live mode or exits after snapshot in --once).
+ * @post Process is kept alive by ink (live mode) or exits after snapshot (--once).
+ * @sideEffect Starts ink renderer; registers providers; may spawn observe polling loop.
+ */
+export declare function run(argv: string[]): Promise<void>;

package/dist/cli/cmd/agent-mon/state/create-state-manager.d.ts

@@ -0,0 +1,32 @@
+import type { SessionChanges } from '../../../../services/agent-mon/model/session-changes.type.js';
+import type { ViewModel } from './view-model.type.js';
+/**
+ * @purpose Public interface of the state manager — query current ViewModel and subscribe to updates.
+ * @invariant getViewModel() always returns the latest snapshot; subscribe fires immediately with current state.
+ */
+export type StateManager = {
+    /**
+     * @purpose Retrieve the current ViewModel snapshot.
+     * @returns Current immutable copy.
+     */
+    getViewModel(): ViewModel;
+    /**
+     * @purpose Register a callback invoked on every ViewModel update, including the current state immediately.
+     * @param fn Callback receiving the updated ViewModel.
+     * @returns Unsubscribe function — call to stop receiving updates.
+     */
+    subscribe(fn: (vm: ViewModel) => void): () => void;
+};
+/**
+ * @purpose Create a state manager that consumes SessionChanges from an async iterable.
+ * @implements {StateManager} in ./create-state-manager.ts
+ * @invariant Subscribers receive the current ViewModel immediately on subscribe; status='loading' until first iteration.
+ * @invariant On observer error: status transitions to 'error', data preserves last successful scan.
+ * @param changes Async iterable of SessionChanges — produced by the agent-mon observe() pipeline.
+ * @param [opts] Optional configuration to control per-provider session limit.
+ * @returns StateManager instance with getViewModel and subscribe methods.
+ * @sideEffect Spawns background async iteration over changes; notifies subscribers on each update.
+ */
+export declare function createStateManager(changes: AsyncIterable<SessionChanges>, opts?: {
+    limit?: number;
+}): StateManager;

package/dist/cli/cmd/agent-mon/state/group-by-provider.d.ts

@@ -0,0 +1,14 @@
+import type { AgentSession } from '../../../../services/agent-mon/model/agent-session.type.js';
+import type { ProviderColumn } from './view-model.type.js';
+/**
+ * @purpose Group sessions by provider, compute per-column counts, and sort sessions within each column.
+ * @invariant Sessions within each column are sorted: active → waiting → idle → completed.
+ * @param sessions Flat array of agent sessions across all providers.
+ * @param [opts] Optional overrides — isWaitingFn replaces default isWaitingForUser for testing.
+ * @returns One ProviderColumn per unique provider, with sessions sorted by status priority.
+ * @sideEffect None — pure transformation.
+ */
+export declare function groupByProvider(sessions: AgentSession[], opts?: {
+    isWaitingFn?: (s: AgentSession) => boolean;
+    limit?: number;
+}): ProviderColumn[];

package/dist/cli/cmd/agent-mon/state/index.d.ts

@@ -0,0 +1,5 @@
+export { createStateManager } from './create-state-manager.js';
+export type { StateManager } from './create-state-manager.js';
+export type { ViewModel, ProviderColumn, SessionCard } from './view-model.type.js';
+export { groupByProvider } from './group-by-provider.js';
+export { isWaitingForUser } from './is-waiting.js';

package/dist/cli/cmd/agent-mon/state/is-waiting.d.ts

@@ -0,0 +1,9 @@
+import type { AgentSession } from '../../../../services/agent-mon/model/agent-session.type.js';
+/**
+ * @purpose Determine whether an agent session is waiting for operator input based on last message content.
+ * @invariant Pure function — no side effects, no I/O, deterministic given same inputs.
+ * @param session Agent session data — uses only lastMessage field for detection.
+ * @param [patterns] Regex patterns for waiting detection; uses DEFAULT_WAIT_PATTERNS when falsy.
+ * @returns true if lastMessage matches any pattern, false otherwise (including when lastMessage is absent).
+ */
+export declare function isWaitingForUser(session: AgentSession, patterns?: RegExp[]): boolean;

package/dist/cli/cmd/agent-mon/state/view-model.type.d.ts

@@ -0,0 +1,74 @@
+/**
+ * @purpose Full dashboard state snapshot consumed by the UI layer.
+ * @invariant status transitions: loading → ready | error; on error, data preserves last successful scan.
+ */
+export type ViewModel = {
+    /** @purpose Current lifecycle state of the dashboard | @invariant 'loading' before first iteration, 'ready' after, 'error' on observer failure */
+    status: 'loading' | 'ready' | 'error';
+    /** @purpose Aggregated dashboard data — columns and summary | @invariant Present only after first successful scan */
+    data?: {
+        /** @purpose Per-provider columns with grouped sessions */
+        columns: ProviderColumn[];
+        /** @purpose Aggregate counts across all providers */
+        summary: {
+            /** @purpose Total session count across all providers */
+            total: number;
+            /** @purpose Session count per provider key */
+            byProvider: Record<string, number>;
+        };
+    };
+    /** @purpose Error object captured on observer failure | @invariant Set only when status='error' */
+    error?: Error;
+    /** @purpose Timestamp of the last ViewModel update | @invariant Epoch milliseconds */
+    lastUpdated: number;
+};
+/**
+ * @purpose Column data for one provider — sessions grouped and sorted.
+ * @invariant sessions are sorted: active → waiting → idle → completed.
+ */
+export type ProviderColumn = {
+    /** @purpose Provider identifier (claude, opencode, etc.) */
+    provider: string;
+    /** @purpose Count of sessions in active state */
+    activeCount: number;
+    /** @purpose Count of sessions waiting for operator input */
+    waitingCount: number;
+    /** @purpose Count of idle sessions */
+    idleCount: number;
+    /** @purpose Sessions in this column, sorted by status priority */
+    sessions: SessionCard[];
+};
+/**
+ * @purpose Rendering data for one session card in the dashboard.
+ * @invariant isWaitingForOperator is derived from isWaitingForUser heuristic applied to lastMessage.
+ */
+export type SessionCard = {
+    /** @purpose Stable session identifier */
+    sessionId: string;
+    /** @purpose Display title of the session */
+    title: string;
+    /** @purpose AI model name used in the session */
+    model?: string;
+    /** @purpose Current session status — 'waiting' derived from isWaitingForUser heuristic */
+    status: 'active' | 'waiting' | 'idle' | 'completed';
+    /** @purpose Human-readable elapsed time string (e.g. '33m', '2.1h') */
+    elapsed: string;
+    /** @purpose Last message content, truncated for display */
+    lastMessage?: string;
+    /** @purpose Input token count */
+    tokensIn?: number;
+    /** @purpose Output token count */
+    tokensOut?: number;
+    /** @purpose CPU usage percentage | @invariant Provider-specific */
+    cpuPercent?: number;
+    /** @purpose Memory usage in megabytes | @invariant Provider-specific */
+    memoryMb?: number;
+    /** @purpose Active tasks within the session | @invariant V1 not populated, deferred */
+    tasks?: {
+        id: string;
+        status: string;
+        subject: string;
+    }[];
+    /** @purpose Whether the session appears to be waiting for operator input */
+    isWaitingForOperator: boolean;
+};

package/dist/cli/cmd/agent-mon/ui/app.d.ts

@@ -0,0 +1,16 @@
+import type { StateManager } from '../state/create-state-manager.js';
+/** @purpose Props for the AgentMonApp root component. */
+export type AgentMonAppProps = {
+    /** @purpose State manager providing ViewModel snapshots and subscription lifecycle */
+    stateManager: StateManager;
+    /** @purpose Dashboard view variant — 'column' renders ColumnView (default) */
+    view?: 'column' | 'compact';
+};
+/**
+ * @purpose Root ink component — subscribes to state manager, handles keyboard exit, selects the active view.
+ * @invariant Subscribes on mount, unsubscribes on unmount — no leaks.
+ * @invariant Loading → "Scanning for active sessions..."; error → red message + last data if available.
+ * @param props Component properties from AgentMonAppProps.
+ * @sideEffect Keyboard input capture for exit (Esc, q, Ctrl+C).
+ */
+export declare function AgentMonApp(props: AgentMonAppProps): import("react/jsx-runtime").JSX.Element;

package/dist/cli/cmd/agent-mon/ui/column-view.d.ts

@@ -0,0 +1,14 @@
+import type { ViewModel } from '../state/view-model.type.js';
+/** @purpose Props for the ColumnView component — dashboard ViewModel. */
+export type ColumnViewProps = {
+    /** @purpose Dashboard ViewModel containing columns data. */
+    viewModel: ViewModel;
+    /** @purpose Max rows per column for terminal height adaptation. */
+    maxRows?: number;
+};
+/**
+ * @purpose Dashboard view that renders provider columns horizontally.
+ * @invariant Empty columns → "No active sessions." message (degradation per spec).
+ * @param props Component properties from ColumnViewProps.
+ */
+export declare function ColumnView(props: ColumnViewProps): import("react/jsx-runtime").JSX.Element;

package/dist/cli/cmd/agent-mon/ui/index.d.ts

@@ -0,0 +1,10 @@
+export { AgentMonApp } from './app.tsx';
+export type { AgentMonAppProps } from './app.tsx';
+export { ColumnView } from './column-view.tsx';
+export type { ColumnViewProps } from './column-view.tsx';
+export { ProviderColumn } from './provider-column.tsx';
+export type { ProviderColumnProps } from './provider-column.tsx';
+export { SessionCard } from './session-card.tsx';
+export type { SessionCardProps } from './session-card.tsx';
+export { StatusBadge } from './status-badge.tsx';
+export type { StatusBadgeProps } from './status-badge.tsx';

package/dist/cli/cmd/agent-mon/ui/provider-column.d.ts

@@ -0,0 +1,14 @@
+import type { ProviderColumn as ProviderColumnData } from '../state/view-model.type.js';
+/** @purpose Props for the ProviderColumn component — column data to render. */
+export type ProviderColumnProps = {
+    /** @purpose Provider column data from the ViewModel. */
+    column: ProviderColumnData;
+    /** @purpose Max session cards to render in this column. */
+    maxCards?: number;
+};
+/**
+ * @purpose Renders one provider column — header with status counts, then stacked session cards.
+ * @invariant Sessions within the column are pre-sorted by status priority (active → waiting → idle → completed) by groupByProvider; no re-sort needed here.
+ * @param props Component properties from ProviderColumnProps.
+ */
+export declare function ProviderColumn(props: ProviderColumnProps): import("react/jsx-runtime").JSX.Element;

package/dist/cli/cmd/agent-mon/ui/session-card.d.ts

@@ -0,0 +1,12 @@
+import type { SessionCard as SessionCardData } from '../state/view-model.type.js';
+/** @purpose Props for the SessionCard component — session data to render. */
+export type SessionCardProps = {
+    /** @purpose Session card data from the ViewModel */
+    card: SessionCardData;
+};
+/**
+ * @purpose Renders one agent session as a bordered card with status badge and metadata.
+ * @invariant Absent optional fields (tokens, cpu, memory) are not rendered — degradation per spec.
+ * @param props Component properties from SessionCardProps.
+ */
+export declare function SessionCard(props: SessionCardProps): import("react/jsx-runtime").JSX.Element;

package/dist/cli/cmd/agent-mon/ui/status-badge.d.ts

@@ -0,0 +1,10 @@
+/** @purpose Props for the StatusBadge component — status selector. */
+export type StatusBadgeProps = {
+    /** @purpose Session status driving the visual indicator */
+    status: 'active' | 'waiting' | 'idle' | 'completed';
+};
+/**
+ * @purpose Visual indicator of agent session status — emoji icon + text label.
+ * @param props Component properties from StatusBadgeProps.
+ */
+export declare function StatusBadge(props: StatusBadgeProps): import("react/jsx-runtime").JSX.Element;

package/dist/cli/cmd/alt-opinion/alt-opinion-parser.d.ts

@@ -0,0 +1,18 @@
+import type { AltOpinionParsedArgs } from './alt-opinion.types.js';
+/**
+ * @purpose Parse CLI arguments for the alt-opinion command.
+ * *
+ * Parses repeated --model, optional --synthModel, --file, --modelPrompt, --synthPrompt, --strict.
+ * Validates provider names, mutual exclusion of stdin/--file, :: syntax for per-model prompts,
+ * and minimum model count.
+ * *
+ * @param rawArgs Raw CLI arguments (typically process.argv).
+ * @param [opts] Options bag carrying pre-read stdin content for test injection.
+ *   When omitted and stdin is not a TTY, the parser reads stdin synchronously.
+ * @throws {Error} On validation failures (missing model, unknown provider, mutual exclusion, etc.).
+ * @returns Parsed arguments with resolved artifact content.
+ * @sideEffect FS: reads stdin when not TTY and opts.stdinContent not provided. Actual data presence is determined by non-empty trimmed content.
+ */
+export declare function parseAltOpinionArgs(rawArgs: string[], opts?: {
+    stdinContent?: string;
+}): AltOpinionParsedArgs;

package/dist/cli/cmd/alt-opinion/alt-opinion-runner.d.ts

@@ -0,0 +1,32 @@
+import type { AltOpinionModelPort, AltOpinionParsedArgs, AltOpinionReport } from './alt-opinion.types.js';
+/** @purpose Dependencies for the alt-opinion runner, injected by the cmd layer. */
+export type RunAltOpinionDeps = {
+    /** @purpose Model ports keyed by `provider/model` string (e.g. "llmproxy/deepseek-v4-pro") */
+    models: Map<string, AltOpinionModelPort>;
+    /** @purpose Optional synthesis model port */
+    synth?: AltOpinionModelPort;
+    /**
+     * @purpose Synchronous file reader for resolving --file, per-model prompts, and shared prompts.
+     * @param path Filesystem path to read.
+     * @returns File contents as a string.
+     */
+    readFile: (path: string) => string;
+};
+/**
+ * @purpose Core alt-opinion runner — polls models in parallel and optionally synthesizes results.
+ * *
+ * Resolves artifact content (from --file or pre-resolved stdin), sanitizes it against prompt injection,
+ * queries all models in parallel via Promise.allSettled with per-model prompts, and optionally runs
+ * synthesis when --synthModel is provided.
+ * *
+ * @invariant Model results preserve the order of --model arguments (Promise.allSettled insertion order).
+ * @invariant Timeout per model: 5 minutes via AbortSignal. Timeout → error in model block, not thrown.
+ * @invariant Exit code: strict mode → 1 if ANY model failed; non-strict → 1 only if ALL failed.
+ * @param args Parsed CLI arguments from parseAltOpinionArgs.
+ * @param deps Runner dependencies: model port registry, optional synth port, and file reader.
+ * @throws {Error} When artifact is empty — validation before any model call.
+ * @returns AltOpinionReport with per-model results, exit code, and optional synthesis block.
+ * @sideEffect FS: readFile for --file artifact resolution and prompt file loading.
+ * @sideEffect Network: AI model API calls via injected ports.
+ */
+export declare function runAltOpinion(args: AltOpinionParsedArgs, deps: RunAltOpinionDeps): Promise<AltOpinionReport>;

package/dist/cli/cmd/alt-opinion/alt-opinion.cmd.d.ts

@@ -0,0 +1,34 @@
+import { createOpenAI } from '@ai-sdk/openai';
+import { generateText } from 'ai';
+import type { AltOpinionReport } from './alt-opinion.types.js';
+/** @purpose Injectable dependencies for the alt-opinion CLI command — enables testing without real stdin/fs. */
+export type AltOpinionCmdDeps = {
+    /** @purpose Pre-read stdin content bypassing process.stdin */
+    stdinContent?: string;
+    /**
+     * @purpose Sync file reader override — defaults to readFileSync
+     * @param path File path to read.
+     * @returns File content as string.
+     */
+    readFile?: (path: string) => string;
+    /** @purpose AI SDK generateText override for testing */
+    generateText?: typeof generateText;
+    /** @purpose AI SDK createOpenAI override for testing */
+    createOpenAI?: typeof createOpenAI;
+};
+/**
+ * @purpose CLI entry point for the alt-opinion command.
+ * *
+ * Parses CLI arguments, creates AI SDK providers from environment variables,
+ * builds a Map of AltOpinionModelPort keyed by "provider/model", calls the core runner,
+ * and formats the results to stdout with anchor-wrapped blocks or synthesis output.
+ * *
+ * @param rawArgs Raw CLI arguments (typically process.argv).
+ * @param [deps] Optional injectable dependencies for testing.
+ * @throws {Error} On parsing failures (missing model, unknown provider, empty input).
+ * @returns AltOpinionReport with per-model results, exit code, and optional synthesis block.
+ * @sideEffect FS: readFile for prompt files and --file resolution.
+ * @sideEffect Env: reads LLM_PROXY_API_KEY, LLM_PROXY_BASE_URL, OPENROUTER_API_KEY.
+ * @sideEffect Network: AI model API calls via @ai-sdk/openai.
+ */
+export declare function run(rawArgs: string[], deps?: AltOpinionCmdDeps): Promise<AltOpinionReport>;

package/dist/cli/cmd/alt-opinion/alt-opinion.types.d.ts

@@ -0,0 +1,88 @@
+/** @purpose Supported AI model providers for alt-opinion. */
+export type AltOpinionProvider = 'llmproxy' | 'openrouter';
+/**
+ * @purpose Descriptor of a single AI model for opinion generation.
+ * @invariant `provider` is validated against AltOpinionProvider at parse time.
+ */
+export type AltOpinionModel = {
+    /** @purpose AI provider identifier | @invariant 'llmproxy' or 'openrouter' */
+    provider: AltOpinionProvider;
+    /** @purpose Model name in provider/{model-id} format */
+    model: string;
+    /** @purpose Optional per-model prompt file path (from :: syntax) */
+    promptPath?: string;
+};
+/** @purpose Telemetry data for a model call — wall time, token usage, and finish reason. */
+export type AltOpinionTelemetry = {
+    /** @purpose Wall-clock time elapsed in milliseconds */
+    wallMs: number;
+    /** @purpose Prompt token count from provider response */
+    promptTokens?: number;
+    /** @purpose Completion token count from provider response */
+    completionTokens?: number;
+    /** @purpose Finish reason from provider (e.g. 'stop', 'length') */
+    finishReason?: string;
+};
+/** @purpose Result of a single model call — either success with content or failure with error. */
+export type AltOpinionResult = {
+    model: AltOpinionModel;
+    success: true;
+    content: string;
+    telemetry?: AltOpinionTelemetry;
+} | {
+    model: AltOpinionModel;
+    success: false;
+    error: string;
+    telemetry?: AltOpinionTelemetry;
+};
+/**
+ * @purpose Aggregated report from the alt-opinion runner.
+ * @invariant exitCode is 0 when at least one model succeeded (non-strict) or all succeeded (strict); 1 otherwise.
+ */
+export type AltOpinionReport = {
+    /** @purpose Per-model results in the same order as --model arguments */
+    results: AltOpinionResult[];
+    /** @purpose Exit code: 0 for success, 1 for failure */
+    exitCode: 0 | 1;
+    /** @purpose Synthesized opinion content when --synthModel is used */
+    synthContent?: string;
+    /** @purpose Telemetry for the synthesis model call | @invariant Present only when --synthModel was used */
+    synthTelemetry?: AltOpinionTelemetry;
+};
+/** @purpose Parsed CLI arguments ready for the runner. */
+export type AltOpinionParsedArgs = {
+    /** @purpose Ordered list of models to query */
+    models: AltOpinionModel[];
+    /** @purpose Optional synthesis model */
+    synthModel?: AltOpinionModel;
+    /** @purpose --file argument value */
+    file?: string;
+    /** @purpose Resolved artifact content (from stdin or --file) */
+    artifact?: string;
+    /** @purpose Path to shared model prompt file */
+    modelPromptPath?: string;
+    /** @purpose Path to synthesis prompt file */
+    synthPromptPath?: string;
+    /** @purpose --strict flag: exit 1 on any model error */
+    strict: boolean;
+};
+/**
+ * @purpose DI port for AI model calls — allows mocking in tests without monkey-patching the AI SDK.
+ * @invariant Implementations must resolve with the generated content and optional usage metadata, or reject with a descriptive error.
+ */
+export interface AltOpinionModelPort {
+    /**
+     * @purpose Generate a text response from the AI model for the given prompt.
+     * @param prompt Complete prompt string to send to the model.
+     * @throws {Error} On network failure, timeout, or API error.
+     * @returns Generated text with optional usage and finish reason metadata.
+     */
+    generate(prompt: string): Promise<{
+        content: string;
+        usage?: {
+            promptTokens: number;
+            completionTokens: number;
+        };
+        finishReason?: string;
+    }>;
+}

package/dist/cli/cmd/alt-opinion/index.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/cli/cmd/cat/cat-url.fn.d.ts

@@ -0,0 +1,19 @@
+import type { CatGenResult } from '../../utils/cat-gen/cat-gen.js';
+/** @purpose Result of resolving a VCS URL to cat-gen file list — either successful with files or failed with an error. */
+export type CatUrlResult = {
+    ok: true;
+    files: CatGenResult[];
+} | {
+    ok: false;
+    error: string;
+};
+/**
+ * @purpose Resolve a VCS URL (GitLab MR or GitHub PR) into CatGenResult files for cat output.
+ * @param url VCS URL to parse and resolve.
+ * @param [options] Optional filtering by exclude patterns or file extensions.
+ * @returns CatUrlResult with either fetched files or a user-facing error message.
+ */
+export declare function resolveCatUrl(url: string, options?: {
+    exclude?: string | string[];
+    extensions?: string[];
+}): Promise<CatUrlResult>;

package/dist/cli/cmd/lint/checks/anchor.check.d.ts

@@ -0,0 +1,11 @@
+import type { LintError } from '../lint.types.js';
+/**
+ * @purpose Validates anchor pairing and nesting in TypeScript source per DbC contract.
+ * @invariant Stack-based: START_X pushes; END_X finds matching START_X in stack and reports nesting for any unclosed blocks above the match.
+ * @invariant Bare #region/#endregion without START_/END_ → ERR_CLI_LINT_ANCHOR_MALFORMED. Bare #endregion auto-closes with stack top.
+ * @invariant Pure function — no I/O, no exceptions. Errors returned in ascending line order.
+ * @param content Source text to validate.
+ * @param filePath File path for error messages.
+ * @returns List of lint errors in line order, empty when anchors are correctly paired and nested.
+ */
+export declare function check(content: string, filePath: string): LintError[];

package/dist/cli/cmd/lint/checks/dbc-contract.check.d.ts

@@ -0,0 +1,16 @@
+import type { LintError } from '../lint.types.js';
+/**
+ * @purpose Adapts DbcTsLinter result into the lint pipeline — translates DbcLintError → LintError.
+ * @implements {DbcContractCheck} in specs/cli/lint/lint.spec.md
+ * @invariant When autofix=false, calls lint(); when autofix=true, calls lintAndFix() with disk mutation.
+ * @param content Pre-read source text — avoids redundant fs.read.
+ * @param filePath Path to the source file for error reporting.
+ * @param autofix When true, auto-fixes are applied to the file on disk via DbcTsLinter.
+ * @throws {Error} Wraps unexpected linter failure with cause-chain.
+ * @returns Object with translated LintError[] and autoFixed count.
+ * @sideEffect When autofix=true, mutates the source file on disk through DbcTsLinter.
+ */
+export declare function check(content: string, filePath: string, autofix: boolean): Promise<{
+    errors: LintError[];
+    autoFixed: number;
+}>;

package/dist/cli/cmd/lint/checks/disables.check.d.ts

@@ -0,0 +1,12 @@
+import type { LintError } from '../lint.types.js';
+/**
+ * @purpose Validates that every TypeScript / linter disable marker in source is accompanied by a Decision Log reference (`D-\d+`) in the same comment line.
+ * @implements {DisablesCheck} in specs/cli/lint/lint.spec.md
+ * @invariant Marker is counted ONLY when preceded by `//` or `/*` on the same line — string literals containing marker text are not flagged.
+ * @invariant `D-\d+` is searched anywhere on the same line as the marker; multi-line block comments are NOT extended (MVP simplification — see lint.spec.md DisablesCheck DbC).
+ * @invariant Pure function — no I/O, no exceptions. Errors returned in ascending line order.
+ * @param content Source text to validate.
+ * @param filePath File path for error messages.
+ * @returns List of lint errors in line order; empty when every disable carries a `D-\d+` reference or no disables exist.
+ */
+export declare function check(content: string, filePath: string): LintError[];

package/dist/cli/cmd/lint/checks/file-header.check.d.ts

@@ -0,0 +1,10 @@
+import type { LintError } from '../lint.types.js';
+/**
+ * @purpose Validate presence of // @file: and // @consumers: directives at file top before first import.
+ * @implements {FileHeaderCheck} in specs/cli/lint/lint.spec.md
+ * @invariant Scans only lines before the first import statement; tags after import are ignored.
+ * @param content Raw file content as string.
+ * @param filePath Path to the file for error reporting.
+ * @returns Empty array when both directives are present.
+ */
+export declare function check(content: string, filePath: string): LintError[];

package/dist/cli/cmd/lint/checks/language.check.d.ts

@@ -0,0 +1,11 @@
+import type { LintError } from '../lint.types.js';
+/**
+ * @purpose Validates that JSDoc contracts and file headers use English, not Russian/Cyrillic.
+ * @implements {LanguageCheck} in specs/cli/lint/lint.spec.md
+ * @invariant Scans JSDoc blocks and file header lines (// @file:, // @consumers:).
+ * @invariant Pure function — no I/O, no exceptions.
+ * @param content Source text to validate.
+ * @param filePath File path for error messages.
+ * @returns List of lint errors in ascending line order, empty when no Cyrillic found.
+ */
+export declare function check(content: string, filePath: string): LintError[];

package/dist/cli/cmd/lint/index.d.ts

@@ -0,0 +1 @@
+import './lint.cmd.ts';

package/dist/cli/cmd/lint/lint.cmd.d.ts

@@ -0,0 +1,18 @@
+import { LintReport } from './lint.types.js';
+import type { LintError } from './lint.types.js';
+/**
+ * @purpose Execute the gennady lint command — collect files, run 4 checks, output ESLint-format report.
+ * @implements {LintCommand} in specs/cli/lint/lint.spec.md
+ * @param rawArgs Raw command-line arguments (process.argv).
+ * @returns LintReport with aggregated errors and exit code.
+ */
+export declare function run(rawArgs: string[]): Promise<LintReport>;
+/**
+ * @purpose Resolve user-provided target paths to a flat list of .ts/.tsx files.
+ * @param targets Paths or glob patterns from CLI arguments.
+ * @returns Resolved file list and any resolution errors.
+ */
+export declare function resolveTargets(targets: string[]): {
+    files: string[];
+    errors: LintError[];
+};