oreshnik-cli 0.1.0-alpha

package/dist/index.d.ts

@@ -0,0 +1,2338 @@
+import { z } from 'zod';
+
+type Result<T, E = OreshnikError> = {
+    ok: true;
+    value: T;
+} | {
+    ok: false;
+    error: E;
+};
+interface OreshnikError {
+    code: string;
+    message: string;
+    exitCode: number;
+    suggestion?: string;
+}
+declare function ok<T>(value: T): Result<T, never>;
+declare function err<E extends OreshnikError>(error: E): Result<never, E>;
+interface PorcelainEntry {
+    status: string;
+    path: string;
+}
+interface MergeOptions {
+    noCommit?: boolean;
+    noFF?: boolean;
+    strategy?: "union" | "ort" | "recursive";
+    message?: string;
+}
+interface MotherRef {
+    name: string;
+    version: number;
+    remote: boolean;
+}
+interface GitError extends OreshnikError {
+    code: "GIT_ERROR";
+    gitCommand?: string;
+    gitStderr?: string;
+}
+type TaskStatus = "ready" | "active" | "pending" | "blocked" | "done" | "rolled_back";
+interface Task {
+    id: string;
+    title: string;
+    owner: string;
+    backupOwner?: string;
+    status: TaskStatus;
+    track?: string;
+    zone?: string[];
+    dependsOn?: string[];
+    acceptance?: string[];
+    handoff?: string;
+    history?: TaskHistoryEntry[];
+}
+interface TaskHistoryEntry {
+    at: string;
+    action: string;
+    operator?: string;
+    from?: string;
+    to?: string;
+    reason?: string;
+    branch?: string;
+    description?: string;
+}
+interface Reassignment {
+    at: string;
+    task: string;
+    from: string;
+    to: string;
+    reason: string;
+}
+interface TaskBoard {
+    project: string;
+    updatedAt: string;
+    resiliencePolicy?: string;
+    closurePolicy?: string;
+    baseTestMatrix?: string[];
+    currentExecutionOrder: string[];
+    tasks: Task[];
+    reassignments?: Reassignment[];
+}
+interface MotherBranchEntry {
+    version: number;
+    name: string;
+    sprint: string;
+    operator: string;
+    date: string;
+    at: string;
+    previous: string;
+    description: string;
+}
+interface MotherVersion {
+    version: number;
+    current: string;
+    branches: MotherBranchEntry[];
+}
+type LockType = "operator_exclusive" | "operator_double" | "shared" | "forbidden" | "owner_per_sprint";
+interface ZoneEntry {
+    owner: string;
+    lock: LockType;
+    sprints: string[];
+    criticality?: "low" | "medium" | "high" | "critical";
+}
+interface ZoneMap {
+    zones: Record<string, ZoneEntry>;
+}
+interface ZoneViolation {
+    file: string;
+    zone: string;
+    reason: string;
+}
+interface ZoneWarning {
+    file: string;
+    reason: string;
+}
+interface ZoneCheckResult {
+    violations: ZoneViolation[];
+    warnings: ZoneWarning[];
+    filesChecked: number;
+}
+interface Checkpoint {
+    id: string;
+    tag: string;
+    timestamp: string;
+    operator: string;
+    sprint?: string;
+    type: "auto" | "manual" | "pre-rollback";
+    git: {
+        tag: string;
+        commit: string;
+        branch: string;
+        motherBranch?: string;
+        motherVersion?: number;
+    };
+    state: {
+        taskBoard: TaskBoard;
+        motherVersion: MotherVersion;
+        workingTreeDirty: boolean;
+        stashRef: string | null;
+    };
+    validation?: {
+        typecheck?: "passed" | "failed" | "skipped";
+        build?: "passed" | "failed" | "skipped";
+        tests?: string;
+        zoneCheck?: "clean" | "violations";
+        canonicalCheck?: "aligned" | "drift";
+    };
+}
+interface DistributedLock {
+    zone: string;
+    owner: string;
+    acquiredAt: string;
+    expiresAt: string;
+    ttlMinutes: number;
+    sprint?: string;
+    reason: string;
+}
+interface GateDefinition {
+    name: string;
+    command: string;
+    args?: string[];
+    timeoutSeconds: number;
+}
+interface OreshnikConfig {
+    version: 1;
+    project: {
+        name: string;
+        mainBranch: string;
+    };
+    operators: Array<{
+        id: string;
+        name: string;
+        email?: string;
+    }>;
+    branching: {
+        motherPrefix: string;
+        childFormat: string;
+        integrationPrefix: string;
+    };
+    validation: {
+        gates: GateDefinition[];
+    };
+    hardStops: {
+        forbiddenPatterns: string[];
+        doubleLockPatterns: string[];
+    };
+    vault: {
+        enabled: boolean;
+        path: string;
+        centralDoc: string;
+    };
+    canonical?: {
+        derivedDocs?: DerivedDocConfig[];
+        knownLegacyTasks?: string[];
+        knownAssignmentTasks?: string[];
+    };
+    sync?: {
+        canonicalAutoConflicts?: string[];
+    };
+    checkpoints: {
+        autoOnClose: boolean;
+        autoPreRollback: boolean;
+        snapshotDir: string;
+    };
+    security: {
+        requireCleanTree: boolean;
+        secretScanning: boolean;
+        blockEnvDiffs: boolean;
+    };
+}
+type InjectionPolicy = "proposal_only" | "direct_with_approval";
+interface PortfolioProject {
+    projectId: string;
+    displayName: string;
+    repoPath: string;
+    defaultBranch: string;
+    operators: string[];
+    taskBoardPath: string;
+    zoneMapPath: string;
+    validationGates: GateDefinition[];
+    injectionPolicy: InjectionPolicy;
+    priority: "low" | "medium" | "high" | "critical";
+}
+interface PortfolioConfig {
+    version: 1;
+    portfolio: {
+        id: string;
+        name: string;
+        sourceNote?: string;
+        continuityDocPath?: string;
+    };
+    projects: PortfolioProject[];
+}
+interface PortfolioProjectStatus {
+    projectId: string;
+    displayName: string;
+    repoPath: string;
+    repoExists: boolean;
+    taskBoardExists: boolean;
+    zoneMapExists: boolean;
+    validationGateCount: number;
+    injectionPolicy: InjectionPolicy;
+    warnings: string[];
+}
+interface PortfolioInspection {
+    configPath: string;
+    portfolioId: string;
+    portfolioName: string;
+    projectCount: number;
+    continuityDocPath?: string;
+    projects: PortfolioProjectStatus[];
+}
+interface PreflightResult {
+    sprint: string | null;
+    operator: string;
+    branch: string;
+    mother: string;
+    effectiveMother: string;
+    dirtyCount: number;
+    blockers: number;
+    warnings: number;
+    checks: PreflightCheck[];
+    at: string;
+}
+interface PreflightCheck {
+    step: number;
+    name: string;
+    status: "ok" | "fail" | "warn" | "skip";
+    message: string;
+}
+type EventType = "created" | "started" | "checkpoint" | "gate_passed" | "gate_failed" | "closed" | "rolled_back" | "reassigned";
+interface SprintEvent {
+    sprint: string;
+    operator: string;
+    type: EventType;
+    date: string;
+    at: string;
+    branch?: string;
+    previousMother?: string;
+    nextMother?: string;
+    description?: string;
+    changedFiles?: string[];
+    gateResults?: Record<string, "passed" | "failed">;
+}
+interface MergeResult {
+    resolved: boolean;
+    content: string | null;
+    conflicts: string[];
+}
+interface LockHandle {
+    path: string;
+    fd: number;
+}
+interface StateError extends OreshnikError {
+    code: "STATE_ERROR";
+}
+interface OperationalMetrics {
+    sprintsClosed: number;
+    sprintsRolledBack: number;
+    conflictsAvoided: number;
+    zoneFalsePositives: number;
+    zoneFalseNegatives: number;
+    avgTimePreflightToClose: number;
+    filesOutOfZone: number;
+    gatesFailedByCategory: Record<string, number>;
+    parallelSprintsNoConflict: number;
+    incompleteHandoffs: number;
+    recoveryTimeAfterBlock: number;
+    updatedAt: string;
+}
+interface DerivedDocConfig {
+    path: string;
+    type: "central" | "collaborator" | "status-board";
+    source: "task-board";
+    filter?: {
+        owner?: string;
+    };
+    extra?: Record<string, string>;
+}
+interface CanonicalIssue {
+    file: string;
+    severity: "blocker" | "warn";
+    reason: string;
+}
+interface CanonicalCheckResult {
+    aligned: boolean;
+    issues: CanonicalIssue[];
+    boardUpdatedAt: string;
+}
+interface SyncResult {
+    success: boolean;
+    merged: boolean;
+    latestMother: string;
+    conflicts: string[];
+    autoResolved: string[];
+    manualRequired: string[];
+}
+interface VaultGuardResult {
+    clean: boolean;
+    configDirty: string[];
+    configRestored: boolean;
+    contentDirty: string[];
+    unstagedStagedOverlap: string[];
+    untracked: string[];
+    errors: string[];
+}
+interface CanonicalConfig {
+    autoFix: boolean;
+    derivedDocs: DerivedDocConfig[];
+    knownLegacyTasks: string[];
+    knownAssignmentTasks: string[];
+}
+interface SyncConfig {
+    canonicalAutoConflicts: string[];
+    derivedDocPaths: string[];
+}
+type TaskType = "feature" | "bug" | "qa" | "docs" | "architecture" | "migration" | "ops";
+type EvidenceType = "code" | "ui" | "docs" | "integration" | "prod";
+interface NoteTask {
+    rawLine: string;
+    lineNumber: number;
+    checked: boolean;
+    projectIds: string[];
+    proposedType: TaskType;
+    proposedOwner: string;
+    proposedPriority: "low" | "medium" | "high" | "critical";
+    proposedSprintPrefix: string;
+    evidenceType: EvidenceType;
+    evidenceExpectation: string;
+}
+interface NotesIngestionResult {
+    sourcePath: string;
+    portfolioId: string;
+    parsedAt: string;
+    dryRun: boolean;
+    totalLines: number;
+    taskLines: number;
+    pendingCount: number;
+    doneCount: number;
+    tasksByProject: Record<string, NoteTask[]>;
+    unclassifiedTasks: NoteTask[];
+    warnings: string[];
+}
+interface ProjectInjectionResult {
+    projectId: string;
+    displayName: string;
+    injectionPolicy: InjectionPolicy;
+    repoPath: string;
+    tasksInjected: number;
+    tasksSkipped: number;
+    checkpointTag?: string;
+    handoffPath?: string;
+    proposalPath?: string;
+    blocked: boolean;
+    blockReason?: string;
+    warnings: string[];
+}
+interface InjectionResult {
+    portfolioId: string;
+    injectedAt: string;
+    dryRun: boolean;
+    confirmed: boolean;
+    projects: ProjectInjectionResult[];
+    summary: {
+        totalProjects: number;
+        projectsBlocked: number;
+        projectsInjected: number;
+        proposalsGenerated: number;
+        totalTasksInjected: number;
+        totalTasksSkipped: number;
+    };
+    errors: string[];
+}
+interface EvidenceRecord {
+    taskId: string;
+    evidenceType: EvidenceType;
+    validatedAt: string;
+    validator: string;
+    result: "passed" | "failed" | "pending";
+    details: string;
+    artifacts?: string[];
+}
+interface TaskEvidenceCheck {
+    taskId: string;
+    taskTitle: string;
+    evidenceType: EvidenceType;
+    hasEvidence: boolean;
+    requiredEvidence: string;
+    currentStatus: TaskStatus;
+    missing: string[];
+}
+interface EvidenceGateResult {
+    checkedAt: string;
+    sprint?: string;
+    operator: string;
+    totalTasks: number;
+    doneTasks: number;
+    tasksWithEvidence: number;
+    tasksWithoutEvidence: number;
+    tasks: TaskEvidenceCheck[];
+    passed: boolean;
+    blockers: string[];
+}
+interface ZoneLock {
+    zone: string;
+    operator: string;
+    sprint: string;
+    acquiredAt: string;
+    ttl: number;
+    expiresAt: string;
+}
+interface LockResult {
+    zone: string;
+    acquired: boolean;
+    existingLock?: ZoneLock;
+    error?: string;
+}
+interface LockList {
+    fetchedAt: string;
+    locks: ZoneLock[];
+    active: ZoneLock[];
+    expired: ZoneLock[];
+}
+
+declare class GitService {
+    private readonly cwd;
+    constructor(cwd: string);
+    exec(args: string[]): {
+        ok: boolean;
+        output: string;
+        error: string;
+        status: number;
+    };
+    private fail;
+    currentBranch(): Result<string, GitError>;
+    refExists(ref: string): boolean;
+    resolveRef(ref: string): Result<string, GitError>;
+    statusPorcelain(): Result<PorcelainEntry[], GitError>;
+    fetch(remote?: string): Result<void, GitError>;
+    getMergeBase(a: string, b: string): Result<string, GitError>;
+    discoverLatestMother(prefix?: string): Result<MotherRef | null, GitError>;
+    diffNames(base: string, target: string, paths?: string[]): Result<string[], GitError>;
+    unmergedFiles(): Result<string[], GitError>;
+    showRef(ref: string, file: string): Result<string | null, GitError>;
+    createBranch(name: string, from?: string): Result<void, GitError>;
+    checkout(branch: string): Result<void, GitError>;
+    merge(ref: string, options?: MergeOptions): Result<void, GitError>;
+    push(remote: string, branch: string, force?: boolean): Result<void, GitError>;
+    pushTag(remote: string, tag: string): Result<void, GitError>;
+    stage(files: string[]): Result<void, GitError>;
+    commit(message: string): Result<void, GitError>;
+    createTag(name: string, message: string): Result<void, GitError>;
+    deleteTag(name: string): Result<void, GitError>;
+    resetHard(ref: string): Result<void, GitError>;
+    deleteBranch(branch: string, force?: boolean): Result<void, GitError>;
+    stashPush(message?: string): Result<string | null, GitError>;
+    stashPop(): Result<void, GitError>;
+    pushLockRef(zone: string, _lockContent: string): Result<void, GitError>;
+    deleteLockRef(zone: string): Result<void, GitError>;
+    fetchLockRefs(): Result<string[], GitError>;
+    getLockContent(ref: string): Result<string | null, GitError>;
+    cherryPick(commit: string): Result<void, GitError>;
+    restoreFromHead(pattern: string): Result<void, GitError>;
+    userConfig(key: string): Result<string, GitError>;
+    mergeFileUnion(currentFile: string, baseFile: string, sourceFile: string): Result<string, GitError>;
+}
+declare function createGitService(cwd: string): GitService;
+
+declare class ZoneEngine {
+    private globToRegex;
+    findMatchingZone(file: string, zoneMap: ZoneMap): {
+        pattern: string;
+        zone: ZoneMap["zones"][string];
+    } | null;
+    check(files: string[], operator: string, sprint: string, zoneMap: ZoneMap): ZoneCheckResult;
+    private checkLock;
+    getModifiedZones(files: string[], zoneMap: ZoneMap): Set<string>;
+}
+declare function createZoneEngine(): ZoneEngine;
+
+declare class StateManager {
+    private readonly root;
+    private readonly runsDir;
+    constructor(root: string);
+    readJson<T>(filePath: string): Result<T, StateError>;
+    writeJson<T>(filePath: string, value: T): Result<void, StateError>;
+    readText(filePath: string): Result<string, StateError>;
+    writeText(filePath: string, content: string): Result<void, StateError>;
+    mergeTextUnion(file: string, base: string, current: string, source: string): Result<string, StateError>;
+    mergeJsonSmart(base: unknown, current: unknown, source: unknown): Result<unknown, StateError>;
+    private mergeValue;
+    acquireLocalLock(lockName: string, timeoutMs?: number): Result<LockHandle, StateError>;
+    private openExclusive;
+    releaseLocalLock(handle: LockHandle): Result<void, StateError>;
+}
+declare function createStateManager(root: string): StateManager;
+
+declare class CanonicalService {
+    private readonly state;
+    private readonly root;
+    constructor(state: StateManager, root: string);
+    checkCanonicalAlignment(taskBoard: TaskBoard, derivedDocs: DerivedDocConfig[], mother: MotherVersion, relicTaskIds?: string[], assignmentTaskIds?: string[]): CanonicalCheckResult;
+    regenerateAllDerivedDocs(taskBoard: TaskBoard, derivedDocs: DerivedDocConfig[], mother: MotherVersion, projectName: string): Result<void, OreshnikError>;
+    generateCentral(taskBoard: TaskBoard, mother: MotherVersion, projectName: string, extra?: Record<string, string>): string;
+    generateCollaborator(taskBoard: TaskBoard, owner: string, projectName: string): string;
+    generateStatusBoard(taskBoard: TaskBoard, projectName: string): string;
+    private hasLegacyClosureConflict;
+    private hasAssignmentConflict;
+    private nowISO;
+}
+declare function createCanonicalService(state: StateManager, root: string): CanonicalService;
+
+declare class SyncService {
+    private readonly git;
+    private readonly state;
+    private readonly canonical;
+    private readonly root;
+    constructor(git: GitService, state: StateManager, canonical: CanonicalService, root: string);
+    syncLatestMother(args: {
+        motherPrefix: string;
+        derivedDocPaths: string[];
+        canonicalAutoConflicts?: string[];
+        projectName: string;
+        derivedDocs: Array<{
+            path: string;
+            type: "central" | "collaborator" | "status-board";
+            filter?: {
+                owner?: string;
+            };
+            extra?: Record<string, string>;
+        }>;
+        operator: string;
+    }): SyncResult;
+    private mergeTaskBoardById;
+    private mergeUniqueReassignments;
+    private readMother;
+    private runsDir;
+    private toGitPath;
+}
+declare function createSyncService(git: GitService, state: StateManager, canonical: CanonicalService, root: string): SyncService;
+
+declare class VaultGuard {
+    private readonly git;
+    constructor(git: GitService);
+    check(vaultPath: string, obsidianConfigDir: string, force?: boolean): VaultGuardResult;
+    restoreConfig(obsidianConfigDir: string): Result<void, OreshnikError>;
+    private gitDirtyFiles;
+    private gitDiffFiles;
+    private gitUntrackedFiles;
+}
+declare function createVaultGuard(git: GitService): VaultGuard;
+
+declare class PortfolioService {
+    private readonly root;
+    constructor(root: string);
+    load(configPath?: string): Result<PortfolioConfig, StateError>;
+    inspect(configPath?: string): Result<PortfolioInspection, StateError>;
+    private inspectProject;
+    private resolvePath;
+    private fail;
+}
+declare function createPortfolioService(root: string): PortfolioService;
+
+declare class NotesIngestionService {
+    private readonly root;
+    constructor(root: string);
+    ingest(options: {
+        sourcePath: string;
+        configPath?: string;
+        dryRun?: boolean;
+    }): Result<NotesIngestionResult, StateError>;
+    private loadPortfolio;
+    private classifyProject;
+    private classifyOwner;
+    private classifyTaskType;
+    private classifyPriority;
+    private resolveSprintPrefix;
+    private classifyEvidence;
+    private resolvePath;
+    private fail;
+}
+declare function createNotesIngestionService(root: string): NotesIngestionService;
+
+declare class InjectionService {
+    private readonly root;
+    constructor(root: string);
+    inject(options: {
+        ingestion: NotesIngestionResult;
+        configPath?: string;
+        dryRun?: boolean;
+        confirm?: boolean;
+        projectFilter?: string[];
+    }): Result<InjectionResult, StateError>;
+    private injectIntoProject;
+    private generateProposal;
+    private generateHandoff;
+    private createPreInjectionCheckpoint;
+    private generateTaskId;
+    private loadPortfolio;
+    private resolveProjectPath;
+    private resolveLocalPath;
+    private fail;
+}
+declare function createInjectionService(root: string): InjectionService;
+
+declare class EvidenceGateService {
+    check(taskBoard: TaskBoard, operator: string, sprint?: string): Result<EvidenceGateResult, StateError>;
+    generateChecklist(taskBoard: TaskBoard, operator: string): string;
+    private evaluateTaskEvidence;
+    private inferEvidenceType;
+    private fail;
+}
+declare function createEvidenceGateService(): EvidenceGateService;
+
+interface BootstrapProjectResult {
+    projectId: string;
+    displayName: string;
+    repoPath: string;
+    repoExists: boolean;
+    taskBoardCreated: boolean;
+    zoneMapCreated: boolean;
+    gatesDocCreated: boolean;
+    errors: string[];
+}
+interface BootstrapResult {
+    portfolioId: string;
+    bootstrappedAt: string;
+    projects: BootstrapProjectResult[];
+}
+declare class BootstrapService {
+    private readonly root;
+    constructor(root: string);
+    bootstrap(configPath?: string, projectFilter?: string[]): Result<BootstrapResult, StateError>;
+    private bootstrapProject;
+    private loadPortfolio;
+    private resolveProjectPath;
+    private resolveLocalPath;
+    private fail;
+}
+declare function createBootstrapService(root: string): BootstrapService;
+
+interface OperatorBreakdown {
+    operator: string;
+    ready: number;
+    active: number;
+    done: number;
+    blocked: number;
+    pending: number;
+    total: number;
+}
+interface TaskEntry {
+    id: string;
+    title: string;
+    owner: string;
+    status: string;
+    dependsOn: string[];
+}
+interface LockSummary {
+    zone: string;
+    operator: string;
+    sprint: string;
+    expiresAt: string;
+    remainingMinutes: number;
+}
+interface ProjectDashboard {
+    projectId: string;
+    displayName: string;
+    repoPath: string;
+    repoExists: boolean;
+    taskBoardExists: boolean;
+    zoneMapExists: boolean;
+    injectionPolicy: string;
+    priority: string;
+    taskCounts: {
+        total: number;
+        ready: number;
+        active: number;
+        done: number;
+        blocked: number;
+        pending: number;
+    };
+    operatorBreakdown: OperatorBreakdown[];
+    tasks: TaskEntry[];
+    locks: LockSummary[];
+    lastUpdated?: string;
+    warnings: string[];
+}
+interface PortfolioDashboard {
+    portfolioId: string;
+    portfolioName: string;
+    generatedAt: string;
+    projectCount: number;
+    projectsWithRepo: number;
+    projectsReady: number;
+    projectsBlocked: number;
+    totalTasks: number;
+    totalDone: number;
+    totalPending: number;
+    projects: ProjectDashboard[];
+}
+declare class DashboardService {
+    private readonly root;
+    private lockService;
+    constructor(root: string);
+    generate(configPath?: string): Result<PortfolioDashboard, StateError>;
+    toMarkdown(dashboard: PortfolioDashboard): string;
+    private inspectProject;
+    private loadPortfolio;
+    private resolvePath;
+    private fail;
+}
+declare function createDashboardService(root: string): DashboardService;
+
+interface ProjectZoneCheck {
+    projectId: string;
+    displayName: string;
+    repoPath: string;
+    zoneMapExists: boolean;
+    zoneMapValid: boolean;
+    branch: string;
+    filesChecked: number;
+    violations: ZoneViolation[];
+    warnings: ZoneWarning[];
+    passed: boolean;
+    errors: string[];
+}
+interface PortfolioZoneCheck {
+    portfolioId: string;
+    checkedAt: string;
+    operator: string;
+    sprint?: string;
+    projects: ProjectZoneCheck[];
+    summary: {
+        totalProjects: number;
+        projectsWithZoneMap: number;
+        projectsWithViolations: number;
+        projectsPassed: number;
+        totalViolations: number;
+        totalWarnings: number;
+    };
+}
+declare class ZoneCheckService {
+    private readonly root;
+    constructor(root: string);
+    checkAll(configPath: string, operator: string, sprint?: string, projectFilter?: string[]): Result<PortfolioZoneCheck, StateError>;
+    private checkProject;
+    private loadPortfolio;
+    private resolvePath;
+    private fail;
+}
+declare function createZoneCheckService(root: string): ZoneCheckService;
+
+interface ProjectAudit {
+    projectId: string;
+    displayName: string;
+    repoPath: string;
+    repoExists: boolean;
+    branch: string;
+    lastCommit?: {
+        hash: string;
+        message: string;
+        date: string;
+        author: string;
+    };
+    checkpointTags: string[];
+    taskBoardExists: boolean;
+    taskCount: number;
+    zoneMapExists: boolean;
+    zoneMapValid: boolean;
+    modifiedFiles: number;
+    errors: string[];
+}
+interface PortfolioAudit {
+    portfolioId: string;
+    auditedAt: string;
+    projects: ProjectAudit[];
+    summary: {
+        totalProjects: number;
+        projectsWithRepo: number;
+        projectsDirty: number;
+        projectsClean: number;
+        totalTasks: number;
+        totalCheckpoints: number;
+    };
+}
+declare class AuditService {
+    private readonly root;
+    constructor(root: string);
+    audit(configPath?: string, projectFilter?: string[]): Result<PortfolioAudit, StateError>;
+    secretScan(configPath?: string): Result<string[], StateError>;
+    private auditProject;
+    private loadPortfolio;
+    private resolvePath;
+    private fail;
+}
+declare function createAuditService(root: string): AuditService;
+
+declare class LockService {
+    private git;
+    constructor(repoPath: string);
+    acquire(zone: string, operator: string, sprint: string, ttl?: number): Result<LockResult, StateError>;
+    release(zone: string): Result<LockResult, StateError>;
+    check(zone?: string): Result<LockList, StateError>;
+    private sanitizeRef;
+    private fail;
+}
+declare function createLockService(repoPath: string): LockService;
+
+type LogLevel = "OK" | "FAIL" | "WARN" | "INFO";
+declare function log(level: LogLevel, message: string): void;
+declare function header(title: string, subtitle?: string): void;
+declare function statusBox(lines: Array<[string, string]>): void;
+declare function resultSummary(blockers: number, warnings: number, operator: string, sprint: string, branch: string, mother: string): void;
+
+declare function sanitize(value: string, maxLength?: number): string;
+declare function today(): string;
+declare function nowISO(): string;
+declare function nowDisplay(timeZone?: string): {
+    display: string;
+    iso: string;
+    date: string;
+};
+declare function formatBranchName(template: string, vars: Record<string, string>): string;
+declare function nonIgnoredDirtyFiles(porcelain: Array<{
+    status: string;
+    path: string;
+}>): string[];
+declare function isMotherBranch(branch: string): boolean;
+declare function isChildBranch(branch: string, operator: string): boolean;
+
+declare function execCommand(command: string, args: string[], options?: {
+    cwd?: string;
+    timeout?: number;
+}): Result<{
+    output: string;
+    exitCode: number;
+}, GitError>;
+declare function execCommandInherit(command: string, args: string[], options?: {
+    cwd?: string;
+    timeout?: number;
+}): Result<{
+    exitCode: number;
+}, GitError>;
+
+declare const TaskBoardSchema: z.ZodObject<{
+    project: z.ZodString;
+    updatedAt: z.ZodString;
+    resiliencePolicy: z.ZodOptional<z.ZodString>;
+    closurePolicy: z.ZodOptional<z.ZodString>;
+    baseTestMatrix: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    currentExecutionOrder: z.ZodArray<z.ZodString, "many">;
+    tasks: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        title: z.ZodString;
+        owner: z.ZodString;
+        backupOwner: z.ZodOptional<z.ZodString>;
+        status: z.ZodEnum<["ready", "active", "pending", "blocked", "done", "rolled_back"]>;
+        track: z.ZodOptional<z.ZodString>;
+        zone: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        dependsOn: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        acceptance: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        handoff: z.ZodOptional<z.ZodString>;
+        history: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            at: z.ZodString;
+            action: z.ZodString;
+            operator: z.ZodOptional<z.ZodString>;
+            from: z.ZodOptional<z.ZodString>;
+            to: z.ZodOptional<z.ZodString>;
+            reason: z.ZodOptional<z.ZodString>;
+            branch: z.ZodOptional<z.ZodString>;
+            description: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            at: string;
+            action: string;
+            branch?: string | undefined;
+            reason?: string | undefined;
+            operator?: string | undefined;
+            from?: string | undefined;
+            to?: string | undefined;
+            description?: string | undefined;
+        }, {
+            at: string;
+            action: string;
+            branch?: string | undefined;
+            reason?: string | undefined;
+            operator?: string | undefined;
+            from?: string | undefined;
+            to?: string | undefined;
+            description?: string | undefined;
+        }>, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        status: "ready" | "active" | "pending" | "blocked" | "done" | "rolled_back";
+        owner: string;
+        id: string;
+        title: string;
+        zone?: string[] | undefined;
+        backupOwner?: string | undefined;
+        track?: string | undefined;
+        dependsOn?: string[] | undefined;
+        acceptance?: string[] | undefined;
+        handoff?: string | undefined;
+        history?: {
+            at: string;
+            action: string;
+            branch?: string | undefined;
+            reason?: string | undefined;
+            operator?: string | undefined;
+            from?: string | undefined;
+            to?: string | undefined;
+            description?: string | undefined;
+        }[] | undefined;
+    }, {
+        status: "ready" | "active" | "pending" | "blocked" | "done" | "rolled_back";
+        owner: string;
+        id: string;
+        title: string;
+        zone?: string[] | undefined;
+        backupOwner?: string | undefined;
+        track?: string | undefined;
+        dependsOn?: string[] | undefined;
+        acceptance?: string[] | undefined;
+        handoff?: string | undefined;
+        history?: {
+            at: string;
+            action: string;
+            branch?: string | undefined;
+            reason?: string | undefined;
+            operator?: string | undefined;
+            from?: string | undefined;
+            to?: string | undefined;
+            description?: string | undefined;
+        }[] | undefined;
+    }>, "many">;
+    reassignments: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        at: z.ZodString;
+        task: z.ZodString;
+        from: z.ZodString;
+        to: z.ZodString;
+        reason: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        at: string;
+        reason: string;
+        from: string;
+        to: string;
+        task: string;
+    }, {
+        at: string;
+        reason: string;
+        from: string;
+        to: string;
+        task: string;
+    }>, "many">>;
+}, "strip", z.ZodTypeAny, {
+    project: string;
+    updatedAt: string;
+    currentExecutionOrder: string[];
+    tasks: {
+        status: "ready" | "active" | "pending" | "blocked" | "done" | "rolled_back";
+        owner: string;
+        id: string;
+        title: string;
+        zone?: string[] | undefined;
+        backupOwner?: string | undefined;
+        track?: string | undefined;
+        dependsOn?: string[] | undefined;
+        acceptance?: string[] | undefined;
+        handoff?: string | undefined;
+        history?: {
+            at: string;
+            action: string;
+            branch?: string | undefined;
+            reason?: string | undefined;
+            operator?: string | undefined;
+            from?: string | undefined;
+            to?: string | undefined;
+            description?: string | undefined;
+        }[] | undefined;
+    }[];
+    resiliencePolicy?: string | undefined;
+    closurePolicy?: string | undefined;
+    baseTestMatrix?: string[] | undefined;
+    reassignments?: {
+        at: string;
+        reason: string;
+        from: string;
+        to: string;
+        task: string;
+    }[] | undefined;
+}, {
+    project: string;
+    updatedAt: string;
+    currentExecutionOrder: string[];
+    tasks: {
+        status: "ready" | "active" | "pending" | "blocked" | "done" | "rolled_back";
+        owner: string;
+        id: string;
+        title: string;
+        zone?: string[] | undefined;
+        backupOwner?: string | undefined;
+        track?: string | undefined;
+        dependsOn?: string[] | undefined;
+        acceptance?: string[] | undefined;
+        handoff?: string | undefined;
+        history?: {
+            at: string;
+            action: string;
+            branch?: string | undefined;
+            reason?: string | undefined;
+            operator?: string | undefined;
+            from?: string | undefined;
+            to?: string | undefined;
+            description?: string | undefined;
+        }[] | undefined;
+    }[];
+    resiliencePolicy?: string | undefined;
+    closurePolicy?: string | undefined;
+    baseTestMatrix?: string[] | undefined;
+    reassignments?: {
+        at: string;
+        reason: string;
+        from: string;
+        to: string;
+        task: string;
+    }[] | undefined;
+}>;
+declare const MotherVersionSchema: z.ZodObject<{
+    version: z.ZodNumber;
+    current: z.ZodString;
+    branches: z.ZodArray<z.ZodObject<{
+        version: z.ZodNumber;
+        name: z.ZodString;
+        sprint: z.ZodString;
+        operator: z.ZodString;
+        date: z.ZodString;
+        at: z.ZodString;
+        previous: z.ZodString;
+        description: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        name: string;
+        version: number;
+        at: string;
+        operator: string;
+        description: string;
+        date: string;
+        sprint: string;
+        previous: string;
+    }, {
+        name: string;
+        version: number;
+        at: string;
+        operator: string;
+        description: string;
+        date: string;
+        sprint: string;
+        previous: string;
+    }>, "many">;
+}, "strip", z.ZodTypeAny, {
+    version: number;
+    current: string;
+    branches: {
+        name: string;
+        version: number;
+        at: string;
+        operator: string;
+        description: string;
+        date: string;
+        sprint: string;
+        previous: string;
+    }[];
+}, {
+    version: number;
+    current: string;
+    branches: {
+        name: string;
+        version: number;
+        at: string;
+        operator: string;
+        description: string;
+        date: string;
+        sprint: string;
+        previous: string;
+    }[];
+}>;
+declare const ZoneMapSchema: z.ZodObject<{
+    zones: z.ZodRecord<z.ZodString, z.ZodObject<{
+        owner: z.ZodString;
+        lock: z.ZodEnum<["operator_exclusive", "operator_double", "shared", "forbidden", "owner_per_sprint"]>;
+        sprints: z.ZodArray<z.ZodString, "many">;
+        criticality: z.ZodOptional<z.ZodEnum<["low", "medium", "high", "critical"]>>;
+    }, "strip", z.ZodTypeAny, {
+        owner: string;
+        lock: "operator_exclusive" | "operator_double" | "shared" | "forbidden" | "owner_per_sprint";
+        sprints: string[];
+        criticality?: "low" | "medium" | "high" | "critical" | undefined;
+    }, {
+        owner: string;
+        lock: "operator_exclusive" | "operator_double" | "shared" | "forbidden" | "owner_per_sprint";
+        sprints: string[];
+        criticality?: "low" | "medium" | "high" | "critical" | undefined;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    zones: Record<string, {
+        owner: string;
+        lock: "operator_exclusive" | "operator_double" | "shared" | "forbidden" | "owner_per_sprint";
+        sprints: string[];
+        criticality?: "low" | "medium" | "high" | "critical" | undefined;
+    }>;
+}, {
+    zones: Record<string, {
+        owner: string;
+        lock: "operator_exclusive" | "operator_double" | "shared" | "forbidden" | "owner_per_sprint";
+        sprints: string[];
+        criticality?: "low" | "medium" | "high" | "critical" | undefined;
+    }>;
+}>;
+declare const DerivedDocConfigSchema: z.ZodObject<{
+    path: z.ZodString;
+    type: z.ZodEnum<["central", "collaborator", "status-board"]>;
+    source: z.ZodLiteral<"task-board">;
+    filter: z.ZodOptional<z.ZodObject<{
+        owner: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        owner: string;
+    }, {
+        owner: string;
+    }>>;
+    extra: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+}, "strip", z.ZodTypeAny, {
+    path: string;
+    type: "central" | "collaborator" | "status-board";
+    source: "task-board";
+    filter?: {
+        owner: string;
+    } | undefined;
+    extra?: Record<string, string> | undefined;
+}, {
+    path: string;
+    type: "central" | "collaborator" | "status-board";
+    source: "task-board";
+    filter?: {
+        owner: string;
+    } | undefined;
+    extra?: Record<string, string> | undefined;
+}>;
+declare const OreshnikConfigSchema: z.ZodObject<{
+    version: z.ZodLiteral<1>;
+    project: z.ZodObject<{
+        name: z.ZodString;
+        mainBranch: z.ZodDefault<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        name: string;
+        mainBranch: string;
+    }, {
+        name: string;
+        mainBranch?: string | undefined;
+    }>;
+    operators: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        email: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        name: string;
+        id: string;
+        email?: string | undefined;
+    }, {
+        name: string;
+        id: string;
+        email?: string | undefined;
+    }>, "many">;
+    branching: z.ZodDefault<z.ZodOptional<z.ZodObject<{
+        motherPrefix: z.ZodDefault<z.ZodString>;
+        childFormat: z.ZodDefault<z.ZodString>;
+        integrationPrefix: z.ZodDefault<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        motherPrefix: string;
+        childFormat: string;
+        integrationPrefix: string;
+    }, {
+        motherPrefix?: string | undefined;
+        childFormat?: string | undefined;
+        integrationPrefix?: string | undefined;
+    }>>>;
+    validation: z.ZodDefault<z.ZodOptional<z.ZodObject<{
+        gates: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            command: z.ZodString;
+            args: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+            timeoutSeconds: z.ZodDefault<z.ZodNumber>;
+        }, "strip", z.ZodTypeAny, {
+            name: string;
+            command: string;
+            timeoutSeconds: number;
+            args?: string[] | undefined;
+        }, {
+            name: string;
+            command: string;
+            args?: string[] | undefined;
+            timeoutSeconds?: number | undefined;
+        }>, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        gates: {
+            name: string;
+            command: string;
+            timeoutSeconds: number;
+            args?: string[] | undefined;
+        }[];
+    }, {
+        gates?: {
+            name: string;
+            command: string;
+            args?: string[] | undefined;
+            timeoutSeconds?: number | undefined;
+        }[] | undefined;
+    }>>>;
+    hardStops: z.ZodDefault<z.ZodOptional<z.ZodObject<{
+        forbiddenPatterns: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+        doubleLockPatterns: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        forbiddenPatterns: string[];
+        doubleLockPatterns: string[];
+    }, {
+        forbiddenPatterns?: string[] | undefined;
+        doubleLockPatterns?: string[] | undefined;
+    }>>>;
+    vault: z.ZodDefault<z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodDefault<z.ZodBoolean>;
+        path: z.ZodDefault<z.ZodString>;
+        centralDoc: z.ZodDefault<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        path: string;
+        enabled: boolean;
+        centralDoc: string;
+    }, {
+        path?: string | undefined;
+        enabled?: boolean | undefined;
+        centralDoc?: string | undefined;
+    }>>>;
+    canonical: z.ZodOptional<z.ZodObject<{
+        derivedDocs: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            path: z.ZodString;
+            type: z.ZodEnum<["central", "collaborator", "status-board"]>;
+            source: z.ZodLiteral<"task-board">;
+            filter: z.ZodOptional<z.ZodObject<{
+                owner: z.ZodString;
+            }, "strip", z.ZodTypeAny, {
+                owner: string;
+            }, {
+                owner: string;
+            }>>;
+            extra: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        }, "strip", z.ZodTypeAny, {
+            path: string;
+            type: "central" | "collaborator" | "status-board";
+            source: "task-board";
+            filter?: {
+                owner: string;
+            } | undefined;
+            extra?: Record<string, string> | undefined;
+        }, {
+            path: string;
+            type: "central" | "collaborator" | "status-board";
+            source: "task-board";
+            filter?: {
+                owner: string;
+            } | undefined;
+            extra?: Record<string, string> | undefined;
+        }>, "many">>;
+        knownLegacyTasks: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        knownAssignmentTasks: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        derivedDocs?: {
+            path: string;
+            type: "central" | "collaborator" | "status-board";
+            source: "task-board";
+            filter?: {
+                owner: string;
+            } | undefined;
+            extra?: Record<string, string> | undefined;
+        }[] | undefined;
+        knownLegacyTasks?: string[] | undefined;
+        knownAssignmentTasks?: string[] | undefined;
+    }, {
+        derivedDocs?: {
+            path: string;
+            type: "central" | "collaborator" | "status-board";
+            source: "task-board";
+            filter?: {
+                owner: string;
+            } | undefined;
+            extra?: Record<string, string> | undefined;
+        }[] | undefined;
+        knownLegacyTasks?: string[] | undefined;
+        knownAssignmentTasks?: string[] | undefined;
+    }>>;
+    sync: z.ZodOptional<z.ZodObject<{
+        canonicalAutoConflicts: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        canonicalAutoConflicts?: string[] | undefined;
+    }, {
+        canonicalAutoConflicts?: string[] | undefined;
+    }>>;
+    checkpoints: z.ZodDefault<z.ZodOptional<z.ZodObject<{
+        autoOnClose: z.ZodDefault<z.ZodBoolean>;
+        autoPreRollback: z.ZodDefault<z.ZodBoolean>;
+        snapshotDir: z.ZodDefault<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        autoOnClose: boolean;
+        autoPreRollback: boolean;
+        snapshotDir: string;
+    }, {
+        autoOnClose?: boolean | undefined;
+        autoPreRollback?: boolean | undefined;
+        snapshotDir?: string | undefined;
+    }>>>;
+    security: z.ZodDefault<z.ZodOptional<z.ZodObject<{
+        requireCleanTree: z.ZodDefault<z.ZodBoolean>;
+        secretScanning: z.ZodDefault<z.ZodBoolean>;
+        blockEnvDiffs: z.ZodDefault<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        requireCleanTree: boolean;
+        secretScanning: boolean;
+        blockEnvDiffs: boolean;
+    }, {
+        requireCleanTree?: boolean | undefined;
+        secretScanning?: boolean | undefined;
+        blockEnvDiffs?: boolean | undefined;
+    }>>>;
+}, "strip", z.ZodTypeAny, {
+    version: 1;
+    validation: {
+        gates: {
+            name: string;
+            command: string;
+            timeoutSeconds: number;
+            args?: string[] | undefined;
+        }[];
+    };
+    project: {
+        name: string;
+        mainBranch: string;
+    };
+    operators: {
+        name: string;
+        id: string;
+        email?: string | undefined;
+    }[];
+    branching: {
+        motherPrefix: string;
+        childFormat: string;
+        integrationPrefix: string;
+    };
+    hardStops: {
+        forbiddenPatterns: string[];
+        doubleLockPatterns: string[];
+    };
+    vault: {
+        path: string;
+        enabled: boolean;
+        centralDoc: string;
+    };
+    checkpoints: {
+        autoOnClose: boolean;
+        autoPreRollback: boolean;
+        snapshotDir: string;
+    };
+    security: {
+        requireCleanTree: boolean;
+        secretScanning: boolean;
+        blockEnvDiffs: boolean;
+    };
+    canonical?: {
+        derivedDocs?: {
+            path: string;
+            type: "central" | "collaborator" | "status-board";
+            source: "task-board";
+            filter?: {
+                owner: string;
+            } | undefined;
+            extra?: Record<string, string> | undefined;
+        }[] | undefined;
+        knownLegacyTasks?: string[] | undefined;
+        knownAssignmentTasks?: string[] | undefined;
+    } | undefined;
+    sync?: {
+        canonicalAutoConflicts?: string[] | undefined;
+    } | undefined;
+}, {
+    version: 1;
+    project: {
+        name: string;
+        mainBranch?: string | undefined;
+    };
+    operators: {
+        name: string;
+        id: string;
+        email?: string | undefined;
+    }[];
+    validation?: {
+        gates?: {
+            name: string;
+            command: string;
+            args?: string[] | undefined;
+            timeoutSeconds?: number | undefined;
+        }[] | undefined;
+    } | undefined;
+    branching?: {
+        motherPrefix?: string | undefined;
+        childFormat?: string | undefined;
+        integrationPrefix?: string | undefined;
+    } | undefined;
+    hardStops?: {
+        forbiddenPatterns?: string[] | undefined;
+        doubleLockPatterns?: string[] | undefined;
+    } | undefined;
+    vault?: {
+        path?: string | undefined;
+        enabled?: boolean | undefined;
+        centralDoc?: string | undefined;
+    } | undefined;
+    canonical?: {
+        derivedDocs?: {
+            path: string;
+            type: "central" | "collaborator" | "status-board";
+            source: "task-board";
+            filter?: {
+                owner: string;
+            } | undefined;
+            extra?: Record<string, string> | undefined;
+        }[] | undefined;
+        knownLegacyTasks?: string[] | undefined;
+        knownAssignmentTasks?: string[] | undefined;
+    } | undefined;
+    sync?: {
+        canonicalAutoConflicts?: string[] | undefined;
+    } | undefined;
+    checkpoints?: {
+        autoOnClose?: boolean | undefined;
+        autoPreRollback?: boolean | undefined;
+        snapshotDir?: string | undefined;
+    } | undefined;
+    security?: {
+        requireCleanTree?: boolean | undefined;
+        secretScanning?: boolean | undefined;
+        blockEnvDiffs?: boolean | undefined;
+    } | undefined;
+}>;
+declare const PortfolioProjectSchema: z.ZodObject<{
+    projectId: z.ZodString;
+    displayName: z.ZodString;
+    repoPath: z.ZodString;
+    defaultBranch: z.ZodString;
+    operators: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    taskBoardPath: z.ZodDefault<z.ZodString>;
+    zoneMapPath: z.ZodDefault<z.ZodString>;
+    validationGates: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        command: z.ZodString;
+        args: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        timeoutSeconds: z.ZodDefault<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        name: string;
+        command: string;
+        timeoutSeconds: number;
+        args?: string[] | undefined;
+    }, {
+        name: string;
+        command: string;
+        args?: string[] | undefined;
+        timeoutSeconds?: number | undefined;
+    }>, "many">>;
+    injectionPolicy: z.ZodDefault<z.ZodEnum<["proposal_only", "direct_with_approval"]>>;
+    priority: z.ZodDefault<z.ZodEnum<["low", "medium", "high", "critical"]>>;
+}, "strip", z.ZodTypeAny, {
+    operators: string[];
+    projectId: string;
+    displayName: string;
+    repoPath: string;
+    defaultBranch: string;
+    taskBoardPath: string;
+    zoneMapPath: string;
+    validationGates: {
+        name: string;
+        command: string;
+        timeoutSeconds: number;
+        args?: string[] | undefined;
+    }[];
+    injectionPolicy: "proposal_only" | "direct_with_approval";
+    priority: "low" | "medium" | "high" | "critical";
+}, {
+    projectId: string;
+    displayName: string;
+    repoPath: string;
+    defaultBranch: string;
+    operators?: string[] | undefined;
+    taskBoardPath?: string | undefined;
+    zoneMapPath?: string | undefined;
+    validationGates?: {
+        name: string;
+        command: string;
+        args?: string[] | undefined;
+        timeoutSeconds?: number | undefined;
+    }[] | undefined;
+    injectionPolicy?: "proposal_only" | "direct_with_approval" | undefined;
+    priority?: "low" | "medium" | "high" | "critical" | undefined;
+}>;
+declare const PortfolioConfigSchema: z.ZodObject<{
+    version: z.ZodLiteral<1>;
+    portfolio: z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        sourceNote: z.ZodOptional<z.ZodString>;
+        continuityDocPath: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        name: string;
+        id: string;
+        sourceNote?: string | undefined;
+        continuityDocPath?: string | undefined;
+    }, {
+        name: string;
+        id: string;
+        sourceNote?: string | undefined;
+        continuityDocPath?: string | undefined;
+    }>;
+    projects: z.ZodArray<z.ZodObject<{
+        projectId: z.ZodString;
+        displayName: z.ZodString;
+        repoPath: z.ZodString;
+        defaultBranch: z.ZodString;
+        operators: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+        taskBoardPath: z.ZodDefault<z.ZodString>;
+        zoneMapPath: z.ZodDefault<z.ZodString>;
+        validationGates: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            command: z.ZodString;
+            args: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+            timeoutSeconds: z.ZodDefault<z.ZodNumber>;
+        }, "strip", z.ZodTypeAny, {
+            name: string;
+            command: string;
+            timeoutSeconds: number;
+            args?: string[] | undefined;
+        }, {
+            name: string;
+            command: string;
+            args?: string[] | undefined;
+            timeoutSeconds?: number | undefined;
+        }>, "many">>;
+        injectionPolicy: z.ZodDefault<z.ZodEnum<["proposal_only", "direct_with_approval"]>>;
+        priority: z.ZodDefault<z.ZodEnum<["low", "medium", "high", "critical"]>>;
+    }, "strip", z.ZodTypeAny, {
+        operators: string[];
+        projectId: string;
+        displayName: string;
+        repoPath: string;
+        defaultBranch: string;
+        taskBoardPath: string;
+        zoneMapPath: string;
+        validationGates: {
+            name: string;
+            command: string;
+            timeoutSeconds: number;
+            args?: string[] | undefined;
+        }[];
+        injectionPolicy: "proposal_only" | "direct_with_approval";
+        priority: "low" | "medium" | "high" | "critical";
+    }, {
+        projectId: string;
+        displayName: string;
+        repoPath: string;
+        defaultBranch: string;
+        operators?: string[] | undefined;
+        taskBoardPath?: string | undefined;
+        zoneMapPath?: string | undefined;
+        validationGates?: {
+            name: string;
+            command: string;
+            args?: string[] | undefined;
+            timeoutSeconds?: number | undefined;
+        }[] | undefined;
+        injectionPolicy?: "proposal_only" | "direct_with_approval" | undefined;
+        priority?: "low" | "medium" | "high" | "critical" | undefined;
+    }>, "many">;
+}, "strip", z.ZodTypeAny, {
+    version: 1;
+    portfolio: {
+        name: string;
+        id: string;
+        sourceNote?: string | undefined;
+        continuityDocPath?: string | undefined;
+    };
+    projects: {
+        operators: string[];
+        projectId: string;
+        displayName: string;
+        repoPath: string;
+        defaultBranch: string;
+        taskBoardPath: string;
+        zoneMapPath: string;
+        validationGates: {
+            name: string;
+            command: string;
+            timeoutSeconds: number;
+            args?: string[] | undefined;
+        }[];
+        injectionPolicy: "proposal_only" | "direct_with_approval";
+        priority: "low" | "medium" | "high" | "critical";
+    }[];
+}, {
+    version: 1;
+    portfolio: {
+        name: string;
+        id: string;
+        sourceNote?: string | undefined;
+        continuityDocPath?: string | undefined;
+    };
+    projects: {
+        projectId: string;
+        displayName: string;
+        repoPath: string;
+        defaultBranch: string;
+        operators?: string[] | undefined;
+        taskBoardPath?: string | undefined;
+        zoneMapPath?: string | undefined;
+        validationGates?: {
+            name: string;
+            command: string;
+            args?: string[] | undefined;
+            timeoutSeconds?: number | undefined;
+        }[] | undefined;
+        injectionPolicy?: "proposal_only" | "direct_with_approval" | undefined;
+        priority?: "low" | "medium" | "high" | "critical" | undefined;
+    }[];
+}>;
+declare const SprintIdSchema: z.ZodString;
+declare const OperatorIdSchema: z.ZodString;
+declare const NoteTaskSchema: z.ZodObject<{
+    rawLine: z.ZodString;
+    lineNumber: z.ZodNumber;
+    checked: z.ZodBoolean;
+    projectIds: z.ZodArray<z.ZodString, "many">;
+    proposedType: z.ZodEnum<["feature", "bug", "qa", "docs", "architecture", "migration", "ops"]>;
+    proposedOwner: z.ZodString;
+    proposedPriority: z.ZodEnum<["low", "medium", "high", "critical"]>;
+    proposedSprintPrefix: z.ZodString;
+    evidenceType: z.ZodEnum<["code", "ui", "docs", "integration", "prod"]>;
+    evidenceExpectation: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    rawLine: string;
+    lineNumber: number;
+    checked: boolean;
+    projectIds: string[];
+    proposedType: "feature" | "bug" | "qa" | "docs" | "architecture" | "migration" | "ops";
+    proposedOwner: string;
+    proposedPriority: "low" | "medium" | "high" | "critical";
+    proposedSprintPrefix: string;
+    evidenceType: "docs" | "code" | "ui" | "integration" | "prod";
+    evidenceExpectation: string;
+}, {
+    rawLine: string;
+    lineNumber: number;
+    checked: boolean;
+    projectIds: string[];
+    proposedType: "feature" | "bug" | "qa" | "docs" | "architecture" | "migration" | "ops";
+    proposedOwner: string;
+    proposedPriority: "low" | "medium" | "high" | "critical";
+    proposedSprintPrefix: string;
+    evidenceType: "docs" | "code" | "ui" | "integration" | "prod";
+    evidenceExpectation: string;
+}>;
+declare const NotesIngestionResultSchema: z.ZodObject<{
+    sourcePath: z.ZodString;
+    portfolioId: z.ZodString;
+    parsedAt: z.ZodString;
+    dryRun: z.ZodBoolean;
+    totalLines: z.ZodNumber;
+    taskLines: z.ZodNumber;
+    pendingCount: z.ZodNumber;
+    doneCount: z.ZodNumber;
+    tasksByProject: z.ZodRecord<z.ZodString, z.ZodArray<z.ZodObject<{
+        rawLine: z.ZodString;
+        lineNumber: z.ZodNumber;
+        checked: z.ZodBoolean;
+        projectIds: z.ZodArray<z.ZodString, "many">;
+        proposedType: z.ZodEnum<["feature", "bug", "qa", "docs", "architecture", "migration", "ops"]>;
+        proposedOwner: z.ZodString;
+        proposedPriority: z.ZodEnum<["low", "medium", "high", "critical"]>;
+        proposedSprintPrefix: z.ZodString;
+        evidenceType: z.ZodEnum<["code", "ui", "docs", "integration", "prod"]>;
+        evidenceExpectation: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        rawLine: string;
+        lineNumber: number;
+        checked: boolean;
+        projectIds: string[];
+        proposedType: "feature" | "bug" | "qa" | "docs" | "architecture" | "migration" | "ops";
+        proposedOwner: string;
+        proposedPriority: "low" | "medium" | "high" | "critical";
+        proposedSprintPrefix: string;
+        evidenceType: "docs" | "code" | "ui" | "integration" | "prod";
+        evidenceExpectation: string;
+    }, {
+        rawLine: string;
+        lineNumber: number;
+        checked: boolean;
+        projectIds: string[];
+        proposedType: "feature" | "bug" | "qa" | "docs" | "architecture" | "migration" | "ops";
+        proposedOwner: string;
+        proposedPriority: "low" | "medium" | "high" | "critical";
+        proposedSprintPrefix: string;
+        evidenceType: "docs" | "code" | "ui" | "integration" | "prod";
+        evidenceExpectation: string;
+    }>, "many">>;
+    unclassifiedTasks: z.ZodArray<z.ZodObject<{
+        rawLine: z.ZodString;
+        lineNumber: z.ZodNumber;
+        checked: z.ZodBoolean;
+        projectIds: z.ZodArray<z.ZodString, "many">;
+        proposedType: z.ZodEnum<["feature", "bug", "qa", "docs", "architecture", "migration", "ops"]>;
+        proposedOwner: z.ZodString;
+        proposedPriority: z.ZodEnum<["low", "medium", "high", "critical"]>;
+        proposedSprintPrefix: z.ZodString;
+        evidenceType: z.ZodEnum<["code", "ui", "docs", "integration", "prod"]>;
+        evidenceExpectation: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        rawLine: string;
+        lineNumber: number;
+        checked: boolean;
+        projectIds: string[];
+        proposedType: "feature" | "bug" | "qa" | "docs" | "architecture" | "migration" | "ops";
+        proposedOwner: string;
+        proposedPriority: "low" | "medium" | "high" | "critical";
+        proposedSprintPrefix: string;
+        evidenceType: "docs" | "code" | "ui" | "integration" | "prod";
+        evidenceExpectation: string;
+    }, {
+        rawLine: string;
+        lineNumber: number;
+        checked: boolean;
+        projectIds: string[];
+        proposedType: "feature" | "bug" | "qa" | "docs" | "architecture" | "migration" | "ops";
+        proposedOwner: string;
+        proposedPriority: "low" | "medium" | "high" | "critical";
+        proposedSprintPrefix: string;
+        evidenceType: "docs" | "code" | "ui" | "integration" | "prod";
+        evidenceExpectation: string;
+    }>, "many">;
+    warnings: z.ZodArray<z.ZodString, "many">;
+}, "strip", z.ZodTypeAny, {
+    sourcePath: string;
+    portfolioId: string;
+    parsedAt: string;
+    dryRun: boolean;
+    totalLines: number;
+    taskLines: number;
+    pendingCount: number;
+    doneCount: number;
+    tasksByProject: Record<string, {
+        rawLine: string;
+        lineNumber: number;
+        checked: boolean;
+        projectIds: string[];
+        proposedType: "feature" | "bug" | "qa" | "docs" | "architecture" | "migration" | "ops";
+        proposedOwner: string;
+        proposedPriority: "low" | "medium" | "high" | "critical";
+        proposedSprintPrefix: string;
+        evidenceType: "docs" | "code" | "ui" | "integration" | "prod";
+        evidenceExpectation: string;
+    }[]>;
+    unclassifiedTasks: {
+        rawLine: string;
+        lineNumber: number;
+        checked: boolean;
+        projectIds: string[];
+        proposedType: "feature" | "bug" | "qa" | "docs" | "architecture" | "migration" | "ops";
+        proposedOwner: string;
+        proposedPriority: "low" | "medium" | "high" | "critical";
+        proposedSprintPrefix: string;
+        evidenceType: "docs" | "code" | "ui" | "integration" | "prod";
+        evidenceExpectation: string;
+    }[];
+    warnings: string[];
+}, {
+    sourcePath: string;
+    portfolioId: string;
+    parsedAt: string;
+    dryRun: boolean;
+    totalLines: number;
+    taskLines: number;
+    pendingCount: number;
+    doneCount: number;
+    tasksByProject: Record<string, {
+        rawLine: string;
+        lineNumber: number;
+        checked: boolean;
+        projectIds: string[];
+        proposedType: "feature" | "bug" | "qa" | "docs" | "architecture" | "migration" | "ops";
+        proposedOwner: string;
+        proposedPriority: "low" | "medium" | "high" | "critical";
+        proposedSprintPrefix: string;
+        evidenceType: "docs" | "code" | "ui" | "integration" | "prod";
+        evidenceExpectation: string;
+    }[]>;
+    unclassifiedTasks: {
+        rawLine: string;
+        lineNumber: number;
+        checked: boolean;
+        projectIds: string[];
+        proposedType: "feature" | "bug" | "qa" | "docs" | "architecture" | "migration" | "ops";
+        proposedOwner: string;
+        proposedPriority: "low" | "medium" | "high" | "critical";
+        proposedSprintPrefix: string;
+        evidenceType: "docs" | "code" | "ui" | "integration" | "prod";
+        evidenceExpectation: string;
+    }[];
+    warnings: string[];
+}>;
+declare const ProjectInjectionResultSchema: z.ZodObject<{
+    projectId: z.ZodString;
+    displayName: z.ZodString;
+    injectionPolicy: z.ZodEnum<["proposal_only", "direct_with_approval"]>;
+    repoPath: z.ZodString;
+    tasksInjected: z.ZodNumber;
+    tasksSkipped: z.ZodNumber;
+    checkpointTag: z.ZodOptional<z.ZodString>;
+    handoffPath: z.ZodOptional<z.ZodString>;
+    proposalPath: z.ZodOptional<z.ZodString>;
+    blocked: z.ZodBoolean;
+    blockReason: z.ZodOptional<z.ZodString>;
+    warnings: z.ZodArray<z.ZodString, "many">;
+}, "strip", z.ZodTypeAny, {
+    blocked: boolean;
+    projectId: string;
+    displayName: string;
+    repoPath: string;
+    injectionPolicy: "proposal_only" | "direct_with_approval";
+    warnings: string[];
+    tasksInjected: number;
+    tasksSkipped: number;
+    checkpointTag?: string | undefined;
+    handoffPath?: string | undefined;
+    proposalPath?: string | undefined;
+    blockReason?: string | undefined;
+}, {
+    blocked: boolean;
+    projectId: string;
+    displayName: string;
+    repoPath: string;
+    injectionPolicy: "proposal_only" | "direct_with_approval";
+    warnings: string[];
+    tasksInjected: number;
+    tasksSkipped: number;
+    checkpointTag?: string | undefined;
+    handoffPath?: string | undefined;
+    proposalPath?: string | undefined;
+    blockReason?: string | undefined;
+}>;
+declare const InjectionResultSchema: z.ZodObject<{
+    portfolioId: z.ZodString;
+    injectedAt: z.ZodString;
+    dryRun: z.ZodBoolean;
+    confirmed: z.ZodBoolean;
+    projects: z.ZodArray<z.ZodObject<{
+        projectId: z.ZodString;
+        displayName: z.ZodString;
+        injectionPolicy: z.ZodEnum<["proposal_only", "direct_with_approval"]>;
+        repoPath: z.ZodString;
+        tasksInjected: z.ZodNumber;
+        tasksSkipped: z.ZodNumber;
+        checkpointTag: z.ZodOptional<z.ZodString>;
+        handoffPath: z.ZodOptional<z.ZodString>;
+        proposalPath: z.ZodOptional<z.ZodString>;
+        blocked: z.ZodBoolean;
+        blockReason: z.ZodOptional<z.ZodString>;
+        warnings: z.ZodArray<z.ZodString, "many">;
+    }, "strip", z.ZodTypeAny, {
+        blocked: boolean;
+        projectId: string;
+        displayName: string;
+        repoPath: string;
+        injectionPolicy: "proposal_only" | "direct_with_approval";
+        warnings: string[];
+        tasksInjected: number;
+        tasksSkipped: number;
+        checkpointTag?: string | undefined;
+        handoffPath?: string | undefined;
+        proposalPath?: string | undefined;
+        blockReason?: string | undefined;
+    }, {
+        blocked: boolean;
+        projectId: string;
+        displayName: string;
+        repoPath: string;
+        injectionPolicy: "proposal_only" | "direct_with_approval";
+        warnings: string[];
+        tasksInjected: number;
+        tasksSkipped: number;
+        checkpointTag?: string | undefined;
+        handoffPath?: string | undefined;
+        proposalPath?: string | undefined;
+        blockReason?: string | undefined;
+    }>, "many">;
+    summary: z.ZodObject<{
+        totalProjects: z.ZodNumber;
+        projectsBlocked: z.ZodNumber;
+        projectsInjected: z.ZodNumber;
+        proposalsGenerated: z.ZodNumber;
+        totalTasksInjected: z.ZodNumber;
+        totalTasksSkipped: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        totalProjects: number;
+        projectsBlocked: number;
+        projectsInjected: number;
+        proposalsGenerated: number;
+        totalTasksInjected: number;
+        totalTasksSkipped: number;
+    }, {
+        totalProjects: number;
+        projectsBlocked: number;
+        projectsInjected: number;
+        proposalsGenerated: number;
+        totalTasksInjected: number;
+        totalTasksSkipped: number;
+    }>;
+    errors: z.ZodArray<z.ZodString, "many">;
+}, "strip", z.ZodTypeAny, {
+    projects: {
+        blocked: boolean;
+        projectId: string;
+        displayName: string;
+        repoPath: string;
+        injectionPolicy: "proposal_only" | "direct_with_approval";
+        warnings: string[];
+        tasksInjected: number;
+        tasksSkipped: number;
+        checkpointTag?: string | undefined;
+        handoffPath?: string | undefined;
+        proposalPath?: string | undefined;
+        blockReason?: string | undefined;
+    }[];
+    errors: string[];
+    portfolioId: string;
+    dryRun: boolean;
+    injectedAt: string;
+    confirmed: boolean;
+    summary: {
+        totalProjects: number;
+        projectsBlocked: number;
+        projectsInjected: number;
+        proposalsGenerated: number;
+        totalTasksInjected: number;
+        totalTasksSkipped: number;
+    };
+}, {
+    projects: {
+        blocked: boolean;
+        projectId: string;
+        displayName: string;
+        repoPath: string;
+        injectionPolicy: "proposal_only" | "direct_with_approval";
+        warnings: string[];
+        tasksInjected: number;
+        tasksSkipped: number;
+        checkpointTag?: string | undefined;
+        handoffPath?: string | undefined;
+        proposalPath?: string | undefined;
+        blockReason?: string | undefined;
+    }[];
+    errors: string[];
+    portfolioId: string;
+    dryRun: boolean;
+    injectedAt: string;
+    confirmed: boolean;
+    summary: {
+        totalProjects: number;
+        projectsBlocked: number;
+        projectsInjected: number;
+        proposalsGenerated: number;
+        totalTasksInjected: number;
+        totalTasksSkipped: number;
+    };
+}>;
+declare const EvidenceRecordSchema: z.ZodObject<{
+    taskId: z.ZodString;
+    evidenceType: z.ZodEnum<["code", "ui", "docs", "integration", "prod"]>;
+    validatedAt: z.ZodString;
+    validator: z.ZodString;
+    result: z.ZodEnum<["passed", "failed", "pending"]>;
+    details: z.ZodString;
+    artifacts: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+}, "strip", z.ZodTypeAny, {
+    evidenceType: "docs" | "code" | "ui" | "integration" | "prod";
+    taskId: string;
+    validatedAt: string;
+    validator: string;
+    result: "pending" | "passed" | "failed";
+    details: string;
+    artifacts?: string[] | undefined;
+}, {
+    evidenceType: "docs" | "code" | "ui" | "integration" | "prod";
+    taskId: string;
+    validatedAt: string;
+    validator: string;
+    result: "pending" | "passed" | "failed";
+    details: string;
+    artifacts?: string[] | undefined;
+}>;
+declare const TaskEvidenceCheckSchema: z.ZodObject<{
+    taskId: z.ZodString;
+    taskTitle: z.ZodString;
+    evidenceType: z.ZodEnum<["code", "ui", "docs", "integration", "prod"]>;
+    hasEvidence: z.ZodBoolean;
+    requiredEvidence: z.ZodString;
+    currentStatus: z.ZodEnum<["ready", "active", "pending", "blocked", "done", "rolled_back"]>;
+    missing: z.ZodArray<z.ZodString, "many">;
+}, "strip", z.ZodTypeAny, {
+    evidenceType: "docs" | "code" | "ui" | "integration" | "prod";
+    taskId: string;
+    taskTitle: string;
+    hasEvidence: boolean;
+    requiredEvidence: string;
+    currentStatus: "ready" | "active" | "pending" | "blocked" | "done" | "rolled_back";
+    missing: string[];
+}, {
+    evidenceType: "docs" | "code" | "ui" | "integration" | "prod";
+    taskId: string;
+    taskTitle: string;
+    hasEvidence: boolean;
+    requiredEvidence: string;
+    currentStatus: "ready" | "active" | "pending" | "blocked" | "done" | "rolled_back";
+    missing: string[];
+}>;
+declare const EvidenceGateResultSchema: z.ZodObject<{
+    checkedAt: z.ZodString;
+    sprint: z.ZodOptional<z.ZodString>;
+    operator: z.ZodString;
+    totalTasks: z.ZodNumber;
+    doneTasks: z.ZodNumber;
+    tasksWithEvidence: z.ZodNumber;
+    tasksWithoutEvidence: z.ZodNumber;
+    tasks: z.ZodArray<z.ZodObject<{
+        taskId: z.ZodString;
+        taskTitle: z.ZodString;
+        evidenceType: z.ZodEnum<["code", "ui", "docs", "integration", "prod"]>;
+        hasEvidence: z.ZodBoolean;
+        requiredEvidence: z.ZodString;
+        currentStatus: z.ZodEnum<["ready", "active", "pending", "blocked", "done", "rolled_back"]>;
+        missing: z.ZodArray<z.ZodString, "many">;
+    }, "strip", z.ZodTypeAny, {
+        evidenceType: "docs" | "code" | "ui" | "integration" | "prod";
+        taskId: string;
+        taskTitle: string;
+        hasEvidence: boolean;
+        requiredEvidence: string;
+        currentStatus: "ready" | "active" | "pending" | "blocked" | "done" | "rolled_back";
+        missing: string[];
+    }, {
+        evidenceType: "docs" | "code" | "ui" | "integration" | "prod";
+        taskId: string;
+        taskTitle: string;
+        hasEvidence: boolean;
+        requiredEvidence: string;
+        currentStatus: "ready" | "active" | "pending" | "blocked" | "done" | "rolled_back";
+        missing: string[];
+    }>, "many">;
+    passed: z.ZodBoolean;
+    blockers: z.ZodArray<z.ZodString, "many">;
+}, "strip", z.ZodTypeAny, {
+    passed: boolean;
+    operator: string;
+    tasks: {
+        evidenceType: "docs" | "code" | "ui" | "integration" | "prod";
+        taskId: string;
+        taskTitle: string;
+        hasEvidence: boolean;
+        requiredEvidence: string;
+        currentStatus: "ready" | "active" | "pending" | "blocked" | "done" | "rolled_back";
+        missing: string[];
+    }[];
+    checkedAt: string;
+    totalTasks: number;
+    doneTasks: number;
+    tasksWithEvidence: number;
+    tasksWithoutEvidence: number;
+    blockers: string[];
+    sprint?: string | undefined;
+}, {
+    passed: boolean;
+    operator: string;
+    tasks: {
+        evidenceType: "docs" | "code" | "ui" | "integration" | "prod";
+        taskId: string;
+        taskTitle: string;
+        hasEvidence: boolean;
+        requiredEvidence: string;
+        currentStatus: "ready" | "active" | "pending" | "blocked" | "done" | "rolled_back";
+        missing: string[];
+    }[];
+    checkedAt: string;
+    totalTasks: number;
+    doneTasks: number;
+    tasksWithEvidence: number;
+    tasksWithoutEvidence: number;
+    blockers: string[];
+    sprint?: string | undefined;
+}>;
+declare const ZoneLockSchema: z.ZodObject<{
+    zone: z.ZodString;
+    operator: z.ZodString;
+    sprint: z.ZodString;
+    acquiredAt: z.ZodString;
+    ttl: z.ZodNumber;
+    expiresAt: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    zone: string;
+    operator: string;
+    sprint: string;
+    acquiredAt: string;
+    expiresAt: string;
+    ttl: number;
+}, {
+    zone: string;
+    operator: string;
+    sprint: string;
+    acquiredAt: string;
+    expiresAt: string;
+    ttl: number;
+}>;
+declare const LockResultSchema: z.ZodObject<{
+    zone: z.ZodString;
+    acquired: z.ZodBoolean;
+    existingLock: z.ZodOptional<z.ZodObject<{
+        zone: z.ZodString;
+        operator: z.ZodString;
+        sprint: z.ZodString;
+        acquiredAt: z.ZodString;
+        ttl: z.ZodNumber;
+        expiresAt: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        zone: string;
+        operator: string;
+        sprint: string;
+        acquiredAt: string;
+        expiresAt: string;
+        ttl: number;
+    }, {
+        zone: string;
+        operator: string;
+        sprint: string;
+        acquiredAt: string;
+        expiresAt: string;
+        ttl: number;
+    }>>;
+    error: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    zone: string;
+    acquired: boolean;
+    error?: string | undefined;
+    existingLock?: {
+        zone: string;
+        operator: string;
+        sprint: string;
+        acquiredAt: string;
+        expiresAt: string;
+        ttl: number;
+    } | undefined;
+}, {
+    zone: string;
+    acquired: boolean;
+    error?: string | undefined;
+    existingLock?: {
+        zone: string;
+        operator: string;
+        sprint: string;
+        acquiredAt: string;
+        expiresAt: string;
+        ttl: number;
+    } | undefined;
+}>;
+declare const LockListSchema: z.ZodObject<{
+    fetchedAt: z.ZodString;
+    locks: z.ZodArray<z.ZodObject<{
+        zone: z.ZodString;
+        operator: z.ZodString;
+        sprint: z.ZodString;
+        acquiredAt: z.ZodString;
+        ttl: z.ZodNumber;
+        expiresAt: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        zone: string;
+        operator: string;
+        sprint: string;
+        acquiredAt: string;
+        expiresAt: string;
+        ttl: number;
+    }, {
+        zone: string;
+        operator: string;
+        sprint: string;
+        acquiredAt: string;
+        expiresAt: string;
+        ttl: number;
+    }>, "many">;
+    active: z.ZodArray<z.ZodObject<{
+        zone: z.ZodString;
+        operator: z.ZodString;
+        sprint: z.ZodString;
+        acquiredAt: z.ZodString;
+        ttl: z.ZodNumber;
+        expiresAt: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        zone: string;
+        operator: string;
+        sprint: string;
+        acquiredAt: string;
+        expiresAt: string;
+        ttl: number;
+    }, {
+        zone: string;
+        operator: string;
+        sprint: string;
+        acquiredAt: string;
+        expiresAt: string;
+        ttl: number;
+    }>, "many">;
+    expired: z.ZodArray<z.ZodObject<{
+        zone: z.ZodString;
+        operator: z.ZodString;
+        sprint: z.ZodString;
+        acquiredAt: z.ZodString;
+        ttl: z.ZodNumber;
+        expiresAt: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        zone: string;
+        operator: string;
+        sprint: string;
+        acquiredAt: string;
+        expiresAt: string;
+        ttl: number;
+    }, {
+        zone: string;
+        operator: string;
+        sprint: string;
+        acquiredAt: string;
+        expiresAt: string;
+        ttl: number;
+    }>, "many">;
+}, "strip", z.ZodTypeAny, {
+    active: {
+        zone: string;
+        operator: string;
+        sprint: string;
+        acquiredAt: string;
+        expiresAt: string;
+        ttl: number;
+    }[];
+    fetchedAt: string;
+    locks: {
+        zone: string;
+        operator: string;
+        sprint: string;
+        acquiredAt: string;
+        expiresAt: string;
+        ttl: number;
+    }[];
+    expired: {
+        zone: string;
+        operator: string;
+        sprint: string;
+        acquiredAt: string;
+        expiresAt: string;
+        ttl: number;
+    }[];
+}, {
+    active: {
+        zone: string;
+        operator: string;
+        sprint: string;
+        acquiredAt: string;
+        expiresAt: string;
+        ttl: number;
+    }[];
+    fetchedAt: string;
+    locks: {
+        zone: string;
+        operator: string;
+        sprint: string;
+        acquiredAt: string;
+        expiresAt: string;
+        ttl: number;
+    }[];
+    expired: {
+        zone: string;
+        operator: string;
+        sprint: string;
+        acquiredAt: string;
+        expiresAt: string;
+        ttl: number;
+    }[];
+}>;
+
+export { AuditService, BootstrapService, type CanonicalCheckResult, type CanonicalConfig, type CanonicalIssue, CanonicalService, type Checkpoint, DashboardService, type DerivedDocConfig, DerivedDocConfigSchema, type DistributedLock, type EvidenceGateResult, EvidenceGateResultSchema, EvidenceGateService, type EvidenceRecord, EvidenceRecordSchema, type EvidenceType, type GitError, GitService, type InjectionResult, InjectionResultSchema, InjectionService, type LockList, LockListSchema, type LockResult, LockResultSchema, LockService, type MergeResult, type MotherVersion, MotherVersionSchema, type NoteTask, NoteTaskSchema, type NotesIngestionResult, NotesIngestionResultSchema, NotesIngestionService, type OperationalMetrics, OperatorIdSchema, type OreshnikConfig, OreshnikConfigSchema, type OreshnikError, type PortfolioConfig, PortfolioConfigSchema, type PortfolioInspection, type PortfolioProject, PortfolioProjectSchema, type PortfolioProjectStatus, PortfolioService, type PreflightResult, type ProjectInjectionResult, ProjectInjectionResultSchema, type Result, type SprintEvent, SprintIdSchema, type StateError, StateManager, type SyncConfig, type SyncResult, SyncService, type Task, type TaskBoard, TaskBoardSchema, type TaskEvidenceCheck, TaskEvidenceCheckSchema, type TaskType, VaultGuard, type VaultGuardResult, type ZoneCheckResult, ZoneCheckService, ZoneEngine, type ZoneLock, ZoneLockSchema, type ZoneMap, ZoneMapSchema, type ZoneViolation, createAuditService, createBootstrapService, createCanonicalService, createDashboardService, createEvidenceGateService, createGitService, createInjectionService, createLockService, createNotesIngestionService, createPortfolioService, createStateManager, createSyncService, createVaultGuard, createZoneCheckService, createZoneEngine, err, execCommand, execCommandInherit, formatBranchName, header, isChildBranch, isMotherBranch, log, nonIgnoredDirtyFiles, nowDisplay, nowISO, ok, resultSummary, sanitize, statusBox, today };