/**
 * Mission store — file-backed deep-planning + execution state for serious
 * engineering work.
 *
 * A mission upgrades the plan/checklist flow into a full discovery →
 * baseline → research → strategy → task-graph → critique → worker-loop →
 * final-review pipeline. Everything lives on disk under `<root>/agent/` so
 * stateless worker kois (spawned via sessions_spawn) can read the same
 * artifacts the controller wrote, and the mission survives restarts.
 *
 * The store is deliberately dumb about WHO calls it — all koi-facing
 * enforcement (stage gating, sub-koi lockout, canvas mirroring) lives in
 * mission-tool.ts. This module owns: types, validation (task quality gate,
 * dependency graph), artifact generation, and the worker prompt.
 */
export declare const MISSION_STAGES: readonly ["discovery", "baseline", "research", "strategy", "tasks", "critique", "execution", "final_review", "complete", "abandoned"];
export type MissionStage = (typeof MISSION_STAGES)[number];
export declare const TASK_TYPES: readonly ["research", "repo-analysis", "architecture", "interface-contract", "test-first", "implementation", "migration", "refactor", "integration", "documentation", "validation", "security-review", "performance-review", "accessibility-review", "final-review"];
export type MissionTaskType = (typeof TASK_TYPES)[number];
/** Task types that change code and therefore need files + validation commands. */
export declare const CODE_TOUCHING_TYPES: ReadonlySet<MissionTaskType>;
export declare const TASK_STATUSES: readonly ["pending", "in_progress", "done", "blocked", "removed"];
export type MissionTaskStatus = (typeof TASK_STATUSES)[number];
export interface MissionTask {
    id: string;
    title: string;
    type: MissionTaskType;
    goal: string;
    why?: string;
    dependsOn: string[];
    research: {
        required: boolean;
        instructions?: string;
    };
    likelyFiles: string[];
    forbiddenPaths: string[];
    outOfScope?: string;
    instructions: string[];
    acceptanceCriteria: string[];
    validationCommands: string[];
    docs: {
        required: boolean;
        files?: string[];
    };
    status: MissionTaskStatus;
    attempts: number;
    blockReason?: string;
    completedAt?: string;
}
export interface BaselineCheck {
    area: string;
    command?: string;
    status: "pass" | "fail" | "skipped" | "unknown";
    note?: string;
}
export interface ResearchFinding {
    topic: string;
    source: string;
    url?: string;
    version?: string;
    summary: string;
    implication: string;
    affectedTasks?: string[];
}
export interface MissionRisk {
    title: string;
    severity: "low" | "medium" | "high";
    mitigation: string;
    relatedTasks?: string[];
}
export interface ValidationMatrixRow {
    area: string;
    validates: string;
    command: string;
    requiredBeforeFinal: boolean;
}
export interface InterfaceContract {
    name: string;
    definition: string;
    notes?: string;
}
export interface MissionAmendment {
    id: string;
    taskId?: string;
    issue: string;
    evidence: string;
    proposedChange: string;
    affectedTasks: string[];
    urgency: "blocking" | "high" | "low";
    at: string;
}
export interface TaskValidationResult {
    command: string;
    outcome: "pass" | "fail";
    /** Set when a failure is a documented pre-existing baseline failure. */
    acceptedAsBaseline?: boolean;
    notes?: string;
}
export interface MissionState {
    version: 1;
    title: string;
    request: string;
    stage: MissionStage;
    createdAt: string;
    updatedAt: string;
    root: string;
    researchFindings: number;
    researchSkipped?: string;
    baseline?: {
        commands: Record<string, string>;
        checks: BaselineCheck[];
        preexistingFailures: string[];
        environmentNotes?: string[];
        workerRules: string[];
    };
    validationMatrix: ValidationMatrixRow[];
    critique?: {
        verdict: "approve" | "revise";
        rounds: number;
    };
    tasks: MissionTask[];
    amendments: MissionAmendment[];
    taskSeq: number;
}
export declare const MISSION_DIRNAME = "agent";
export declare function missionDir(root: string): string;
export declare function missionStatePath(root: string): string;
export declare function taskPacketPath(root: string, taskId: string): string;
export declare function taskNotesPath(root: string, taskId: string): string;
export declare function saveMission(state: MissionState): void;
export declare function loadMission(root: string): MissionState | null;
export declare function initMission(root: string, opts: {
    title: string;
    request: string;
}): MissionState;
export declare function writeDiscoveryArtifacts(state: MissionState, input: {
    codebaseBriefMd: string;
    architectureMapMd: string;
    dependencyMapMd?: string;
    inspected: Array<{
        path: string;
        finding: string;
    }>;
    knownRisks: Array<{
        area: string;
        reason: string;
    }>;
}): void;
export declare function writeBaselineArtifact(state: MissionState, baseline: NonNullable<MissionState["baseline"]>): void;
export declare function appendResearchFindings(state: MissionState, findings: ResearchFinding[]): void;
export declare function writeStrategyArtifacts(state: MissionState, input: {
    strategyMd: string;
    contracts?: InterfaceContract[];
    risks: MissionRisk[];
    validationMatrix: ValidationMatrixRow[];
    projectAcceptance: string[];
    featureAcceptance?: string[];
    documentationPlanMd?: string;
    migrationPlanMd?: string;
    rollbackPlanMd?: string;
    featureFlagsMd?: string;
}): void;
export declare function appendDecision(state: MissionState, decision: string, why: string): void;
export declare function appendAmendment(state: MissionState, amendment: MissionAmendment): void;
export declare function writeCritiqueArtifact(state: MissionState, input: {
    verdict: "approve" | "revise";
    criticNotes: string;
    findings: string[];
}): void;
export declare function appendCompletionLog(state: MissionState, input: {
    taskId: string;
    changedFiles: string[];
    whatChanged: string;
    validation: TaskValidationResult[];
    notesForFutureWorkers?: string;
}): void;
export declare function writeFinalArtifacts(state: MissionState, input: {
    reviewMd: string;
    validation: TaskValidationResult[];
    summaryMd: string;
}): void;
export interface TaskInput {
    title?: string;
    type?: string;
    goal?: string;
    why?: string;
    dependsOn?: string[];
    researchRequired?: boolean;
    researchInstructions?: string;
    likelyFiles?: string[];
    forbiddenPaths?: string[];
    outOfScope?: string;
    instructions?: string[];
    acceptanceCriteria?: string[];
    validationCommands?: string[];
    docsRequired?: boolean;
    docsFiles?: string[];
}
/**
 * The task quality gate (spec §22): a task is not allowed into the
 * checklist unless it has a clear goal, scope, boundaries, dependencies,
 * acceptance criteria, validation commands, and a research policy.
 * Returns the list of problems; empty means the task passes.
 */
