@specatlas/core 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,1656 @@
+import { z } from 'zod';
+export { defaultTokens, renderDocument, renderStyles } from '@specatlas/render';
+
+declare const CORE_VERSION = "0.0.1";
+
+type Severity = 'error' | 'warning' | 'info';
+interface Diagnostic {
+    code: string;
+    severity: Severity;
+    message: string;
+    path?: string;
+    line?: number;
+    suggestion?: string;
+}
+declare function diag(code: string, severity: Severity, message: string, opts?: {
+    path?: string;
+    line?: number;
+    suggestion?: string;
+}): Diagnostic;
+declare function countBySeverity(diags: readonly Diagnostic[]): {
+    errors: number;
+    warnings: number;
+    infos: number;
+};
+declare function hasErrors(diags: readonly Diagnostic[]): boolean;
+
+type Lane = 'fix' | 'standard' | 'full';
+type RiskLevel = 'low' | 'medium' | 'high';
+type Domain = 'frontend' | 'backend' | 'database' | 'mobile' | 'reports' | 'testing' | 'infra' | 'fullstack' | 'other';
+type Language = 'es' | 'en';
+declare const REQ_ID_RE: RegExp;
+declare const SCENARIO_ID_RE: RegExp;
+declare const RULE_ID_RE: RegExp;
+declare const TASK_ID_RE: RegExp;
+interface Rule {
+    id: string;
+    text: string;
+    line: number;
+}
+interface Scenario {
+    id: string;
+    title: string;
+    reqId: string;
+    when: string[];
+    then: string[];
+    line: number;
+}
+interface Requirement {
+    id: string;
+    title: string;
+    prose: string;
+    rules: Rule[];
+    scenarios: Scenario[];
+    line: number;
+}
+interface SpecFile {
+    path: string;
+    frontmatter: Record<string, unknown>;
+    domain?: string;
+    title?: string;
+    version?: number;
+    requirements: Requirement[];
+    diagnostics: Diagnostic[];
+}
+type DeltaOp = 'added' | 'modified' | 'removed' | 'renamed';
+interface Rename {
+    from: {
+        id: string;
+        title: string;
+    };
+    to: {
+        id: string;
+        title: string;
+    };
+    line: number;
+}
+interface Delta {
+    path: string;
+    added: Requirement[];
+    modified: Requirement[];
+    removed: Requirement[];
+    renamed: Rename[];
+    sectionsFound: DeltaOp[];
+    diagnostics: Diagnostic[];
+}
+interface Task {
+    id: string;
+    block: string;
+    text: string;
+    done: boolean;
+    files: string[];
+    covers: string[];
+    dependsOn: string[];
+    rollback?: string;
+    infra: boolean;
+    line: number;
+}
+interface TaskBlock {
+    id: string;
+    title: string;
+    line: number;
+    tasks: Task[];
+}
+interface TasksFile {
+    path: string;
+    blocks: TaskBlock[];
+    diagnostics: Diagnostic[];
+    counts: {
+        done: number;
+        total: number;
+    };
+}
+type EvidenceMethod = 'executable' | 'automatic' | 'semi' | 'manual';
+type EvidenceResult = 'pass' | 'fail' | 'skipped';
+interface Evidence {
+    scenario: string;
+    method: EvidenceMethod;
+    command?: string;
+    result: EvidenceResult;
+    outputHash?: string;
+    date: string;
+    by: string;
+    notes?: string;
+    line: number;
+}
+interface VerifyFile {
+    path: string;
+    evidence: Evidence[];
+    diagnostics: Diagnostic[];
+}
+interface Override {
+    gate: string;
+    reason: string;
+    by: string;
+    at: string;
+}
+interface ChangeMeta {
+    schemaVersion: number;
+    slug: string;
+    title?: string;
+    domain?: string;
+    lane: Lane;
+    risk?: RiskLevel;
+    created?: string;
+    owner?: string;
+    tracker?: {
+        provider: string;
+        id: string;
+        url?: string;
+    };
+    paused?: {
+        reason: string;
+        at: string;
+        by: string;
+    };
+    laneHistory?: Array<{
+        from: Lane;
+        to: Lane;
+        at: string;
+        by: string;
+    }>;
+    diagramExceptions?: string[];
+    overrides?: Override[];
+}
+interface Approval {
+    artifact: string;
+    artifactHash: string;
+    approvedBy: string;
+    approvedAt: string;
+    channel: 'presentation' | 'editor' | 'pr' | 'tracker' | 'cli';
+    note?: string;
+}
+interface ApprovalsFile {
+    schemaVersion: number;
+    approvals: Approval[];
+}
+interface MockupScreen {
+    id: string;
+    file: string;
+    title?: string;
+    illustrates?: string[];
+    states?: string[];
+    breakpoints?: number[];
+    themes?: string[];
+}
+interface MockupManifest {
+    schemaVersion: number;
+    version: number;
+    level: 'sketch' | 'hifi';
+    platform: 'web' | 'mobile' | 'desktop';
+    inputsHash?: string;
+    generatedAt?: string;
+    tokens?: string;
+    screens: MockupScreen[];
+}
+interface Change {
+    slug: string;
+    dir: string;
+    meta?: ChangeMeta;
+    delta?: Delta;
+    tasks?: TasksFile;
+    verify?: VerifyFile;
+    fix?: VerifyFile;
+    planPath?: string;
+    mockupManifestPath?: string;
+    diagnostics: Diagnostic[];
+}
+interface SpecRef {
+    domain: string;
+    path: string;
+    spec: SpecFile;
+}
+interface Workspace {
+    root: string;
+    sddDir: string;
+    specs: SpecRef[];
+    changes: Change[];
+    diagnostics: Diagnostic[];
+}
+
+declare function exists(p: string): Promise<boolean>;
+declare function isDirectory(p: string): Promise<boolean>;
+declare function readText(p: string): Promise<string>;
+declare function readTextIfExists(p: string): Promise<string | undefined>;
+declare function writeText(p: string, content: string): Promise<void>;
+declare function ensureDir(p: string): Promise<void>;
+declare function copyFile(from: string, to: string): Promise<void>;
+declare function listDir(p: string): Promise<string[]>;
+declare function listDirs(p: string): Promise<string[]>;
+interface WalkEntry {
+    path: string;
+    name: string;
+}
+declare function walkFiles(root: string, opts?: {
+    skipDirs?: string[];
+}): Promise<WalkEntry[]>;
+declare function toPosix(p: string): string;
+
+declare const CONFIG_FILE = "config.yaml";
+declare const atlasConfigSchema: z.ZodObject<{
+    schema_version: z.ZodDefault<z.ZodNumber>;
+    project: z.ZodDefault<z.ZodObject<{
+        name: z.ZodDefault<z.ZodString>;
+        language: z.ZodDefault<z.ZodEnum<["es", "en"]>>;
+    }, "strip", z.ZodTypeAny, {
+        name: string;
+        language: "es" | "en";
+    }, {
+        name?: string | undefined;
+        language?: "es" | "en" | undefined;
+    }>>;
+    lanes: z.ZodDefault<z.ZodObject<{
+        default: z.ZodDefault<z.ZodEnum<["fix", "standard", "full"]>>;
+        allowed: z.ZodDefault<z.ZodArray<z.ZodEnum<["fix", "standard", "full"]>, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        default: "fix" | "standard" | "full";
+        allowed: ("fix" | "standard" | "full")[];
+    }, {
+        default?: "fix" | "standard" | "full" | undefined;
+        allowed?: ("fix" | "standard" | "full")[] | undefined;
+    }>>;
+    gates: z.ZodDefault<z.ZodObject<{
+        approval: z.ZodDefault<z.ZodEnum<["file", "none", "github-label"]>>;
+        approval_label: z.ZodDefault<z.ZodString>;
+        analyze: z.ZodDefault<z.ZodObject<{
+            mode: z.ZodDefault<z.ZodEnum<["off", "advisory", "blocking"]>>;
+            min_severity: z.ZodDefault<z.ZodEnum<["low", "medium", "high"]>>;
+        }, "strip", z.ZodTypeAny, {
+            mode: "off" | "advisory" | "blocking";
+            min_severity: "low" | "medium" | "high";
+        }, {
+            mode?: "off" | "advisory" | "blocking" | undefined;
+            min_severity?: "low" | "medium" | "high" | undefined;
+        }>>;
+        verify: z.ZodDefault<z.ZodObject<{
+            mode: z.ZodDefault<z.ZodEnum<["off", "advisory", "blocking"]>>;
+            require_evidence: z.ZodDefault<z.ZodBoolean>;
+        }, "strip", z.ZodTypeAny, {
+            mode: "off" | "advisory" | "blocking";
+            require_evidence: boolean;
+        }, {
+            mode?: "off" | "advisory" | "blocking" | undefined;
+            require_evidence?: boolean | undefined;
+        }>>;
+        review: z.ZodDefault<z.ZodObject<{
+            mode: z.ZodDefault<z.ZodEnum<["off", "advisory", "blocking"]>>;
+        }, "strip", z.ZodTypeAny, {
+            mode: "off" | "advisory" | "blocking";
+        }, {
+            mode?: "off" | "advisory" | "blocking" | undefined;
+        }>>;
+        mockup: z.ZodDefault<z.ZodObject<{
+            require_approval: z.ZodDefault<z.ZodBoolean>;
+            compare_in_verify: z.ZodDefault<z.ZodBoolean>;
+        }, "strip", z.ZodTypeAny, {
+            require_approval: boolean;
+            compare_in_verify: boolean;
+        }, {
+            require_approval?: boolean | undefined;
+            compare_in_verify?: boolean | undefined;
+        }>>;
+    }, "strip", z.ZodTypeAny, {
+        approval: "file" | "none" | "github-label";
+        approval_label: string;
+        analyze: {
+            mode: "off" | "advisory" | "blocking";
+            min_severity: "low" | "medium" | "high";
+        };
+        verify: {
+            mode: "off" | "advisory" | "blocking";
+            require_evidence: boolean;
+        };
+        review: {
+            mode: "off" | "advisory" | "blocking";
+        };
+        mockup: {
+            require_approval: boolean;
+            compare_in_verify: boolean;
+        };
+    }, {
+        approval?: "file" | "none" | "github-label" | undefined;
+        approval_label?: string | undefined;
+        analyze?: {
+            mode?: "off" | "advisory" | "blocking" | undefined;
+            min_severity?: "low" | "medium" | "high" | undefined;
+        } | undefined;
+        verify?: {
+            mode?: "off" | "advisory" | "blocking" | undefined;
+            require_evidence?: boolean | undefined;
+        } | undefined;
+        review?: {
+            mode?: "off" | "advisory" | "blocking" | undefined;
+        } | undefined;
+        mockup?: {
+            require_approval?: boolean | undefined;
+            compare_in_verify?: boolean | undefined;
+        } | undefined;
+    }>>;
+    trace: z.ZodDefault<z.ZodObject<{
+        mode: z.ZodDefault<z.ZodEnum<["off", "advisory", "blocking"]>>;
+        prefix: z.ZodDefault<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        mode: "off" | "advisory" | "blocking";
+        prefix: string;
+    }, {
+        mode?: "off" | "advisory" | "blocking" | undefined;
+        prefix?: string | undefined;
+    }>>;
+    waves: z.ZodDefault<z.ZodObject<{
+        max_parallel: z.ZodDefault<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        max_parallel: number;
+    }, {
+        max_parallel?: number | undefined;
+    }>>;
+    ci: z.ZodDefault<z.ZodObject<{
+        drift: z.ZodDefault<z.ZodEnum<["advisory", "strict"]>>;
+    }, "strip", z.ZodTypeAny, {
+        drift: "advisory" | "strict";
+    }, {
+        drift?: "advisory" | "strict" | undefined;
+    }>>;
+    spec: z.ZodDefault<z.ZodObject<{
+        language: z.ZodDefault<z.ZodEnum<["es", "en"]>>;
+        business_only: z.ZodDefault<z.ZodBoolean>;
+        glossary: z.ZodDefault<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        language: "es" | "en";
+        business_only: boolean;
+        glossary: string;
+    }, {
+        language?: "es" | "en" | undefined;
+        business_only?: boolean | undefined;
+        glossary?: string | undefined;
+    }>>;
+    syntax: z.ZodDefault<z.ZodObject<{
+        headers: z.ZodOptional<z.ZodEnum<["es", "en"]>>;
+    }, "strip", z.ZodTypeAny, {
+        headers?: "es" | "en" | undefined;
+    }, {
+        headers?: "es" | "en" | undefined;
+    }>>;
+    mockups: z.ZodDefault<z.ZodObject<{
+        level: z.ZodDefault<z.ZodEnum<["sketch", "hifi"]>>;
+        platform: z.ZodDefault<z.ZodEnum<["auto", "web", "mobile", "desktop"]>>;
+        a11y: z.ZodDefault<z.ZodEnum<["off", "A", "AA", "AAA"]>>;
+    }, "strip", z.ZodTypeAny, {
+        level: "sketch" | "hifi";
+        platform: "mobile" | "web" | "desktop" | "auto";
+        a11y: "off" | "A" | "AA" | "AAA";
+    }, {
+        level?: "sketch" | "hifi" | undefined;
+        platform?: "mobile" | "web" | "desktop" | "auto" | undefined;
+        a11y?: "off" | "A" | "AA" | "AAA" | undefined;
+    }>>;
+    editor: z.ZodDefault<z.ZodObject<{
+        vscode: z.ZodDefault<z.ZodBoolean>;
+        lsp: z.ZodDefault<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        vscode: boolean;
+        lsp: boolean;
+    }, {
+        vscode?: boolean | undefined;
+        lsp?: boolean | undefined;
+    }>>;
+    adapters: z.ZodDefault<z.ZodObject<{
+        targets: z.ZodDefault<z.ZodArray<z.ZodEnum<["opencode", "claude-code", "cursor", "copilot", "gemini", "codex", "generic"]>, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        targets: ("opencode" | "claude-code" | "cursor" | "copilot" | "gemini" | "codex" | "generic")[];
+    }, {
+        targets?: ("opencode" | "claude-code" | "cursor" | "copilot" | "gemini" | "codex" | "generic")[] | undefined;
+    }>>;
+    packs: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    integrations: z.ZodDefault<z.ZodObject<{
+        tracker: z.ZodDefault<z.ZodEnum<["none", "github", "jira", "linear", "clickup"]>>;
+    }, "strip", z.ZodTypeAny, {
+        tracker: "none" | "github" | "jira" | "linear" | "clickup";
+    }, {
+        tracker?: "none" | "github" | "jira" | "linear" | "clickup" | undefined;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    editor: {
+        vscode: boolean;
+        lsp: boolean;
+    };
+    schema_version: number;
+    project: {
+        name: string;
+        language: "es" | "en";
+    };
+    lanes: {
+        default: "fix" | "standard" | "full";
+        allowed: ("fix" | "standard" | "full")[];
+    };
+    gates: {
+        approval: "file" | "none" | "github-label";
+        approval_label: string;
+        analyze: {
+            mode: "off" | "advisory" | "blocking";
+            min_severity: "low" | "medium" | "high";
+        };
+        verify: {
+            mode: "off" | "advisory" | "blocking";
+            require_evidence: boolean;
+        };
+        review: {
+            mode: "off" | "advisory" | "blocking";
+        };
+        mockup: {
+            require_approval: boolean;
+            compare_in_verify: boolean;
+        };
+    };
+    trace: {
+        mode: "off" | "advisory" | "blocking";
+        prefix: string;
+    };
+    waves: {
+        max_parallel: number;
+    };
+    ci: {
+        drift: "advisory" | "strict";
+    };
+    spec: {
+        language: "es" | "en";
+        business_only: boolean;
+        glossary: string;
+    };
+    syntax: {
+        headers?: "es" | "en" | undefined;
+    };
+    mockups: {
+        level: "sketch" | "hifi";
+        platform: "mobile" | "web" | "desktop" | "auto";
+        a11y: "off" | "A" | "AA" | "AAA";
+    };
+    adapters: {
+        targets: ("opencode" | "claude-code" | "cursor" | "copilot" | "gemini" | "codex" | "generic")[];
+    };
+    packs: string[];
+    integrations: {
+        tracker: "none" | "github" | "jira" | "linear" | "clickup";
+    };
+}, {
+    editor?: {
+        vscode?: boolean | undefined;
+        lsp?: boolean | undefined;
+    } | undefined;
+    schema_version?: number | undefined;
+    project?: {
+        name?: string | undefined;
+        language?: "es" | "en" | undefined;
+    } | undefined;
+    lanes?: {
+        default?: "fix" | "standard" | "full" | undefined;
+        allowed?: ("fix" | "standard" | "full")[] | undefined;
+    } | undefined;
+    gates?: {
+        approval?: "file" | "none" | "github-label" | undefined;
+        approval_label?: string | undefined;
+        analyze?: {
+            mode?: "off" | "advisory" | "blocking" | undefined;
+            min_severity?: "low" | "medium" | "high" | undefined;
+        } | undefined;
+        verify?: {
+            mode?: "off" | "advisory" | "blocking" | undefined;
+            require_evidence?: boolean | undefined;
+        } | undefined;
+        review?: {
+            mode?: "off" | "advisory" | "blocking" | undefined;
+        } | undefined;
+        mockup?: {
+            require_approval?: boolean | undefined;
+            compare_in_verify?: boolean | undefined;
+        } | undefined;
+    } | undefined;
+    trace?: {
+        mode?: "off" | "advisory" | "blocking" | undefined;
+        prefix?: string | undefined;
+    } | undefined;
+    waves?: {
+        max_parallel?: number | undefined;
+    } | undefined;
+    ci?: {
+        drift?: "advisory" | "strict" | undefined;
+    } | undefined;
+    spec?: {
+        language?: "es" | "en" | undefined;
+        business_only?: boolean | undefined;
+        glossary?: string | undefined;
+    } | undefined;
+    syntax?: {
+        headers?: "es" | "en" | undefined;
+    } | undefined;
+    mockups?: {
+        level?: "sketch" | "hifi" | undefined;
+        platform?: "mobile" | "web" | "desktop" | "auto" | undefined;
+        a11y?: "off" | "A" | "AA" | "AAA" | undefined;
+    } | undefined;
+    adapters?: {
+        targets?: ("opencode" | "claude-code" | "cursor" | "copilot" | "gemini" | "codex" | "generic")[] | undefined;
+    } | undefined;
+    packs?: string[] | undefined;
+    integrations?: {
+        tracker?: "none" | "github" | "jira" | "linear" | "clickup" | undefined;
+    } | undefined;
+}>;
+type AtlasConfig = z.infer<typeof atlasConfigSchema>;
+declare function defaultConfig(overrides?: {
+    name?: string;
+    language?: Language;
+}): AtlasConfig;
+declare function configToYaml(cfg: AtlasConfig): string;
+interface LoadedConfig {
+    config: AtlasConfig;
+    diagnostics: Diagnostic[];
+}
+declare function parseConfig(raw: string, configPath?: string): LoadedConfig;
+declare function loadConfig(sddDir: string): Promise<LoadedConfig>;
+declare function writeConfig(sddDir: string, cfg: AtlasConfig): Promise<void>;
+declare function laneOrDefault(cfg: AtlasConfig, lane?: string): Lane;
+
+interface FrontmatterResult {
+    data: Record<string, unknown>;
+    body: string;
+    bodyStartLine: number;
+    diagnostics: Diagnostic[];
+}
+declare function parseFrontmatter(content: string, filePath?: string): FrontmatterResult;
+declare function emitFrontmatter(data: Record<string, unknown>, body: string): string;
+declare function getString(data: Record<string, unknown>, key: string): string | undefined;
+declare function getNumber(data: Record<string, unknown>, key: string): number | undefined;
+
+/**
+ * Canonicaliza markdown para hashing estable entre sistemas:
+ * - EOL siempre \n (clave en Windows)
+ * - sin BOM
+ * - sin espacios finales de línea
+ * - máximo una línea vacía consecutiva
+ * - sin líneas vacías al inicio o al final
+ */
+declare function canonicalizeMarkdown(md: string): string;
+declare function sha256(content: string | Uint8Array): string;
+declare function artifactHash(markdown: string): string;
+declare function shortHash(hash: string): string;
+
+declare const REQ_HEAD_RE: RegExp;
+declare const SCENARIO_HEAD_RE: RegExp;
+declare const RULE_RE: RegExp;
+/**
+ * Extrae requisitos de un cuerpo markdown (sirve para specs vivas y para
+ * bloques dentro de un delta). Los encabezados aceptan español e inglés.
+ */
+declare function parseRequirementBlocks(body: string, startLine?: number, filePath?: string): {
+    requirements: Requirement[];
+    diagnostics: Diagnostic[];
+};
+declare function parseSpecFile(content: string, filePath: string): SpecFile;
+declare function renderRequirement(req: Requirement, language?: 'es' | 'en'): string;
+
+declare function parseDelta(content: string, filePath: string): Delta;
+
+declare const BLOCK_HEAD_RE: RegExp;
+declare const TASK_LINE_RE: RegExp;
+declare function parseTasksFile(content: string, filePath: string): TasksFile;
+
+declare function parseVerifyFile(content: string, filePath: string): VerifyFile;
+
+declare const changeMetaSchema: z.ZodObject<{
+    schema_version: z.ZodDefault<z.ZodNumber>;
+    slug: z.ZodString;
+    title: z.ZodOptional<z.ZodString>;
+    domain: z.ZodOptional<z.ZodString>;
+    lane: z.ZodDefault<z.ZodEnum<["fix", "standard", "full"]>>;
+    risk: z.ZodOptional<z.ZodEnum<["low", "medium", "high"]>>;
+    created: z.ZodOptional<z.ZodString>;
+    owner: z.ZodOptional<z.ZodString>;
+    tracker: z.ZodOptional<z.ZodObject<{
+        provider: z.ZodString;
+        id: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        id: string;
+        provider: string;
+    }, {
+        id: string;
+        provider: string;
+    }>>;
+    paused: z.ZodOptional<z.ZodObject<{
+        reason: z.ZodString;
+        at: z.ZodString;
+        by: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        at: string;
+        by: string;
+        reason: string;
+    }, {
+        at: string;
+        by: string;
+        reason: string;
+    }>>;
+    lane_history: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        from: z.ZodEnum<["fix", "standard", "full"]>;
+        to: z.ZodEnum<["fix", "standard", "full"]>;
+        at: z.ZodString;
+        by: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        at: string;
+        by: string;
+        from: "fix" | "standard" | "full";
+        to: "fix" | "standard" | "full";
+    }, {
+        at: string;
+        by: string;
+        from: "fix" | "standard" | "full";
+        to: "fix" | "standard" | "full";
+    }>, "many">>;
+    diagram_exceptions: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    overrides: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        gate: z.ZodString;
+        reason: z.ZodString;
+        by: z.ZodString;
+        at: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        at: string;
+        by: string;
+        reason: string;
+        gate: string;
+    }, {
+        at: string;
+        by: string;
+        reason: string;
+        gate: string;
+    }>, "many">>;
+}, "strip", z.ZodTypeAny, {
+    schema_version: number;
+    slug: string;
+    lane: "fix" | "standard" | "full";
+    tracker?: {
+        id: string;
+        provider: string;
+    } | undefined;
+    domain?: string | undefined;
+    title?: string | undefined;
+    risk?: "low" | "medium" | "high" | undefined;
+    created?: string | undefined;
+    owner?: string | undefined;
+    paused?: {
+        at: string;
+        by: string;
+        reason: string;
+    } | undefined;
+    lane_history?: {
+        at: string;
+        by: string;
+        from: "fix" | "standard" | "full";
+        to: "fix" | "standard" | "full";
+    }[] | undefined;
+    diagram_exceptions?: string[] | undefined;
+    overrides?: {
+        at: string;
+        by: string;
+        reason: string;
+        gate: string;
+    }[] | undefined;
+}, {
+    slug: string;
+    tracker?: {
+        id: string;
+        provider: string;
+    } | undefined;
+    schema_version?: number | undefined;
+    domain?: string | undefined;
+    title?: string | undefined;
+    lane?: "fix" | "standard" | "full" | undefined;
+    risk?: "low" | "medium" | "high" | undefined;
+    created?: string | undefined;
+    owner?: string | undefined;
+    paused?: {
+        at: string;
+        by: string;
+        reason: string;
+    } | undefined;
+    lane_history?: {
+        at: string;
+        by: string;
+        from: "fix" | "standard" | "full";
+        to: "fix" | "standard" | "full";
+    }[] | undefined;
+    diagram_exceptions?: string[] | undefined;
+    overrides?: {
+        at: string;
+        by: string;
+        reason: string;
+        gate: string;
+    }[] | undefined;
+}>;
+declare function parseChangeMeta(raw: string, filePath: string): {
+    meta?: ChangeMeta;
+    diagnostics: Diagnostic[];
+};
+declare const approvalsSchema: z.ZodObject<{
+    schema_version: z.ZodDefault<z.ZodNumber>;
+    approvals: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        artifact: z.ZodString;
+        artifact_hash: z.ZodString;
+        approved_by: z.ZodString;
+        approved_at: z.ZodString;
+        channel: z.ZodDefault<z.ZodEnum<["presentation", "editor", "pr", "tracker", "cli"]>>;
+        note: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        artifact: string;
+        artifact_hash: string;
+        approved_by: string;
+        approved_at: string;
+        channel: "presentation" | "editor" | "pr" | "tracker" | "cli";
+        note?: string | undefined;
+    }, {
+        artifact: string;
+        artifact_hash: string;
+        approved_by: string;
+        approved_at: string;
+        channel?: "presentation" | "editor" | "pr" | "tracker" | "cli" | undefined;
+        note?: string | undefined;
+    }>, "many">>;
+}, "strip", z.ZodTypeAny, {
+    schema_version: number;
+    approvals: {
+        artifact: string;
+        artifact_hash: string;
+        approved_by: string;
+        approved_at: string;
+        channel: "presentation" | "editor" | "pr" | "tracker" | "cli";
+        note?: string | undefined;
+    }[];
+}, {
+    schema_version?: number | undefined;
+    approvals?: {
+        artifact: string;
+        artifact_hash: string;
+        approved_by: string;
+        approved_at: string;
+        channel?: "presentation" | "editor" | "pr" | "tracker" | "cli" | undefined;
+        note?: string | undefined;
+    }[] | undefined;
+}>;
+declare function parseApprovals(raw: string, filePath: string): {
+    approvals?: ApprovalsFile;
+    diagnostics: Diagnostic[];
+};
+
+interface LintOptions {
+    language?: 'es' | 'en';
+    businessOnly?: boolean;
+}
+declare function lintRequirement(req: Requirement, path: string, opts?: LintOptions): Diagnostic[];
+declare function lintDelta(delta: Delta, livingRequirements: Map<string, Requirement>, path: string, opts?: LintOptions): Diagnostic[];
+declare function lintTasks(_tasks: TasksFile): Diagnostic[];
+declare function lintVerify(_verify: VerifyFile): Diagnostic[];
+declare function lintSpec(spec: SpecFile, opts?: LintOptions): Diagnostic[];
+
+interface TraceNode {
+    kind: 'requirement' | 'scenario' | 'task' | 'evidence';
+    id: string;
+}
+interface TraceEdge {
+    from: string;
+    to: string;
+    kind: 'covers' | 'evidences' | 'depends';
+}
+interface TraceGraph {
+    nodes: TraceNode[];
+    edges: TraceEdge[];
+}
+interface TraceFinding extends Diagnostic {
+    target?: string;
+}
+interface TraceResult {
+    graph: TraceGraph;
+    findings: TraceFinding[];
+    summary: {
+        errors: number;
+        warnings: number;
+        infos: number;
+    };
+}
+interface TraceInput {
+    specs: SpecRef[];
+    change: Change;
+    requireEvidence: boolean;
+}
+declare function buildTraceGraph(input: TraceInput): TraceGraph;
+declare function checkTrace(input: TraceInput): TraceResult;
+
+interface BlockWavePlan {
+    block: string;
+    title: string;
+    waves: Task[][];
+    degraded: Array<{
+        task: string;
+        reason: 'file-collision' | 'orphan-dependency';
+        movedToWave: number;
+    }>;
+    diagnostics: Diagnostic[];
+}
+interface WavePlan {
+    maxParallel: number;
+    blocks: BlockWavePlan[];
+    summary: {
+        blocks: number;
+        waves: number;
+        tasks: number;
+    };
+}
+declare function compareTaskIds(a: string, b: string): number;
+declare function planWaves(tasks: TasksFile, opts?: {
+    maxParallel?: number;
+}): WavePlan;
+declare function planBlock(block: TaskBlock, maxParallel: number): BlockWavePlan;
+
+type ChangeState = 'draft' | 'spec_draft' | 'awaiting_approval' | 'approved' | 'planned' | 'building' | 'built' | 'verified' | 'ready' | 'archived';
+interface NextAction {
+    command: string;
+    description: string;
+    requiresAgent: boolean;
+}
+interface DerivedState {
+    state: ChangeState;
+    blockedBy: string[];
+    nextAction: NextAction;
+    progress: {
+        tasksDone: number;
+        tasksTotal: number;
+        scenariosEvidenced: number;
+        scenariosTotal: number;
+    };
+}
+interface ApprovalStatus {
+    status: 'valid' | 'stale' | 'missing' | 'not_required' | 'overridden';
+    approvedBy?: string;
+    approvedAt?: string;
+}
+declare function verifyApproval(change: Change, approvals: Map<string, {
+    hash: string;
+    by: string;
+    at: string;
+}>, cfg: AtlasConfig, specContent?: string): ApprovalStatus;
+interface DeriveInput {
+    change: Change;
+    cfg: AtlasConfig;
+    approval: ApprovalStatus;
+    blockingFindings: number;
+    specContent?: string;
+}
+declare function deriveState(input: DeriveInput): DerivedState;
+declare function stateLabel(state: ChangeState): string;
+
+declare const profileSchema: z.ZodObject<{
+    name: z.ZodString;
+    display_name: z.ZodDefault<z.ZodString>;
+    detection: z.ZodDefault<z.ZodObject<{
+        files: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+        manifests: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            file: z.ZodString;
+            contains: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+        }, "strip", z.ZodTypeAny, {
+            file: string;
+            contains: string[];
+        }, {
+            file: string;
+            contains?: string[] | undefined;
+        }>, "many">>;
+        priority: z.ZodDefault<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        files: string[];
+        manifests: {
+            file: string;
+            contains: string[];
+        }[];
+        priority: number;
+    }, {
+        files?: string[] | undefined;
+        manifests?: {
+            file: string;
+            contains?: string[] | undefined;
+        }[] | undefined;
+        priority?: number | undefined;
+    }>>;
+    domains: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    commands: z.ZodDefault<z.ZodObject<{
+        build: z.ZodOptional<z.ZodString>;
+        lint: z.ZodOptional<z.ZodString>;
+        test: z.ZodOptional<z.ZodString>;
+        format: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        build?: string | undefined;
+        lint?: string | undefined;
+        test?: string | undefined;
+        format?: string | undefined;
+    }, {
+        build?: string | undefined;
+        lint?: string | undefined;
+        test?: string | undefined;
+        format?: string | undefined;
+    }>>;
+    verify: z.ZodDefault<z.ZodObject<{
+        executable: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+        automatic: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+        manual: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        executable: string[];
+        automatic: string[];
+        manual: string[];
+    }, {
+        executable?: string[] | undefined;
+        automatic?: string[] | undefined;
+        manual?: string[] | undefined;
+    }>>;
+    rollback: z.ZodDefault<z.ZodString>;
+    antipatterns: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    assumptions: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    verify: {
+        executable: string[];
+        automatic: string[];
+        manual: string[];
+    };
+    rollback: string;
+    display_name: string;
+    detection: {
+        files: string[];
+        manifests: {
+            file: string;
+            contains: string[];
+        }[];
+        priority: number;
+    };
+    domains: string[];
+    commands: {
+        build?: string | undefined;
+        lint?: string | undefined;
+        test?: string | undefined;
+        format?: string | undefined;
+    };
+    antipatterns: string[];
+    assumptions: string[];
+}, {
+    name: string;
+    verify?: {
+        executable?: string[] | undefined;
+        automatic?: string[] | undefined;
+        manual?: string[] | undefined;
+    } | undefined;
+    rollback?: string | undefined;
+    display_name?: string | undefined;
+    detection?: {
+        files?: string[] | undefined;
+        manifests?: {
+            file: string;
+            contains?: string[] | undefined;
+        }[] | undefined;
+        priority?: number | undefined;
+    } | undefined;
+    domains?: string[] | undefined;
+    commands?: {
+        build?: string | undefined;
+        lint?: string | undefined;
+        test?: string | undefined;
+        format?: string | undefined;
+    } | undefined;
+    antipatterns?: string[] | undefined;
+    assumptions?: string[] | undefined;
+}>;
+type StackProfile = z.infer<typeof profileSchema>;
+interface ProfileMatch {
+    name: string;
+    displayName: string;
+    score: number;
+    domains: string[];
+    path: string;
+}
+interface DetectionResult {
+    matches: ProfileMatch[];
+    best?: ProfileMatch;
+}
+declare function matchGlob(pattern: string, filePath: string): boolean;
+declare function loadProfileFile(filePath: string): Promise<StackProfile | undefined>;
+declare function loadProfilesFromDir(dir: string): Promise<StackProfile[]>;
+declare function detectProfiles(root: string, profiles: StackProfile[]): Promise<DetectionResult>;
+declare function loadDetectedBest(sddDir: string): Promise<string | undefined>;
+/**
+ * Devuelve el perfil activo del proyecto (el "best" de detected.yaml) buscándolo
+ * en los directorios de perfiles dados; fallback al perfil genérico si existe.
+ */
+declare function loadActiveProfile(sddDir: string, dirs: string[]): Promise<StackProfile | undefined>;
+declare function detectionToYaml(result: DetectionResult, generatedAt: string): string;
+
+declare const SDD_DIR = ".sdd";
+declare function findWorkspaceRoot(start: string): Promise<string | undefined>;
+interface ApprovalsIndex {
+    byArtifact: Map<string, {
+        hash: string;
+        by: string;
+        at: string;
+    }>;
+    diagnostics: Diagnostic[];
+}
+declare function loadApprovals(sddDir: string): Promise<ApprovalsIndex>;
+declare function loadSpecs(sddDir: string): Promise<SpecRef[]>;
+declare function loadChange(root: string, slug: string): Promise<Change>;
+declare function listChangeSlugs(root: string, opts?: {
+    includeArchived?: boolean;
+}): Promise<string[]>;
+declare function loadWorkspace(root: string): Promise<{
+    workspace: Workspace;
+    config: AtlasConfig;
+}>;
+declare function ensureSddDirs(sddDir: string): Promise<string[]>;
+
+interface TemplateSet {
+    constitution: string;
+    glossary: string;
+    proposal: string;
+    specDelta: (vars: {
+        title: string;
+        domainUpper: string;
+        domain: string;
+    }) => string;
+    plan: string;
+    tasks: string;
+    verify: string;
+    fix: string;
+}
+declare function templatesFor(language: Language): TemplateSet;
+declare function renderTemplate(template: string, vars: Record<string, string>): string;
+declare function changeMetaYaml(meta: ChangeMeta): string;
+declare function indexMarkdown(input: {
+    projectName: string;
+    language: Language;
+    specs: Array<{
+        domain: string;
+        requirements: number;
+    }>;
+    changes: Array<{
+        slug: string;
+        lane: Lane;
+    }>;
+    archived: number;
+}): string;
+
+interface SignApprovalOptions {
+    root: string;
+    artifact: string;
+    by: string;
+    channel?: Approval['channel'];
+    note?: string;
+    now?: Date;
+    dryRun?: boolean;
+}
+interface SignApprovalResult {
+    approval?: Approval;
+    file: string;
+    diagnostics: Diagnostic[];
+}
+declare function signApproval(opts: SignApprovalOptions): Promise<SignApprovalResult>;
+
+interface ExecResult {
+    ok: boolean;
+    exitCode: number;
+    stdout: string;
+    stderr: string;
+    durationMs: number;
+    command: string;
+    resolvedBinary: string;
+}
+interface ExecOptions {
+    cwd?: string;
+    timeoutMs?: number;
+    maxBytes?: number;
+    input?: string;
+}
+declare function hasShellMetacharacters(command: string): boolean;
+declare function splitCommand(command: string): string[];
+declare function firstToken(command: string): string;
+/**
+ * Ejecuta un comando sin shell, con timeout y sin interpretar metacaracteres.
+ * En Windows prueba el sufijo .cmd para binarios de npm cuando hace falta.
+ */
+declare function runProcess(command: string, opts?: ExecOptions): Promise<ExecResult>;
+declare function isCommandAllowed(command: string, allowedPrefixes: string[]): boolean;
+
+type GhRunner = (command: string, opts?: ExecOptions) => Promise<ExecResult>;
+interface GitHubRepo {
+    owner: string;
+    name: string;
+}
+declare function parseGitHubRemote(url: string): GitHubRepo | undefined;
+declare function changeMarker(slug: string): string;
+declare function ghAvailable(runner?: GhRunner): Promise<boolean>;
+declare function ghAuthStatus(runner?: GhRunner): Promise<boolean>;
+declare function detectRepo(root: string, runner?: GhRunner): Promise<GitHubRepo | undefined>;
+interface IssueBodyInput {
+    change: Change;
+    next: string;
+    nextDescription: string;
+    scenarios: number;
+}
+declare function issueBody(input: IssueBodyInput): string;
+interface LinkedIssue {
+    number: number;
+    url: string;
+    title: string;
+    state: string;
+}
+declare function findLinkedIssue(root: string, slug: string, runner?: GhRunner): Promise<LinkedIssue | undefined>;
+declare function parseIssueUrl(url: string): LinkedIssue | undefined;
+declare function createIssue(root: string, opts: {
+    title: string;
+    body: string;
+    labels?: string[];
+}, runner?: GhRunner): Promise<{
+    issue?: LinkedIssue;
+    diagnostics: Diagnostic[];
+}>;
+declare function editIssue(root: string, number: number, opts: {
+    title?: string;
+    body?: string;
+}, runner?: GhRunner): Promise<Diagnostic[]>;
+declare function issueLabels(root: string, number: number, runner?: GhRunner): Promise<{
+    labels: string[];
+    diagnostics: Diagnostic[];
+}>;
+declare function commentIssue(root: string, number: number, body: string, runner?: GhRunner): Promise<Diagnostic[]>;
+declare function patchChangeMeta(root: string, slug: string, patch: Record<string, unknown>): Promise<{
+    path: string;
+    diagnostics: Diagnostic[];
+}>;
+interface ApproveFromGithubOptions {
+    root: string;
+    slug: string;
+    label?: string;
+    by?: string;
+    runner?: GhRunner;
+}
+interface ApproveFromGithubResult {
+    approved: boolean;
+    label: string;
+    issueNumber?: number;
+    approvedBy?: string;
+    diagnostics: Diagnostic[];
+}
+declare function approveFromGithub(opts: ApproveFromGithubOptions): Promise<ApproveFromGithubResult>;
+interface SyncGithubOptions {
+    labels?: string[];
+    next?: {
+        command: string;
+        description: string;
+    };
+    runner?: GhRunner;
+}
+interface SyncGithubResult {
+    slug: string;
+    created: boolean;
+    issue?: LinkedIssue;
+    diagnostics: Diagnostic[];
+}
+declare function syncGithubIssue(root: string, slug: string, opts?: SyncGithubOptions): Promise<SyncGithubResult>;
+
+interface RecordEvidenceOptions {
+    root: string;
+    slug: string;
+    scenario: string;
+    command?: string;
+    method?: EvidenceMethod;
+    result?: EvidenceResult;
+    by: string;
+    notes?: string;
+    allowCommand?: boolean;
+    allowedPrefixes?: string[];
+    timeoutMs?: number;
+    now?: Date;
+    dryRun?: boolean;
+    file?: 'verify' | 'fix';
+}
+interface RecordEvidenceResult {
+    evidence?: Evidence;
+    exitCode: number;
+    stdout?: string;
+    stderr?: string;
+    path: string;
+    diagnostics: Diagnostic[];
+}
+declare function recordEvidence(opts: RecordEvidenceOptions): Promise<RecordEvidenceResult>;
+declare function evidenceSummary(content: string): Map<string, EvidenceResult>;
+
+type RunStatus = 'active' | 'paused' | 'completed' | 'aborted';
+declare const RUN_EVENT_TYPES: readonly ["run_started", "task_started", "task_completed", "wave_started", "wave_completed", "block_started", "block_completed", "validate_run", "trace_run", "analyze_run", "verify_run", "mockup_checked", "presentation_generated", "override_applied", "paused", "resumed", "run_completed"];
+type RunEventType = (typeof RUN_EVENT_TYPES)[number];
+interface RunState {
+    runId: string;
+    slug: string;
+    phase: string;
+    status: RunStatus;
+    startedAt: string;
+    updatedAt: string;
+    inputs?: Record<string, unknown>;
+}
+interface RunEvent {
+    eventId: string;
+    at: string;
+    type: string;
+    data?: Record<string, unknown>;
+}
+interface RunRecord {
+    state: RunState;
+    events: RunEvent[];
+}
+declare function generateRunId(now?: Date): string;
+declare function createRun(root: string, slug: string, phase: string, inputs?: Record<string, unknown>, now?: Date): Promise<RunState>;
+declare function appendRunEvent(root: string, runId: string, type: string, data?: Record<string, unknown>, now?: Date): Promise<RunEvent>;
+declare function updateRunStatus(root: string, runId: string, status: RunStatus, now?: Date): Promise<void>;
+declare function readRun(root: string, runId: string): Promise<{
+    record?: RunRecord;
+    diagnostics: Diagnostic[];
+}>;
+declare function listRuns(root: string, filter?: {
+    slug?: string;
+    status?: RunStatus;
+}): Promise<RunState[]>;
+
+interface AnalyzeOptions {
+    root: string;
+    slug: string;
+    now?: Date;
+    write?: boolean;
+}
+interface AnalyzePackSummary {
+    id: string;
+    title: string;
+    status: 'ok' | 'fail' | 'n/a';
+    passed: number;
+    failed: number;
+}
+interface AnalyzeResult {
+    slug: string;
+    status: 'passed' | 'passed_with_debt' | 'blocked';
+    findings: Diagnostic[];
+    path?: string;
+    summary: {
+        errors: number;
+        warnings: number;
+        infos: number;
+    };
+    waves?: {
+        blocks: number;
+        waves: number;
+        tasks: number;
+    };
+    evidence: {
+        done: number;
+        total: number;
+    };
+    mockups?: {
+        screens: number;
+        stale: boolean;
+    };
+    packs?: AnalyzePackSummary[];
+}
+declare function runAnalyze(opts: AnalyzeOptions): Promise<AnalyzeResult>;
+
+interface ChangeMetrics {
+    slug: string;
+    title?: string;
+    domain?: string;
+    lane: string;
+    state: ChangeState;
+    stateLabel: string;
+    tasksDone: number;
+    tasksTotal: number;
+    scenariosTotal: number;
+    scenariosPassed: number;
+    findingsErrors: number;
+    findingsWarnings: number;
+    blockedBy: string[];
+    next: string;
+    ageDays?: number;
+}
+interface AgingBucket {
+    label: string;
+    value: number;
+}
+interface AttentionItem {
+    slug: string;
+    kind: 'blocked' | 'aging' | 'missing-evidence';
+    detail: string;
+}
+interface WorkspaceMetrics {
+    generatedAt: string;
+    project: string;
+    root: string;
+    changes: ChangeMetrics[];
+    totals: {
+        changes: number;
+        tasks: number;
+        tasksDone: number;
+        scenarios: number;
+        scenariosPassed: number;
+        errors: number;
+        warnings: number;
+        archived: number;
+    };
+    wipByState: Record<string, {
+        label: string;
+        count: number;
+    }>;
+    throughputByMonth: Record<string, number>;
+    evidenceByMethod: Record<string, number>;
+    blocked: Array<{
+        slug: string;
+        reason: string;
+    }>;
+    aging: {
+        averageDays?: number;
+        oldest?: {
+            slug: string;
+            ageDays: number;
+        };
+        buckets: AgingBucket[];
+    };
+    byLane: Array<{
+        label: string;
+        value: number;
+    }>;
+    attention: AttentionItem[];
+}
+declare function collectMetrics(root: string, now?: Date): Promise<WorkspaceMetrics>;
+
+type PackCheckType = 'task-rollback' | 'evidence-strong' | 'spec-terms' | 'rule-terms' | 'nfr-measurable' | 'approval-provider';
+interface PackCheck {
+    id: string;
+    title: string;
+    type: PackCheckType;
+    severity: Severity;
+    appliesTo?: {
+        domains?: string[];
+        lanes?: Lane[];
+    };
+    params?: {
+        terms?: string[];
+    };
+    hint?: string;
+}
+interface Pack {
+    id: string;
+    title: string;
+    description: string;
+    source: 'builtin' | 'project';
+    checks: PackCheck[];
+}
+declare const BUILTIN_PACKS: Pack[];
+interface PackCheckResult {
+    packId: string;
+    checkId: string;
+    title: string;
+    severity: Severity;
+    status: 'ok' | 'fail' | 'n/a';
+    message?: string;
+    hint?: string;
+}
+interface PackEvaluation {
+    pack: Pack;
+    status: 'ok' | 'fail' | 'n/a';
+    results: PackCheckResult[];
+    passed: number;
+    failed: number;
+}
+declare function loadProjectPacks(sddDir: string): Promise<{
+    packs: Pack[];
+    diagnostics: Diagnostic[];
+}>;
+declare function resolvePacks(sddDir: string, config: AtlasConfig): Promise<{
+    packs: Pack[];
+    diagnostics: Diagnostic[];
+}>;
+declare function evaluatePacks(packs: Pack[], change: Change, config: AtlasConfig): PackEvaluation[];
+declare function packFindings(evaluations: PackEvaluation[], change: Change): Diagnostic[];
+
+interface PresentOptions {
+    root: string;
+    slug: string;
+    now?: Date;
+}
+interface PresentResult {
+    slug: string;
+    path?: string;
+    hash?: string;
+    diagnostics: Diagnostic[];
+}
+declare function generatePresentation(opts: PresentOptions): Promise<PresentResult>;
+declare function esc(text: string): string;
+declare function inline(text: string): string;
+declare function renderMarkdown(markdown: string): string;
+
+declare const mockupManifestSchema: z.ZodObject<{
+    schema_version: z.ZodDefault<z.ZodNumber>;
+    version: z.ZodDefault<z.ZodNumber>;
+    level: z.ZodDefault<z.ZodEnum<["sketch", "hifi"]>>;
+    platform: z.ZodDefault<z.ZodEnum<["web", "mobile", "desktop"]>>;
+    inputs_hash: z.ZodOptional<z.ZodString>;
+    generated_at: z.ZodOptional<z.ZodString>;
+    tokens: z.ZodOptional<z.ZodString>;
+    screens: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        file: z.ZodString;
+        title: z.ZodOptional<z.ZodString>;
+        illustrates: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+        states: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+        breakpoints: z.ZodDefault<z.ZodArray<z.ZodNumber, "many">>;
+        themes: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        file: string;
+        id: string;
+        illustrates: string[];
+        states: string[];
+        breakpoints: number[];
+        themes: string[];
+        title?: string | undefined;
+    }, {
+        file: string;
+        id: string;
+        title?: string | undefined;
+        illustrates?: string[] | undefined;
+        states?: string[] | undefined;
+        breakpoints?: number[] | undefined;
+        themes?: string[] | undefined;
+    }>, "many">>;
+    screenshots: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+}, "strip", z.ZodTypeAny, {
+    schema_version: number;
+    level: "sketch" | "hifi";
+    platform: "mobile" | "web" | "desktop";
+    version: number;
+    screens: {
+        file: string;
+        id: string;
+        illustrates: string[];
+        states: string[];
+        breakpoints: number[];
+        themes: string[];
+        title?: string | undefined;
+    }[];
+    screenshots: string[];
+    inputs_hash?: string | undefined;
+    generated_at?: string | undefined;
+    tokens?: string | undefined;
+}, {
+    schema_version?: number | undefined;
+    level?: "sketch" | "hifi" | undefined;
+    platform?: "mobile" | "web" | "desktop" | undefined;
+    version?: number | undefined;
+    inputs_hash?: string | undefined;
+    generated_at?: string | undefined;
+    tokens?: string | undefined;
+    screens?: {
+        file: string;
+        id: string;
+        title?: string | undefined;
+        illustrates?: string[] | undefined;
+        states?: string[] | undefined;
+        breakpoints?: number[] | undefined;
+        themes?: string[] | undefined;
+    }[] | undefined;
+    screenshots?: string[] | undefined;
+}>;
+interface MockupPlanScreen {
+    id: string;
+    title: string;
+    file: string;
+    illustrates: string[];
+    states: string[];
+    breakpoints: number[];
+}
+interface MockupPlan {
+    platform: 'web' | 'mobile' | 'desktop';
+    screens: MockupPlanScreen[];
+}
+interface MockupCheckResult {
+    findings: Diagnostic[];
+    stale: boolean;
+    manifest?: MockupManifest;
+    manifestPath?: string;
+}
+declare function mockupsDir(root: string, slug: string): string;
+declare function tokensFile(root: string): Promise<string | undefined>;
+declare function computeInputsHash(root: string, change: Change): Promise<string>;
+declare function planMockups(change: Change, platform?: 'web' | 'mobile' | 'desktop'): MockupPlan;
+declare function readMockupManifest(root: string, slug: string): Promise<{
+    manifest?: MockupManifest;
+    path?: string;
+    diagnostics: Diagnostic[];
+}>;
+declare function lintMockupHtml(html: string, file: string): Diagnostic[];
+declare function lintMockupManifest(manifest: MockupManifest, knownScenarios: Set<string>, file: string): Diagnostic[];
+declare function checkMockups(root: string, slug: string, change: Change): Promise<MockupCheckResult>;
+declare function writeMockupPlan(root: string, slug: string, plan: MockupPlan, now?: Date): Promise<string>;
+declare function writeMockupManifest(root: string, slug: string, plan: MockupPlan, inputsHash: string, now?: Date): Promise<string>;
+declare function updateMockupScreenshots(root: string, slug: string, screenshots: string[]): Promise<string | undefined>;
+interface CaptureResult {
+    screenshots: string[];
+    diagnostics: Diagnostic[];
+}
+declare function captureMockups(root: string, slug: string, manifest: MockupManifest, now?: Date): Promise<CaptureResult>;
+
+interface AdoptOptions {
+    root: string;
+    domains?: string[];
+    dryRun?: boolean;
+    profilesDirs?: string[];
+    now?: Date;
+}
+interface AdoptDomain {
+    name: string;
+    files: number;
+    samples: string[];
+    existingSpec: boolean;
+}
+interface AdoptResult {
+    root: string;
+    domains: AdoptDomain[];
+    createdSpecs: string[];
+    reportPath?: string;
+    stack?: {
+        name: string;
+        score: number;
+    };
+    diagnostics: Diagnostic[];
+    dryRun: boolean;
+}
+declare function adoptWorkspace(opts: AdoptOptions): Promise<AdoptResult>;
+
+interface InitOptions {
+    root: string;
+    name?: string;
+    language?: Language;
+    local?: boolean;
+    profilesDir?: string;
+    now?: Date;
+}
+interface InitResult {
+    sddDir: string;
+    created: string[];
+    detected?: DetectionResult;
+    diagnostics: Diagnostic[];
+}
+declare function initWorkspace(opts: InitOptions): Promise<InitResult>;
+
+declare const SLUG_RE: RegExp;
+interface NewChangeOptions {
+    root: string;
+    slug: string;
+    lane?: Lane;
+    domain?: string;
+    title?: string;
+    language?: Language;
+    cfg?: AtlasConfig;
+    now?: Date;
+}
+interface NewChangeResult {
+    slug: string;
+    dir: string;
+    files: string[];
+    diagnostics: Diagnostic[];
+}
+declare function createChange(opts: NewChangeOptions): Promise<NewChangeResult>;
+
+interface FoldOutcome {
+    content: string;
+    applied: {
+        added: string[];
+        modified: string[];
+        removed: string[];
+        renamed: string[];
+    };
+    diagnostics: Diagnostic[];
+}
+declare function foldDelta(livingBody: string, delta: Delta, language?: Language): FoldOutcome;
+interface ArchiveOptions {
+    root: string;
+    slug: string;
+    language?: Language;
+    now?: Date;
+    dryRun?: boolean;
+}
+interface ArchiveResult {
+    slug: string;
+    domain?: string;
+    archivedTo?: string;
+    fold: FoldOutcome;
+    diagnostics: Diagnostic[];
+    dryRun: boolean;
+}
+declare function archiveChange(opts: ArchiveOptions): Promise<ArchiveResult>;
+declare function regenerateIndex(root: string, cfg?: AtlasConfig, now?: Date): Promise<void>;
+
+interface DoctorReport {
+    findings: Diagnostic[];
+    summary: {
+        errors: number;
+        warnings: number;
+        infos: number;
+    };
+}
+declare function runDoctor(root: string): Promise<DoctorReport>;
+declare function specHashOf(filePath: string): Promise<string | undefined>;
+
+export { type AdoptDomain, type AdoptOptions, type AdoptResult, type AgingBucket, type AnalyzeOptions, type AnalyzePackSummary, type AnalyzeResult, type Approval, type ApprovalStatus, type ApprovalsFile, type ApprovalsIndex, type ApproveFromGithubOptions, type ApproveFromGithubResult, type ArchiveOptions, type ArchiveResult, type AtlasConfig, type AttentionItem, BLOCK_HEAD_RE, BUILTIN_PACKS, type BlockWavePlan, CONFIG_FILE, CORE_VERSION, type CaptureResult, type Change, type ChangeMeta, type ChangeMetrics, type ChangeState, type Delta, type DeltaOp, type DeriveInput, type DerivedState, type DetectionResult, type Diagnostic, type DoctorReport, type Domain, type Evidence, type EvidenceMethod, type EvidenceResult, type ExecOptions, type ExecResult, type FoldOutcome, type FrontmatterResult, type GhRunner, type GitHubRepo, type InitOptions, type InitResult, type IssueBodyInput, type Lane, type Language, type LinkedIssue, type LintOptions, type LoadedConfig, type MockupCheckResult, type MockupManifest, type MockupPlan, type MockupPlanScreen, type MockupScreen, type NewChangeOptions, type NewChangeResult, type NextAction, type Override, type Pack, type PackCheck, type PackCheckResult, type PackCheckType, type PackEvaluation, type PresentOptions, type PresentResult, type ProfileMatch, REQ_HEAD_RE, REQ_ID_RE, RULE_ID_RE, RULE_RE, RUN_EVENT_TYPES, type RecordEvidenceOptions, type RecordEvidenceResult, type Rename, type Requirement, type RiskLevel, type Rule, type RunEvent, type RunEventType, type RunRecord, type RunState, type RunStatus, SCENARIO_HEAD_RE, SCENARIO_ID_RE, SDD_DIR, SLUG_RE, type Scenario, type Severity, type SignApprovalOptions, type SignApprovalResult, type SpecFile, type SpecRef, type StackProfile, type SyncGithubOptions, type SyncGithubResult, TASK_ID_RE, TASK_LINE_RE, type Task, type TaskBlock, type TasksFile, type TemplateSet, type TraceEdge, type TraceFinding, type TraceGraph, type TraceInput, type TraceNode, type TraceResult, type VerifyFile, type WalkEntry, type WavePlan, type Workspace, type WorkspaceMetrics, adoptWorkspace, appendRunEvent, approvalsSchema, approveFromGithub, archiveChange, artifactHash, atlasConfigSchema, buildTraceGraph, canonicalizeMarkdown, captureMockups, changeMarker, changeMetaSchema, changeMetaYaml, checkMockups, checkTrace, collectMetrics, commentIssue, compareTaskIds, computeInputsHash, configToYaml, copyFile, countBySeverity, createChange, createIssue, createRun, defaultConfig, deriveState, detectProfiles, detectRepo, detectionToYaml, diag, editIssue, emitFrontmatter, ensureDir, ensureSddDirs, esc, evaluatePacks, evidenceSummary, exists, findLinkedIssue, findWorkspaceRoot, firstToken, foldDelta, generatePresentation, generateRunId, getNumber, getString, ghAuthStatus, ghAvailable, hasErrors, hasShellMetacharacters, indexMarkdown, initWorkspace, inline, isCommandAllowed, isDirectory, issueBody, issueLabels, laneOrDefault, lintDelta, lintMockupHtml, lintMockupManifest, lintRequirement, lintSpec, lintTasks, lintVerify, listChangeSlugs, listDir, listDirs, listRuns, loadActiveProfile, loadApprovals, loadChange, loadConfig, loadDetectedBest, loadProfileFile, loadProfilesFromDir, loadProjectPacks, loadSpecs, loadWorkspace, matchGlob, mockupManifestSchema, mockupsDir, packFindings, parseApprovals, parseChangeMeta, parseConfig, parseDelta, parseFrontmatter, parseGitHubRemote, parseIssueUrl, parseRequirementBlocks, parseSpecFile, parseTasksFile, parseVerifyFile, patchChangeMeta, planBlock, planMockups, planWaves, profileSchema, readMockupManifest, readRun, readText, readTextIfExists, recordEvidence, regenerateIndex, renderMarkdown, renderRequirement, renderTemplate, resolvePacks, runAnalyze, runDoctor, runProcess, sha256, shortHash, signApproval, specHashOf, splitCommand, stateLabel, syncGithubIssue, templatesFor, toPosix, tokensFile, updateMockupScreenshots, updateRunStatus, verifyApproval, walkFiles, writeConfig, writeMockupManifest, writeMockupPlan, writeText };