@ornexus/neocortex 4.60.16

package/packages/client/dist/commands/invoke.d.ts

@@ -0,0 +1,546 @@
+/**
+ * @license FSL-1.1
+ * Copyright (c) 2026 OrNexus AI
+ *
+ * This file is part of Neocortex CLI, licensed under the
+ * Functional Source License, Version 1.1 (FSL-1.1).
+ *
+ * Change Date: February 20, 2029
+ * Change License: MIT
+ *
+ * See the LICENSE file in the project root for full license text.
+ */
+import type { YoloopPersistedState } from '../yoloop/shared-yoloop-types.js';
+import { type RunnerBootstrapPolicyDecision } from '../continuity/runner-bootstrap-policy.js';
+import { type RunnerSchedulerBootstrapOptions, type RunnerSchedulerBootstrapResult } from '../runner/scheduler.js';
+import { type ContinuityProcessingSummaryCursorTarget } from '../continuity/continuity-client-state-store.js';
+export declare const INVOKE_PAYLOAD_LIMIT_BYTES: number;
+export declare const INVOKE_PAYLOAD_WARNING_THRESHOLD_BYTES: number;
+interface InitProjectMemoryBootstrapSnapshot {
+    readonly canonical: {
+        readonly path: 'NEOCORTEX.md';
+        readonly exists: boolean;
+        readonly incompleteReasons: readonly string[];
+        readonly confidence: 'high' | 'medium' | 'low';
+    };
+    readonly permittedSources: {
+        readonly packageBuildFiles: number;
+        readonly architectureReadmeDocs: number;
+        readonly runtimeConfigTemplates: number;
+        readonly platformWrappers: number;
+    };
+    readonly wrapperFiles: readonly string[];
+    readonly recommendedPreviewCommand: string;
+    readonly recommendedRefreshCommand: string;
+    readonly guardrails: readonly string[];
+}
+export declare function isInitTrigger(args: string): boolean;
+export declare function collectInitProjectMemoryBootstrapSnapshot(projectRoot: string): InitProjectMemoryBootstrapSnapshot;
+export interface InvokeOptions {
+    /** Raw args from the user (e.g., "*yolo @docs/stories/1.1.story.md") */
+    readonly args: string;
+    /** Project root directory (default: cwd; Git repository not required) */
+    readonly projectRoot?: string;
+    /** Output format: 'json' for full response, 'plain' for instructions only */
+    readonly format?: 'json' | 'plain';
+    /** Server URL override */
+    readonly serverUrl?: string;
+    /** Platform target (default: 'claude-code') */
+    readonly platformTarget?: string;
+    /** CLI input source, used to decide when stdin/args-file need chunk transport. */
+    readonly inputSource?: InvokeCliInputSource;
+    /** Foreground local continuity watcher requested by CLI `--watch`. */
+    readonly watch?: boolean;
+    /** Test/integration seam for runner auto-bootstrap; CLI callers leave unset. */
+    readonly runnerBootstrapper?: InvokeRunnerSchedulerBootstrapper;
+    /** Test/integration seam for recursion guard env; CLI callers leave unset. */
+    readonly environment?: NodeJS.ProcessEnv;
+}
+/**
+ * Normalize the project root received from wrappers/CLI flags.
+ *
+ * Generated platform wrappers historically used
+ * `$(git rev-parse --show-toplevel)`. In a legitimate non-Git workspace that
+ * command expands to an empty string, which then reached the server as
+ * `projectRoot: ""` and was rejected by request validation before orchestration
+ * could run. Treat a missing/blank value as the current working directory so
+ * projects that intentionally do not have a Git repository can still invoke
+ * Neocortex commands.
+ */
+export declare function resolveInvokeProjectRoot(projectRoot: string | undefined, fallbackRoot?: string): string;
+export interface InvokeResult {
+    readonly success: boolean;
+    readonly instructions?: string;
+    readonly metadata?: Record<string, unknown>;
+    readonly error?: string;
+    readonly errorCode?: string;
+    readonly exitCode: number;
+}
+type InvokeWatchFormat = 'plain' | 'json';
+interface InvokeWatchWritable {
+    write(chunk: string): unknown;
+}
+export interface InvokeWatchOptions {
+    readonly projectRoot: string;
+    readonly format: InvokeWatchFormat;
+    readonly stdout?: InvokeWatchWritable;
+    readonly signal?: AbortSignal;
+    readonly target?: ContinuityProcessingSummaryCursorTarget;
+    readonly targetJobId?: string;
+    readonly serverHeldStream?: false;
+    readonly initialCursor?: string;
+    readonly limit?: number;
+    readonly pollIntervalMs?: number;
+    readonly maxIdlePolls?: number;
+    readonly maxPolls?: number;
+    readonly sleep?: (ms: number, signal?: AbortSignal) => Promise<void>;
+}
+type InvokeWatchTargetResolutionState = 'inactive' | 'pending' | 'resolved' | 'unresolved' | 'malformed' | 'ambiguous' | 'multiple' | 'unsafe' | 'unavailable';
+type InvokeWatchSnapshotStatus = 'not_requested' | 'pending' | 'available' | 'empty' | 'unavailable' | 'unsafe';
+type InvokeWatchCursorState = 'not_started' | 'unchanged' | 'advanced' | 'exhausted' | 'unavailable';
+type InvokeWatchLifecycleStatus = 'inactive' | 'active' | 'polling' | 'waiting' | 'stopped' | 'blocked';
+type InvokeWatchStopReason = 'not_stopped' | 'idle_limit_reached' | 'max_polls_reached' | 'target_unresolved' | 'cancelled' | 'error' | 'unsafe_evidence' | 'unavailable_evidence';
+interface InvokeWatchTargetEvidence {
+    readonly schemaVersion: 1;
+    readonly contractVersion: 'continuity-v1';
+    readonly targetResolutionState: InvokeWatchTargetResolutionState;
+    readonly targetKind?: ContinuityProcessingSummaryCursorTarget['selectorKind'];
+    readonly targetId?: string;
+    readonly targetJobId?: string;
+    readonly jobId?: string;
+    readonly goalId?: string;
+    readonly loopId?: string;
+    readonly relatedJobIds?: readonly string[];
+    readonly relatedJobCount?: number;
+    readonly reasonCodes: readonly string[];
+    readonly publicSafe: true;
+}
+interface InvokeWatchSnapshotEvidence {
+    readonly schemaVersion: 1;
+    readonly contractVersion: 'continuity-v1';
+    readonly snapshotStatus: InvokeWatchSnapshotStatus;
+    readonly generatedAt?: string;
+    readonly renderedSummaryCount?: number;
+    readonly latestEventId?: string;
+    readonly reasonCodes: readonly string[];
+    readonly publicSafe: true;
+}
+interface InvokeWatchCursorEvidence {
+    readonly schemaVersion: 1;
+    readonly contractVersion: 'continuity-v1';
+    readonly cursorState: InvokeWatchCursorState;
+    readonly initialCursor?: string;
+    readonly currentCursor?: string;
+    readonly nextCursor?: string;
+    readonly cursorAdvanced?: boolean;
+    readonly eventId?: string;
+    readonly reasonCodes: readonly string[];
+    readonly publicSafe: true;
+}
+export interface InvokeWatchStatusRecord {
+    readonly type: 'watch_status';
+    readonly schemaVersion: 1;
+    readonly contractVersion: 'continuity-v1';
+    readonly recordType: 'watch_status';
+    readonly command: 'invoke';
+    readonly operation: 'watch';
+    readonly watchStatus: InvokeWatchLifecycleStatus;
+    readonly active: boolean;
+    readonly targetResolutionState?: InvokeWatchTargetResolutionState;
+    readonly targetKind?: ContinuityProcessingSummaryCursorTarget['selectorKind'];
+    readonly targetId?: string;
+    readonly targetEvidence?: InvokeWatchTargetEvidence;
+    readonly snapshotEvidence?: InvokeWatchSnapshotEvidence;
+    readonly cursorEvidence?: InvokeWatchCursorEvidence;
+    readonly stopReason?: InvokeWatchStopReason;
+    readonly reasonCodes: readonly string[];
+    readonly generatedAt: string;
+    readonly publicSafe: true;
+}
+export interface InvokeWatchResult {
+    readonly status: 'completed' | 'cancelled' | 'idle-timeout' | 'max-polls' | 'store-unavailable' | 'target-unresolved';
+    readonly summariesEmitted: number;
+    readonly polls: number;
+    readonly reasonCodes: readonly string[];
+    readonly watchStatus?: InvokeWatchLifecycleStatus;
+    readonly stopReason?: InvokeWatchStopReason;
+    readonly targetEvidence?: InvokeWatchTargetEvidence;
+    readonly snapshotEvidence?: InvokeWatchSnapshotEvidence;
+    readonly cursorEvidence?: InvokeWatchCursorEvidence;
+    readonly statusRecord?: InvokeWatchStatusRecord;
+    readonly metadata?: Record<string, unknown>;
+    readonly publicSafe: true;
+}
+type InvokeWatchTargetSource = 'watcher-metadata' | 'goal-loop-continuity-metadata' | 'continuity-state-update-operation-log' | 'explicit-args';
+interface InvokeWatchTarget {
+    readonly target?: ContinuityProcessingSummaryCursorTarget;
+    readonly targetJobId?: string;
+    readonly initialCursor?: string;
+    readonly source?: InvokeWatchTargetSource;
+    readonly serverHeldStream?: false;
+    readonly disabled?: boolean;
+    readonly reasonCodes?: readonly string[];
+}
+export interface InvokeRunnerBootstrapMetadata {
+    readonly schemaVersion: 1;
+    readonly action: RunnerBootstrapPolicyDecision['action'];
+    readonly failurePolicy: RunnerBootstrapPolicyDecision['failurePolicy'];
+    readonly command: RunnerBootstrapPolicyDecision['command'];
+    readonly operation: RunnerBootstrapPolicyDecision['operation'];
+    readonly attempted: boolean;
+    readonly ok: boolean;
+    readonly cached: boolean;
+    readonly installed: boolean;
+    readonly started: boolean;
+    readonly projectKey?: string;
+    readonly reasonCodes: readonly string[];
+    readonly publicSummary: string;
+    readonly failOpenWarning?: boolean;
+    readonly publicSafe: true;
+}
+export interface InvokeRunnerAutoBootstrapResult {
+    readonly shouldContinue: boolean;
+    readonly attachToRequest: boolean;
+    readonly metadata: InvokeRunnerBootstrapMetadata;
+    readonly warning?: string;
+    readonly error?: string;
+    readonly errorCode?: string;
+    readonly exitCode?: number;
+}
+export type InvokeRunnerSchedulerBootstrapper = (options: RunnerSchedulerBootstrapOptions) => Promise<RunnerSchedulerBootstrapResult>;
+export interface InvokeRunnerAutoBootstrapOptions {
+    readonly args: string;
+    readonly projectRoot: string;
+    readonly platformTarget: string;
+    readonly environment?: NodeJS.ProcessEnv;
+    readonly bootstrapper?: InvokeRunnerSchedulerBootstrapper;
+}
+export declare function sanitizeInvokeCliOutput(instructions: string | undefined, metadata: Record<string, unknown> | undefined): {
+    instructions: string;
+    metadata: Record<string, unknown> | undefined;
+};
+type InvokeCliInputSource = 'args' | 'stdin' | 'args-file';
+export interface InvokeCliParsedOptions {
+    readonly args: string;
+    readonly inputSource: InvokeCliInputSource;
+    readonly projectRoot?: string;
+    readonly format: 'json' | 'plain';
+    readonly watch: boolean;
+    readonly commandLevelWatch?: InvokeCommandLevelWatchMetadata;
+    readonly serverUrl?: string;
+}
+type InvokeCommandLevelWatchCommand = 'goal' | 'loop' | 'jobs';
+type InvokeCommandLevelWatchOperation = 'create' | 'start' | 'resume' | 'run-once' | 'watch';
+interface InvokeCommandLevelWatchTokenSpan {
+    readonly literal: '--watch';
+    readonly position: 'final';
+    readonly start: number;
+    readonly end: number;
+    readonly quoted: false;
+    readonly publicSafe: true;
+}
+export interface InvokeCommandLevelWatchMetadata {
+    readonly schemaVersion: 1;
+    readonly contractVersion: 'continuity-v1';
+    readonly command?: InvokeCommandLevelWatchCommand;
+    readonly operation?: InvokeCommandLevelWatchOperation;
+    readonly active: boolean;
+    readonly watchToken?: InvokeCommandLevelWatchTokenSpan;
+    readonly reasonCodes: readonly string[];
+    readonly serverHeldStream: false;
+    readonly allJobsPolling: false;
+    readonly targetResolution: 'required-after-dispatch' | 'inactive';
+    readonly publicSafe: true;
+}
+export interface InvokeCommandLevelWatchResolution {
+    readonly args: string;
+    readonly watch: boolean;
+    readonly reasonCodes: readonly string[];
+    readonly metadata: InvokeCommandLevelWatchMetadata;
+    readonly publicSafe: true;
+}
+export interface InvokeCliInputReaders {
+    readonly readStdin?: () => string;
+    readonly readArgsFile?: (filePath: string) => string;
+}
+export declare class InvokeCliInputError extends Error {
+    readonly code: string;
+    constructor(code: string, message: string);
+}
+export type StateSnapshotScopeKind = 'full' | 'projected';
+export type StateSnapshotCommandPolicy = 'full' | 'story-targeted' | 'epic-targeted' | 'yoloop-targeted' | 'epic-summary' | 'continuity-scoped' | 'adaptive-targeted' | (string & {});
+export type StateSnapshotProjectionMode = 'full-compatible' | 'summary-only' | 'targeted-story' | 'targeted-epic' | 'structural-required' | (string & {});
+export type StateSnapshotProjectionReason = 'full-state' | 'targeted-invocation' | 'summary-only' | 'epic-summary' | 'body-size' | 'context-cost' | 'unknown' | (string & {});
+interface StateSnapshotScopeBase {
+    readonly kind: StateSnapshotScopeKind;
+    readonly commandId?: string | null;
+    readonly stateProjectionPolicy?: StateSnapshotCommandPolicy | null;
+    readonly projectionMode?: StateSnapshotProjectionMode;
+    readonly trigger?: string;
+    readonly targetEpicId?: string | null;
+    readonly targetStoryId?: string | null;
+    readonly includedStoryCount: number;
+    readonly includedEpicCount?: number;
+    readonly omittedStoryCount: number;
+    readonly omittedEpicCount: number;
+    readonly reason: StateSnapshotProjectionReason;
+    readonly reasonCodes?: readonly string[];
+}
+export interface FullStateSnapshotScope extends StateSnapshotScopeBase {
+    readonly kind: 'full';
+    readonly omittedStoryCount: 0;
+    readonly omittedEpicCount: 0;
+    readonly reason: 'full-state';
+}
+export interface ProjectedStateSnapshotScope extends StateSnapshotScopeBase {
+    readonly kind: 'projected';
+}
+export type StateSnapshotScope = FullStateSnapshotScope | ProjectedStateSnapshotScope;
+export interface StateSnapshotCurrentSession {
+    readonly active_epic_id?: string | null;
+    readonly active_story_id?: string | null;
+    readonly active_step_id?: string | null;
+    readonly session_id?: string | null;
+    readonly started_at?: string | null;
+}
+export interface StateSummaryRecentStoryRef {
+    readonly id: string;
+    readonly epicId?: string;
+    readonly status?: string;
+    readonly lastStep?: string;
+    readonly lastUpdated?: string;
+}
+export interface StateSummarySessionRef {
+    readonly activeEpicId?: string | null;
+    readonly activeStoryId?: string | null;
+    readonly activeStepId?: string | null;
+    readonly sessionId?: string | null;
+    readonly startedAt?: string | null;
+}
+export interface StateSummaryYoloopRef {
+    readonly active?: boolean;
+    readonly currentEpicId?: string | null;
+    readonly currentStoryId?: string | null;
+    readonly sessionId?: string | null;
+    readonly lockEpicId?: string | null;
+}
+export interface StateSummaryContinuityRef {
+    readonly present: boolean;
+    readonly activeJobId?: string | null;
+    readonly activeGoalId?: string | null;
+    readonly activeLoopId?: string | null;
+    readonly reasonCodes?: readonly string[];
+}
+export interface StateSummaryProjectionRef {
+    readonly commandId?: string | null;
+    readonly stateProjectionPolicy?: StateSnapshotCommandPolicy | null;
+    readonly projectionMode?: StateSnapshotProjectionMode;
+    readonly scopeKind: StateSnapshotScopeKind;
+    readonly includedStoryCount: number;
+    readonly includedEpicCount: number;
+    readonly omittedStoryCount: number;
+    readonly omittedEpicCount: number;
+    readonly reason: StateSnapshotProjectionReason;
+}
+export interface StateSummary {
+    readonly schemaVersion: 1;
+    readonly totals: {
+        readonly stories: number;
+        readonly epics: number;
+        readonly storyStatus: Readonly<Record<string, number>>;
+        readonly epicStatus: Readonly<Record<string, number>>;
+        readonly blockedStories: number;
+    };
+    readonly active: {
+        readonly epicId: string | null;
+        readonly storyId: string | null;
+        readonly stepId: string | null;
+    };
+    readonly blockedCount: number;
+    readonly recentStories: readonly StateSummaryRecentStoryRef[];
+    readonly currentSession?: StateSummarySessionRef;
+    readonly currentYoloopSession?: StateSummaryYoloopRef;
+    readonly currentContinuitySession?: StateSummaryContinuityRef;
+    readonly projection: StateSummaryProjectionRef;
+    readonly reasonCodes: readonly string[];
+    readonly publicSafe: true;
+}
+export interface StateSnapshot {
+    readonly schema_version?: number;
+    readonly config: {
+        readonly project_name: string;
+        readonly default_branch: string;
+        readonly language: string;
+        readonly yolo_mode?: boolean;
+        readonly user_name?: string;
+        readonly worktree_base?: string;
+        readonly max_parallel_stories?: number;
+    };
+    readonly stories: Record<string, Record<string, unknown>>;
+    readonly epics: Record<string, Record<string, unknown>>;
+    readonly current_session?: StateSnapshotCurrentSession;
+    /**
+     * P141.01 -- request-only scope metadata. Never persisted to state.json.
+     * `projected` snapshots mean omitted entries are unknown/out-of-scope for
+     * this request, not nonexistent.
+     */
+    readonly scope?: StateSnapshotScope;
+    /**
+     * P198.03 -- bounded public-safe state affordance attached to request-only
+     * invoke snapshots. Never persisted to `.neocortex/state.json`.
+     */
+    readonly stateSummary?: StateSummary;
+    /**
+     * Epic P101.03 -- yoloop client-side persisted state echoed on each invoke
+     * so the server can treat yoloop as a pure function over client state.
+     * Optional during the P101 rollout; once MIN_CLIENT_VERSION bumps (P101.11),
+     * yoloop invocations without this field will receive CLIENT_UPGRADE_REQUIRED.
+     */
+    readonly yoloop?: YoloopPersistedState;
+    /**
+     * P180.05 -- optional client-owned Enterprise continuity snapshot.
+     * Compact/public-safe only; omitted when the SQLite store is absent or an
+     * adapter is unavailable for non-continuity commands.
+     */
+    readonly continuity?: unknown;
+    /**
+     * P158.06 -- optional client-side deterministic graph retrieval enrichment.
+     * This is request-only metadata for server validation/consumption; it never
+     * decides workflow locally and is omitted when disabled or unavailable.
+     */
+    readonly graphRetrieval?: unknown;
+    /**
+     * P181.04 -- request-only runner auto-bootstrap summary. Public-safe only;
+     * never persisted to `.neocortex/state.json` and omitted for unrelated
+     * non-continuity commands.
+     */
+    readonly runnerBootstrap?: InvokeRunnerBootstrapMetadata;
+}
+export interface InvokeArgsRef {
+    readonly manifestId: string;
+    readonly sha256?: string;
+    readonly byteLength?: number;
+    readonly chunkCount?: number;
+    readonly expiresAt?: string;
+}
+interface InvokeRequestBodyBase {
+    readonly projectRoot: string;
+    readonly stateSnapshot: StateSnapshot;
+    readonly platformTarget?: string;
+}
+export type InvokeRequestBody = InvokeRequestBodyBase & ({
+    readonly args: string;
+    readonly argsRef?: never;
+} | {
+    readonly args?: never;
+    readonly argsRef: InvokeArgsRef;
+});
+export interface InvokePayloadTelemetry {
+    readonly schemaVersion: 1;
+    readonly payloadBytes: number;
+    readonly limitBytes: number;
+    readonly warningThresholdBytes: number;
+    readonly scope: {
+        readonly kind: StateSnapshotScopeKind;
+        readonly projectionMode?: StateSnapshotProjectionMode;
+        readonly commandId?: string | null;
+        readonly stateProjectionPolicy?: StateSnapshotCommandPolicy | null;
+    };
+    readonly includedStories: number;
+    readonly omittedStories: number;
+    readonly includedEpics: number;
+    readonly omittedEpics: number;
+    readonly graphRetrieval: {
+        readonly accepted: boolean;
+        readonly itemCount: number;
+    };
+    readonly reasonCodes: readonly string[];
+    readonly publicSafe: true;
+}
+export interface InvokePayloadGuardrailResult {
+    readonly body: InvokeRequestBody;
+    readonly telemetry: InvokePayloadTelemetry;
+    readonly degraded: boolean;
+}
+export declare class InvokePayloadTooLargeError extends Error {
+    readonly code = "PAYLOAD_TOO_LARGE";
+    readonly telemetry: InvokePayloadTelemetry;
+    constructor(telemetry: InvokePayloadTelemetry);
+}
+/**
+ * P103.02: Describe a schema-drift issue detected in a user's state.json.
+ * Codes map to concrete misalignments against the canonical v1 schema
+ * documented in docs/arquitetura-software/STATE-JSON-SCHEMA.md.
+ */
+export interface SchemaDriftIssue {
+    readonly code: 'PLANNING_LEGACY' | 'STORIES_AS_ARRAY' | 'EPIC_STORIES_NOT_ARRAY' | 'SCHEMA_VERSION_MISSING' | 'SCHEMA_VERSION_OUTDATED';
+    readonly message: string;
+}
+/**
+ * P103.02: Detect legacy/malformed shapes that cause the orchestrator to
+ * silently treat the workspace as empty. Pure function — does NOT emit
+ * warnings, does NOT throw. Returns empty array when the shape looks v1-OK
+ * or when state has no data (new project).
+ */
+export declare function detectStateSchemaDrift(stateData: unknown): SchemaDriftIssue[];
+/**
+ * P103.02 test utility: reset the one-time flag between test cases.
+ * Exported for tests only; not part of the public API.
+ */
+export declare function __resetSchemaDriftWarnedForTests(): void;
+/**
+ * Read state.json and construct a sanitized snapshot for the server.
+ * Relative paths only - no absolute paths sent to server.
+ */
+export declare function collectStateSnapshot(projectRoot: string): StateSnapshot;
+export declare function createFullStateSnapshotScope(trigger: string, snapshot: Pick<StateSnapshot, 'stories' | 'epics'>): FullStateSnapshotScope;
+export declare function computeInvokeRequestBodySizeBytes(body: InvokeRequestBody): number;
+export declare function createInvokePayloadTelemetry(body: InvokeRequestBody, payloadBytes?: number, reasonCodes?: readonly string[], options?: {
+    readonly limitBytes?: number;
+    readonly warningThresholdBytes?: number;
+}): InvokePayloadTelemetry;
+export declare function guardInvokeRequestBodySize(body: InvokeRequestBody, options?: {
+    readonly limitBytes?: number;
+    readonly warningThresholdBytes?: number;
+}): InvokePayloadGuardrailResult;
+export declare function maybeEmitInvokePayloadSizeWarning(body: InvokeRequestBody): number;
+export declare function maybeRunInvokeRunnerAutoBootstrap(options: InvokeRunnerAutoBootstrapOptions): Promise<InvokeRunnerAutoBootstrapResult>;
+export declare function watchContinuityProcessingSummaries(options: InvokeWatchOptions): Promise<InvokeWatchResult>;
+export declare function resolveInvokeCommandLevelWatch(args: string): InvokeCommandLevelWatchResolution;
+export declare function resolveInvokeWatchTarget(metadata: Record<string, unknown> | undefined, args: string): InvokeWatchTarget;
+/**
+ * Execute the invoke command.
+ *
+ * Flow:
+ * 1. Load config to get server URL
+ * 2. Collect state snapshot from project root
+ * 3. Check menu cache for empty invocations
+ * 4. Send POST /api/v1/invoke
+ * 5. Format and return result
+ */
+export declare function invoke(options: InvokeOptions): Promise<InvokeResult>;
+/**
+ * Extract the canonical trigger for client-side pre-flight checks.
+ * Mirrors server tolerant parsing only for explicit first-token command forms:
+ * `*yolo`, `yolo`, `22`, and registered aliases. It deliberately does not
+ * infer commands from free text or paths, so uncertain server-side inference
+ * remains fail-open and cannot block local invocation.
+ */
+export declare function extractPreFlightTrigger(args: string): string | null;
+export declare const INVOKE_HELP_TEXT: string;
+export declare function parseInvokeCliOptions(argv: string[], readers?: InvokeCliInputReaders): InvokeCliParsedOptions;
+export declare function writeInvokeCliSuccessOutput(result: InvokeResult, parsed: Pick<InvokeCliParsedOptions, 'format' | 'watch' | 'commandLevelWatch'>, stdout?: InvokeWatchWritable, stderr?: InvokeWatchWritable): void;
+/**
+ * CLI handler for the invoke command.
+ * Parses CLI args and delegates to invoke().
+ *
+ * Usage:
+ *   neocortex-client invoke --args "*yolo @story.md" --project-root /path
+ *   neocortex-client invoke --args "*status" --format json
+ *   neocortex-client invoke --args "*jobs watch @goal-G001 --watch" --format json
+ *   neocortex-client invoke --args "*jobs watch @loop-L001" --watch
+ *   neocortex-client invoke --stdin < synthetic.story.md
+ *   neocortex-client invoke --args-file ./synthetic.story.md
+ */
+export declare function invokeCliHandler(argv: string[]): Promise<number>;
+export {};