export declare function taskQualityProblems(input: TaskInput, ordinal: number): string[];
export declare function normalizeTask(input: TaskInput, id: string): MissionTask;
/**
 * Validate the whole task set: unknown deps, cycles, missing validation task.
 * `knownIds` lets callers whitelist ids that exist but aren't in `tasks`
 * (e.g. tasks removed by an amendment — dependents treat them as satisfied).
 */
export declare function taskGraphProblems(tasks: MissionTask[], knownIds?: Set<string>): string[];
/** Advisory (non-blocking) warnings about the task set's shape. */
export declare function taskSetWarnings(tasks: MissionTask[]): string[];
export declare function nextTaskId(state: MissionState): string;
/** Next runnable task: pending, all dependencies done, lowest id first. */
export declare function pickNextTask(state: MissionState): MissionTask | null;
export declare function missionSummary(state: MissionState): {
    title: string;
    stage: "strategy" | "discovery" | "baseline" | "research" | "tasks" | "critique" | "execution" | "final_review" | "complete" | "abandoned";
    dir: string;
    tasks: {
        total: number;
        done: number;
        inProgress: string[];
        blocked: string[];
        pending: number;
    };
    researchFindings: number;
    amendments: number;
    critique: {
        verdict: "approve" | "revise";
        rounds: number;
    } | undefined;
};
/**
 * The default coding-workflow surface for a mission: checklist left, current
 * task packet center, completion log right, agent changelog bottom. Published
 * to the session's surface canvas doc when execution starts and re-pointed at
 * each task hand-off; the TUI mounts/updates it live. The planner may replace
 * it with a workflow-shaped one via the `surface` tool.
 */
export declare function buildMissionSurface(state: MissionState, currentTaskId?: string): Record<string, unknown>;
export declare function writeTuiPlan(state: MissionState): void;
export declare function renderTaskPacket(state: MissionState, task: MissionTask): string;
export declare function writeTaskPacket(state: MissionState, task: MissionTask): void;
/**
 * The full briefing handed to a stateless worker sub-koi (via
 * sessions_spawn). The worker gets ONE task, strict authority boundaries,
 * and a completion protocol; the controller reviews and marks completion.
 */
export declare function buildWorkerPrompt(state: MissionState, task: MissionTask): string;