import { _ as TranslationCacheSettings } from "./document-translation-CBqubtWC.mjs";
import { C as CliSpecList, Ot as OpenSpecUIConfig, Y as CliJsonValue, Z as CliDiagnostic, at as CliRoot, b as CliShowSpec, ct as CliRootSourceSchema, et as CliDiagnosticSchema, f as CliArchiveInstructions, h as CliArtifactInstructions, k as CliWorkflowStatus, l as CliApplyInstructions, lt as CliExecutor, q as CliCommandResult, s as CliWorkflowOptions, t as CliRootSelector, v as CliChangeListEntry } from "./index-CajHC-38.mjs";
import { G as RootContext } from "./active-root-config-DxYz3yKb.mjs";
import { r as CliProjectionCommandEvidence } from "./cli-projection-Bf5KrMN0.mjs";
import { g as Spec, l as DeltaSpec, n as ChangeFile, t as Change, v as Task } from "./schemas-CxBYcq-e.mjs";
import { D as SchemaInfo, K as TrackedTaskPhase, P as TemplatesMap, T as SchemaDetail, U as TaskProjections, V as DocumentChecklistSummary, j as TemplateContentMap, k as SchemaResolution, l as ArtifactInstructions, p as ChangeStatus, q as TrackedTaskProgress, s as ArchiveInstructions, t as ApplyInstructions, y as OpsxConfigBundle } from "./opsx-types-DXBwJP68.mjs";
import { o as OpsxEntityReadOptions, r as OpsxEntityDetail, s as OpsxEntityStage } from "./opsx-entity-eoJAox1u.mjs";
import { Ot as TranslationLocalCt2Settings, Pt as TranslationLocalSettings, Ut as TranslationOpenAISettings, at as TranslationEngineId, jt as TranslationLocalLlamaSettings, rt as TranslationEngineGlobalSettingsUpdate } from "./translator-BgCkaOkw.mjs";
import { d as OpsxTextInputAction, f as OpsxWorkflowId, l as OpsxArtifactInputAction, t as OPSX_ALL_WORKFLOWS, u as OpsxChangeInputAction } from "./opsx-workflows-B72EGtj_.mjs";
import { i as HostedStoreContentSpecsEnvelopeSchema, n as HostedStoreContentChangesEnvelopeSchema } from "./store-content-projection-BnNYyb0x.mjs";
import { AsyncLocalStorage } from "node:async_hooks";
import { z } from "zod";
import { EventEmitter } from "events";
import { ChildProcess, SpawnOptionsWithoutStdio } from "node:child_process";

//#region src/validator.d.ts
interface ValidationIssue {
  severity: 'ERROR' | 'WARNING' | 'INFO';
  message: string;
  path?: string;
  line?: number;
}
interface ValidationResult {
  valid: boolean;
  issues: ValidationIssue[];
}
/**
 * Validator for OpenSpec documents
 */
declare class Validator {
  /**
   * Validate a spec document
   */
  validateSpec(spec: Spec): ValidationResult;
  /**
   * Validate a change proposal
   */
  validateChange(change: Change): ValidationResult;
}
//#endregion
//#region src/adapter.d.ts
/** Spec metadata with time info */
interface SpecMeta {
  id: string;
  name: string;
  createdAt: number;
  updatedAt: number;
}
/** Change metadata with time info */
interface ChangeMeta {
  id: string;
  name: string;
  trackedTaskProgress: TrackedTaskProgress;
  documentChecklistSummary: DocumentChecklistSummary;
  createdAt: number;
  updatedAt: number;
  /**
   * Task counts and phase as reported by `openspec list` for this row, when the CLI
   * projection has been observed. Null when no CLI list evidence exists yet — the CLI is
   * the task-count authority and UI-side file arithmetic must not backfill it.
   */
  cliTaskSummary: {
    completedTasks: number;
    totalTasks: number;
    status: 'no-tasks' | 'complete' | 'in-progress';
  } | null;
}
/** Archived change metadata with time info */
interface ArchiveMeta {
  id: string;
  name: string;
  trackedTaskProgress: TrackedTaskProgress;
  documentChecklistSummary: DocumentChecklistSummary;
  createdAt: number;
  updatedAt: number;
}
/** Launch-project-local initialization fact; it never describes an external Store or selected Planning Root. */
interface LaunchProjectInitialization {
  initialized: boolean;
  launchProjectPath: string;
  openspecPath: string;
}
/**
 * OpenSpec filesystem adapter
 * Handles reading, writing, and managing OpenSpec files
 */
declare class OpenSpecAdapter {
  private projectDir;
  private parser;
  private validator;
  constructor(projectDir: string);
  private get openspecDir();
  private get specsDir();
  private get changesDir();
  private get archiveDir();
  isInitialized(): Promise<boolean>;
  /** File time info derived from filesystem (reactive) */
  private getFileTimeInfo;
  /** List every Spec directory containing `spec.md` as a slash-separated relative identity. */
  listSpecs(): Promise<string[]>;
  /**
   * List specs with metadata (id, name, and time info)
   * Only returns specs that have valid spec.md
   * Sorted by updatedAt descending (most recent first)
   */
  listSpecsWithMeta(): Promise<SpecMeta[]>;
  listChanges(): Promise<string[]>;
  /** Read one active Change row without resolving workflow Status, Apply, or artifact instructions. */
  readChangeMeta(id: string): Promise<ChangeMeta>;
  /**
   * List changes with metadata, separated task projections, and time info.
   * Returns every change directory, including schema-specific layouts that
   * don't use proposal.md/tasks.md.
   * Sorted by updatedAt descending (most recent first)
   */
  listChangesWithMeta(): Promise<ChangeMeta[]>;
  listArchivedChanges(): Promise<string[]>;
  /**
   * List archived changes with metadata and time info
   * Returns every archive directory, including schema-specific layouts that
   * don't use proposal.md/tasks.md.
   * Sorted by updatedAt descending (most recent first)
   */
  listArchivedChangesWithMeta(): Promise<ArchiveMeta[]>;
  /**
   * Read project.md content (reactive)
   */
  readProjectMd(): Promise<string | null>;
  /**
   * Write project.md content
   */
  writeProjectMd(content: string): Promise<void>;
  readSpec(specId: string): Promise<Spec | null>;
  readSpecRaw(specId: string): Promise<string | null>;
  readChange(changeId: string): Promise<Change | null>;
  readChangeFiles(changeId: string): Promise<ChangeFile[]>;
  readArchivedChangeFiles(changeId: string): Promise<ChangeFile[]>;
  readChangeTaskProjection(changeId: string): Promise<TaskProjections>;
  readArchivedChangeTaskProjection(changeId: string): Promise<TaskProjections>;
  readEntityDetail(stage: 'change' | 'archive', id: string, options?: OpsxEntityReadOptions): Promise<OpsxEntityDetail | null>;
  private readFilesUnderRoot;
  private collectChangeFiles;
  private readProjectSchemaDetail;
  private readEntityTaskProjection;
  readChangeRaw(changeId: string): Promise<{
    proposal: string;
    tasks: string;
    design?: string;
    deltaSpecs: DeltaSpec[];
  } | null>;
  /** Read delta specs from a specs directory */
  private readDeltaSpecs;
  /**
   * Read an archived change
   */
  readArchivedChange(changeId: string): Promise<Change | null>;
  /**
   * Read raw archived change files (reactive)
   */
  readArchivedChangeRaw(changeId: string): Promise<{
    proposal: string;
    tasks: string;
    design?: string;
    deltaSpecs: DeltaSpec[];
  } | null>;
  writeSpec(specId: string, content: string): Promise<void>;
  writeChange(changeId: string, proposal: string, tasks?: string): Promise<void>;
  /** Write one validated Change or Archive entity file through the shared physical/reactive owner. */
  writeEntityFile(stage: OpsxEntityStage, changeId: string, path: string, content: string): Promise<void>;
  /** Read the reactive local `openspec/` existence fact for the Launch Project. */
  readLaunchProjectInitialization(): Promise<LaunchProjectInitialization>;
  init(): Promise<void>;
  validateSpec(specId: string): Promise<ValidationResult>;
  validateChange(changeId: string): Promise<ValidationResult>;
  getDashboardData(): Promise<{
    specs: {
      id: string;
      name: string;
      requirements: {
        id: string;
        text: string;
        title: string;
        scenarios: {
          title: string;
          rawText: string;
          bodyMarkdown: string;
          steps?: {
            rawText: string;
            keyword: "GIVEN" | "WHEN" | "THEN" | "AND" | "BUT";
            contentMarkdown: string;
          }[] | undefined;
        }[];
        bodyMarkdown: string;
      }[];
      overview: string;
      metadata?: {
        version: string;
        format: "openspec";
        sourcePath?: string | undefined;
      } | undefined;
    }[];
    changes: {
      id: string;
      name: string;
      trackedTaskProgress: {
        source: {
          kind: "artifact";
          outputPath: string;
          artifactId: string;
          filePaths: string[];
        } | {
          kind: "top-level-fallback";
          outputPath: "tasks.md";
          artifactId: null;
          filePaths: ["tasks.md"];
        } | {
          kind: "none";
          outputPath: null;
          artifactId: null;
          filePaths: [];
        };
        tasks: {
          id: string;
          text: string;
          completed: boolean;
          location: {
            filePath: string;
            taskIndex: number;
          };
          section?: string | undefined;
        }[];
        total: number;
        remaining: number;
        completed: number;
        phase: "no-tasks" | "complete" | "in-progress";
      };
      why: string;
      whatChanges: string;
      deltas: {
        description: string;
        spec: string;
        operation: "ADDED" | "MODIFIED" | "REMOVED" | "RENAMED";
        requirements?: {
          id: string;
          text: string;
          title: string;
          scenarios: {
            title: string;
            rawText: string;
            bodyMarkdown: string;
            steps?: {
              rawText: string;
              keyword: "GIVEN" | "WHEN" | "THEN" | "AND" | "BUT";
              contentMarkdown: string;
            }[] | undefined;
          }[];
          bodyMarkdown: string;
        }[] | undefined;
        requirement?: {
          id: string;
          text: string;
          title: string;
          scenarios: {
            title: string;
            rawText: string;
            bodyMarkdown: string;
            steps?: {
              rawText: string;
              keyword: "GIVEN" | "WHEN" | "THEN" | "AND" | "BUT";
              contentMarkdown: string;
            }[] | undefined;
          }[];
          bodyMarkdown: string;
        } | undefined;
        rename?: {
          from: string;
          to: string;
        } | undefined;
      }[];
      documentChecklistSummary: {
        groups: {
          tasks: {
            id: string;
            text: string;
            completed: boolean;
            section?: string | undefined;
          }[];
          total: number;
          remaining: number;
          completed: number;
          filePath: string;
          artifactIds: string[];
        }[];
        total: number;
        remaining: number;
        completed: number;
      };
      metadata?: {
        version: string;
        format: "openspec-change";
      } | undefined;
      design?: string | undefined;
      deltaSpecs?: {
        specId: string;
        content: string;
      }[] | undefined;
    }[];
    archivedCount: number;
    summary: {
      specCount: number;
      requirementCount: number;
      activeChangeCount: number;
      archivedChangeCount: number;
      totalTasks: number;
      completedTasks: number;
      progressPercent: number;
    };
  }>;
}
//#endregion
//#region src/change-projection.d.ts
/** A row-level failure that does not discard successfully projected Change rows. */
interface ChangeProjectionRowError {
  changeId: string;
  message: string;
}
/** Stable completed data for one active-Change inventory projection. */
interface ChangeProjectionData {
  rows: ChangeMeta[];
  errors: ChangeProjectionRowError[];
}
/** One bounded incremental delivery from the active-Change inventory. */
interface ChangeProjectionBatch {
  rows: ChangeMeta[];
  errors: ChangeProjectionRowError[];
  progress: {
    completed: number;
    total: number | 'unknown';
  };
}
//#endregion
//#region src/parser.d.ts
/**
 * Markdown parser for OpenSpec documents
 */
declare class MarkdownParser {
  /**
   * Parse a spec markdown content into a Spec object
   */
  parseSpec(specId: string, content: string): Spec;
  /**
   * Parse a change proposal markdown content into a Change object
   */
  parseChange(changeId: string, proposalContent: string, tasksContent?: string, options?: {
    design?: string;
    deltaSpecs?: DeltaSpec[];
  }): Change;
  private parseDeltasFromWhatChanges;
  private parseDeltasFromDeltaSpecs;
  private parseDeltaSpecContent;
  /**
   * Parse tasks from a tasks.md content
   */
  parseTasks(content: string): Task[];
  /**
   * Serialize a spec back to markdown
   */
  serializeSpec(spec: Spec): string;
}
//#endregion
//#region src/file-preview.d.ts
declare const FILE_PREVIEW_KINDS: readonly ["markdown", "html", "image", "audio", "video", "pdf", "text", "none"];
type FilePreviewKind = (typeof FILE_PREVIEW_KINDS)[number];
declare function inferFileMime(path: string): string | null;
declare function inferFilePreviewKind(path: string, mime?: string | null): FilePreviewKind;
declare function isTextLikeMime(mime: string | null | undefined): boolean;
declare function isTextLikeFile(path: string, mime?: string | null): boolean;
declare function isPreviewableFile(path: string, mime?: string | null): boolean;
//#endregion
//#region src/spec-catalog.d.ts
/** Runtime validator for one writable owned Spec identity. */
declare const OwnedSpecIdentitySchema: z.ZodObject<{
  kind: z.ZodLiteral<"owned">;
  specId: z.ZodEffects<z.ZodString, string, string>;
}, "strip", z.ZodTypeAny, {
  kind: "owned";
  specId: string;
}, {
  kind: "owned";
  specId: string;
}>;
/** Runtime validator for one Store-qualified read-only Spec identity. */
declare const ReferencedSpecIdentitySchema: z.ZodObject<{
  kind: z.ZodLiteral<"referenced">;
  storeId: z.ZodString;
  specId: z.ZodEffects<z.ZodString, string, string>;
}, "strip", z.ZodTypeAny, {
  kind: "referenced";
  specId: string;
  storeId: string;
}, {
  kind: "referenced";
  specId: string;
  storeId: string;
}>;
/** Runtime validator for the complete compound Spec identity union. */
declare const SpecIdentitySchema: z.ZodDiscriminatedUnion<"kind", [z.ZodObject<{
  kind: z.ZodLiteral<"owned">;
  specId: z.ZodEffects<z.ZodString, string, string>;
}, "strip", z.ZodTypeAny, {
  kind: "owned";
  specId: string;
}, {
  kind: "owned";
  specId: string;
}>, z.ZodObject<{
  kind: z.ZodLiteral<"referenced">;
  storeId: z.ZodString;
  specId: z.ZodEffects<z.ZodString, string, string>;
}, "strip", z.ZodTypeAny, {
  kind: "referenced";
  specId: string;
  storeId: string;
}, {
  kind: "referenced";
  specId: string;
  storeId: string;
}>]>;
/** Writable planning-root Spec identity. */
type OwnedSpecIdentity = z.infer<typeof OwnedSpecIdentitySchema>;
/** Store-qualified read-only Spec identity. */
type ReferencedSpecIdentity = z.infer<typeof ReferencedSpecIdentitySchema>;
/** Complete collision-safe Spec identity union. */
type SpecIdentity = z.infer<typeof SpecIdentitySchema>;
/** Writable planning-root Spec metadata used in Catalog lists. */
interface OwnedSpecCatalogEntry {
  identity: OwnedSpecIdentity;
  source: 'owned';
  readOnly: false;
  name: string;
  summary: null;
  requirementCount: number;
  updatedAt: number;
}
/** Read-only Store-qualified Spec metadata from `list --specs --store --json`. */
interface ReferencedSpecCatalogEntry {
  identity: ReferencedSpecIdentity;
  source: 'referenced';
  readOnly: true;
  /** Spec list exposes ids, not a distinct title field. */
  name: string;
  summary: null;
  requirementCount: number;
  updatedAt: 0;
}
/** Source-aware Spec Catalog entry union. */
type SpecCatalogEntry = OwnedSpecCatalogEntry | ReferencedSpecCatalogEntry;
/** Source-aware Spec list with per-Reference enumeration evidence. */
interface SpecCatalog {
  entries: SpecCatalogEntry[];
  ownedProjection: SpecCatalogOwnedProjection;
  referenceSources: SpecCatalogReferenceSource[];
  referenceProjection: SpecCatalogReferenceProjection;
  observedAt: number;
}
/** Raw process and contract evidence retained for one Spec CLI command. */
type SpecCommandEvidence = CliProjectionCommandEvidence;
declare const SpecCommandEvidenceSchema: z.ZodObject<{
  success: z.ZodBoolean;
  stdout: z.ZodString;
  stderr: z.ZodString;
  exitCode: z.ZodNullable<z.ZodNumber>;
  payload: z.ZodNullable<z.ZodType<CliJsonValue, z.ZodTypeDef, CliJsonValue>>;
  diagnostics: z.ZodArray<z.ZodObject<{
    severity: z.ZodEnum<["error", "warning", "info"]>;
    code: z.ZodString;
    message: z.ZodString;
    target: z.ZodOptional<z.ZodString>;
    fix: z.ZodOptional<z.ZodString>;
  }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
    severity: z.ZodEnum<["error", "warning", "info"]>;
    code: z.ZodString;
    message: z.ZodString;
    target: z.ZodOptional<z.ZodString>;
    fix: z.ZodOptional<z.ZodString>;
  }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
    severity: z.ZodEnum<["error", "warning", "info"]>;
    code: z.ZodString;
    message: z.ZodString;
    target: z.ZodOptional<z.ZodString>;
    fix: z.ZodOptional<z.ZodString>;
  }, z.ZodTypeAny, "passthrough">>, "many">;
  contractError: z.ZodOptional<z.ZodString>;
}, "strip", z.ZodTypeAny, {
  success: boolean;
  stdout: string;
  stderr: string;
  exitCode: number | null;
  payload: CliJsonValue;
  diagnostics: z.objectOutputType<{
    severity: z.ZodEnum<["error", "warning", "info"]>;
    code: z.ZodString;
    message: z.ZodString;
    target: z.ZodOptional<z.ZodString>;
    fix: z.ZodOptional<z.ZodString>;
  }, z.ZodTypeAny, "passthrough">[];
  contractError?: string | undefined;
}, {
  success: boolean;
  stdout: string;
  stderr: string;
  exitCode: number | null;
  payload: CliJsonValue;
  diagnostics: z.objectInputType<{
    severity: z.ZodEnum<["error", "warning", "info"]>;
    code: z.ZodString;
    message: z.ZodString;
    target: z.ZodOptional<z.ZodString>;
    fix: z.ZodOptional<z.ZodString>;
  }, z.ZodTypeAny, "passthrough">[];
  contractError?: string | undefined;
}>;
/** Owned Catalog membership projected by a real OpenSpec CLI list command. */
interface LiveSpecCatalogOwnedProjection {
  provenance: 'live';
  root: CliRoot;
  evidence: SpecCommandEvidence;
}
/** Owned Catalog membership projected solely from a published static snapshot. */
type StaticSpecCatalogOwnedProjection = {
  provenance: 'static';
  state: 'available';
  snapshot: {
    specCount: number;
  };
} | {
  provenance: 'static';
  state: 'unavailable';
};
/** Source-exact provenance for the writable Spec inventory. */
type SpecCatalogOwnedProjection = LiveSpecCatalogOwnedProjection | StaticSpecCatalogOwnedProjection;
/** Per-Store Doctor and list evidence retained even when one live Reference cannot be enumerated. */
interface LiveSpecCatalogReferenceSource {
  storeId: string;
  provenance: 'live';
  state: 'ready' | 'error';
  diagnostics: CliDiagnostic[];
  evidence: SpecCommandEvidence;
}
/** Published per-Store snapshot facts; static export never runs a CLI command. */
interface StaticSpecCatalogReferenceSource {
  storeId: string;
  provenance: 'static';
  state: 'ready' | 'error';
  snapshot: {
    policy: 'include';
    specCount: number;
  };
}
/** Per-Store Reference projection, distinguished by live execution or published snapshot provenance. */
type SpecCatalogReferenceSource = LiveSpecCatalogReferenceSource | StaticSpecCatalogReferenceSource;
/** Whole-Catalog Reference provenance when live source inventory is present. */
interface LiveSpecCatalogReferenceProjection {
  provenance: 'live';
}
/** Whole-Catalog published static policy without invented Store identity or CLI evidence. */
type StaticSpecCatalogReferenceProjection = {
  provenance: 'static';
  policy: 'include';
} | {
  provenance: 'static';
  policy: 'omit';
  referenceSourceCount: number;
} | {
  provenance: 'static';
  policy: 'none';
} | {
  provenance: 'static';
  policy: 'unavailable';
};
/** Whole-Catalog Reference inventory or published static policy fact. */
type SpecCatalogReferenceProjection = LiveSpecCatalogReferenceProjection | StaticSpecCatalogReferenceProjection;
/** Runtime schema for the complete source-aware Spec Catalog. */
declare const SpecCatalogSchema: z.ZodType<SpecCatalog, z.ZodTypeDef, unknown>;
/** Map a published snapshot count without implying that the browser executed OpenSpec CLI. */
declare function createStaticSpecCatalogOwnedProjection(specCount?: number): StaticSpecCatalogOwnedProjection;
/** Map published Reference source facts without implying a CLI execution occurred. */
declare function createStaticSpecCatalogReferenceSource(input: {
  storeId: string;
  state: 'ready' | 'error';
  specCount: number;
}): StaticSpecCatalogReferenceSource;
/** Map published static policy without converting omitted or unavailable facts into empty live inventory. */
declare function createStaticSpecCatalogReferenceProjection(policy: {
  kind: 'include';
} | {
  kind: 'omit';
  referenceSourceCount: number;
} | {
  kind: 'none';
} | undefined): StaticSpecCatalogReferenceProjection;
/** Successful `show --type spec --json` document payload. */
type CliShowSpecDocument = Extract<CliShowSpec, {
  id: string;
}>;
/** Writable planning-root Spec document projection. */
interface OwnedSpecDocumentProjection {
  identity: OwnedSpecIdentity;
  source: 'owned';
  readOnly: false;
  state: 'ready' | 'not-found';
  spec: Spec | null;
  rawMarkdown: string | null;
  upstream: null;
  evidence: null;
}
/** Read-only Store-qualified Spec document projection. */
interface ReferencedSpecDocumentProjectionBase {
  identity: ReferencedSpecIdentity;
  source: 'referenced';
  readOnly: true;
  state: 'ready' | 'error';
  /**
   * Live mode never parses a referenced Spec body; static mode materializes it through
   * `--references include` and exposes the parsed body here as a ready projection.
   */
  spec: Spec | null;
  /**
   * Live mode never returns referenced raw markdown; static mode exposes the materialized
   * source when the snapshot carried the referenced Spec body.
   */
  rawMarkdown: string | null;
  upstream: CliShowSpecDocument | null;
}
/** Referenced document projected by a real OpenSpec CLI command. */
interface LiveReferencedSpecDocumentProjection extends ReferencedSpecDocumentProjectionBase {
  provenance: {
    kind: 'live';
  };
  evidence: SpecCommandEvidence;
}
/** Referenced document projected solely from the published static snapshot. */
interface StaticReferencedSpecDocumentProjection extends ReferencedSpecDocumentProjectionBase {
  provenance: {
    kind: 'static';
    state: 'included' | 'missing';
    policy: 'include' | 'unrecorded';
    source: StaticSpecCatalogReferenceSource | null;
  } | {
    kind: 'static';
    state: 'omitted';
    policy: 'omit';
    referenceSourceCount: number;
  } | {
    kind: 'static';
    state: 'none';
    policy: 'none';
  } | {
    kind: 'static';
    state: 'snapshot-unavailable';
    policy: 'absent';
  };
  evidence: null;
}
/** Read-only Store-qualified document with source-discriminated evidence. */
type ReferencedSpecDocumentProjection = LiveReferencedSpecDocumentProjection | StaticReferencedSpecDocumentProjection;
/** Source-aware owned/referenced Spec document projection union. */
type SpecDocumentProjection = OwnedSpecDocumentProjection | ReferencedSpecDocumentProjection;
/** Runtime schema for one source-aware owned or referenced Spec document projection. */
declare const SpecDocumentProjectionSchema: z.ZodType<SpecDocumentProjection, z.ZodTypeDef, unknown>;
/** Build a collision-safe cache/search key for a compound Spec identity. */
declare function specIdentityKey(identity: SpecIdentity): string;
/** Build the canonical live/static route for a compound Spec identity. */
declare function specRoutePath(identity: SpecIdentity): string;
/** Build the shared user-visible document path for live and static search results. */
declare function specDocumentDisplayPath(identity: SpecIdentity): string;
/** Recover compound Spec identity from canonical route parameters. */
declare function specIdentityFromRoute(params: {
  specId: string;
  storeId?: string;
}): SpecIdentity;
/** Merge already projected owned and referenced entries without bare-id deduplication. */
declare function mergeSpecCatalog(owned: readonly OwnedSpecCatalogEntry[], referenced: readonly ReferencedSpecCatalogEntry[], ownedProjection: SpecCatalogOwnedProjection, referenceSources: readonly SpecCatalogReferenceSource[], observedAt: number, referenceProjection?: SpecCatalogReferenceProjection): SpecCatalog;
/** Project CLI-owned Spec membership and explicit per-Store Spec lists into one Catalog. */
declare function buildSpecCatalog(input: {
  owned: CliSpecList['specs'];
  ownedProjection: SpecCatalogOwnedProjection;
  referenced: ReadonlyArray<{
    storeId: string;
    specs: CliSpecList['specs'];
  }>;
  referenceSources: readonly SpecCatalogReferenceSource[];
  observedAt: number;
}): SpecCatalog;
/** Look up only the exact compound identity in a Catalog. */
declare function getSpecCatalogEntry(catalog: SpecCatalog, identity: SpecIdentity): SpecCatalogEntry | null;
/** Narrow a compound Spec identity to its Store-qualified read-only form. */
declare function isReferencedSpecIdentity(identity: SpecIdentity): identity is ReferencedSpecIdentity;
//#endregion
//#region src/reactive-fs/project-watcher.d.ts
/**
 * 事件类型
 */
type WatchEventType = 'create' | 'update' | 'delete';
/**
 * 监听事件
 */
interface WatchEvent {
  type: WatchEventType;
  path: string;
}
/**
 * 路径订阅回调
 */
type PathCallback = (events: WatchEvent[]) => void;
/** watcher 重建原因 */
type ProjectWatcherReinitializeReason = 'drop-events' | 'watcher-error' | 'missing-project-dir' | 'project-dir-replaced' | 'manual';
type ProjectResidencyEvictionReason = Extract<ProjectWatcherReinitializeReason, 'missing-project-dir' | 'project-dir-replaced'>;
type ProjectResidencyStatus = {
  state: 'active';
} | {
  state: 'evicted';
  reason: ProjectResidencyEvictionReason;
  detectedAt: number;
};
/** watcher 运行时状态（用于调试和运维观测） */
interface ProjectWatcherRuntimeStatus {
  generation: number;
  reinitializeCount: number;
  lastReinitializeReason: ProjectWatcherReinitializeReason | null;
  reinitializeReasonCounts: Readonly<Record<ProjectWatcherReinitializeReason, number>>;
  projectResidency: ProjectResidencyStatus;
}
type ProjectWatcherRuntimeStatusListener = (status: ProjectWatcherRuntimeStatus) => void;
/**
 * 项目监听器
 *
 * 使用 @parcel/watcher 监听项目根目录，
 * 然后通过路径前缀匹配分发事件给订阅者。
 *
 * 特性：
 * - 单个 watcher 监听整个项目
 * - 自动处理新创建的目录
 * - 内置防抖机制
 * - 高性能原生实现
 */
declare class ProjectWatcher {
  private projectDir;
  private subscription;
  private pathSubscriptions;
  private pendingEvents;
  private debounceTimer;
  private debounceMs;
  private ignore;
  private initialized;
  private initPromise;
  private reinitializeTimer;
  private reinitializePending;
  private reinitializeReasonPending;
  private pathLivenessTimer;
  private projectDirFingerprint;
  private generation;
  private reinitializeCount;
  private lastReinitializeReason;
  private reinitializeReasonCounts;
  private projectResidency;
  private runtimeStatusListeners;
  constructor(projectDir: string, options?: {
    debounceMs?: number;
    ignore?: string[];
  });
  /**
   * 初始化 watcher
   * 懒加载，首次订阅时自动调用
   */
  init(): Promise<void>;
  private doInit;
  /**
   * 处理 watcher 错误
   * 统一走错误驱动重建流程
   */
  private handleWatcherError;
  /**
   * 延迟重建 watcher（防抖，避免频繁重建）
   */
  private scheduleReinitialize;
  /**
   * 读取项目目录指纹（目录不存在时返回 null）
   * 用于检测 path 对应实体是否被替换（inode/dev 漂移）
   */
  private getProjectDirFingerprint;
  /**
   * 启动路径语义监测（避免 watcher 绑定到已失效句柄）
   */
  private startPathLivenessMonitor;
  /**
   * 停止路径语义监测
   */
  private stopPathLivenessMonitor;
  /**
   * 只读检查 projectDir 是否仍指向初始化时的目录实体
   */
  private checkPathLiveness;
  /**
   * 处理原始事件
   */
  private handleEvents;
  /**
   * 分发事件给订阅者
   */
  private flushEvents;
  /**
   * 检查事件是否匹配订阅
   */
  private matchPath;
  /**
   * 同步订阅路径变更（watcher 必须已初始化）
   *
   * 这是同步版本，用于在 watcher 已初始化后快速注册订阅。
   * 如果 watcher 未初始化，抛出错误。
   *
   * @param path 要监听的路径
   * @param callback 变更回调
   * @param options 订阅选项
   * @returns 取消订阅函数
   */
  subscribeSync(path: string, callback: PathCallback, options?: {
    watchChildren?: boolean;
    watchAncestorsWhileMissing?: boolean;
  }): () => void;
  /**
   * 订阅路径变更（异步版本，自动初始化）
   *
   * @param path 要监听的路径
   * @param callback 变更回调
   * @param options 订阅选项
   * @returns 取消订阅函数
   */
  subscribe(path: string, callback: PathCallback, options?: {
    watchChildren?: boolean;
    watchAncestorsWhileMissing?: boolean;
  }): Promise<() => void>;
  /**
   * 获取当前订阅数量（用于调试）
   */
  get subscriptionCount(): number;
  /**
   * 检查是否已初始化
   */
  get isInitialized(): boolean;
  /**
   * 获取 watcher 运行时状态
   */
  get runtimeStatus(): ProjectWatcherRuntimeStatus;
  subscribeRuntimeStatus(listener: ProjectWatcherRuntimeStatusListener, options?: {
    emitCurrent?: boolean;
  }): () => void;
  /**
   * 记录重建统计
   */
  private markReinitialized;
  private markProjectResidencyActive;
  private markProjectResidencyEvicted;
  private emitRuntimeStatus;
  /**
   * 重新初始化 watcher
   */
  private reinitialize;
  /**
   * 等待项目目录被创建
   */
  private waitForProjectDir;
  /**
   * 关闭 watcher
   */
  close(): Promise<void>;
}
/**
 * 获取或创建项目监听器
 */
declare function getProjectWatcher(projectDir: string, options?: ConstructorParameters<typeof ProjectWatcher>[1]): ProjectWatcher;
/**
 * 关闭所有 ProjectWatcher（用于测试清理）
 */
declare function closeAllProjectWatchers(): Promise<void>;
//#endregion
//#region src/reactive-fs/watcher-pool.d.ts
type WatcherRootRelease = () => Promise<void>;
interface WatcherRootRuntimeStatus extends ProjectWatcherRuntimeStatus {
  rootPath: string;
  referenceCount: number;
  initialized: boolean;
  subscriptionCount: number;
}
/** Aggregate watcher state for the current process. */
interface WatcherRuntimeStatus {
  initialized: boolean;
  rootCount: number;
  subscriptionCount: number;
  roots: WatcherRootRuntimeStatus[];
}
/** Acquire one physical observation root and release it when the returned lease is no longer used. */
declare function acquireWatcherRoot(rootPath: string): Promise<WatcherRootRelease>;
/**
 * Acquire a shared path subscription.
 *
 * The subscription remains pending when no active root contains the path and binds automatically
 * after a matching root is acquired. This keeps static reads inert without making later live reads
 * permanently lose observation.
 */
declare function acquireWatcher(path: string, onChange: () => void, options?: {
  recursive?: boolean;
  debounceMs?: number;
  onError?: () => void;
  watchAncestorsWhileMissing?: boolean;
}): () => void;
declare function getActiveWatcherCount(): number;
/** Close the entire process-level pool. Intended for runtime teardown and test isolation. */
declare function closeAllWatchers(): Promise<void>;
declare function isWatcherPoolInitialized(): boolean;
declare function getWatcherRuntimeStatus(): WatcherRuntimeStatus | null;
declare function subscribeWatcherRuntimeStatus(listener: (status: WatcherRuntimeStatus | null) => void, options?: {
  emitCurrent?: boolean;
}): () => void;
//#endregion
//#region src/reactive-fs/observation-environment.d.ts
/** One observed root and its reference count inside an environment. */
interface ObservationEnvironmentRoot {
  rootPath: string;
  referenceCount: number;
}
/** Reference-counted root acquisition boundary for reactive observation. */
interface ObservationRootOwner {
  acquireRoot(rootPath: string): Promise<WatcherRootRelease>;
}
/** Runtime-environment owner for all roots observed by one backend process. */
declare class ReactiveObservationEnvironment implements ObservationRootOwner {
  private readonly roots;
  private disposed;
  acquireRoot(rootPath: string): Promise<WatcherRootRelease>;
  getRoots(): ObservationEnvironmentRoot[];
  dispose(): Promise<void>;
}
//#endregion
//#region src/reactive-fs/reactive-state.d.ts
interface IReactiveContext {
  track(state: ReactiveState<unknown>): void;
  notifyChange(): void;
}
/**
 * 全局的 AsyncLocalStorage，用于在异步调用链中传递 ReactiveContext
 * 这是实现依赖收集的核心机制
 */
declare const contextStorage: AsyncLocalStorage<IReactiveContext>;
/** ReactiveState 配置选项 */
interface ReactiveStateOptions<T> {
  /** 自定义相等性比较函数 */
  equals?: (a: T, b: T) => boolean;
}
/**
 * 响应式状态类，类似 Signal.State
 *
 * 核心机制：
 * - get() 时自动注册到当前 ReactiveContext 的依赖列表
 * - set() 时如果值变化，通知所有依赖的 Context
 */
declare class ReactiveState<T> {
  private currentValue;
  private readonly equals;
  /** 所有依赖此状态的 Context */
  private readonly subscribers;
  constructor(initialValue: T, options?: ReactiveStateOptions<T>);
  /**
   * 获取当前值
   * 如果在 ReactiveContext 中调用，会自动注册依赖
   */
  get(): T;
  /**
   * 设置新值
   * 如果值变化，通知所有订阅者
   * @returns 是否发生了变化
   */
  set(newValue: T): boolean;
  /**
   * 取消订阅
   * 当 Context 销毁时调用
   */
  unsubscribe(context: IReactiveContext): void;
  /**
   * 获取当前订阅者数量（用于调试）
   */
  get subscriberCount(): number;
}
//#endregion
//#region src/reactive-fs/reactive-context.d.ts
/** 观察依赖驱动的替换任务生命周期，不改变流的数据输出。 */
interface ReactiveContextStreamObserver {
  /** 依赖唤醒且排除取消后、替换任务执行前调用一次。 */
  onRecomputeStarted(): void;
}
/**
 * 响应式上下文，管理依赖收集和变更通知
 *
 * 核心机制：
 * - 在 stream() 中执行任务时，通过 AsyncLocalStorage 传递 this
 * - 任务中的所有 ReactiveState.get() 调用都会自动注册依赖
 * - 当任何依赖变更时，重新执行任务并 yield 新结果
 */
declare class ReactiveContext {
  /** 当前追踪的依赖 */
  private dependencies;
  /** 等待变更的 Promise */
  private changePromise?;
  /** 是否已销毁 */
  private destroyed;
  /** 当前任务执行期间是否已有依赖变化，使其结果不再可提交 */
  private changePending;
  /**
   * 追踪依赖
   * 由 ReactiveState.get() 调用
   */
  track(state: ReactiveState<unknown>): void;
  /**
   * 通知变更
   * 由 ReactiveState.set() 调用
   */
  notifyChange(): void;
  /**
   * 运行响应式任务流
   * 每次依赖变更时重新执行任务并 yield 结果
   *
   * @param task 要执行的异步任务
   * @param signal 用于取消的 AbortSignal
   * @param observer 可选的依赖重算生命周期观察器
   */
  stream<T>(task: () => Promise<T>, signal?: AbortSignal, observer?: ReactiveContextStreamObserver): AsyncGenerator<T>;
  /**
   * 执行一次任务（非响应式）
   * 用于初始数据获取
   */
  runOnce<T>(task: () => Promise<T>): Promise<T>;
  /**
   * 清理依赖
   */
  private clearDependencies;
  /**
   * 销毁上下文
   * @param reason 可选的销毁原因，如果提供则 reject changePromise
   */
  private destroy;
  /**
   * 等待 AbortSignal
   */
  private waitForAbort;
}
//#endregion
//#region src/reactive-fs/reactive-fs.d.ts
/**
 * 响应式读取文件内容
 *
 * 特性：
 * - 自动注册文件监听
 * - 文件变更时自动更新状态
 * - 在 ReactiveContext 中调用时自动追踪依赖
 * - 支持监听尚未创建的文件（通过 @parcel/watcher）
 *
 * @param filepath 文件路径
 * @returns 文件内容，文件不存在时返回 null
 */
declare function reactiveReadFile(filepath: string): Promise<string | null>;
/**
 * 主动更新响应式文件缓存（用于写入后立即推送订阅）
 *
 * 仅当该文件已有缓存状态时生效；不会创建新的监听器。
 */
declare function updateReactiveFileCache(filepath: string, content: string | null): void;
/**
 * 响应式读取目录内容
 *
 * 特性：
 * - 自动注册目录监听
 * - 目录变更时自动更新状态
 * - 在 ReactiveContext 中调用时自动追踪依赖
 * - 支持监听尚未创建的目录（通过 @parcel/watcher）
 *
 * @param dirpath 目录路径
 * @param options 选项
 * @returns 目录项名称数组
 */
declare function reactiveReadDir(dirpath: string, options?: {
  /** 是否只返回目录 */
  directoriesOnly?: boolean;
  /** 是否只返回文件 */
  filesOnly?: boolean;
  /** 是否包含隐藏文件（以 . 开头） */
  includeHidden?: boolean;
  /** 排除的名称 */
  exclude?: string[];
  /** Missing directories remain empty; other filesystem errors may fail the owning projection. */
  throwOnError?: boolean;
}): Promise<string[]>;
/**
 * 响应式检查路径是否存在
 *
 * @param path 路径
 * @returns 是否存在
 */
declare function reactiveExists(path: string): Promise<boolean>;
/**
 * 响应式获取文件/目录的 stat 信息
 *
 * @param path 路径
 * @returns stat 信息，不存在时返回 null
 */
declare function reactiveStat(path: string): Promise<{
  isDirectory: boolean;
  isFile: boolean;
  mtime: number;
  birthtime: number;
} | null>;
/**
 * 清除指定路径的缓存（用于测试）
 */
declare function clearCache(path?: string): void;
/**
 * 获取缓存大小（用于调试）
 */
declare function getCacheSize(): number;
//#endregion
//#region src/watcher.d.ts
/**
 * File change event types
 */
type FileChangeType = 'spec' | 'change' | 'archive' | 'project';
/**
 * File change event payload
 */
interface FileChangeEvent {
  type: FileChangeType;
  action: 'create' | 'update' | 'delete';
  id?: string;
  path: string;
  timestamp: number;
}
/**
 * OpenSpec file watcher
 * Watches the openspec/ directory for changes and emits events
 */
declare class OpenSpecWatcher extends EventEmitter {
  private projectDir;
  private watchers;
  private debounceTimers;
  private debounceMs;
  constructor(projectDir: string, options?: {
    debounceMs?: number;
  });
  private get openspecDir();
  private get specsDir();
  private get changesDir();
  private get archiveDir();
  /**
   * Start watching for file changes
   */
  start(): void;
  /**
   * Stop watching for file changes
   */
  stop(): void;
  /** Close every watcher and wait until native filesystem handles are released. */
  close(): Promise<void>;
  private takeWatchers;
  /**
   * Watch a directory recursively
   */
  private watchDir;
  /**
   * Emit event with debouncing to avoid duplicate events
   */
  private emitDebounced;
}
/**
 * Create a file change observable for use with tRPC subscriptions
 */
declare function createFileChangeObservable(watcher: OpenSpecWatcher): {
  subscribe: (observer: {
    next: (event: FileChangeEvent) => void;
    error?: (error: Error) => void;
    complete?: () => void;
  }) => {
    unsubscribe: () => void;
  };
};
//#endregion
//#region src/global-settings.d.ts
declare const DocumentTranslationGlobalSettingsSchema: z.ZodObject<{
  enabled: z.ZodDefault<z.ZodBoolean>;
  targetLanguage: z.ZodDefault<z.ZodString>;
  displayMode: z.ZodDefault<z.ZodEnum<["direct", "bilingual"]>>;
  cacheEnabled: z.ZodDefault<z.ZodBoolean>;
}, "strip", z.ZodTypeAny, {
  enabled: boolean;
  targetLanguage: string;
  displayMode: "direct" | "bilingual";
  cacheEnabled: boolean;
}, {
  enabled?: boolean | undefined;
  targetLanguage?: string | undefined;
  displayMode?: "direct" | "bilingual" | undefined;
  cacheEnabled?: boolean | undefined;
}>;
declare const DocumentTranslationGlobalSettingsUpdateSchema: z.ZodObject<{
  enabled: z.ZodOptional<z.ZodBoolean>;
  targetLanguage: z.ZodOptional<z.ZodString>;
  displayMode: z.ZodOptional<z.ZodEnum<["direct", "bilingual"]>>;
  cacheEnabled: z.ZodOptional<z.ZodBoolean>;
}, "strip", z.ZodTypeAny, {
  enabled?: boolean | undefined;
  targetLanguage?: string | undefined;
  displayMode?: "direct" | "bilingual" | undefined;
  cacheEnabled?: boolean | undefined;
}, {
  enabled?: boolean | undefined;
  targetLanguage?: string | undefined;
  displayMode?: "direct" | "bilingual" | undefined;
  cacheEnabled?: boolean | undefined;
}>;
type DocumentTranslationGlobalSettings = z.infer<typeof DocumentTranslationGlobalSettingsSchema>;
declare const SERVE_PRESENTATION_MODES: readonly ["app", "web"];
type ServePresentationMode = (typeof SERVE_PRESENTATION_MODES)[number];
declare const ServePresentationModeSchema: z.ZodEnum<["app", "web"]>;
declare const OpenSpecUIGlobalSettingsSchema: z.ZodObject<{
  translation: z.ZodDefault<z.ZodObject<{
    enabled: z.ZodDefault<z.ZodBoolean>;
    targetLanguage: z.ZodDefault<z.ZodString>;
    displayMode: z.ZodDefault<z.ZodEnum<["direct", "bilingual"]>>;
    cacheEnabled: z.ZodDefault<z.ZodBoolean>;
  }, "strip", z.ZodTypeAny, {
    enabled: boolean;
    targetLanguage: string;
    displayMode: "direct" | "bilingual";
    cacheEnabled: boolean;
  }, {
    enabled?: boolean | undefined;
    targetLanguage?: string | undefined;
    displayMode?: "direct" | "bilingual" | undefined;
    cacheEnabled?: boolean | undefined;
  }>>;
  translationCache: z.ZodDefault<z.ZodObject<{
    entryLimit: z.ZodDefault<z.ZodNumber>;
  }, "strip", z.ZodTypeAny, {
    entryLimit: number;
  }, {
    entryLimit?: number | undefined;
  }>>;
  translationEngines: z.ZodDefault<z.ZodObject<{
    engineId: z.ZodDefault<z.ZodEnum<["browser", "local", "local-ct2", "local-llama", "openai"]>>;
    openai: z.ZodDefault<z.ZodObject<{
      baseUrl: z.ZodDefault<z.ZodString>;
      token: z.ZodDefault<z.ZodString>;
      model: z.ZodDefault<z.ZodString>;
    }, "strip", z.ZodTypeAny, {
      model: string;
      baseUrl: string;
      token: string;
    }, {
      model?: string | undefined;
      baseUrl?: string | undefined;
      token?: string | undefined;
    }>>;
    local: z.ZodDefault<z.ZodObject<{
      model: z.ZodDefault<z.ZodString>;
      selectedGroupId: z.ZodOptional<z.ZodString>;
      hfEndpoint: z.ZodDefault<z.ZodString>;
      memoryBudgetPercent: z.ZodDefault<z.ZodNumber>;
    }, "strip", z.ZodTypeAny, {
      model: string;
      hfEndpoint: string;
      memoryBudgetPercent: number;
      selectedGroupId?: string | undefined;
    }, {
      model?: string | undefined;
      selectedGroupId?: string | undefined;
      hfEndpoint?: string | undefined;
      memoryBudgetPercent?: number | undefined;
    }>>;
    localCt2: z.ZodDefault<z.ZodObject<{
      model: z.ZodDefault<z.ZodString>;
      selectedGroupId: z.ZodOptional<z.ZodString>;
      hfEndpoint: z.ZodDefault<z.ZodString>;
      memoryBudgetPercent: z.ZodDefault<z.ZodNumber>;
    }, "strip", z.ZodTypeAny, {
      model: string;
      hfEndpoint: string;
      memoryBudgetPercent: number;
      selectedGroupId?: string | undefined;
    }, {
      model?: string | undefined;
      selectedGroupId?: string | undefined;
      hfEndpoint?: string | undefined;
      memoryBudgetPercent?: number | undefined;
    }>>;
    localLlama: z.ZodDefault<z.ZodObject<{
      model: z.ZodDefault<z.ZodString>;
      selectedGroupId: z.ZodOptional<z.ZodString>;
      hfEndpoint: z.ZodDefault<z.ZodString>;
      memoryBudgetPercent: z.ZodDefault<z.ZodNumber>;
    }, "strip", z.ZodTypeAny, {
      model: string;
      hfEndpoint: string;
      memoryBudgetPercent: number;
      selectedGroupId?: string | undefined;
    }, {
      model?: string | undefined;
      selectedGroupId?: string | undefined;
      hfEndpoint?: string | undefined;
      memoryBudgetPercent?: number | undefined;
    }>>;
  }, "strip", z.ZodTypeAny, {
    local: {
      model: string;
      hfEndpoint: string;
      memoryBudgetPercent: number;
      selectedGroupId?: string | undefined;
    };
    localCt2: {
      model: string;
      hfEndpoint: string;
      memoryBudgetPercent: number;
      selectedGroupId?: string | undefined;
    };
    localLlama: {
      model: string;
      hfEndpoint: string;
      memoryBudgetPercent: number;
      selectedGroupId?: string | undefined;
    };
    openai: {
      model: string;
      baseUrl: string;
      token: string;
    };
    engineId: "local" | "openai" | "browser" | "local-ct2" | "local-llama";
  }, {
    local?: {
      model?: string | undefined;
      selectedGroupId?: string | undefined;
      hfEndpoint?: string | undefined;
      memoryBudgetPercent?: number | undefined;
    } | undefined;
    localCt2?: {
      model?: string | undefined;
      selectedGroupId?: string | undefined;
      hfEndpoint?: string | undefined;
      memoryBudgetPercent?: number | undefined;
    } | undefined;
    localLlama?: {
      model?: string | undefined;
      selectedGroupId?: string | undefined;
      hfEndpoint?: string | undefined;
      memoryBudgetPercent?: number | undefined;
    } | undefined;
    openai?: {
      model?: string | undefined;
      baseUrl?: string | undefined;
      token?: string | undefined;
    } | undefined;
    engineId?: "local" | "openai" | "browser" | "local-ct2" | "local-llama" | undefined;
  }>>;
  servePresentation: z.ZodOptional<z.ZodEnum<["app", "web"]>>;
}, "strip", z.ZodTypeAny, {
  translation: {
    enabled: boolean;
    targetLanguage: string;
    displayMode: "direct" | "bilingual";
    cacheEnabled: boolean;
  };
  translationCache: {
    entryLimit: number;
  };
  translationEngines: {
    local: {
      model: string;
      hfEndpoint: string;
      memoryBudgetPercent: number;
      selectedGroupId?: string | undefined;
    };
    localCt2: {
      model: string;
      hfEndpoint: string;
      memoryBudgetPercent: number;
      selectedGroupId?: string | undefined;
    };
    localLlama: {
      model: string;
      hfEndpoint: string;
      memoryBudgetPercent: number;
      selectedGroupId?: string | undefined;
    };
    openai: {
      model: string;
      baseUrl: string;
      token: string;
    };
    engineId: "local" | "openai" | "browser" | "local-ct2" | "local-llama";
  };
  servePresentation?: "app" | "web" | undefined;
}, {
  translation?: {
    enabled?: boolean | undefined;
    targetLanguage?: string | undefined;
    displayMode?: "direct" | "bilingual" | undefined;
    cacheEnabled?: boolean | undefined;
  } | undefined;
  translationCache?: {
    entryLimit?: number | undefined;
  } | undefined;
  translationEngines?: {
    local?: {
      model?: string | undefined;
      selectedGroupId?: string | undefined;
      hfEndpoint?: string | undefined;
      memoryBudgetPercent?: number | undefined;
    } | undefined;
    localCt2?: {
      model?: string | undefined;
      selectedGroupId?: string | undefined;
      hfEndpoint?: string | undefined;
      memoryBudgetPercent?: number | undefined;
    } | undefined;
    localLlama?: {
      model?: string | undefined;
      selectedGroupId?: string | undefined;
      hfEndpoint?: string | undefined;
      memoryBudgetPercent?: number | undefined;
    } | undefined;
    openai?: {
      model?: string | undefined;
      baseUrl?: string | undefined;
      token?: string | undefined;
    } | undefined;
    engineId?: "local" | "openai" | "browser" | "local-ct2" | "local-llama" | undefined;
  } | undefined;
  servePresentation?: "app" | "web" | undefined;
}>;
type OpenSpecUIGlobalSettings = z.infer<typeof OpenSpecUIGlobalSettingsSchema>;
type OpenSpecUIGlobalSettingsUpdate = {
  translation?: Partial<DocumentTranslationGlobalSettings>;
  translationCache?: Partial<TranslationCacheSettings>;
  translationEngines?: TranslationEngineGlobalSettingsUpdate;
  servePresentation?: ServePresentationMode | null;
};
declare const OpenSpecUIGlobalSettingsUpdateSchema: z.ZodObject<{
  translation: z.ZodOptional<z.ZodObject<{
    enabled: z.ZodOptional<z.ZodBoolean>;
    targetLanguage: z.ZodOptional<z.ZodString>;
    displayMode: z.ZodOptional<z.ZodEnum<["direct", "bilingual"]>>;
    cacheEnabled: z.ZodOptional<z.ZodBoolean>;
  }, "strip", z.ZodTypeAny, {
    enabled?: boolean | undefined;
    targetLanguage?: string | undefined;
    displayMode?: "direct" | "bilingual" | undefined;
    cacheEnabled?: boolean | undefined;
  }, {
    enabled?: boolean | undefined;
    targetLanguage?: string | undefined;
    displayMode?: "direct" | "bilingual" | undefined;
    cacheEnabled?: boolean | undefined;
  }>>;
  translationCache: z.ZodOptional<z.ZodObject<{
    entryLimit: z.ZodOptional<z.ZodNumber>;
  }, "strip", z.ZodTypeAny, {
    entryLimit?: number | undefined;
  }, {
    entryLimit?: number | undefined;
  }>>;
  translationEngines: z.ZodOptional<z.ZodObject<{
    engineId: z.ZodOptional<z.ZodEnum<["browser", "local", "local-ct2", "local-llama", "openai"]>>;
    openai: z.ZodOptional<z.ZodObject<{
      baseUrl: z.ZodOptional<z.ZodString>;
      token: z.ZodOptional<z.ZodString>;
      model: z.ZodOptional<z.ZodString>;
    }, "strip", z.ZodTypeAny, {
      model?: string | undefined;
      baseUrl?: string | undefined;
      token?: string | undefined;
    }, {
      model?: string | undefined;
      baseUrl?: string | undefined;
      token?: string | undefined;
    }>>;
    local: z.ZodOptional<z.ZodObject<{
      model: z.ZodOptional<z.ZodString>;
      selectedGroupId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
      hfEndpoint: z.ZodOptional<z.ZodString>;
      memoryBudgetPercent: z.ZodOptional<z.ZodNumber>;
    }, "strip", z.ZodTypeAny, {
      model?: string | undefined;
      selectedGroupId?: string | null | undefined;
      hfEndpoint?: string | undefined;
      memoryBudgetPercent?: number | undefined;
    }, {
      model?: string | undefined;
      selectedGroupId?: string | null | undefined;
      hfEndpoint?: string | undefined;
      memoryBudgetPercent?: number | undefined;
    }>>;
    localCt2: z.ZodOptional<z.ZodObject<{
      model: z.ZodOptional<z.ZodString>;
      selectedGroupId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
      hfEndpoint: z.ZodOptional<z.ZodString>;
      memoryBudgetPercent: z.ZodOptional<z.ZodNumber>;
    }, "strip", z.ZodTypeAny, {
      model?: string | undefined;
      selectedGroupId?: string | null | undefined;
      hfEndpoint?: string | undefined;
      memoryBudgetPercent?: number | undefined;
    }, {
      model?: string | undefined;
      selectedGroupId?: string | null | undefined;
      hfEndpoint?: string | undefined;
      memoryBudgetPercent?: number | undefined;
    }>>;
    localLlama: z.ZodOptional<z.ZodObject<{
      model: z.ZodOptional<z.ZodString>;
      selectedGroupId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
      hfEndpoint: z.ZodOptional<z.ZodString>;
      memoryBudgetPercent: z.ZodOptional<z.ZodNumber>;
    }, "strip", z.ZodTypeAny, {
      model?: string | undefined;
      selectedGroupId?: string | null | undefined;
      hfEndpoint?: string | undefined;
      memoryBudgetPercent?: number | undefined;
    }, {
      model?: string | undefined;
      selectedGroupId?: string | null | undefined;
      hfEndpoint?: string | undefined;
      memoryBudgetPercent?: number | undefined;
    }>>;
  }, "strip", z.ZodTypeAny, {
    local?: {
      model?: string | undefined;
      selectedGroupId?: string | null | undefined;
      hfEndpoint?: string | undefined;
      memoryBudgetPercent?: number | undefined;
    } | undefined;
    localCt2?: {
      model?: string | undefined;
      selectedGroupId?: string | null | undefined;
      hfEndpoint?: string | undefined;
      memoryBudgetPercent?: number | undefined;
    } | undefined;
    localLlama?: {
      model?: string | undefined;
      selectedGroupId?: string | null | undefined;
      hfEndpoint?: string | undefined;
      memoryBudgetPercent?: number | undefined;
    } | undefined;
    openai?: {
      model?: string | undefined;
      baseUrl?: string | undefined;
      token?: string | undefined;
    } | undefined;
    engineId?: "local" | "openai" | "browser" | "local-ct2" | "local-llama" | undefined;
  }, {
    local?: {
      model?: string | undefined;
      selectedGroupId?: string | null | undefined;
      hfEndpoint?: string | undefined;
      memoryBudgetPercent?: number | undefined;
    } | undefined;
    localCt2?: {
      model?: string | undefined;
      selectedGroupId?: string | null | undefined;
      hfEndpoint?: string | undefined;
      memoryBudgetPercent?: number | undefined;
    } | undefined;
    localLlama?: {
      model?: string | undefined;
      selectedGroupId?: string | null | undefined;
      hfEndpoint?: string | undefined;
      memoryBudgetPercent?: number | undefined;
    } | undefined;
    openai?: {
      model?: string | undefined;
      baseUrl?: string | undefined;
      token?: string | undefined;
    } | undefined;
    engineId?: "local" | "openai" | "browser" | "local-ct2" | "local-llama" | undefined;
  }>>;
  servePresentation: z.ZodOptional<z.ZodNullable<z.ZodEnum<["app", "web"]>>>;
}, "strip", z.ZodTypeAny, {
  translation?: {
    enabled?: boolean | undefined;
    targetLanguage?: string | undefined;
    displayMode?: "direct" | "bilingual" | undefined;
    cacheEnabled?: boolean | undefined;
  } | undefined;
  translationCache?: {
    entryLimit?: number | undefined;
  } | undefined;
  translationEngines?: {
    local?: {
      model?: string | undefined;
      selectedGroupId?: string | null | undefined;
      hfEndpoint?: string | undefined;
      memoryBudgetPercent?: number | undefined;
    } | undefined;
    localCt2?: {
      model?: string | undefined;
      selectedGroupId?: string | null | undefined;
      hfEndpoint?: string | undefined;
      memoryBudgetPercent?: number | undefined;
    } | undefined;
    localLlama?: {
      model?: string | undefined;
      selectedGroupId?: string | null | undefined;
      hfEndpoint?: string | undefined;
      memoryBudgetPercent?: number | undefined;
    } | undefined;
    openai?: {
      model?: string | undefined;
      baseUrl?: string | undefined;
      token?: string | undefined;
    } | undefined;
    engineId?: "local" | "openai" | "browser" | "local-ct2" | "local-llama" | undefined;
  } | undefined;
  servePresentation?: "app" | "web" | null | undefined;
}, {
  translation?: {
    enabled?: boolean | undefined;
    targetLanguage?: string | undefined;
    displayMode?: "direct" | "bilingual" | undefined;
    cacheEnabled?: boolean | undefined;
  } | undefined;
  translationCache?: {
    entryLimit?: number | undefined;
  } | undefined;
  translationEngines?: {
    local?: {
      model?: string | undefined;
      selectedGroupId?: string | null | undefined;
      hfEndpoint?: string | undefined;
      memoryBudgetPercent?: number | undefined;
    } | undefined;
    localCt2?: {
      model?: string | undefined;
      selectedGroupId?: string | null | undefined;
      hfEndpoint?: string | undefined;
      memoryBudgetPercent?: number | undefined;
    } | undefined;
    localLlama?: {
      model?: string | undefined;
      selectedGroupId?: string | null | undefined;
      hfEndpoint?: string | undefined;
      memoryBudgetPercent?: number | undefined;
    } | undefined;
    openai?: {
      model?: string | undefined;
      baseUrl?: string | undefined;
      token?: string | undefined;
    } | undefined;
    engineId?: "local" | "openai" | "browser" | "local-ct2" | "local-llama" | undefined;
  } | undefined;
  servePresentation?: "app" | "web" | null | undefined;
}>;
type PersistedOpenSpecUIGlobalSettings = {
  translation?: Partial<OpenSpecUIGlobalSettings['translation']>;
  translationCache?: Partial<TranslationCacheSettings>;
  translationEngines?: {
    engineId?: TranslationEngineId;
    openai?: Partial<TranslationOpenAISettings>;
    local?: Partial<TranslationLocalSettings>;
    localCt2?: Partial<TranslationLocalCt2Settings>;
    localLlama?: Partial<TranslationLocalLlamaSettings>;
  };
  servePresentation?: ServePresentationMode;
};
declare const DEFAULT_GLOBAL_SETTINGS: OpenSpecUIGlobalSettings;
declare function getDefaultGlobalSettingsPath(): string;
declare function toPersistedGlobalSettings(settings: OpenSpecUIGlobalSettings): PersistedOpenSpecUIGlobalSettings;
/**
 * User-level OpenSpecUI settings stored outside project worktrees.
 *
 * This manager owns cross-project policy only; project opt-in remains in
 * `openspec/.openspecui.json`.
 */
declare class GlobalSettingsManager {
  private readonly settingsPath;
  private writeChain;
  constructor(settingsPath?: string);
  getSettingsPath(): string;
  private parseSettingsContent;
  readSettings(): Promise<OpenSpecUIGlobalSettings>;
  writeSettings(update: OpenSpecUIGlobalSettingsUpdate): Promise<void>;
  private enqueueWrite;
}
//#endregion
//#region src/child-process-tree.d.ts
/** Terminate a Windows tree only when the root PID still owns the expected executable. */
declare function terminateWindowsProcessTreeByIdentity(rootPid: number, expectedExecutablePath: string): Promise<void>;
/** Request termination of one spawned child and every Windows descendant it owns. */
declare function terminateChildProcessTree(child: ChildProcess, signal?: NodeJS.Signals): Promise<void>;
//#endregion
//#region src/command-invocation.d.ts
interface CommandInvocation {
  readonly args: string[];
  readonly command: string;
}
interface CommandInvocationOptions {
  readonly cwd?: string;
  readonly env?: NodeJS.ProcessEnv;
}
/** Resolve one Windows command without projecting argv through cmd.exe. */
declare function resolveWindowsCommandInvocation(command: string, args: readonly string[], options?: CommandInvocationOptions): CommandInvocation;
/** Resolve one command using the caller's cwd and environment while preserving POSIX behavior. */
declare function resolveCommandInvocation(command: string, args: readonly string[], options?: CommandInvocationOptions): CommandInvocation;
//#endregion
//#region src/spawn-safe.d.ts
interface SpawnErrorInfo {
  code?: string;
  message: string;
}
/** Shell-independent child-process startup result, including synchronous spawn failures. */
type SafeSpawnResult = {
  ok: true;
  child: ChildProcess;
} | {
  ok: false;
  error: SpawnErrorInfo;
};
/** Spawn without a shell after resolving one caller-environment native argv boundary. */
declare function spawnSafe(command: string, args: readonly string[], options: SpawnOptionsWithoutStdio): SafeSpawnResult;
//#endregion
//#region src/runtime-package-manager.d.ts
type RuntimePackageDependencyField = 'dependencies' | 'optionalDependencies';
type RuntimePackageManagerSource = 'deno-env' | 'user-agent' | 'exec-path' | 'package-manager-field' | 'lockfile' | 'fallback';
interface RuntimePackageManagerResolution {
  id: string;
  source: RuntimePackageManagerSource;
}
interface RuntimePackageInstallCommand {
  cmd: string;
  args: string[];
  displayCommand: string;
}
interface RuntimePackageInstallStrategy {
  id: string;
  preservesDependencyField: boolean;
  buildCommand(input: Omit<RuntimePackageInstallCommandInput, 'packageManager'>): RuntimePackageInstallCommand | null;
}
interface RuntimePackageManagerOptions {
  startDir: string;
  env?: NodeJS.ProcessEnv;
}
interface RuntimePackageInstallCommandInput {
  packageManager: string;
  packages: readonly string[];
  dependencyField?: RuntimePackageDependencyField;
  ignoreWorkspace?: boolean;
  allowBuildPackages?: readonly string[];
}
declare function detectRuntimePackageManager(options: RuntimePackageManagerOptions): RuntimePackageManagerResolution;
declare function resolveRuntimePackageInstallStrategy(packageManager: string): RuntimePackageInstallStrategy | null;
declare function buildRuntimePackageInstallCommand(input: RuntimePackageInstallCommandInput): RuntimePackageInstallCommand | null;
//#endregion
//#region src/openspec-cli-worker.d.ts
type OpenSpecSpawnMode = 'process' | 'worker';
declare const OPENSPEC_SPAWN_MODE_ENV = "OPENSPEC_SPAWN_MODE";
/** Resolve the main-thread buffered OpenSpec execution mode. */
declare function resolveOpenSpecSpawnMode(value?: string | undefined): OpenSpecSpawnMode;
//#endregion
//#region src/physical-reactive-file-writer.d.ts
/** One non-root path selected relative to an existing physical ownership root. */
interface PhysicalReactivePathTarget {
  /** Existing ownership root. The root itself may be reached through a symlink. */
  rootPath: string;
  /** Root-relative target; absolute, parent-traversal, NUL, and root-self paths are rejected. */
  relativePath: string;
}
/** Input for one Planning-root-confined UTF-8 write with post-commit reactive settlement. */
interface PhysicalReactiveFileWrite extends PhysicalReactivePathTarget {
  /** UTF-8 content written to disk and then published to reactive readers. */
  content: string;
}
/** Input for one byte-compared atomic UTF-8 replacement. */
interface PhysicalReactiveFileCompareWrite extends PhysicalReactiveFileWrite {
  /** Exact current UTF-8 source observed by the caller; null means the file was absent. */
  expectedContent: string | null;
}
/** Physical compare-and-write result returned after reactive settlement. */
type PhysicalReactiveFileCompareWriteResult = {
  state: 'written';
} | {
  state: 'conflict';
  content: string | null;
};
/** Commit one prepared replacement through rename, retrying transient Windows file locks. */
declare function replaceFileAtomically(temporaryPath: string, targetPath: string): Promise<void>;
/**
 * Write one UTF-8 file inside an existing physical root and synchronously settle reactive readers.
 *
 * Existing ancestors and the final target are resolved immediately before the write. This rejects
 * observed symlink escapes but cannot make path checks race-free against concurrent filesystem
 * replacement on platforms without a directory-handle-relative write primitive.
 */
declare function writePhysicalReactiveFile(input: PhysicalReactiveFileWrite): Promise<void>;
/**
 * Atomically replace one UTF-8 file inside an existing physical root, then settle reactive readers.
 *
 * The temporary file is created exclusively in the target directory, flushed, and renamed over the
 * destination. Existing permission bits are retained where available. Crash-durable directory fsync is
 * intentionally outside this cross-platform contract; successful callers observe one complete replacement.
 */
declare function writeAtomicPhysicalReactiveFile(input: PhysicalReactiveFileWrite): Promise<void>;
/**
 * Compare current physical bytes immediately before atomic replacement and settle either outcome.
 *
 * This closes stale in-process writers through their serialized caller and detects observed external
 * replacement after the temporary file is ready. Platforms expose no path-level atomic compare-and-swap,
 * so an external process can still race in the final compare-to-rename interval.
 */
declare function compareAndWriteAtomicPhysicalReactiveFile(input: PhysicalReactiveFileCompareWrite): Promise<PhysicalReactiveFileCompareWriteResult>;
/** Create one root-confined directory and synchronously settle overlapping reactive readers. */
declare function createPhysicalReactiveDirectory(input: PhysicalReactivePathTarget): Promise<void>;
/** Remove one root-confined file or directory and synchronously settle descendant projections. */
declare function removePhysicalReactivePath(input: PhysicalReactivePathTarget): Promise<void>;
/**
 * Guard and settle a mutation performed by an external owner such as the OpenSpec CLI.
 *
 * The pre/post checks reject observed symlink escape, but cannot close replacement races between
 * checks and the external process. Hard-link aliases are likewise not identifiable from the path.
 */
declare function runPhysicalReactivePathMutation<T>(input: PhysicalReactivePathTarget, mutation: () => Promise<T>): Promise<T>;
//#endregion
//#region src/runtime-invalidation.d.ts
/** Complete runtime projection facet vocabulary. */
declare const RUNTIME_INVALIDATION_FACETS: readonly ["project", "stores", "worksets", "schemas", "context"];
/** One invalidatable runtime projection facet. */
type RuntimeInvalidationFacet = (typeof RUNTIME_INVALIDATION_FACETS)[number];
/** Monotonic invalidation identity for one runtime facet. */
interface RuntimeInvalidationToken {
  facet: RuntimeInvalidationFacet;
  generation: number;
}
/** Listener notified with invalidation identities rather than projected data. */
type RuntimeInvalidationListener = (tokens: RuntimeInvalidationToken[]) => void;
/** Read/subscribe surface for runtime invalidation identities. */
interface RuntimeInvalidationReader {
  track(...facets: RuntimeInvalidationFacet[]): RuntimeInvalidationToken[];
  subscribe(facets: readonly RuntimeInvalidationFacet[], listener: RuntimeInvalidationListener): () => void;
}
/** Mutable runtime invalidation surface used by backend owners. */
interface RuntimeInvalidationController extends RuntimeInvalidationReader {
  invalidate(facets: readonly RuntimeInvalidationFacet[]): RuntimeInvalidationToken[];
}
/** Environment-local invalidation identity. Authoritative data stays in CLI-backed projections. */
declare class RuntimeInvalidationIndex implements RuntimeInvalidationController {
  private readonly generations;
  private readonly states;
  private readonly listeners;
  private pendingNotifications;
  private notificationScheduled;
  constructor();
  current(facet: RuntimeInvalidationFacet): number;
  track(...facets: RuntimeInvalidationFacet[]): RuntimeInvalidationToken[];
  invalidate(facets: readonly RuntimeInvalidationFacet[]): RuntimeInvalidationToken[];
  private enqueueNotifications;
  private flushNotifications;
  subscribe(facets: readonly RuntimeInvalidationFacet[], listener: RuntimeInvalidationListener): () => void;
}
//#endregion
//#region src/open-spec-data-home-observer.d.ts
/** Dependencies required to observe the effective OpenSpec data home. */
interface OpenSpecDataHomeObserverOptions {
  dataHomePath: string;
  environment: ObservationRootOwner;
  invalidation: RuntimeInvalidationController;
}
/** Official OpenSpec 1.6 data-home paths and the projections whose inputs they can change. */
declare const OPEN_SPEC_DATA_HOME_OBSERVATION_TARGETS: readonly [{
  readonly relativePath: "stores/registry.yaml";
  readonly recursive: false;
  readonly facets: readonly ["stores", "context"];
}, {
  readonly relativePath: "worksets";
  readonly recursive: true;
  readonly facets: readonly ["worksets"];
}, {
  readonly relativePath: "schemas";
  readonly recursive: true;
  readonly facets: readonly ["schemas", "context"];
}];
/** Lifecycle state of effective OpenSpec data-home observation. */
type OpenSpecDataHomeObservationState = 'idle' | 'starting' | 'active' | 'failed' | 'disposed';
/** Observe one effective OpenSpec data home without parsing or owning its domain data. */
declare class OpenSpecDataHomeObserver {
  readonly dataHomePath: string;
  private readonly environment;
  private readonly invalidation;
  private startPromise;
  private releasePathSubscriptions;
  private releaseRoot;
  private disposed;
  private state;
  constructor(options: OpenSpecDataHomeObserverOptions);
  start(): Promise<void>;
  /** Current lease state used by the bounded watcher-failure fallback. */
  getState(): OpenSpecDataHomeObservationState;
  dispose(): Promise<void>;
}
//#endregion
//#region src/planning-cli-projection.d.ts
/** Runtime selector for one Planning-root CLI-backed projection. */
declare const PlanningCliProjectionSelectorSchema: z.ZodDiscriminatedUnion<"kind", [z.ZodObject<{
  kind: z.ZodLiteral<"opsx-status">;
  change: z.ZodString;
  schema: z.ZodOptional<z.ZodString>;
}, "strip", z.ZodTypeAny, {
  kind: "opsx-status";
  change: string;
  schema?: string | undefined;
}, {
  kind: "opsx-status";
  change: string;
  schema?: string | undefined;
}>, z.ZodObject<{
  kind: z.ZodLiteral<"opsx-change-list">;
}, "strip", z.ZodTypeAny, {
  kind: "opsx-change-list";
}, {
  kind: "opsx-change-list";
}>, z.ZodObject<{
  kind: z.ZodLiteral<"opsx-status-list">;
}, "strip", z.ZodTypeAny, {
  kind: "opsx-status-list";
}, {
  kind: "opsx-status-list";
}>, z.ZodObject<{
  kind: z.ZodLiteral<"opsx-instructions">;
  change: z.ZodString;
  artifact: z.ZodString;
  schema: z.ZodOptional<z.ZodString>;
}, "strip", z.ZodTypeAny, {
  kind: "opsx-instructions";
  change: string;
  artifact: string;
  schema?: string | undefined;
}, {
  kind: "opsx-instructions";
  change: string;
  artifact: string;
  schema?: string | undefined;
}>, z.ZodObject<{
  kind: z.ZodLiteral<"opsx-apply-instructions">;
  change: z.ZodString;
  schema: z.ZodOptional<z.ZodString>;
}, "strip", z.ZodTypeAny, {
  kind: "opsx-apply-instructions";
  change: string;
  schema?: string | undefined;
}, {
  kind: "opsx-apply-instructions";
  change: string;
  schema?: string | undefined;
}>, z.ZodObject<{
  kind: z.ZodLiteral<"opsx-archive-instructions">;
  change: z.ZodString;
  schema: z.ZodOptional<z.ZodString>;
}, "strip", z.ZodTypeAny, {
  kind: "opsx-archive-instructions";
  change: string;
  schema?: string | undefined;
}, {
  kind: "opsx-archive-instructions";
  change: string;
  schema?: string | undefined;
}>, z.ZodObject<{
  kind: z.ZodLiteral<"opsx-config-bundle">;
}, "strip", z.ZodTypeAny, {
  kind: "opsx-config-bundle";
}, {
  kind: "opsx-config-bundle";
}>, z.ZodObject<{
  kind: z.ZodLiteral<"opsx-templates">;
  schema: z.ZodOptional<z.ZodString>;
}, "strip", z.ZodTypeAny, {
  kind: "opsx-templates";
  schema?: string | undefined;
}, {
  kind: "opsx-templates";
  schema?: string | undefined;
}>, z.ZodObject<{
  kind: z.ZodLiteral<"opsx-template-contents">;
  schema: z.ZodOptional<z.ZodString>;
}, "strip", z.ZodTypeAny, {
  kind: "opsx-template-contents";
  schema?: string | undefined;
}, {
  kind: "opsx-template-contents";
  schema?: string | undefined;
}>, z.ZodObject<{
  kind: z.ZodLiteral<"spec-catalog">;
}, "strip", z.ZodTypeAny, {
  kind: "spec-catalog";
}, {
  kind: "spec-catalog";
}>, z.ZodObject<{
  kind: z.ZodLiteral<"spec-document">;
  identity: z.ZodDiscriminatedUnion<"kind", [z.ZodObject<{
    kind: z.ZodLiteral<"owned">;
    specId: z.ZodEffects<z.ZodString, string, string>;
  }, "strip", z.ZodTypeAny, {
    kind: "owned";
    specId: string;
  }, {
    kind: "owned";
    specId: string;
  }>, z.ZodObject<{
    kind: z.ZodLiteral<"referenced">;
    storeId: z.ZodString;
    specId: z.ZodEffects<z.ZodString, string, string>;
  }, "strip", z.ZodTypeAny, {
    kind: "referenced";
    specId: string;
    storeId: string;
  }, {
    kind: "referenced";
    specId: string;
    storeId: string;
  }>]>;
}, "strip", z.ZodTypeAny, {
  kind: "spec-document";
  identity: {
    kind: "owned";
    specId: string;
  } | {
    kind: "referenced";
    specId: string;
    storeId: string;
  };
}, {
  kind: "spec-document";
  identity: {
    kind: "owned";
    specId: string;
  } | {
    kind: "referenced";
    specId: string;
    storeId: string;
  };
}>]>;
type PlanningCliProjectionSelector = z.infer<typeof PlanningCliProjectionSelectorSchema>;
/** Data payload retained by one Planning-root Projection Work registry. */
declare const PlanningCliProjectionDataSchema: z.ZodDiscriminatedUnion<"kind", [z.ZodObject<{
  kind: z.ZodLiteral<"opsx-status">;
  value: z.ZodObject<{
    changeName: z.ZodString;
    schemaName: z.ZodString;
    isPlanningComplete: z.ZodBoolean;
    applyRequires: z.ZodArray<z.ZodString, "many">;
    artifacts: z.ZodArray<z.ZodObject<{
      id: z.ZodString;
      outputPath: z.ZodString;
      status: z.ZodEnum<["done", "skipped", "ready", "blocked"]>;
      requires: z.ZodArray<z.ZodString, "many">;
      missingDeps: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
      relativePath: z.ZodOptional<z.ZodString>;
    }, "strip", z.ZodTypeAny, {
      status: "ready" | "done" | "skipped" | "blocked";
      id: string;
      outputPath: string;
      requires: string[];
      missingDeps?: string[] | undefined;
      relativePath?: string | undefined;
    }, {
      status: "ready" | "done" | "skipped" | "blocked";
      id: string;
      outputPath: string;
      requires: string[];
      missingDeps?: string[] | undefined;
      relativePath?: string | undefined;
    }>, "many">;
    provenance: z.ZodDiscriminatedUnion<"kind", [z.ZodObject<{
      kind: z.ZodLiteral<"cli">;
      planningHome: z.ZodObject<{
        kind: z.ZodLiteral<"repo">;
        root: z.ZodString;
        changesDir: z.ZodString;
        defaultSchema: z.ZodString;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        kind: z.ZodLiteral<"repo">;
        root: z.ZodString;
        changesDir: z.ZodString;
        defaultSchema: z.ZodString;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        kind: z.ZodLiteral<"repo">;
        root: z.ZodString;
        changesDir: z.ZodString;
        defaultSchema: z.ZodString;
      }, z.ZodTypeAny, "passthrough">>;
      changeRoot: z.ZodString;
      artifactPaths: z.ZodRecord<z.ZodString, z.ZodObject<{
        outputPath: z.ZodString;
        resolvedOutputPath: z.ZodString;
        existingOutputPaths: z.ZodArray<z.ZodString, "many">;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        outputPath: z.ZodString;
        resolvedOutputPath: z.ZodString;
        existingOutputPaths: z.ZodArray<z.ZodString, "many">;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        outputPath: z.ZodString;
        resolvedOutputPath: z.ZodString;
        existingOutputPaths: z.ZodArray<z.ZodString, "many">;
      }, z.ZodTypeAny, "passthrough">>>;
      nextSteps: z.ZodArray<z.ZodString, "many">;
      actionContext: z.ZodObject<{
        mode: z.ZodLiteral<"repo-local">;
        sourceOfTruth: z.ZodLiteral<"repo">;
        planningArtifacts: z.ZodArray<z.ZodString, "many">;
        linkedContext: z.ZodArray<z.ZodObject<{
          name: z.ZodString;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          name: z.ZodString;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          name: z.ZodString;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        allowedEditRoots: z.ZodArray<z.ZodString, "many">;
        requiresAffectedAreaSelection: z.ZodBoolean;
        constraints: z.ZodArray<z.ZodString, "many">;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        mode: z.ZodLiteral<"repo-local">;
        sourceOfTruth: z.ZodLiteral<"repo">;
        planningArtifacts: z.ZodArray<z.ZodString, "many">;
        linkedContext: z.ZodArray<z.ZodObject<{
          name: z.ZodString;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          name: z.ZodString;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          name: z.ZodString;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        allowedEditRoots: z.ZodArray<z.ZodString, "many">;
        requiresAffectedAreaSelection: z.ZodBoolean;
        constraints: z.ZodArray<z.ZodString, "many">;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        mode: z.ZodLiteral<"repo-local">;
        sourceOfTruth: z.ZodLiteral<"repo">;
        planningArtifacts: z.ZodArray<z.ZodString, "many">;
        linkedContext: z.ZodArray<z.ZodObject<{
          name: z.ZodString;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          name: z.ZodString;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          name: z.ZodString;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        allowedEditRoots: z.ZodArray<z.ZodString, "many">;
        requiresAffectedAreaSelection: z.ZodBoolean;
        constraints: z.ZodArray<z.ZodString, "many">;
      }, z.ZodTypeAny, "passthrough">>;
      root: z.ZodObject<{
        path: z.ZodString;
        source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
        store_id: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        path: z.ZodString;
        source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
        store_id: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        path: z.ZodString;
        source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
        store_id: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>;
      evidence: z.ZodObject<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        payload: z.ZodNullable<z.ZodType<CliJsonValue, z.ZodTypeDef, CliJsonValue>>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
        selector: z.ZodObject<{
          store: z.ZodOptional<z.ZodString>;
        }, "strict", z.ZodTypeAny, {
          store?: string | undefined;
        }, {
          store?: string | undefined;
        }>;
        root: z.ZodOptional<z.ZodObject<{
          path: z.ZodString;
          source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
          store_id: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          path: z.ZodString;
          source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
          store_id: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          path: z.ZodString;
          source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
          store_id: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>>;
      } & {
        command: z.ZodLiteral<"status">;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        payload: z.ZodNullable<z.ZodType<CliJsonValue, z.ZodTypeDef, CliJsonValue>>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
        selector: z.ZodObject<{
          store: z.ZodOptional<z.ZodString>;
        }, "strict", z.ZodTypeAny, {
          store?: string | undefined;
        }, {
          store?: string | undefined;
        }>;
        root: z.ZodOptional<z.ZodObject<{
          path: z.ZodString;
          source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
          store_id: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          path: z.ZodString;
          source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
          store_id: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          path: z.ZodString;
          source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
          store_id: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>>;
      } & {
        command: z.ZodLiteral<"status">;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        payload: z.ZodNullable<z.ZodType<CliJsonValue, z.ZodTypeDef, CliJsonValue>>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
        selector: z.ZodObject<{
          store: z.ZodOptional<z.ZodString>;
        }, "strict", z.ZodTypeAny, {
          store?: string | undefined;
        }, {
          store?: string | undefined;
        }>;
        root: z.ZodOptional<z.ZodObject<{
          path: z.ZodString;
          source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
          store_id: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          path: z.ZodString;
          source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
          store_id: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          path: z.ZodString;
          source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
          store_id: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>>;
      } & {
        command: z.ZodLiteral<"status">;
      }, z.ZodTypeAny, "passthrough">>;
    }, "strip", z.ZodTypeAny, {
      root: {
        path: string;
        source: "store" | "declared" | "nearest" | "global_default" | "implicit";
        store_id?: string | undefined;
      } & {
        [k: string]: unknown;
      };
      kind: "cli";
      evidence: {
        success: boolean;
        stdout: string;
        stderr: string;
        exitCode: number | null;
        payload: CliJsonValue;
        diagnostics: z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">[];
        command: "status";
        selector: {
          store?: string | undefined;
        };
        root?: z.objectOutputType<{
          path: z.ZodString;
          source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
          store_id: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough"> | undefined;
        contractError?: string | undefined;
      } & {
        [k: string]: unknown;
      };
      planningHome: {
        root: string;
        kind: "repo";
        changesDir: string;
        defaultSchema: string;
      } & {
        [k: string]: unknown;
      };
      changeRoot: string;
      artifactPaths: Record<string, z.objectOutputType<{
        outputPath: z.ZodString;
        resolvedOutputPath: z.ZodString;
        existingOutputPaths: z.ZodArray<z.ZodString, "many">;
      }, z.ZodTypeAny, "passthrough">>;
      nextSteps: string[];
      actionContext: {
        mode: "repo-local";
        sourceOfTruth: "repo";
        planningArtifacts: string[];
        linkedContext: z.objectOutputType<{
          name: z.ZodString;
        }, z.ZodTypeAny, "passthrough">[];
        allowedEditRoots: string[];
        requiresAffectedAreaSelection: boolean;
        constraints: string[];
      } & {
        [k: string]: unknown;
      };
    }, {
      root: {
        path: string;
        source: "store" | "declared" | "nearest" | "global_default" | "implicit";
        store_id?: string | undefined;
      } & {
        [k: string]: unknown;
      };
      kind: "cli";
      evidence: {
        success: boolean;
        stdout: string;
        stderr: string;
        exitCode: number | null;
        payload: CliJsonValue;
        diagnostics: z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">[];
        command: "status";
        selector: {
          store?: string | undefined;
        };
        root?: z.objectInputType<{
          path: z.ZodString;
          source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
          store_id: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough"> | undefined;
        contractError?: string | undefined;
      } & {
        [k: string]: unknown;
      };
      planningHome: {
        root: string;
        kind: "repo";
        changesDir: string;
        defaultSchema: string;
      } & {
        [k: string]: unknown;
      };
      changeRoot: string;
      artifactPaths: Record<string, z.objectInputType<{
        outputPath: z.ZodString;
        resolvedOutputPath: z.ZodString;
        existingOutputPaths: z.ZodArray<z.ZodString, "many">;
      }, z.ZodTypeAny, "passthrough">>;
      nextSteps: string[];
      actionContext: {
        mode: "repo-local";
        sourceOfTruth: "repo";
        planningArtifacts: string[];
        linkedContext: z.objectInputType<{
          name: z.ZodString;
        }, z.ZodTypeAny, "passthrough">[];
        allowedEditRoots: string[];
        requiresAffectedAreaSelection: boolean;
        constraints: string[];
      } & {
        [k: string]: unknown;
      };
    }>, z.ZodObject<{
      kind: z.ZodLiteral<"static">;
    }, "strip", z.ZodTypeAny, {
      kind: "static";
    }, {
      kind: "static";
    }>]>;
  }, "strip", z.ZodTypeAny, {
    changeName: string;
    schemaName: string;
    isPlanningComplete: boolean;
    applyRequires: string[];
    artifacts: {
      status: "ready" | "done" | "skipped" | "blocked";
      id: string;
      outputPath: string;
      requires: string[];
      missingDeps?: string[] | undefined;
      relativePath?: string | undefined;
    }[];
    provenance: {
      root: {
        path: string;
        source: "store" | "declared" | "nearest" | "global_default" | "implicit";
        store_id?: string | undefined;
      } & {
        [k: string]: unknown;
      };
      kind: "cli";
      evidence: {
        success: boolean;
        stdout: string;
        stderr: string;
        exitCode: number | null;
        payload: CliJsonValue;
        diagnostics: z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">[];
        command: "status";
        selector: {
          store?: string | undefined;
        };
        root?: z.objectOutputType<{
          path: z.ZodString;
          source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
          store_id: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough"> | undefined;
        contractError?: string | undefined;
      } & {
        [k: string]: unknown;
      };
      planningHome: {
        root: string;
        kind: "repo";
        changesDir: string;
        defaultSchema: string;
      } & {
        [k: string]: unknown;
      };
      changeRoot: string;
      artifactPaths: Record<string, z.objectOutputType<{
        outputPath: z.ZodString;
        resolvedOutputPath: z.ZodString;
        existingOutputPaths: z.ZodArray<z.ZodString, "many">;
      }, z.ZodTypeAny, "passthrough">>;
      nextSteps: string[];
      actionContext: {
        mode: "repo-local";
        sourceOfTruth: "repo";
        planningArtifacts: string[];
        linkedContext: z.objectOutputType<{
          name: z.ZodString;
        }, z.ZodTypeAny, "passthrough">[];
        allowedEditRoots: string[];
        requiresAffectedAreaSelection: boolean;
        constraints: string[];
      } & {
        [k: string]: unknown;
      };
    } | {
      kind: "static";
    };
  }, {
    changeName: string;
    schemaName: string;
    isPlanningComplete: boolean;
    applyRequires: string[];
    artifacts: {
      status: "ready" | "done" | "skipped" | "blocked";
      id: string;
      outputPath: string;
      requires: string[];
      missingDeps?: string[] | undefined;
      relativePath?: string | undefined;
    }[];
    provenance: {
      root: {
        path: string;
        source: "store" | "declared" | "nearest" | "global_default" | "implicit";
        store_id?: string | undefined;
      } & {
        [k: string]: unknown;
      };
      kind: "cli";
      evidence: {
        success: boolean;
        stdout: string;
        stderr: string;
        exitCode: number | null;
        payload: CliJsonValue;
        diagnostics: z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">[];
        command: "status";
        selector: {
          store?: string | undefined;
        };
        root?: z.objectInputType<{
          path: z.ZodString;
          source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
          store_id: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough"> | undefined;
        contractError?: string | undefined;
      } & {
        [k: string]: unknown;
      };
      planningHome: {
        root: string;
        kind: "repo";
        changesDir: string;
        defaultSchema: string;
      } & {
        [k: string]: unknown;
      };
      changeRoot: string;
      artifactPaths: Record<string, z.objectInputType<{
        outputPath: z.ZodString;
        resolvedOutputPath: z.ZodString;
        existingOutputPaths: z.ZodArray<z.ZodString, "many">;
      }, z.ZodTypeAny, "passthrough">>;
      nextSteps: string[];
      actionContext: {
        mode: "repo-local";
        sourceOfTruth: "repo";
        planningArtifacts: string[];
        linkedContext: z.objectInputType<{
          name: z.ZodString;
        }, z.ZodTypeAny, "passthrough">[];
        allowedEditRoots: string[];
        requiresAffectedAreaSelection: boolean;
        constraints: string[];
      } & {
        [k: string]: unknown;
      };
    } | {
      kind: "static";
    };
  }>;
}, "strip", z.ZodTypeAny, {
  value: {
    changeName: string;
    schemaName: string;
    isPlanningComplete: boolean;
    applyRequires: string[];
    artifacts: {
      status: "ready" | "done" | "skipped" | "blocked";
      id: string;
      outputPath: string;
      requires: string[];
      missingDeps?: string[] | undefined;
      relativePath?: string | undefined;
    }[];
    provenance: {
      root: {
        path: string;
        source: "store" | "declared" | "nearest" | "global_default" | "implicit";
        store_id?: string | undefined;
      } & {
        [k: string]: unknown;
      };
      kind: "cli";
      evidence: {
        success: boolean;
        stdout: string;
        stderr: string;
        exitCode: number | null;
        payload: CliJsonValue;
        diagnostics: z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">[];
        command: "status";
        selector: {
          store?: string | undefined;
        };
        root?: z.objectOutputType<{
          path: z.ZodString;
          source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
          store_id: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough"> | undefined;
        contractError?: string | undefined;
      } & {
        [k: string]: unknown;
      };
      planningHome: {
        root: string;
        kind: "repo";
        changesDir: string;
        defaultSchema: string;
      } & {
        [k: string]: unknown;
      };
      changeRoot: string;
      artifactPaths: Record<string, z.objectOutputType<{
        outputPath: z.ZodString;
        resolvedOutputPath: z.ZodString;
        existingOutputPaths: z.ZodArray<z.ZodString, "many">;
      }, z.ZodTypeAny, "passthrough">>;
      nextSteps: string[];
      actionContext: {
        mode: "repo-local";
        sourceOfTruth: "repo";
        planningArtifacts: string[];
        linkedContext: z.objectOutputType<{
          name: z.ZodString;
        }, z.ZodTypeAny, "passthrough">[];
        allowedEditRoots: string[];
        requiresAffectedAreaSelection: boolean;
        constraints: string[];
      } & {
        [k: string]: unknown;
      };
    } | {
      kind: "static";
    };
  };
  kind: "opsx-status";
}, {
  value: {
    changeName: string;
    schemaName: string;
    isPlanningComplete: boolean;
    applyRequires: string[];
    artifacts: {
      status: "ready" | "done" | "skipped" | "blocked";
      id: string;
      outputPath: string;
      requires: string[];
      missingDeps?: string[] | undefined;
      relativePath?: string | undefined;
    }[];
    provenance: {
      root: {
        path: string;
        source: "store" | "declared" | "nearest" | "global_default" | "implicit";
        store_id?: string | undefined;
      } & {
        [k: string]: unknown;
      };
      kind: "cli";
      evidence: {
        success: boolean;
        stdout: string;
        stderr: string;
        exitCode: number | null;
        payload: CliJsonValue;
        diagnostics: z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">[];
        command: "status";
        selector: {
          store?: string | undefined;
        };
        root?: z.objectInputType<{
          path: z.ZodString;
          source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
          store_id: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough"> | undefined;
        contractError?: string | undefined;
      } & {
        [k: string]: unknown;
      };
      planningHome: {
        root: string;
        kind: "repo";
        changesDir: string;
        defaultSchema: string;
      } & {
        [k: string]: unknown;
      };
      changeRoot: string;
      artifactPaths: Record<string, z.objectInputType<{
        outputPath: z.ZodString;
        resolvedOutputPath: z.ZodString;
        existingOutputPaths: z.ZodArray<z.ZodString, "many">;
      }, z.ZodTypeAny, "passthrough">>;
      nextSteps: string[];
      actionContext: {
        mode: "repo-local";
        sourceOfTruth: "repo";
        planningArtifacts: string[];
        linkedContext: z.objectInputType<{
          name: z.ZodString;
        }, z.ZodTypeAny, "passthrough">[];
        allowedEditRoots: string[];
        requiresAffectedAreaSelection: boolean;
        constraints: string[];
      } & {
        [k: string]: unknown;
      };
    } | {
      kind: "static";
    };
  };
  kind: "opsx-status";
}>, z.ZodObject<{
  kind: z.ZodLiteral<"opsx-change-list">;
  value: z.ZodArray<z.ZodString, "many">;
  entries: z.ZodArray<z.ZodObject<{
    name: z.ZodString;
    completedTasks: z.ZodNumber;
    totalTasks: z.ZodNumber;
    lastModified: z.ZodString;
    status: z.ZodEnum<["no-tasks", "complete", "in-progress"]>;
  }, "strip", z.ZodTypeAny, {
    status: "no-tasks" | "complete" | "in-progress";
    name: string;
    completedTasks: number;
    totalTasks: number;
    lastModified: string;
  }, {
    status: "no-tasks" | "complete" | "in-progress";
    name: string;
    completedTasks: number;
    totalTasks: number;
    lastModified: string;
  }>, "many">;
  evidence: z.ZodObject<{
    success: z.ZodBoolean;
    stdout: z.ZodString;
    stderr: z.ZodString;
    exitCode: z.ZodNullable<z.ZodNumber>;
    payload: z.ZodNullable<z.ZodType<CliJsonValue, z.ZodTypeDef, CliJsonValue>>;
    diagnostics: z.ZodArray<z.ZodObject<{
      severity: z.ZodEnum<["error", "warning", "info"]>;
      code: z.ZodString;
      message: z.ZodString;
      target: z.ZodOptional<z.ZodString>;
      fix: z.ZodOptional<z.ZodString>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      severity: z.ZodEnum<["error", "warning", "info"]>;
      code: z.ZodString;
      message: z.ZodString;
      target: z.ZodOptional<z.ZodString>;
      fix: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      severity: z.ZodEnum<["error", "warning", "info"]>;
      code: z.ZodString;
      message: z.ZodString;
      target: z.ZodOptional<z.ZodString>;
      fix: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">>, "many">;
    contractError: z.ZodOptional<z.ZodString>;
  }, "strip", z.ZodTypeAny, {
    success: boolean;
    stdout: string;
    stderr: string;
    exitCode: number | null;
    payload: CliJsonValue;
    diagnostics: z.objectOutputType<{
      severity: z.ZodEnum<["error", "warning", "info"]>;
      code: z.ZodString;
      message: z.ZodString;
      target: z.ZodOptional<z.ZodString>;
      fix: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">[];
    contractError?: string | undefined;
  }, {
    success: boolean;
    stdout: string;
    stderr: string;
    exitCode: number | null;
    payload: CliJsonValue;
    diagnostics: z.objectInputType<{
      severity: z.ZodEnum<["error", "warning", "info"]>;
      code: z.ZodString;
      message: z.ZodString;
      target: z.ZodOptional<z.ZodString>;
      fix: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">[];
    contractError?: string | undefined;
  }>;
}, "strip", z.ZodTypeAny, {
  value: string[];
  entries: {
    status: "no-tasks" | "complete" | "in-progress";
    name: string;
    completedTasks: number;
    totalTasks: number;
    lastModified: string;
  }[];
  kind: "opsx-change-list";
  evidence: {
    success: boolean;
    stdout: string;
    stderr: string;
    exitCode: number | null;
    payload: CliJsonValue;
    diagnostics: z.objectOutputType<{
      severity: z.ZodEnum<["error", "warning", "info"]>;
      code: z.ZodString;
      message: z.ZodString;
      target: z.ZodOptional<z.ZodString>;
      fix: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">[];
    contractError?: string | undefined;
  };
}, {
  value: string[];
  entries: {
    status: "no-tasks" | "complete" | "in-progress";
    name: string;
    completedTasks: number;
    totalTasks: number;
    lastModified: string;
  }[];
  kind: "opsx-change-list";
  evidence: {
    success: boolean;
    stdout: string;
    stderr: string;
    exitCode: number | null;
    payload: CliJsonValue;
    diagnostics: z.objectInputType<{
      severity: z.ZodEnum<["error", "warning", "info"]>;
      code: z.ZodString;
      message: z.ZodString;
      target: z.ZodOptional<z.ZodString>;
      fix: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">[];
    contractError?: string | undefined;
  };
}>, z.ZodObject<{
  kind: z.ZodLiteral<"opsx-status-list">;
  value: z.ZodArray<z.ZodObject<{
    changeName: z.ZodString;
    schemaName: z.ZodString;
    isPlanningComplete: z.ZodBoolean;
    applyRequires: z.ZodArray<z.ZodString, "many">;
    artifacts: z.ZodArray<z.ZodObject<{
      id: z.ZodString;
      outputPath: z.ZodString;
      status: z.ZodEnum<["done", "skipped", "ready", "blocked"]>;
      requires: z.ZodArray<z.ZodString, "many">;
      missingDeps: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
      relativePath: z.ZodOptional<z.ZodString>;
    }, "strip", z.ZodTypeAny, {
      status: "ready" | "done" | "skipped" | "blocked";
      id: string;
      outputPath: string;
      requires: string[];
      missingDeps?: string[] | undefined;
      relativePath?: string | undefined;
    }, {
      status: "ready" | "done" | "skipped" | "blocked";
      id: string;
      outputPath: string;
      requires: string[];
      missingDeps?: string[] | undefined;
      relativePath?: string | undefined;
    }>, "many">;
    provenance: z.ZodDiscriminatedUnion<"kind", [z.ZodObject<{
      kind: z.ZodLiteral<"cli">;
      planningHome: z.ZodObject<{
        kind: z.ZodLiteral<"repo">;
        root: z.ZodString;
        changesDir: z.ZodString;
        defaultSchema: z.ZodString;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        kind: z.ZodLiteral<"repo">;
        root: z.ZodString;
        changesDir: z.ZodString;
        defaultSchema: z.ZodString;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        kind: z.ZodLiteral<"repo">;
        root: z.ZodString;
        changesDir: z.ZodString;
        defaultSchema: z.ZodString;
      }, z.ZodTypeAny, "passthrough">>;
      changeRoot: z.ZodString;
      artifactPaths: z.ZodRecord<z.ZodString, z.ZodObject<{
        outputPath: z.ZodString;
        resolvedOutputPath: z.ZodString;
        existingOutputPaths: z.ZodArray<z.ZodString, "many">;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        outputPath: z.ZodString;
        resolvedOutputPath: z.ZodString;
        existingOutputPaths: z.ZodArray<z.ZodString, "many">;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        outputPath: z.ZodString;
        resolvedOutputPath: z.ZodString;
        existingOutputPaths: z.ZodArray<z.ZodString, "many">;
      }, z.ZodTypeAny, "passthrough">>>;
      nextSteps: z.ZodArray<z.ZodString, "many">;
      actionContext: z.ZodObject<{
        mode: z.ZodLiteral<"repo-local">;
        sourceOfTruth: z.ZodLiteral<"repo">;
        planningArtifacts: z.ZodArray<z.ZodString, "many">;
        linkedContext: z.ZodArray<z.ZodObject<{
          name: z.ZodString;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          name: z.ZodString;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          name: z.ZodString;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        allowedEditRoots: z.ZodArray<z.ZodString, "many">;
        requiresAffectedAreaSelection: z.ZodBoolean;
        constraints: z.ZodArray<z.ZodString, "many">;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        mode: z.ZodLiteral<"repo-local">;
        sourceOfTruth: z.ZodLiteral<"repo">;
        planningArtifacts: z.ZodArray<z.ZodString, "many">;
        linkedContext: z.ZodArray<z.ZodObject<{
          name: z.ZodString;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          name: z.ZodString;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          name: z.ZodString;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        allowedEditRoots: z.ZodArray<z.ZodString, "many">;
        requiresAffectedAreaSelection: z.ZodBoolean;
        constraints: z.ZodArray<z.ZodString, "many">;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        mode: z.ZodLiteral<"repo-local">;
        sourceOfTruth: z.ZodLiteral<"repo">;
        planningArtifacts: z.ZodArray<z.ZodString, "many">;
        linkedContext: z.ZodArray<z.ZodObject<{
          name: z.ZodString;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          name: z.ZodString;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          name: z.ZodString;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        allowedEditRoots: z.ZodArray<z.ZodString, "many">;
        requiresAffectedAreaSelection: z.ZodBoolean;
        constraints: z.ZodArray<z.ZodString, "many">;
      }, z.ZodTypeAny, "passthrough">>;
      root: z.ZodObject<{
        path: z.ZodString;
        source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
        store_id: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        path: z.ZodString;
        source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
        store_id: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        path: z.ZodString;
        source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
        store_id: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>;
      evidence: z.ZodObject<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        payload: z.ZodNullable<z.ZodType<CliJsonValue, z.ZodTypeDef, CliJsonValue>>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
        selector: z.ZodObject<{
          store: z.ZodOptional<z.ZodString>;
        }, "strict", z.ZodTypeAny, {
          store?: string | undefined;
        }, {
          store?: string | undefined;
        }>;
        root: z.ZodOptional<z.ZodObject<{
          path: z.ZodString;
          source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
          store_id: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          path: z.ZodString;
          source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
          store_id: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          path: z.ZodString;
          source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
          store_id: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>>;
      } & {
        command: z.ZodLiteral<"status">;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        payload: z.ZodNullable<z.ZodType<CliJsonValue, z.ZodTypeDef, CliJsonValue>>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
        selector: z.ZodObject<{
          store: z.ZodOptional<z.ZodString>;
        }, "strict", z.ZodTypeAny, {
          store?: string | undefined;
        }, {
          store?: string | undefined;
        }>;
        root: z.ZodOptional<z.ZodObject<{
          path: z.ZodString;
          source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
          store_id: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          path: z.ZodString;
          source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
          store_id: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          path: z.ZodString;
          source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
          store_id: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>>;
      } & {
        command: z.ZodLiteral<"status">;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        payload: z.ZodNullable<z.ZodType<CliJsonValue, z.ZodTypeDef, CliJsonValue>>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
        selector: z.ZodObject<{
          store: z.ZodOptional<z.ZodString>;
        }, "strict", z.ZodTypeAny, {
          store?: string | undefined;
        }, {
          store?: string | undefined;
        }>;
        root: z.ZodOptional<z.ZodObject<{
          path: z.ZodString;
          source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
          store_id: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          path: z.ZodString;
          source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
          store_id: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          path: z.ZodString;
          source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
          store_id: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>>;
      } & {
        command: z.ZodLiteral<"status">;
      }, z.ZodTypeAny, "passthrough">>;
    }, "strip", z.ZodTypeAny, {
      root: {
        path: string;
        source: "store" | "declared" | "nearest" | "global_default" | "implicit";
        store_id?: string | undefined;
      } & {
        [k: string]: unknown;
      };
      kind: "cli";
      evidence: {
        success: boolean;
        stdout: string;
        stderr: string;
        exitCode: number | null;
        payload: CliJsonValue;
        diagnostics: z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">[];
        command: "status";
        selector: {
          store?: string | undefined;
        };
        root?: z.objectOutputType<{
          path: z.ZodString;
          source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
          store_id: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough"> | undefined;
        contractError?: string | undefined;
      } & {
        [k: string]: unknown;
      };
      planningHome: {
        root: string;
        kind: "repo";
        changesDir: string;
        defaultSchema: string;
      } & {
        [k: string]: unknown;
      };
      changeRoot: string;
      artifactPaths: Record<string, z.objectOutputType<{
        outputPath: z.ZodString;
        resolvedOutputPath: z.ZodString;
        existingOutputPaths: z.ZodArray<z.ZodString, "many">;
      }, z.ZodTypeAny, "passthrough">>;
      nextSteps: string[];
      actionContext: {
        mode: "repo-local";
        sourceOfTruth: "repo";
        planningArtifacts: string[];
        linkedContext: z.objectOutputType<{
          name: z.ZodString;
        }, z.ZodTypeAny, "passthrough">[];
        allowedEditRoots: string[];
        requiresAffectedAreaSelection: boolean;
        constraints: string[];
      } & {
        [k: string]: unknown;
      };
    }, {
      root: {
        path: string;
        source: "store" | "declared" | "nearest" | "global_default" | "implicit";
        store_id?: string | undefined;
      } & {
        [k: string]: unknown;
      };
      kind: "cli";
      evidence: {
        success: boolean;
        stdout: string;
        stderr: string;
        exitCode: number | null;
        payload: CliJsonValue;
        diagnostics: z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">[];
        command: "status";
        selector: {
          store?: string | undefined;
        };
        root?: z.objectInputType<{
          path: z.ZodString;
          source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
          store_id: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough"> | undefined;
        contractError?: string | undefined;
      } & {
        [k: string]: unknown;
      };
      planningHome: {
        root: string;
        kind: "repo";
        changesDir: string;
        defaultSchema: string;
      } & {
        [k: string]: unknown;
      };
      changeRoot: string;
      artifactPaths: Record<string, z.objectInputType<{
        outputPath: z.ZodString;
        resolvedOutputPath: z.ZodString;
        existingOutputPaths: z.ZodArray<z.ZodString, "many">;
      }, z.ZodTypeAny, "passthrough">>;
      nextSteps: string[];
      actionContext: {
        mode: "repo-local";
        sourceOfTruth: "repo";
        planningArtifacts: string[];
        linkedContext: z.objectInputType<{
          name: z.ZodString;
        }, z.ZodTypeAny, "passthrough">[];
        allowedEditRoots: string[];
        requiresAffectedAreaSelection: boolean;
        constraints: string[];
      } & {
        [k: string]: unknown;
      };
    }>, z.ZodObject<{
      kind: z.ZodLiteral<"static">;
    }, "strip", z.ZodTypeAny, {
      kind: "static";
    }, {
      kind: "static";
    }>]>;
  }, "strip", z.ZodTypeAny, {
    changeName: string;
    schemaName: string;
    isPlanningComplete: boolean;
    applyRequires: string[];
    artifacts: {
      status: "ready" | "done" | "skipped" | "blocked";
      id: string;
      outputPath: string;
      requires: string[];
      missingDeps?: string[] | undefined;
      relativePath?: string | undefined;
    }[];
    provenance: {
      root: {
        path: string;
        source: "store" | "declared" | "nearest" | "global_default" | "implicit";
        store_id?: string | undefined;
      } & {
        [k: string]: unknown;
      };
      kind: "cli";
      evidence: {
        success: boolean;
        stdout: string;
        stderr: string;
        exitCode: number | null;
        payload: CliJsonValue;
        diagnostics: z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">[];
        command: "status";
        selector: {
          store?: string | undefined;
        };
        root?: z.objectOutputType<{
          path: z.ZodString;
          source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
          store_id: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough"> | undefined;
        contractError?: string | undefined;
      } & {
        [k: string]: unknown;
      };
      planningHome: {
        root: string;
        kind: "repo";
        changesDir: string;
        defaultSchema: string;
      } & {
        [k: string]: unknown;
      };
      changeRoot: string;
      artifactPaths: Record<string, z.objectOutputType<{
        outputPath: z.ZodString;
        resolvedOutputPath: z.ZodString;
        existingOutputPaths: z.ZodArray<z.ZodString, "many">;
      }, z.ZodTypeAny, "passthrough">>;
      nextSteps: string[];
      actionContext: {
        mode: "repo-local";
        sourceOfTruth: "repo";
        planningArtifacts: string[];
        linkedContext: z.objectOutputType<{
          name: z.ZodString;
        }, z.ZodTypeAny, "passthrough">[];
        allowedEditRoots: string[];
        requiresAffectedAreaSelection: boolean;
        constraints: string[];
      } & {
        [k: string]: unknown;
      };
    } | {
      kind: "static";
    };
  }, {
    changeName: string;
    schemaName: string;
    isPlanningComplete: boolean;
    applyRequires: string[];
    artifacts: {
      status: "ready" | "done" | "skipped" | "blocked";
      id: string;
      outputPath: string;
      requires: string[];
      missingDeps?: string[] | undefined;
      relativePath?: string | undefined;
    }[];
    provenance: {
      root: {
        path: string;
        source: "store" | "declared" | "nearest" | "global_default" | "implicit";
        store_id?: string | undefined;
      } & {
        [k: string]: unknown;
      };
      kind: "cli";
      evidence: {
        success: boolean;
        stdout: string;
        stderr: string;
        exitCode: number | null;
        payload: CliJsonValue;
        diagnostics: z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">[];
        command: "status";
        selector: {
          store?: string | undefined;
        };
        root?: z.objectInputType<{
          path: z.ZodString;
          source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
          store_id: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough"> | undefined;
        contractError?: string | undefined;
      } & {
        [k: string]: unknown;
      };
      planningHome: {
        root: string;
        kind: "repo";
        changesDir: string;
        defaultSchema: string;
      } & {
        [k: string]: unknown;
      };
      changeRoot: string;
      artifactPaths: Record<string, z.objectInputType<{
        outputPath: z.ZodString;
        resolvedOutputPath: z.ZodString;
        existingOutputPaths: z.ZodArray<z.ZodString, "many">;
      }, z.ZodTypeAny, "passthrough">>;
      nextSteps: string[];
      actionContext: {
        mode: "repo-local";
        sourceOfTruth: "repo";
        planningArtifacts: string[];
        linkedContext: z.objectInputType<{
          name: z.ZodString;
        }, z.ZodTypeAny, "passthrough">[];
        allowedEditRoots: string[];
        requiresAffectedAreaSelection: boolean;
        constraints: string[];
      } & {
        [k: string]: unknown;
      };
    } | {
      kind: "static";
    };
  }>, "many">;
  evidence: z.ZodObject<{
    success: z.ZodBoolean;
    stdout: z.ZodString;
    stderr: z.ZodString;
    exitCode: z.ZodNullable<z.ZodNumber>;
    payload: z.ZodNullable<z.ZodType<CliJsonValue, z.ZodTypeDef, CliJsonValue>>;
    diagnostics: z.ZodArray<z.ZodObject<{
      severity: z.ZodEnum<["error", "warning", "info"]>;
      code: z.ZodString;
      message: z.ZodString;
      target: z.ZodOptional<z.ZodString>;
      fix: z.ZodOptional<z.ZodString>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      severity: z.ZodEnum<["error", "warning", "info"]>;
      code: z.ZodString;
      message: z.ZodString;
      target: z.ZodOptional<z.ZodString>;
      fix: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      severity: z.ZodEnum<["error", "warning", "info"]>;
      code: z.ZodString;
      message: z.ZodString;
      target: z.ZodOptional<z.ZodString>;
      fix: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">>, "many">;
    contractError: z.ZodOptional<z.ZodString>;
  }, "strip", z.ZodTypeAny, {
    success: boolean;
    stdout: string;
    stderr: string;
    exitCode: number | null;
    payload: CliJsonValue;
    diagnostics: z.objectOutputType<{
      severity: z.ZodEnum<["error", "warning", "info"]>;
      code: z.ZodString;
      message: z.ZodString;
      target: z.ZodOptional<z.ZodString>;
      fix: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">[];
    contractError?: string | undefined;
  }, {
    success: boolean;
    stdout: string;
    stderr: string;
    exitCode: number | null;
    payload: CliJsonValue;
    diagnostics: z.objectInputType<{
      severity: z.ZodEnum<["error", "warning", "info"]>;
      code: z.ZodString;
      message: z.ZodString;
      target: z.ZodOptional<z.ZodString>;
      fix: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">[];
    contractError?: string | undefined;
  }>;
}, "strip", z.ZodTypeAny, {
  value: {
    changeName: string;
    schemaName: string;
    isPlanningComplete: boolean;
    applyRequires: string[];
    artifacts: {
      status: "ready" | "done" | "skipped" | "blocked";
      id: string;
      outputPath: string;
      requires: string[];
      missingDeps?: string[] | undefined;
      relativePath?: string | undefined;
    }[];
    provenance: {
      root: {
        path: string;
        source: "store" | "declared" | "nearest" | "global_default" | "implicit";
        store_id?: string | undefined;
      } & {
        [k: string]: unknown;
      };
      kind: "cli";
      evidence: {
        success: boolean;
        stdout: string;
        stderr: string;
        exitCode: number | null;
        payload: CliJsonValue;
        diagnostics: z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">[];
        command: "status";
        selector: {
          store?: string | undefined;
        };
        root?: z.objectOutputType<{
          path: z.ZodString;
          source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
          store_id: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough"> | undefined;
        contractError?: string | undefined;
      } & {
        [k: string]: unknown;
      };
      planningHome: {
        root: string;
        kind: "repo";
        changesDir: string;
        defaultSchema: string;
      } & {
        [k: string]: unknown;
      };
      changeRoot: string;
      artifactPaths: Record<string, z.objectOutputType<{
        outputPath: z.ZodString;
        resolvedOutputPath: z.ZodString;
        existingOutputPaths: z.ZodArray<z.ZodString, "many">;
      }, z.ZodTypeAny, "passthrough">>;
      nextSteps: string[];
      actionContext: {
        mode: "repo-local";
        sourceOfTruth: "repo";
        planningArtifacts: string[];
        linkedContext: z.objectOutputType<{
          name: z.ZodString;
        }, z.ZodTypeAny, "passthrough">[];
        allowedEditRoots: string[];
        requiresAffectedAreaSelection: boolean;
        constraints: string[];
      } & {
        [k: string]: unknown;
      };
    } | {
      kind: "static";
    };
  }[];
  kind: "opsx-status-list";
  evidence: {
    success: boolean;
    stdout: string;
    stderr: string;
    exitCode: number | null;
    payload: CliJsonValue;
    diagnostics: z.objectOutputType<{
      severity: z.ZodEnum<["error", "warning", "info"]>;
      code: z.ZodString;
      message: z.ZodString;
      target: z.ZodOptional<z.ZodString>;
      fix: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">[];
    contractError?: string | undefined;
  };
}, {
  value: {
    changeName: string;
    schemaName: string;
    isPlanningComplete: boolean;
    applyRequires: string[];
    artifacts: {
      status: "ready" | "done" | "skipped" | "blocked";
      id: string;
      outputPath: string;
      requires: string[];
      missingDeps?: string[] | undefined;
      relativePath?: string | undefined;
    }[];
    provenance: {
      root: {
        path: string;
        source: "store" | "declared" | "nearest" | "global_default" | "implicit";
        store_id?: string | undefined;
      } & {
        [k: string]: unknown;
      };
      kind: "cli";
      evidence: {
        success: boolean;
        stdout: string;
        stderr: string;
        exitCode: number | null;
        payload: CliJsonValue;
        diagnostics: z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">[];
        command: "status";
        selector: {
          store?: string | undefined;
        };
        root?: z.objectInputType<{
          path: z.ZodString;
          source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
          store_id: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough"> | undefined;
        contractError?: string | undefined;
      } & {
        [k: string]: unknown;
      };
      planningHome: {
        root: string;
        kind: "repo";
        changesDir: string;
        defaultSchema: string;
      } & {
        [k: string]: unknown;
      };
      changeRoot: string;
      artifactPaths: Record<string, z.objectInputType<{
        outputPath: z.ZodString;
        resolvedOutputPath: z.ZodString;
        existingOutputPaths: z.ZodArray<z.ZodString, "many">;
      }, z.ZodTypeAny, "passthrough">>;
      nextSteps: string[];
      actionContext: {
        mode: "repo-local";
        sourceOfTruth: "repo";
        planningArtifacts: string[];
        linkedContext: z.objectInputType<{
          name: z.ZodString;
        }, z.ZodTypeAny, "passthrough">[];
        allowedEditRoots: string[];
        requiresAffectedAreaSelection: boolean;
        constraints: string[];
      } & {
        [k: string]: unknown;
      };
    } | {
      kind: "static";
    };
  }[];
  kind: "opsx-status-list";
  evidence: {
    success: boolean;
    stdout: string;
    stderr: string;
    exitCode: number | null;
    payload: CliJsonValue;
    diagnostics: z.objectInputType<{
      severity: z.ZodEnum<["error", "warning", "info"]>;
      code: z.ZodString;
      message: z.ZodString;
      target: z.ZodOptional<z.ZodString>;
      fix: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">[];
    contractError?: string | undefined;
  };
}>, z.ZodObject<{
  kind: z.ZodLiteral<"opsx-instructions">;
  value: z.ZodObject<{
    changeName: z.ZodString;
    artifactId: z.ZodString;
    schemaName: z.ZodString;
    changeDir: z.ZodString;
    outputPath: z.ZodString;
    description: z.ZodString;
    instruction: z.ZodOptional<z.ZodNullable<z.ZodString>>;
    context: z.ZodOptional<z.ZodNullable<z.ZodString>>;
    rules: z.ZodNullable<z.ZodOptional<z.ZodArray<z.ZodString, "many">>>;
    template: z.ZodString;
    dependencies: z.ZodArray<z.ZodObject<{
      id: z.ZodString;
      done: z.ZodBoolean;
      path: z.ZodString;
      description: z.ZodString;
      skipped: z.ZodOptional<z.ZodBoolean>;
    }, "strip", z.ZodTypeAny, {
      path: string;
      id: string;
      description: string;
      done: boolean;
      skipped?: boolean | undefined;
    }, {
      path: string;
      id: string;
      description: string;
      done: boolean;
      skipped?: boolean | undefined;
    }>, "many">;
    unlocks: z.ZodArray<z.ZodString, "many">;
    references: z.ZodOptional<z.ZodArray<z.ZodObject<{
      store_id: z.ZodString;
      root: z.ZodOptional<z.ZodString>;
      status: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    } & {
      specs: z.ZodOptional<z.ZodArray<z.ZodObject<{
        id: z.ZodString;
        summary: z.ZodString;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        id: z.ZodString;
        summary: z.ZodString;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        id: z.ZodString;
        summary: z.ZodString;
      }, z.ZodTypeAny, "passthrough">>, "many">>;
      fetch: z.ZodOptional<z.ZodString>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      store_id: z.ZodString;
      root: z.ZodOptional<z.ZodString>;
      status: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    } & {
      specs: z.ZodOptional<z.ZodArray<z.ZodObject<{
        id: z.ZodString;
        summary: z.ZodString;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        id: z.ZodString;
        summary: z.ZodString;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        id: z.ZodString;
        summary: z.ZodString;
      }, z.ZodTypeAny, "passthrough">>, "many">>;
      fetch: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      store_id: z.ZodString;
      root: z.ZodOptional<z.ZodString>;
      status: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    } & {
      specs: z.ZodOptional<z.ZodArray<z.ZodObject<{
        id: z.ZodString;
        summary: z.ZodString;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        id: z.ZodString;
        summary: z.ZodString;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        id: z.ZodString;
        summary: z.ZodString;
      }, z.ZodTypeAny, "passthrough">>, "many">>;
      fetch: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">>, "many">>;
    evidence: z.ZodObject<{
      success: z.ZodBoolean;
      stdout: z.ZodString;
      stderr: z.ZodString;
      exitCode: z.ZodNullable<z.ZodNumber>;
      payload: z.ZodNullable<z.ZodType<CliJsonValue, z.ZodTypeDef, CliJsonValue>>;
      diagnostics: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
      contractError: z.ZodOptional<z.ZodString>;
      selector: z.ZodObject<{
        store: z.ZodOptional<z.ZodString>;
      }, "strict", z.ZodTypeAny, {
        store?: string | undefined;
      }, {
        store?: string | undefined;
      }>;
      root: z.ZodOptional<z.ZodObject<{
        path: z.ZodString;
        source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
        store_id: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        path: z.ZodString;
        source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
        store_id: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        path: z.ZodString;
        source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
        store_id: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>>;
    } & {
      command: z.ZodLiteral<"instructions">;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      success: z.ZodBoolean;
      stdout: z.ZodString;
      stderr: z.ZodString;
      exitCode: z.ZodNullable<z.ZodNumber>;
      payload: z.ZodNullable<z.ZodType<CliJsonValue, z.ZodTypeDef, CliJsonValue>>;
      diagnostics: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
      contractError: z.ZodOptional<z.ZodString>;
      selector: z.ZodObject<{
        store: z.ZodOptional<z.ZodString>;
      }, "strict", z.ZodTypeAny, {
        store?: string | undefined;
      }, {
        store?: string | undefined;
      }>;
      root: z.ZodOptional<z.ZodObject<{
        path: z.ZodString;
        source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
        store_id: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        path: z.ZodString;
        source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
        store_id: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        path: z.ZodString;
        source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
        store_id: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>>;
    } & {
      command: z.ZodLiteral<"instructions">;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      success: z.ZodBoolean;
      stdout: z.ZodString;
      stderr: z.ZodString;
      exitCode: z.ZodNullable<z.ZodNumber>;
      payload: z.ZodNullable<z.ZodType<CliJsonValue, z.ZodTypeDef, CliJsonValue>>;
      diagnostics: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
      contractError: z.ZodOptional<z.ZodString>;
      selector: z.ZodObject<{
        store: z.ZodOptional<z.ZodString>;
      }, "strict", z.ZodTypeAny, {
        store?: string | undefined;
      }, {
        store?: string | undefined;
      }>;
      root: z.ZodOptional<z.ZodObject<{
        path: z.ZodString;
        source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
        store_id: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        path: z.ZodString;
        source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
        store_id: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        path: z.ZodString;
        source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
        store_id: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>>;
    } & {
      command: z.ZodLiteral<"instructions">;
    }, z.ZodTypeAny, "passthrough">>;
  }, "strip", z.ZodTypeAny, {
    description: string;
    template: string;
    evidence: {
      success: boolean;
      stdout: string;
      stderr: string;
      exitCode: number | null;
      payload: CliJsonValue;
      diagnostics: z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">[];
      command: "instructions";
      selector: {
        store?: string | undefined;
      };
      root?: z.objectOutputType<{
        path: z.ZodString;
        source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
        store_id: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough"> | undefined;
      contractError?: string | undefined;
    } & {
      [k: string]: unknown;
    };
    changeName: string;
    schemaName: string;
    outputPath: string;
    artifactId: string;
    changeDir: string;
    dependencies: {
      path: string;
      id: string;
      description: string;
      done: boolean;
      skipped?: boolean | undefined;
    }[];
    unlocks: string[];
    context?: string | null | undefined;
    instruction?: string | null | undefined;
    rules?: string[] | null | undefined;
    references?: z.objectOutputType<{
      store_id: z.ZodString;
      root: z.ZodOptional<z.ZodString>;
      status: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    } & {
      specs: z.ZodOptional<z.ZodArray<z.ZodObject<{
        id: z.ZodString;
        summary: z.ZodString;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        id: z.ZodString;
        summary: z.ZodString;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        id: z.ZodString;
        summary: z.ZodString;
      }, z.ZodTypeAny, "passthrough">>, "many">>;
      fetch: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">[] | undefined;
  }, {
    description: string;
    template: string;
    evidence: {
      success: boolean;
      stdout: string;
      stderr: string;
      exitCode: number | null;
      payload: CliJsonValue;
      diagnostics: z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">[];
      command: "instructions";
      selector: {
        store?: string | undefined;
      };
      root?: z.objectInputType<{
        path: z.ZodString;
        source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
        store_id: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough"> | undefined;
      contractError?: string | undefined;
    } & {
      [k: string]: unknown;
    };
    changeName: string;
    schemaName: string;
    outputPath: string;
    artifactId: string;
    changeDir: string;
    dependencies: {
      path: string;
      id: string;
      description: string;
      done: boolean;
      skipped?: boolean | undefined;
    }[];
    unlocks: string[];
    context?: string | null | undefined;
    instruction?: string | null | undefined;
    rules?: string[] | null | undefined;
    references?: z.objectInputType<{
      store_id: z.ZodString;
      root: z.ZodOptional<z.ZodString>;
      status: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    } & {
      specs: z.ZodOptional<z.ZodArray<z.ZodObject<{
        id: z.ZodString;
        summary: z.ZodString;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        id: z.ZodString;
        summary: z.ZodString;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        id: z.ZodString;
        summary: z.ZodString;
      }, z.ZodTypeAny, "passthrough">>, "many">>;
      fetch: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">[] | undefined;
  }>;
}, "strip", z.ZodTypeAny, {
  value: {
    description: string;
    template: string;
    evidence: {
      success: boolean;
      stdout: string;
      stderr: string;
      exitCode: number | null;
      payload: CliJsonValue;
      diagnostics: z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">[];
      command: "instructions";
      selector: {
        store?: string | undefined;
      };
      root?: z.objectOutputType<{
        path: z.ZodString;
        source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
        store_id: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough"> | undefined;
      contractError?: string | undefined;
    } & {
      [k: string]: unknown;
    };
    changeName: string;
    schemaName: string;
    outputPath: string;
    artifactId: string;
    changeDir: string;
    dependencies: {
      path: string;
      id: string;
      description: string;
      done: boolean;
      skipped?: boolean | undefined;
    }[];
    unlocks: string[];
    context?: string | null | undefined;
    instruction?: string | null | undefined;
    rules?: string[] | null | undefined;
    references?: z.objectOutputType<{
      store_id: z.ZodString;
      root: z.ZodOptional<z.ZodString>;
      status: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    } & {
      specs: z.ZodOptional<z.ZodArray<z.ZodObject<{
        id: z.ZodString;
        summary: z.ZodString;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        id: z.ZodString;
        summary: z.ZodString;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        id: z.ZodString;
        summary: z.ZodString;
      }, z.ZodTypeAny, "passthrough">>, "many">>;
      fetch: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">[] | undefined;
  };
  kind: "opsx-instructions";
}, {
  value: {
    description: string;
    template: string;
    evidence: {
      success: boolean;
      stdout: string;
      stderr: string;
      exitCode: number | null;
      payload: CliJsonValue;
      diagnostics: z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">[];
      command: "instructions";
      selector: {
        store?: string | undefined;
      };
      root?: z.objectInputType<{
        path: z.ZodString;
        source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
        store_id: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough"> | undefined;
      contractError?: string | undefined;
    } & {
      [k: string]: unknown;
    };
    changeName: string;
    schemaName: string;
    outputPath: string;
    artifactId: string;
    changeDir: string;
    dependencies: {
      path: string;
      id: string;
      description: string;
      done: boolean;
      skipped?: boolean | undefined;
    }[];
    unlocks: string[];
    context?: string | null | undefined;
    instruction?: string | null | undefined;
    rules?: string[] | null | undefined;
    references?: z.objectInputType<{
      store_id: z.ZodString;
      root: z.ZodOptional<z.ZodString>;
      status: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    } & {
      specs: z.ZodOptional<z.ZodArray<z.ZodObject<{
        id: z.ZodString;
        summary: z.ZodString;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        id: z.ZodString;
        summary: z.ZodString;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        id: z.ZodString;
        summary: z.ZodString;
      }, z.ZodTypeAny, "passthrough">>, "many">>;
      fetch: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">[] | undefined;
  };
  kind: "opsx-instructions";
}>, z.ZodObject<{
  kind: z.ZodLiteral<"opsx-apply-instructions">;
  value: z.ZodObject<{
    changeName: z.ZodString;
    changeDir: z.ZodString;
    schemaName: z.ZodString;
    contextFiles: z.ZodRecord<z.ZodString, z.ZodEffects<z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">]>, string[], string | string[]>>;
    tasks: z.ZodArray<z.ZodObject<{
      id: z.ZodString;
      description: z.ZodString;
      done: z.ZodBoolean;
    }, "strip", z.ZodTypeAny, {
      id: string;
      description: string;
      done: boolean;
    }, {
      id: string;
      description: string;
      done: boolean;
    }>, "many">;
    state: z.ZodEnum<["blocked", "all_done", "ready"]>;
    missingArtifacts: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
    instruction: z.ZodString;
    references: z.ZodOptional<z.ZodArray<z.ZodObject<{
      store_id: z.ZodString;
      root: z.ZodOptional<z.ZodString>;
      status: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    } & {
      specs: z.ZodOptional<z.ZodArray<z.ZodObject<{
        id: z.ZodString;
        summary: z.ZodString;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        id: z.ZodString;
        summary: z.ZodString;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        id: z.ZodString;
        summary: z.ZodString;
      }, z.ZodTypeAny, "passthrough">>, "many">>;
      fetch: z.ZodOptional<z.ZodString>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      store_id: z.ZodString;
      root: z.ZodOptional<z.ZodString>;
      status: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    } & {
      specs: z.ZodOptional<z.ZodArray<z.ZodObject<{
        id: z.ZodString;
        summary: z.ZodString;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        id: z.ZodString;
        summary: z.ZodString;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        id: z.ZodString;
        summary: z.ZodString;
      }, z.ZodTypeAny, "passthrough">>, "many">>;
      fetch: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      store_id: z.ZodString;
      root: z.ZodOptional<z.ZodString>;
      status: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    } & {
      specs: z.ZodOptional<z.ZodArray<z.ZodObject<{
        id: z.ZodString;
        summary: z.ZodString;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        id: z.ZodString;
        summary: z.ZodString;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        id: z.ZodString;
        summary: z.ZodString;
      }, z.ZodTypeAny, "passthrough">>, "many">>;
      fetch: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">>, "many">>;
    context: z.ZodOptional<z.ZodString>;
    operationGuidance: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
    evidence: z.ZodObject<{
      success: z.ZodBoolean;
      stdout: z.ZodString;
      stderr: z.ZodString;
      exitCode: z.ZodNullable<z.ZodNumber>;
      payload: z.ZodNullable<z.ZodType<CliJsonValue, z.ZodTypeDef, CliJsonValue>>;
      diagnostics: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
      contractError: z.ZodOptional<z.ZodString>;
      selector: z.ZodObject<{
        store: z.ZodOptional<z.ZodString>;
      }, "strict", z.ZodTypeAny, {
        store?: string | undefined;
      }, {
        store?: string | undefined;
      }>;
      root: z.ZodOptional<z.ZodObject<{
        path: z.ZodString;
        source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
        store_id: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        path: z.ZodString;
        source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
        store_id: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        path: z.ZodString;
        source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
        store_id: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>>;
    } & {
      command: z.ZodLiteral<"instructions apply">;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      success: z.ZodBoolean;
      stdout: z.ZodString;
      stderr: z.ZodString;
      exitCode: z.ZodNullable<z.ZodNumber>;
      payload: z.ZodNullable<z.ZodType<CliJsonValue, z.ZodTypeDef, CliJsonValue>>;
      diagnostics: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
      contractError: z.ZodOptional<z.ZodString>;
      selector: z.ZodObject<{
        store: z.ZodOptional<z.ZodString>;
      }, "strict", z.ZodTypeAny, {
        store?: string | undefined;
      }, {
        store?: string | undefined;
      }>;
      root: z.ZodOptional<z.ZodObject<{
        path: z.ZodString;
        source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
        store_id: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        path: z.ZodString;
        source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
        store_id: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        path: z.ZodString;
        source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
        store_id: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>>;
    } & {
      command: z.ZodLiteral<"instructions apply">;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      success: z.ZodBoolean;
      stdout: z.ZodString;
      stderr: z.ZodString;
      exitCode: z.ZodNullable<z.ZodNumber>;
      payload: z.ZodNullable<z.ZodType<CliJsonValue, z.ZodTypeDef, CliJsonValue>>;
      diagnostics: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
      contractError: z.ZodOptional<z.ZodString>;
      selector: z.ZodObject<{
        store: z.ZodOptional<z.ZodString>;
      }, "strict", z.ZodTypeAny, {
        store?: string | undefined;
      }, {
        store?: string | undefined;
      }>;
      root: z.ZodOptional<z.ZodObject<{
        path: z.ZodString;
        source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
        store_id: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        path: z.ZodString;
        source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
        store_id: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        path: z.ZodString;
        source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
        store_id: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>>;
    } & {
      command: z.ZodLiteral<"instructions apply">;
    }, z.ZodTypeAny, "passthrough">>;
    applyInstructionProgress: z.ZodObject<{
      source: z.ZodLiteral<"openspec-instructions-apply">;
      total: z.ZodNumber;
      complete: z.ZodNumber;
      remaining: z.ZodNumber;
      state: z.ZodEnum<["blocked", "all_done", "ready"]>;
      divergence: z.ZodNullable<z.ZodObject<{
        kind: z.ZodLiteral<"tracked-task-mismatch">;
        message: z.ZodString;
        apply: z.ZodObject<{
          total: z.ZodNumber;
          complete: z.ZodNumber;
          remaining: z.ZodNumber;
        }, "strip", z.ZodTypeAny, {
          complete: number;
          total: number;
          remaining: number;
        }, {
          complete: number;
          total: number;
          remaining: number;
        }>;
        tracked: z.ZodObject<{
          total: z.ZodNumber;
          completed: z.ZodNumber;
          remaining: z.ZodNumber;
          phase: z.ZodEnum<["no-tasks", "in-progress", "complete"]>;
        }, "strip", z.ZodTypeAny, {
          total: number;
          remaining: number;
          completed: number;
          phase: "no-tasks" | "complete" | "in-progress";
        }, {
          total: number;
          remaining: number;
          completed: number;
          phase: "no-tasks" | "complete" | "in-progress";
        }>;
      }, "strip", z.ZodTypeAny, {
        message: string;
        kind: "tracked-task-mismatch";
        apply: {
          complete: number;
          total: number;
          remaining: number;
        };
        tracked: {
          total: number;
          remaining: number;
          completed: number;
          phase: "no-tasks" | "complete" | "in-progress";
        };
      }, {
        message: string;
        kind: "tracked-task-mismatch";
        apply: {
          complete: number;
          total: number;
          remaining: number;
        };
        tracked: {
          total: number;
          remaining: number;
          completed: number;
          phase: "no-tasks" | "complete" | "in-progress";
        };
      }>>;
    }, "strip", z.ZodTypeAny, {
      source: "openspec-instructions-apply";
      state: "ready" | "blocked" | "all_done";
      complete: number;
      total: number;
      remaining: number;
      divergence: {
        message: string;
        kind: "tracked-task-mismatch";
        apply: {
          complete: number;
          total: number;
          remaining: number;
        };
        tracked: {
          total: number;
          remaining: number;
          completed: number;
          phase: "no-tasks" | "complete" | "in-progress";
        };
      } | null;
    }, {
      source: "openspec-instructions-apply";
      state: "ready" | "blocked" | "all_done";
      complete: number;
      total: number;
      remaining: number;
      divergence: {
        message: string;
        kind: "tracked-task-mismatch";
        apply: {
          complete: number;
          total: number;
          remaining: number;
        };
        tracked: {
          total: number;
          remaining: number;
          completed: number;
          phase: "no-tasks" | "complete" | "in-progress";
        };
      } | null;
    }>;
  }, "strip", z.ZodTypeAny, {
    state: "ready" | "blocked" | "all_done";
    evidence: {
      success: boolean;
      stdout: string;
      stderr: string;
      exitCode: number | null;
      payload: CliJsonValue;
      diagnostics: z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">[];
      command: "instructions apply";
      selector: {
        store?: string | undefined;
      };
      root?: z.objectOutputType<{
        path: z.ZodString;
        source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
        store_id: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough"> | undefined;
      contractError?: string | undefined;
    } & {
      [k: string]: unknown;
    };
    changeName: string;
    schemaName: string;
    changeDir: string;
    instruction: string;
    contextFiles: Record<string, string[]>;
    tasks: {
      id: string;
      description: string;
      done: boolean;
    }[];
    applyInstructionProgress: {
      source: "openspec-instructions-apply";
      state: "ready" | "blocked" | "all_done";
      complete: number;
      total: number;
      remaining: number;
      divergence: {
        message: string;
        kind: "tracked-task-mismatch";
        apply: {
          complete: number;
          total: number;
          remaining: number;
        };
        tracked: {
          total: number;
          remaining: number;
          completed: number;
          phase: "no-tasks" | "complete" | "in-progress";
        };
      } | null;
    };
    context?: string | undefined;
    references?: z.objectOutputType<{
      store_id: z.ZodString;
      root: z.ZodOptional<z.ZodString>;
      status: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    } & {
      specs: z.ZodOptional<z.ZodArray<z.ZodObject<{
        id: z.ZodString;
        summary: z.ZodString;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        id: z.ZodString;
        summary: z.ZodString;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        id: z.ZodString;
        summary: z.ZodString;
      }, z.ZodTypeAny, "passthrough">>, "many">>;
      fetch: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">[] | undefined;
    missingArtifacts?: string[] | undefined;
    operationGuidance?: string[] | undefined;
  }, {
    state: "ready" | "blocked" | "all_done";
    evidence: {
      success: boolean;
      stdout: string;
      stderr: string;
      exitCode: number | null;
      payload: CliJsonValue;
      diagnostics: z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">[];
      command: "instructions apply";
      selector: {
        store?: string | undefined;
      };
      root?: z.objectInputType<{
        path: z.ZodString;
        source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
        store_id: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough"> | undefined;
      contractError?: string | undefined;
    } & {
      [k: string]: unknown;
    };
    changeName: string;
    schemaName: string;
    changeDir: string;
    instruction: string;
    contextFiles: Record<string, string | string[]>;
    tasks: {
      id: string;
      description: string;
      done: boolean;
    }[];
    applyInstructionProgress: {
      source: "openspec-instructions-apply";
      state: "ready" | "blocked" | "all_done";
      complete: number;
      total: number;
      remaining: number;
      divergence: {
        message: string;
        kind: "tracked-task-mismatch";
        apply: {
          complete: number;
          total: number;
          remaining: number;
        };
        tracked: {
          total: number;
          remaining: number;
          completed: number;
          phase: "no-tasks" | "complete" | "in-progress";
        };
      } | null;
    };
    context?: string | undefined;
    references?: z.objectInputType<{
      store_id: z.ZodString;
      root: z.ZodOptional<z.ZodString>;
      status: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    } & {
      specs: z.ZodOptional<z.ZodArray<z.ZodObject<{
        id: z.ZodString;
        summary: z.ZodString;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        id: z.ZodString;
        summary: z.ZodString;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        id: z.ZodString;
        summary: z.ZodString;
      }, z.ZodTypeAny, "passthrough">>, "many">>;
      fetch: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">[] | undefined;
    missingArtifacts?: string[] | undefined;
    operationGuidance?: string[] | undefined;
  }>;
}, "strip", z.ZodTypeAny, {
  value: {
    state: "ready" | "blocked" | "all_done";
    evidence: {
      success: boolean;
      stdout: string;
      stderr: string;
      exitCode: number | null;
      payload: CliJsonValue;
      diagnostics: z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">[];
      command: "instructions apply";
      selector: {
        store?: string | undefined;
      };
      root?: z.objectOutputType<{
        path: z.ZodString;
        source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
        store_id: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough"> | undefined;
      contractError?: string | undefined;
    } & {
      [k: string]: unknown;
    };
    changeName: string;
    schemaName: string;
    changeDir: string;
    instruction: string;
    contextFiles: Record<string, string[]>;
    tasks: {
      id: string;
      description: string;
      done: boolean;
    }[];
    applyInstructionProgress: {
      source: "openspec-instructions-apply";
      state: "ready" | "blocked" | "all_done";
      complete: number;
      total: number;
      remaining: number;
      divergence: {
        message: string;
        kind: "tracked-task-mismatch";
        apply: {
          complete: number;
          total: number;
          remaining: number;
        };
        tracked: {
          total: number;
          remaining: number;
          completed: number;
          phase: "no-tasks" | "complete" | "in-progress";
        };
      } | null;
    };
    context?: string | undefined;
    references?: z.objectOutputType<{
      store_id: z.ZodString;
      root: z.ZodOptional<z.ZodString>;
      status: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    } & {
      specs: z.ZodOptional<z.ZodArray<z.ZodObject<{
        id: z.ZodString;
        summary: z.ZodString;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        id: z.ZodString;
        summary: z.ZodString;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        id: z.ZodString;
        summary: z.ZodString;
      }, z.ZodTypeAny, "passthrough">>, "many">>;
      fetch: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">[] | undefined;
    missingArtifacts?: string[] | undefined;
    operationGuidance?: string[] | undefined;
  };
  kind: "opsx-apply-instructions";
}, {
  value: {
    state: "ready" | "blocked" | "all_done";
    evidence: {
      success: boolean;
      stdout: string;
      stderr: string;
      exitCode: number | null;
      payload: CliJsonValue;
      diagnostics: z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">[];
      command: "instructions apply";
      selector: {
        store?: string | undefined;
      };
      root?: z.objectInputType<{
        path: z.ZodString;
        source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
        store_id: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough"> | undefined;
      contractError?: string | undefined;
    } & {
      [k: string]: unknown;
    };
    changeName: string;
    schemaName: string;
    changeDir: string;
    instruction: string;
    contextFiles: Record<string, string | string[]>;
    tasks: {
      id: string;
      description: string;
      done: boolean;
    }[];
    applyInstructionProgress: {
      source: "openspec-instructions-apply";
      state: "ready" | "blocked" | "all_done";
      complete: number;
      total: number;
      remaining: number;
      divergence: {
        message: string;
        kind: "tracked-task-mismatch";
        apply: {
          complete: number;
          total: number;
          remaining: number;
        };
        tracked: {
          total: number;
          remaining: number;
          completed: number;
          phase: "no-tasks" | "complete" | "in-progress";
        };
      } | null;
    };
    context?: string | undefined;
    references?: z.objectInputType<{
      store_id: z.ZodString;
      root: z.ZodOptional<z.ZodString>;
      status: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    } & {
      specs: z.ZodOptional<z.ZodArray<z.ZodObject<{
        id: z.ZodString;
        summary: z.ZodString;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        id: z.ZodString;
        summary: z.ZodString;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        id: z.ZodString;
        summary: z.ZodString;
      }, z.ZodTypeAny, "passthrough">>, "many">>;
      fetch: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">[] | undefined;
    missingArtifacts?: string[] | undefined;
    operationGuidance?: string[] | undefined;
  };
  kind: "opsx-apply-instructions";
}>, z.ZodObject<{
  kind: z.ZodLiteral<"opsx-archive-instructions">;
  rootGeneration: z.ZodString;
  value: z.ZodObject<{
    changeName: z.ZodString;
    context: z.ZodOptional<z.ZodString>;
    operationGuidance: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
    evidence: z.ZodObject<{
      success: z.ZodBoolean;
      stdout: z.ZodString;
      stderr: z.ZodString;
      exitCode: z.ZodNullable<z.ZodNumber>;
      payload: z.ZodNullable<z.ZodType<CliJsonValue, z.ZodTypeDef, CliJsonValue>>;
      diagnostics: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
      contractError: z.ZodOptional<z.ZodString>;
      selector: z.ZodObject<{
        store: z.ZodOptional<z.ZodString>;
      }, "strict", z.ZodTypeAny, {
        store?: string | undefined;
      }, {
        store?: string | undefined;
      }>;
      root: z.ZodOptional<z.ZodObject<{
        path: z.ZodString;
        source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
        store_id: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        path: z.ZodString;
        source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
        store_id: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        path: z.ZodString;
        source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
        store_id: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>>;
    } & {
      command: z.ZodLiteral<"instructions archive">;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      success: z.ZodBoolean;
      stdout: z.ZodString;
      stderr: z.ZodString;
      exitCode: z.ZodNullable<z.ZodNumber>;
      payload: z.ZodNullable<z.ZodType<CliJsonValue, z.ZodTypeDef, CliJsonValue>>;
      diagnostics: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
      contractError: z.ZodOptional<z.ZodString>;
      selector: z.ZodObject<{
        store: z.ZodOptional<z.ZodString>;
      }, "strict", z.ZodTypeAny, {
        store?: string | undefined;
      }, {
        store?: string | undefined;
      }>;
      root: z.ZodOptional<z.ZodObject<{
        path: z.ZodString;
        source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
        store_id: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        path: z.ZodString;
        source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
        store_id: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        path: z.ZodString;
        source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
        store_id: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>>;
    } & {
      command: z.ZodLiteral<"instructions archive">;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      success: z.ZodBoolean;
      stdout: z.ZodString;
      stderr: z.ZodString;
      exitCode: z.ZodNullable<z.ZodNumber>;
      payload: z.ZodNullable<z.ZodType<CliJsonValue, z.ZodTypeDef, CliJsonValue>>;
      diagnostics: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
      contractError: z.ZodOptional<z.ZodString>;
      selector: z.ZodObject<{
        store: z.ZodOptional<z.ZodString>;
      }, "strict", z.ZodTypeAny, {
        store?: string | undefined;
      }, {
        store?: string | undefined;
      }>;
      root: z.ZodOptional<z.ZodObject<{
        path: z.ZodString;
        source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
        store_id: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        path: z.ZodString;
        source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
        store_id: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        path: z.ZodString;
        source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
        store_id: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>>;
    } & {
      command: z.ZodLiteral<"instructions archive">;
    }, z.ZodTypeAny, "passthrough">>;
  }, "strip", z.ZodTypeAny, {
    evidence: {
      success: boolean;
      stdout: string;
      stderr: string;
      exitCode: number | null;
      payload: CliJsonValue;
      diagnostics: z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">[];
      command: "instructions archive";
      selector: {
        store?: string | undefined;
      };
      root?: z.objectOutputType<{
        path: z.ZodString;
        source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
        store_id: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough"> | undefined;
      contractError?: string | undefined;
    } & {
      [k: string]: unknown;
    };
    changeName: string;
    context?: string | undefined;
    operationGuidance?: string[] | undefined;
  }, {
    evidence: {
      success: boolean;
      stdout: string;
      stderr: string;
      exitCode: number | null;
      payload: CliJsonValue;
      diagnostics: z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">[];
      command: "instructions archive";
      selector: {
        store?: string | undefined;
      };
      root?: z.objectInputType<{
        path: z.ZodString;
        source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
        store_id: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough"> | undefined;
      contractError?: string | undefined;
    } & {
      [k: string]: unknown;
    };
    changeName: string;
    context?: string | undefined;
    operationGuidance?: string[] | undefined;
  }>;
}, "strip", z.ZodTypeAny, {
  value: {
    evidence: {
      success: boolean;
      stdout: string;
      stderr: string;
      exitCode: number | null;
      payload: CliJsonValue;
      diagnostics: z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">[];
      command: "instructions archive";
      selector: {
        store?: string | undefined;
      };
      root?: z.objectOutputType<{
        path: z.ZodString;
        source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
        store_id: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough"> | undefined;
      contractError?: string | undefined;
    } & {
      [k: string]: unknown;
    };
    changeName: string;
    context?: string | undefined;
    operationGuidance?: string[] | undefined;
  };
  kind: "opsx-archive-instructions";
  rootGeneration: string;
}, {
  value: {
    evidence: {
      success: boolean;
      stdout: string;
      stderr: string;
      exitCode: number | null;
      payload: CliJsonValue;
      diagnostics: z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">[];
      command: "instructions archive";
      selector: {
        store?: string | undefined;
      };
      root?: z.objectInputType<{
        path: z.ZodString;
        source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
        store_id: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough"> | undefined;
      contractError?: string | undefined;
    } & {
      [k: string]: unknown;
    };
    changeName: string;
    context?: string | undefined;
    operationGuidance?: string[] | undefined;
  };
  kind: "opsx-archive-instructions";
  rootGeneration: string;
}>, z.ZodObject<{
  kind: z.ZodLiteral<"opsx-config-bundle">;
  value: z.ZodObject<{
    schemas: z.ZodArray<z.ZodObject<{
      name: z.ZodString;
      description: z.ZodOptional<z.ZodString>;
      artifacts: z.ZodArray<z.ZodString, "many">;
      source: z.ZodEnum<["project", "user", "package"]>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      name: z.ZodString;
      description: z.ZodOptional<z.ZodString>;
      artifacts: z.ZodArray<z.ZodString, "many">;
      source: z.ZodEnum<["project", "user", "package"]>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      name: z.ZodString;
      description: z.ZodOptional<z.ZodString>;
      artifacts: z.ZodArray<z.ZodString, "many">;
      source: z.ZodEnum<["project", "user", "package"]>;
    }, z.ZodTypeAny, "passthrough">>, "many">;
    schemaDetails: z.ZodRecord<z.ZodString, z.ZodNullable<z.ZodObject<{
      name: z.ZodString;
      description: z.ZodOptional<z.ZodString>;
      version: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
      artifacts: z.ZodArray<z.ZodObject<{
        id: z.ZodString;
        outputPath: z.ZodString;
        description: z.ZodOptional<z.ZodString>;
        template: z.ZodOptional<z.ZodString>;
        instruction: z.ZodOptional<z.ZodString>;
        requires: z.ZodArray<z.ZodString, "many">;
      }, "strip", z.ZodTypeAny, {
        id: string;
        outputPath: string;
        requires: string[];
        description?: string | undefined;
        template?: string | undefined;
        instruction?: string | undefined;
      }, {
        id: string;
        outputPath: string;
        requires: string[];
        description?: string | undefined;
        template?: string | undefined;
        instruction?: string | undefined;
      }>, "many">;
      applyRequires: z.ZodArray<z.ZodString, "many">;
      applyTracks: z.ZodOptional<z.ZodString>;
      applyInstruction: z.ZodOptional<z.ZodString>;
    }, "strip", z.ZodTypeAny, {
      name: string;
      applyRequires: string[];
      artifacts: {
        id: string;
        outputPath: string;
        requires: string[];
        description?: string | undefined;
        template?: string | undefined;
        instruction?: string | undefined;
      }[];
      version?: string | number | undefined;
      description?: string | undefined;
      applyTracks?: string | undefined;
      applyInstruction?: string | undefined;
    }, {
      name: string;
      applyRequires: string[];
      artifacts: {
        id: string;
        outputPath: string;
        requires: string[];
        description?: string | undefined;
        template?: string | undefined;
        instruction?: string | undefined;
      }[];
      version?: string | number | undefined;
      description?: string | undefined;
      applyTracks?: string | undefined;
      applyInstruction?: string | undefined;
    }>>>;
    schemaResolutions: z.ZodRecord<z.ZodString, z.ZodNullable<z.ZodObject<{
      name: z.ZodString;
      source: z.ZodEnum<["project", "user", "package"]>;
      path: z.ZodString;
    } & {
      displayPath: z.ZodOptional<z.ZodString>;
      shadows: z.ZodArray<z.ZodObject<{
        source: z.ZodEnum<["project", "user", "package"]>;
        path: z.ZodString;
      } & {
        displayPath: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        source: z.ZodEnum<["project", "user", "package"]>;
        path: z.ZodString;
      } & {
        displayPath: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        source: z.ZodEnum<["project", "user", "package"]>;
        path: z.ZodString;
      } & {
        displayPath: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      name: z.ZodString;
      source: z.ZodEnum<["project", "user", "package"]>;
      path: z.ZodString;
    } & {
      displayPath: z.ZodOptional<z.ZodString>;
      shadows: z.ZodArray<z.ZodObject<{
        source: z.ZodEnum<["project", "user", "package"]>;
        path: z.ZodString;
      } & {
        displayPath: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        source: z.ZodEnum<["project", "user", "package"]>;
        path: z.ZodString;
      } & {
        displayPath: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        source: z.ZodEnum<["project", "user", "package"]>;
        path: z.ZodString;
      } & {
        displayPath: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      name: z.ZodString;
      source: z.ZodEnum<["project", "user", "package"]>;
      path: z.ZodString;
    } & {
      displayPath: z.ZodOptional<z.ZodString>;
      shadows: z.ZodArray<z.ZodObject<{
        source: z.ZodEnum<["project", "user", "package"]>;
        path: z.ZodString;
      } & {
        displayPath: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        source: z.ZodEnum<["project", "user", "package"]>;
        path: z.ZodString;
      } & {
        displayPath: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        source: z.ZodEnum<["project", "user", "package"]>;
        path: z.ZodString;
      } & {
        displayPath: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, z.ZodTypeAny, "passthrough">>>>;
  }, "strip", z.ZodTypeAny, {
    schemas: z.objectOutputType<{
      name: z.ZodString;
      description: z.ZodOptional<z.ZodString>;
      artifacts: z.ZodArray<z.ZodString, "many">;
      source: z.ZodEnum<["project", "user", "package"]>;
    }, z.ZodTypeAny, "passthrough">[];
    schemaDetails: Record<string, {
      name: string;
      applyRequires: string[];
      artifacts: {
        id: string;
        outputPath: string;
        requires: string[];
        description?: string | undefined;
        template?: string | undefined;
        instruction?: string | undefined;
      }[];
      version?: string | number | undefined;
      description?: string | undefined;
      applyTracks?: string | undefined;
      applyInstruction?: string | undefined;
    } | null>;
    schemaResolutions: Record<string, z.objectOutputType<{
      name: z.ZodString;
      source: z.ZodEnum<["project", "user", "package"]>;
      path: z.ZodString;
    } & {
      displayPath: z.ZodOptional<z.ZodString>;
      shadows: z.ZodArray<z.ZodObject<{
        source: z.ZodEnum<["project", "user", "package"]>;
        path: z.ZodString;
      } & {
        displayPath: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        source: z.ZodEnum<["project", "user", "package"]>;
        path: z.ZodString;
      } & {
        displayPath: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        source: z.ZodEnum<["project", "user", "package"]>;
        path: z.ZodString;
      } & {
        displayPath: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, z.ZodTypeAny, "passthrough"> | null>;
  }, {
    schemas: z.objectInputType<{
      name: z.ZodString;
      description: z.ZodOptional<z.ZodString>;
      artifacts: z.ZodArray<z.ZodString, "many">;
      source: z.ZodEnum<["project", "user", "package"]>;
    }, z.ZodTypeAny, "passthrough">[];
    schemaDetails: Record<string, {
      name: string;
      applyRequires: string[];
      artifacts: {
        id: string;
        outputPath: string;
        requires: string[];
        description?: string | undefined;
        template?: string | undefined;
        instruction?: string | undefined;
      }[];
      version?: string | number | undefined;
      description?: string | undefined;
      applyTracks?: string | undefined;
      applyInstruction?: string | undefined;
    } | null>;
    schemaResolutions: Record<string, z.objectInputType<{
      name: z.ZodString;
      source: z.ZodEnum<["project", "user", "package"]>;
      path: z.ZodString;
    } & {
      displayPath: z.ZodOptional<z.ZodString>;
      shadows: z.ZodArray<z.ZodObject<{
        source: z.ZodEnum<["project", "user", "package"]>;
        path: z.ZodString;
      } & {
        displayPath: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        source: z.ZodEnum<["project", "user", "package"]>;
        path: z.ZodString;
      } & {
        displayPath: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        source: z.ZodEnum<["project", "user", "package"]>;
        path: z.ZodString;
      } & {
        displayPath: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, z.ZodTypeAny, "passthrough"> | null>;
  }>;
  evidence: z.ZodObject<{
    schemas: z.ZodObject<{
      success: z.ZodBoolean;
      stdout: z.ZodString;
      stderr: z.ZodString;
      exitCode: z.ZodNullable<z.ZodNumber>;
      payload: z.ZodNullable<z.ZodType<CliJsonValue, z.ZodTypeDef, CliJsonValue>>;
      diagnostics: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
      contractError: z.ZodOptional<z.ZodString>;
    }, "strip", z.ZodTypeAny, {
      success: boolean;
      stdout: string;
      stderr: string;
      exitCode: number | null;
      payload: CliJsonValue;
      diagnostics: z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">[];
      contractError?: string | undefined;
    }, {
      success: boolean;
      stdout: string;
      stderr: string;
      exitCode: number | null;
      payload: CliJsonValue;
      diagnostics: z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">[];
      contractError?: string | undefined;
    }>;
    schemaResolutions: z.ZodRecord<z.ZodString, z.ZodObject<{
      success: z.ZodBoolean;
      stdout: z.ZodString;
      stderr: z.ZodString;
      exitCode: z.ZodNullable<z.ZodNumber>;
      payload: z.ZodNullable<z.ZodType<CliJsonValue, z.ZodTypeDef, CliJsonValue>>;
      diagnostics: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
      contractError: z.ZodOptional<z.ZodString>;
    }, "strip", z.ZodTypeAny, {
      success: boolean;
      stdout: string;
      stderr: string;
      exitCode: number | null;
      payload: CliJsonValue;
      diagnostics: z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">[];
      contractError?: string | undefined;
    }, {
      success: boolean;
      stdout: string;
      stderr: string;
      exitCode: number | null;
      payload: CliJsonValue;
      diagnostics: z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">[];
      contractError?: string | undefined;
    }>>;
  }, "strip", z.ZodTypeAny, {
    schemas: {
      success: boolean;
      stdout: string;
      stderr: string;
      exitCode: number | null;
      payload: CliJsonValue;
      diagnostics: z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">[];
      contractError?: string | undefined;
    };
    schemaResolutions: Record<string, {
      success: boolean;
      stdout: string;
      stderr: string;
      exitCode: number | null;
      payload: CliJsonValue;
      diagnostics: z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">[];
      contractError?: string | undefined;
    }>;
  }, {
    schemas: {
      success: boolean;
      stdout: string;
      stderr: string;
      exitCode: number | null;
      payload: CliJsonValue;
      diagnostics: z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">[];
      contractError?: string | undefined;
    };
    schemaResolutions: Record<string, {
      success: boolean;
      stdout: string;
      stderr: string;
      exitCode: number | null;
      payload: CliJsonValue;
      diagnostics: z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">[];
      contractError?: string | undefined;
    }>;
  }>;
}, "strip", z.ZodTypeAny, {
  value: {
    schemas: z.objectOutputType<{
      name: z.ZodString;
      description: z.ZodOptional<z.ZodString>;
      artifacts: z.ZodArray<z.ZodString, "many">;
      source: z.ZodEnum<["project", "user", "package"]>;
    }, z.ZodTypeAny, "passthrough">[];
    schemaDetails: Record<string, {
      name: string;
      applyRequires: string[];
      artifacts: {
        id: string;
        outputPath: string;
        requires: string[];
        description?: string | undefined;
        template?: string | undefined;
        instruction?: string | undefined;
      }[];
      version?: string | number | undefined;
      description?: string | undefined;
      applyTracks?: string | undefined;
      applyInstruction?: string | undefined;
    } | null>;
    schemaResolutions: Record<string, z.objectOutputType<{
      name: z.ZodString;
      source: z.ZodEnum<["project", "user", "package"]>;
      path: z.ZodString;
    } & {
      displayPath: z.ZodOptional<z.ZodString>;
      shadows: z.ZodArray<z.ZodObject<{
        source: z.ZodEnum<["project", "user", "package"]>;
        path: z.ZodString;
      } & {
        displayPath: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        source: z.ZodEnum<["project", "user", "package"]>;
        path: z.ZodString;
      } & {
        displayPath: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        source: z.ZodEnum<["project", "user", "package"]>;
        path: z.ZodString;
      } & {
        displayPath: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, z.ZodTypeAny, "passthrough"> | null>;
  };
  kind: "opsx-config-bundle";
  evidence: {
    schemas: {
      success: boolean;
      stdout: string;
      stderr: string;
      exitCode: number | null;
      payload: CliJsonValue;
      diagnostics: z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">[];
      contractError?: string | undefined;
    };
    schemaResolutions: Record<string, {
      success: boolean;
      stdout: string;
      stderr: string;
      exitCode: number | null;
      payload: CliJsonValue;
      diagnostics: z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">[];
      contractError?: string | undefined;
    }>;
  };
}, {
  value: {
    schemas: z.objectInputType<{
      name: z.ZodString;
      description: z.ZodOptional<z.ZodString>;
      artifacts: z.ZodArray<z.ZodString, "many">;
      source: z.ZodEnum<["project", "user", "package"]>;
    }, z.ZodTypeAny, "passthrough">[];
    schemaDetails: Record<string, {
      name: string;
      applyRequires: string[];
      artifacts: {
        id: string;
        outputPath: string;
        requires: string[];
        description?: string | undefined;
        template?: string | undefined;
        instruction?: string | undefined;
      }[];
      version?: string | number | undefined;
      description?: string | undefined;
      applyTracks?: string | undefined;
      applyInstruction?: string | undefined;
    } | null>;
    schemaResolutions: Record<string, z.objectInputType<{
      name: z.ZodString;
      source: z.ZodEnum<["project", "user", "package"]>;
      path: z.ZodString;
    } & {
      displayPath: z.ZodOptional<z.ZodString>;
      shadows: z.ZodArray<z.ZodObject<{
        source: z.ZodEnum<["project", "user", "package"]>;
        path: z.ZodString;
      } & {
        displayPath: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        source: z.ZodEnum<["project", "user", "package"]>;
        path: z.ZodString;
      } & {
        displayPath: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        source: z.ZodEnum<["project", "user", "package"]>;
        path: z.ZodString;
      } & {
        displayPath: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, z.ZodTypeAny, "passthrough"> | null>;
  };
  kind: "opsx-config-bundle";
  evidence: {
    schemas: {
      success: boolean;
      stdout: string;
      stderr: string;
      exitCode: number | null;
      payload: CliJsonValue;
      diagnostics: z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">[];
      contractError?: string | undefined;
    };
    schemaResolutions: Record<string, {
      success: boolean;
      stdout: string;
      stderr: string;
      exitCode: number | null;
      payload: CliJsonValue;
      diagnostics: z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">[];
      contractError?: string | undefined;
    }>;
  };
}>, z.ZodObject<{
  kind: z.ZodLiteral<"opsx-templates">;
  value: z.ZodRecord<z.ZodString, z.ZodObject<{
    path: z.ZodString;
    source: z.ZodEnum<["project", "user", "package"]>;
  } & {
    displayPath: z.ZodOptional<z.ZodString>;
  }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
    path: z.ZodString;
    source: z.ZodEnum<["project", "user", "package"]>;
  } & {
    displayPath: z.ZodOptional<z.ZodString>;
  }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
    path: z.ZodString;
    source: z.ZodEnum<["project", "user", "package"]>;
  } & {
    displayPath: z.ZodOptional<z.ZodString>;
  }, z.ZodTypeAny, "passthrough">>>;
  evidence: z.ZodObject<{
    success: z.ZodBoolean;
    stdout: z.ZodString;
    stderr: z.ZodString;
    exitCode: z.ZodNullable<z.ZodNumber>;
    payload: z.ZodNullable<z.ZodType<CliJsonValue, z.ZodTypeDef, CliJsonValue>>;
    diagnostics: z.ZodArray<z.ZodObject<{
      severity: z.ZodEnum<["error", "warning", "info"]>;
      code: z.ZodString;
      message: z.ZodString;
      target: z.ZodOptional<z.ZodString>;
      fix: z.ZodOptional<z.ZodString>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      severity: z.ZodEnum<["error", "warning", "info"]>;
      code: z.ZodString;
      message: z.ZodString;
      target: z.ZodOptional<z.ZodString>;
      fix: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      severity: z.ZodEnum<["error", "warning", "info"]>;
      code: z.ZodString;
      message: z.ZodString;
      target: z.ZodOptional<z.ZodString>;
      fix: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">>, "many">;
    contractError: z.ZodOptional<z.ZodString>;
  }, "strip", z.ZodTypeAny, {
    success: boolean;
    stdout: string;
    stderr: string;
    exitCode: number | null;
    payload: CliJsonValue;
    diagnostics: z.objectOutputType<{
      severity: z.ZodEnum<["error", "warning", "info"]>;
      code: z.ZodString;
      message: z.ZodString;
      target: z.ZodOptional<z.ZodString>;
      fix: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">[];
    contractError?: string | undefined;
  }, {
    success: boolean;
    stdout: string;
    stderr: string;
    exitCode: number | null;
    payload: CliJsonValue;
    diagnostics: z.objectInputType<{
      severity: z.ZodEnum<["error", "warning", "info"]>;
      code: z.ZodString;
      message: z.ZodString;
      target: z.ZodOptional<z.ZodString>;
      fix: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">[];
    contractError?: string | undefined;
  }>;
}, "strip", z.ZodTypeAny, {
  value: Record<string, z.objectOutputType<{
    path: z.ZodString;
    source: z.ZodEnum<["project", "user", "package"]>;
  } & {
    displayPath: z.ZodOptional<z.ZodString>;
  }, z.ZodTypeAny, "passthrough">>;
  kind: "opsx-templates";
  evidence: {
    success: boolean;
    stdout: string;
    stderr: string;
    exitCode: number | null;
    payload: CliJsonValue;
    diagnostics: z.objectOutputType<{
      severity: z.ZodEnum<["error", "warning", "info"]>;
      code: z.ZodString;
      message: z.ZodString;
      target: z.ZodOptional<z.ZodString>;
      fix: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">[];
    contractError?: string | undefined;
  };
}, {
  value: Record<string, z.objectInputType<{
    path: z.ZodString;
    source: z.ZodEnum<["project", "user", "package"]>;
  } & {
    displayPath: z.ZodOptional<z.ZodString>;
  }, z.ZodTypeAny, "passthrough">>;
  kind: "opsx-templates";
  evidence: {
    success: boolean;
    stdout: string;
    stderr: string;
    exitCode: number | null;
    payload: CliJsonValue;
    diagnostics: z.objectInputType<{
      severity: z.ZodEnum<["error", "warning", "info"]>;
      code: z.ZodString;
      message: z.ZodString;
      target: z.ZodOptional<z.ZodString>;
      fix: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">[];
    contractError?: string | undefined;
  };
}>, z.ZodObject<{
  kind: z.ZodLiteral<"opsx-template-contents">;
  value: z.ZodRecord<z.ZodString, z.ZodObject<{
    content: z.ZodNullable<z.ZodString>;
    path: z.ZodString;
    displayPath: z.ZodOptional<z.ZodString>;
    source: z.ZodEnum<["project", "user", "package"]>;
  }, "strip", z.ZodTypeAny, {
    path: string;
    source: "project" | "user" | "package";
    content: string | null;
    displayPath?: string | undefined;
  }, {
    path: string;
    source: "project" | "user" | "package";
    content: string | null;
    displayPath?: string | undefined;
  }>>;
  evidence: z.ZodObject<{
    success: z.ZodBoolean;
    stdout: z.ZodString;
    stderr: z.ZodString;
    exitCode: z.ZodNullable<z.ZodNumber>;
    payload: z.ZodNullable<z.ZodType<CliJsonValue, z.ZodTypeDef, CliJsonValue>>;
    diagnostics: z.ZodArray<z.ZodObject<{
      severity: z.ZodEnum<["error", "warning", "info"]>;
      code: z.ZodString;
      message: z.ZodString;
      target: z.ZodOptional<z.ZodString>;
      fix: z.ZodOptional<z.ZodString>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      severity: z.ZodEnum<["error", "warning", "info"]>;
      code: z.ZodString;
      message: z.ZodString;
      target: z.ZodOptional<z.ZodString>;
      fix: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      severity: z.ZodEnum<["error", "warning", "info"]>;
      code: z.ZodString;
      message: z.ZodString;
      target: z.ZodOptional<z.ZodString>;
      fix: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">>, "many">;
    contractError: z.ZodOptional<z.ZodString>;
  }, "strip", z.ZodTypeAny, {
    success: boolean;
    stdout: string;
    stderr: string;
    exitCode: number | null;
    payload: CliJsonValue;
    diagnostics: z.objectOutputType<{
      severity: z.ZodEnum<["error", "warning", "info"]>;
      code: z.ZodString;
      message: z.ZodString;
      target: z.ZodOptional<z.ZodString>;
      fix: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">[];
    contractError?: string | undefined;
  }, {
    success: boolean;
    stdout: string;
    stderr: string;
    exitCode: number | null;
    payload: CliJsonValue;
    diagnostics: z.objectInputType<{
      severity: z.ZodEnum<["error", "warning", "info"]>;
      code: z.ZodString;
      message: z.ZodString;
      target: z.ZodOptional<z.ZodString>;
      fix: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">[];
    contractError?: string | undefined;
  }>;
}, "strip", z.ZodTypeAny, {
  value: Record<string, {
    path: string;
    source: "project" | "user" | "package";
    content: string | null;
    displayPath?: string | undefined;
  }>;
  kind: "opsx-template-contents";
  evidence: {
    success: boolean;
    stdout: string;
    stderr: string;
    exitCode: number | null;
    payload: CliJsonValue;
    diagnostics: z.objectOutputType<{
      severity: z.ZodEnum<["error", "warning", "info"]>;
      code: z.ZodString;
      message: z.ZodString;
      target: z.ZodOptional<z.ZodString>;
      fix: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">[];
    contractError?: string | undefined;
  };
}, {
  value: Record<string, {
    path: string;
    source: "project" | "user" | "package";
    content: string | null;
    displayPath?: string | undefined;
  }>;
  kind: "opsx-template-contents";
  evidence: {
    success: boolean;
    stdout: string;
    stderr: string;
    exitCode: number | null;
    payload: CliJsonValue;
    diagnostics: z.objectInputType<{
      severity: z.ZodEnum<["error", "warning", "info"]>;
      code: z.ZodString;
      message: z.ZodString;
      target: z.ZodOptional<z.ZodString>;
      fix: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">[];
    contractError?: string | undefined;
  };
}>, z.ZodObject<{
  kind: z.ZodLiteral<"spec-catalog">;
  value: z.ZodType<SpecCatalog, z.ZodTypeDef, unknown>;
}, "strip", z.ZodTypeAny, {
  value: SpecCatalog;
  kind: "spec-catalog";
}, {
  kind: "spec-catalog";
  value?: unknown;
}>, z.ZodObject<{
  kind: z.ZodLiteral<"spec-document">;
  value: z.ZodType<SpecDocumentProjection, z.ZodTypeDef, unknown>;
}, "strip", z.ZodTypeAny, {
  value: SpecDocumentProjection;
  kind: "spec-document";
}, {
  kind: "spec-document";
  value?: unknown;
}>]>;
type PlanningCliProjectionData = z.infer<typeof PlanningCliProjectionDataSchema>;
/** Browser-safe lifecycle Pull schema for every selector-exact Planning-root projection. */
declare const PlanningCliProjectionStateSchema: z.ZodDiscriminatedUnion<"state", [z.ZodObject<{
  state: z.ZodLiteral<"loading">;
  data: z.ZodNull;
  freshness: z.ZodNull;
  snapshotGeneration: z.ZodNull;
  error: z.ZodNull;
  identity: z.ZodString;
  workGeneration: z.ZodNumber;
  invalidationCause: z.ZodEnum<["initial", "dependency", "explicit-refresh", "subscriber-resume"]>;
}, "strip", z.ZodTypeAny, {
  error: null;
  state: "loading";
  data: null;
  freshness: null;
  snapshotGeneration: null;
  identity: string;
  workGeneration: number;
  invalidationCause: "dependency" | "initial" | "explicit-refresh" | "subscriber-resume";
}, {
  error: null;
  state: "loading";
  data: null;
  freshness: null;
  snapshotGeneration: null;
  identity: string;
  workGeneration: number;
  invalidationCause: "dependency" | "initial" | "explicit-refresh" | "subscriber-resume";
}>, z.ZodObject<{
  state: z.ZodLiteral<"ready">;
  data: z.ZodType<{
    value: {
      changeName: string;
      schemaName: string;
      isPlanningComplete: boolean;
      applyRequires: string[];
      artifacts: {
        status: "ready" | "done" | "skipped" | "blocked";
        id: string;
        outputPath: string;
        requires: string[];
        missingDeps?: string[] | undefined;
        relativePath?: string | undefined;
      }[];
      provenance: {
        root: {
          path: string;
          source: "store" | "declared" | "nearest" | "global_default" | "implicit";
          store_id?: string | undefined;
        } & {
          [k: string]: unknown;
        };
        kind: "cli";
        evidence: {
          success: boolean;
          stdout: string;
          stderr: string;
          exitCode: number | null;
          payload: CliJsonValue;
          diagnostics: z.objectOutputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">[];
          command: "status";
          selector: {
            store?: string | undefined;
          };
          root?: z.objectOutputType<{
            path: z.ZodString;
            source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
            store_id: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough"> | undefined;
          contractError?: string | undefined;
        } & {
          [k: string]: unknown;
        };
        planningHome: {
          root: string;
          kind: "repo";
          changesDir: string;
          defaultSchema: string;
        } & {
          [k: string]: unknown;
        };
        changeRoot: string;
        artifactPaths: Record<string, z.objectOutputType<{
          outputPath: z.ZodString;
          resolvedOutputPath: z.ZodString;
          existingOutputPaths: z.ZodArray<z.ZodString, "many">;
        }, z.ZodTypeAny, "passthrough">>;
        nextSteps: string[];
        actionContext: {
          mode: "repo-local";
          sourceOfTruth: "repo";
          planningArtifacts: string[];
          linkedContext: z.objectOutputType<{
            name: z.ZodString;
          }, z.ZodTypeAny, "passthrough">[];
          allowedEditRoots: string[];
          requiresAffectedAreaSelection: boolean;
          constraints: string[];
        } & {
          [k: string]: unknown;
        };
      } | {
        kind: "static";
      };
    };
    kind: "opsx-status";
  } | {
    value: string[];
    entries: {
      status: "no-tasks" | "complete" | "in-progress";
      name: string;
      completedTasks: number;
      totalTasks: number;
      lastModified: string;
    }[];
    kind: "opsx-change-list";
    evidence: {
      success: boolean;
      stdout: string;
      stderr: string;
      exitCode: number | null;
      payload: CliJsonValue;
      diagnostics: z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">[];
      contractError?: string | undefined;
    };
  } | {
    value: {
      changeName: string;
      schemaName: string;
      isPlanningComplete: boolean;
      applyRequires: string[];
      artifacts: {
        status: "ready" | "done" | "skipped" | "blocked";
        id: string;
        outputPath: string;
        requires: string[];
        missingDeps?: string[] | undefined;
        relativePath?: string | undefined;
      }[];
      provenance: {
        root: {
          path: string;
          source: "store" | "declared" | "nearest" | "global_default" | "implicit";
          store_id?: string | undefined;
        } & {
          [k: string]: unknown;
        };
        kind: "cli";
        evidence: {
          success: boolean;
          stdout: string;
          stderr: string;
          exitCode: number | null;
          payload: CliJsonValue;
          diagnostics: z.objectOutputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">[];
          command: "status";
          selector: {
            store?: string | undefined;
          };
          root?: z.objectOutputType<{
            path: z.ZodString;
            source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
            store_id: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough"> | undefined;
          contractError?: string | undefined;
        } & {
          [k: string]: unknown;
        };
        planningHome: {
          root: string;
          kind: "repo";
          changesDir: string;
          defaultSchema: string;
        } & {
          [k: string]: unknown;
        };
        changeRoot: string;
        artifactPaths: Record<string, z.objectOutputType<{
          outputPath: z.ZodString;
          resolvedOutputPath: z.ZodString;
          existingOutputPaths: z.ZodArray<z.ZodString, "many">;
        }, z.ZodTypeAny, "passthrough">>;
        nextSteps: string[];
        actionContext: {
          mode: "repo-local";
          sourceOfTruth: "repo";
          planningArtifacts: string[];
          linkedContext: z.objectOutputType<{
            name: z.ZodString;
          }, z.ZodTypeAny, "passthrough">[];
          allowedEditRoots: string[];
          requiresAffectedAreaSelection: boolean;
          constraints: string[];
        } & {
          [k: string]: unknown;
        };
      } | {
        kind: "static";
      };
    }[];
    kind: "opsx-status-list";
    evidence: {
      success: boolean;
      stdout: string;
      stderr: string;
      exitCode: number | null;
      payload: CliJsonValue;
      diagnostics: z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">[];
      contractError?: string | undefined;
    };
  } | {
    value: {
      description: string;
      template: string;
      evidence: {
        success: boolean;
        stdout: string;
        stderr: string;
        exitCode: number | null;
        payload: CliJsonValue;
        diagnostics: z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">[];
        command: "instructions";
        selector: {
          store?: string | undefined;
        };
        root?: z.objectOutputType<{
          path: z.ZodString;
          source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
          store_id: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough"> | undefined;
        contractError?: string | undefined;
      } & {
        [k: string]: unknown;
      };
      changeName: string;
      schemaName: string;
      outputPath: string;
      artifactId: string;
      changeDir: string;
      dependencies: {
        path: string;
        id: string;
        description: string;
        done: boolean;
        skipped?: boolean | undefined;
      }[];
      unlocks: string[];
      context?: string | null | undefined;
      instruction?: string | null | undefined;
      rules?: string[] | null | undefined;
      references?: z.objectOutputType<{
        store_id: z.ZodString;
        root: z.ZodOptional<z.ZodString>;
        status: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
      } & {
        specs: z.ZodOptional<z.ZodArray<z.ZodObject<{
          id: z.ZodString;
          summary: z.ZodString;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          id: z.ZodString;
          summary: z.ZodString;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          id: z.ZodString;
          summary: z.ZodString;
        }, z.ZodTypeAny, "passthrough">>, "many">>;
        fetch: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">[] | undefined;
    };
    kind: "opsx-instructions";
  } | {
    value: {
      state: "ready" | "blocked" | "all_done";
      evidence: {
        success: boolean;
        stdout: string;
        stderr: string;
        exitCode: number | null;
        payload: CliJsonValue;
        diagnostics: z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">[];
        command: "instructions apply";
        selector: {
          store?: string | undefined;
        };
        root?: z.objectOutputType<{
          path: z.ZodString;
          source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
          store_id: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough"> | undefined;
        contractError?: string | undefined;
      } & {
        [k: string]: unknown;
      };
      changeName: string;
      schemaName: string;
      changeDir: string;
      instruction: string;
      contextFiles: Record<string, string[]>;
      tasks: {
        id: string;
        description: string;
        done: boolean;
      }[];
      applyInstructionProgress: {
        source: "openspec-instructions-apply";
        state: "ready" | "blocked" | "all_done";
        complete: number;
        total: number;
        remaining: number;
        divergence: {
          message: string;
          kind: "tracked-task-mismatch";
          apply: {
            complete: number;
            total: number;
            remaining: number;
          };
          tracked: {
            total: number;
            remaining: number;
            completed: number;
            phase: "no-tasks" | "complete" | "in-progress";
          };
        } | null;
      };
      context?: string | undefined;
      references?: z.objectOutputType<{
        store_id: z.ZodString;
        root: z.ZodOptional<z.ZodString>;
        status: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
      } & {
        specs: z.ZodOptional<z.ZodArray<z.ZodObject<{
          id: z.ZodString;
          summary: z.ZodString;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          id: z.ZodString;
          summary: z.ZodString;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          id: z.ZodString;
          summary: z.ZodString;
        }, z.ZodTypeAny, "passthrough">>, "many">>;
        fetch: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">[] | undefined;
      missingArtifacts?: string[] | undefined;
      operationGuidance?: string[] | undefined;
    };
    kind: "opsx-apply-instructions";
  } | {
    value: {
      evidence: {
        success: boolean;
        stdout: string;
        stderr: string;
        exitCode: number | null;
        payload: CliJsonValue;
        diagnostics: z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">[];
        command: "instructions archive";
        selector: {
          store?: string | undefined;
        };
        root?: z.objectOutputType<{
          path: z.ZodString;
          source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
          store_id: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough"> | undefined;
        contractError?: string | undefined;
      } & {
        [k: string]: unknown;
      };
      changeName: string;
      context?: string | undefined;
      operationGuidance?: string[] | undefined;
    };
    kind: "opsx-archive-instructions";
    rootGeneration: string;
  } | {
    value: {
      schemas: z.objectOutputType<{
        name: z.ZodString;
        description: z.ZodOptional<z.ZodString>;
        artifacts: z.ZodArray<z.ZodString, "many">;
        source: z.ZodEnum<["project", "user", "package"]>;
      }, z.ZodTypeAny, "passthrough">[];
      schemaDetails: Record<string, {
        name: string;
        applyRequires: string[];
        artifacts: {
          id: string;
          outputPath: string;
          requires: string[];
          description?: string | undefined;
          template?: string | undefined;
          instruction?: string | undefined;
        }[];
        version?: string | number | undefined;
        description?: string | undefined;
        applyTracks?: string | undefined;
        applyInstruction?: string | undefined;
      } | null>;
      schemaResolutions: Record<string, z.objectOutputType<{
        name: z.ZodString;
        source: z.ZodEnum<["project", "user", "package"]>;
        path: z.ZodString;
      } & {
        displayPath: z.ZodOptional<z.ZodString>;
        shadows: z.ZodArray<z.ZodObject<{
          source: z.ZodEnum<["project", "user", "package"]>;
          path: z.ZodString;
        } & {
          displayPath: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          source: z.ZodEnum<["project", "user", "package"]>;
          path: z.ZodString;
        } & {
          displayPath: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          source: z.ZodEnum<["project", "user", "package"]>;
          path: z.ZodString;
        } & {
          displayPath: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
      }, z.ZodTypeAny, "passthrough"> | null>;
    };
    kind: "opsx-config-bundle";
    evidence: {
      schemas: {
        success: boolean;
        stdout: string;
        stderr: string;
        exitCode: number | null;
        payload: CliJsonValue;
        diagnostics: z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">[];
        contractError?: string | undefined;
      };
      schemaResolutions: Record<string, {
        success: boolean;
        stdout: string;
        stderr: string;
        exitCode: number | null;
        payload: CliJsonValue;
        diagnostics: z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">[];
        contractError?: string | undefined;
      }>;
    };
  } | {
    value: Record<string, z.objectOutputType<{
      path: z.ZodString;
      source: z.ZodEnum<["project", "user", "package"]>;
    } & {
      displayPath: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">>;
    kind: "opsx-templates";
    evidence: {
      success: boolean;
      stdout: string;
      stderr: string;
      exitCode: number | null;
      payload: CliJsonValue;
      diagnostics: z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">[];
      contractError?: string | undefined;
    };
  } | {
    value: Record<string, {
      path: string;
      source: "project" | "user" | "package";
      content: string | null;
      displayPath?: string | undefined;
    }>;
    kind: "opsx-template-contents";
    evidence: {
      success: boolean;
      stdout: string;
      stderr: string;
      exitCode: number | null;
      payload: CliJsonValue;
      diagnostics: z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">[];
      contractError?: string | undefined;
    };
  } | {
    value: SpecCatalog;
    kind: "spec-catalog";
  } | {
    value: SpecDocumentProjection;
    kind: "spec-document";
  }, z.ZodTypeDef, {
    value: {
      changeName: string;
      schemaName: string;
      isPlanningComplete: boolean;
      applyRequires: string[];
      artifacts: {
        status: "ready" | "done" | "skipped" | "blocked";
        id: string;
        outputPath: string;
        requires: string[];
        missingDeps?: string[] | undefined;
        relativePath?: string | undefined;
      }[];
      provenance: {
        root: {
          path: string;
          source: "store" | "declared" | "nearest" | "global_default" | "implicit";
          store_id?: string | undefined;
        } & {
          [k: string]: unknown;
        };
        kind: "cli";
        evidence: {
          success: boolean;
          stdout: string;
          stderr: string;
          exitCode: number | null;
          payload: CliJsonValue;
          diagnostics: z.objectInputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">[];
          command: "status";
          selector: {
            store?: string | undefined;
          };
          root?: z.objectInputType<{
            path: z.ZodString;
            source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
            store_id: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough"> | undefined;
          contractError?: string | undefined;
        } & {
          [k: string]: unknown;
        };
        planningHome: {
          root: string;
          kind: "repo";
          changesDir: string;
          defaultSchema: string;
        } & {
          [k: string]: unknown;
        };
        changeRoot: string;
        artifactPaths: Record<string, z.objectInputType<{
          outputPath: z.ZodString;
          resolvedOutputPath: z.ZodString;
          existingOutputPaths: z.ZodArray<z.ZodString, "many">;
        }, z.ZodTypeAny, "passthrough">>;
        nextSteps: string[];
        actionContext: {
          mode: "repo-local";
          sourceOfTruth: "repo";
          planningArtifacts: string[];
          linkedContext: z.objectInputType<{
            name: z.ZodString;
          }, z.ZodTypeAny, "passthrough">[];
          allowedEditRoots: string[];
          requiresAffectedAreaSelection: boolean;
          constraints: string[];
        } & {
          [k: string]: unknown;
        };
      } | {
        kind: "static";
      };
    };
    kind: "opsx-status";
  } | {
    value: string[];
    entries: {
      status: "no-tasks" | "complete" | "in-progress";
      name: string;
      completedTasks: number;
      totalTasks: number;
      lastModified: string;
    }[];
    kind: "opsx-change-list";
    evidence: {
      success: boolean;
      stdout: string;
      stderr: string;
      exitCode: number | null;
      payload: CliJsonValue;
      diagnostics: z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">[];
      contractError?: string | undefined;
    };
  } | {
    value: {
      changeName: string;
      schemaName: string;
      isPlanningComplete: boolean;
      applyRequires: string[];
      artifacts: {
        status: "ready" | "done" | "skipped" | "blocked";
        id: string;
        outputPath: string;
        requires: string[];
        missingDeps?: string[] | undefined;
        relativePath?: string | undefined;
      }[];
      provenance: {
        root: {
          path: string;
          source: "store" | "declared" | "nearest" | "global_default" | "implicit";
          store_id?: string | undefined;
        } & {
          [k: string]: unknown;
        };
        kind: "cli";
        evidence: {
          success: boolean;
          stdout: string;
          stderr: string;
          exitCode: number | null;
          payload: CliJsonValue;
          diagnostics: z.objectInputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">[];
          command: "status";
          selector: {
            store?: string | undefined;
          };
          root?: z.objectInputType<{
            path: z.ZodString;
            source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
            store_id: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough"> | undefined;
          contractError?: string | undefined;
        } & {
          [k: string]: unknown;
        };
        planningHome: {
          root: string;
          kind: "repo";
          changesDir: string;
          defaultSchema: string;
        } & {
          [k: string]: unknown;
        };
        changeRoot: string;
        artifactPaths: Record<string, z.objectInputType<{
          outputPath: z.ZodString;
          resolvedOutputPath: z.ZodString;
          existingOutputPaths: z.ZodArray<z.ZodString, "many">;
        }, z.ZodTypeAny, "passthrough">>;
        nextSteps: string[];
        actionContext: {
          mode: "repo-local";
          sourceOfTruth: "repo";
          planningArtifacts: string[];
          linkedContext: z.objectInputType<{
            name: z.ZodString;
          }, z.ZodTypeAny, "passthrough">[];
          allowedEditRoots: string[];
          requiresAffectedAreaSelection: boolean;
          constraints: string[];
        } & {
          [k: string]: unknown;
        };
      } | {
        kind: "static";
      };
    }[];
    kind: "opsx-status-list";
    evidence: {
      success: boolean;
      stdout: string;
      stderr: string;
      exitCode: number | null;
      payload: CliJsonValue;
      diagnostics: z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">[];
      contractError?: string | undefined;
    };
  } | {
    value: {
      description: string;
      template: string;
      evidence: {
        success: boolean;
        stdout: string;
        stderr: string;
        exitCode: number | null;
        payload: CliJsonValue;
        diagnostics: z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">[];
        command: "instructions";
        selector: {
          store?: string | undefined;
        };
        root?: z.objectInputType<{
          path: z.ZodString;
          source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
          store_id: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough"> | undefined;
        contractError?: string | undefined;
      } & {
        [k: string]: unknown;
      };
      changeName: string;
      schemaName: string;
      outputPath: string;
      artifactId: string;
      changeDir: string;
      dependencies: {
        path: string;
        id: string;
        description: string;
        done: boolean;
        skipped?: boolean | undefined;
      }[];
      unlocks: string[];
      context?: string | null | undefined;
      instruction?: string | null | undefined;
      rules?: string[] | null | undefined;
      references?: z.objectInputType<{
        store_id: z.ZodString;
        root: z.ZodOptional<z.ZodString>;
        status: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
      } & {
        specs: z.ZodOptional<z.ZodArray<z.ZodObject<{
          id: z.ZodString;
          summary: z.ZodString;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          id: z.ZodString;
          summary: z.ZodString;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          id: z.ZodString;
          summary: z.ZodString;
        }, z.ZodTypeAny, "passthrough">>, "many">>;
        fetch: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">[] | undefined;
    };
    kind: "opsx-instructions";
  } | {
    value: {
      state: "ready" | "blocked" | "all_done";
      evidence: {
        success: boolean;
        stdout: string;
        stderr: string;
        exitCode: number | null;
        payload: CliJsonValue;
        diagnostics: z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">[];
        command: "instructions apply";
        selector: {
          store?: string | undefined;
        };
        root?: z.objectInputType<{
          path: z.ZodString;
          source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
          store_id: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough"> | undefined;
        contractError?: string | undefined;
      } & {
        [k: string]: unknown;
      };
      changeName: string;
      schemaName: string;
      changeDir: string;
      instruction: string;
      contextFiles: Record<string, string | string[]>;
      tasks: {
        id: string;
        description: string;
        done: boolean;
      }[];
      applyInstructionProgress: {
        source: "openspec-instructions-apply";
        state: "ready" | "blocked" | "all_done";
        complete: number;
        total: number;
        remaining: number;
        divergence: {
          message: string;
          kind: "tracked-task-mismatch";
          apply: {
            complete: number;
            total: number;
            remaining: number;
          };
          tracked: {
            total: number;
            remaining: number;
            completed: number;
            phase: "no-tasks" | "complete" | "in-progress";
          };
        } | null;
      };
      context?: string | undefined;
      references?: z.objectInputType<{
        store_id: z.ZodString;
        root: z.ZodOptional<z.ZodString>;
        status: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
      } & {
        specs: z.ZodOptional<z.ZodArray<z.ZodObject<{
          id: z.ZodString;
          summary: z.ZodString;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          id: z.ZodString;
          summary: z.ZodString;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          id: z.ZodString;
          summary: z.ZodString;
        }, z.ZodTypeAny, "passthrough">>, "many">>;
        fetch: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">[] | undefined;
      missingArtifacts?: string[] | undefined;
      operationGuidance?: string[] | undefined;
    };
    kind: "opsx-apply-instructions";
  } | {
    value: {
      evidence: {
        success: boolean;
        stdout: string;
        stderr: string;
        exitCode: number | null;
        payload: CliJsonValue;
        diagnostics: z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">[];
        command: "instructions archive";
        selector: {
          store?: string | undefined;
        };
        root?: z.objectInputType<{
          path: z.ZodString;
          source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
          store_id: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough"> | undefined;
        contractError?: string | undefined;
      } & {
        [k: string]: unknown;
      };
      changeName: string;
      context?: string | undefined;
      operationGuidance?: string[] | undefined;
    };
    kind: "opsx-archive-instructions";
    rootGeneration: string;
  } | {
    value: {
      schemas: z.objectInputType<{
        name: z.ZodString;
        description: z.ZodOptional<z.ZodString>;
        artifacts: z.ZodArray<z.ZodString, "many">;
        source: z.ZodEnum<["project", "user", "package"]>;
      }, z.ZodTypeAny, "passthrough">[];
      schemaDetails: Record<string, {
        name: string;
        applyRequires: string[];
        artifacts: {
          id: string;
          outputPath: string;
          requires: string[];
          description?: string | undefined;
          template?: string | undefined;
          instruction?: string | undefined;
        }[];
        version?: string | number | undefined;
        description?: string | undefined;
        applyTracks?: string | undefined;
        applyInstruction?: string | undefined;
      } | null>;
      schemaResolutions: Record<string, z.objectInputType<{
        name: z.ZodString;
        source: z.ZodEnum<["project", "user", "package"]>;
        path: z.ZodString;
      } & {
        displayPath: z.ZodOptional<z.ZodString>;
        shadows: z.ZodArray<z.ZodObject<{
          source: z.ZodEnum<["project", "user", "package"]>;
          path: z.ZodString;
        } & {
          displayPath: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          source: z.ZodEnum<["project", "user", "package"]>;
          path: z.ZodString;
        } & {
          displayPath: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          source: z.ZodEnum<["project", "user", "package"]>;
          path: z.ZodString;
        } & {
          displayPath: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
      }, z.ZodTypeAny, "passthrough"> | null>;
    };
    kind: "opsx-config-bundle";
    evidence: {
      schemas: {
        success: boolean;
        stdout: string;
        stderr: string;
        exitCode: number | null;
        payload: CliJsonValue;
        diagnostics: z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">[];
        contractError?: string | undefined;
      };
      schemaResolutions: Record<string, {
        success: boolean;
        stdout: string;
        stderr: string;
        exitCode: number | null;
        payload: CliJsonValue;
        diagnostics: z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">[];
        contractError?: string | undefined;
      }>;
    };
  } | {
    value: Record<string, z.objectInputType<{
      path: z.ZodString;
      source: z.ZodEnum<["project", "user", "package"]>;
    } & {
      displayPath: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">>;
    kind: "opsx-templates";
    evidence: {
      success: boolean;
      stdout: string;
      stderr: string;
      exitCode: number | null;
      payload: CliJsonValue;
      diagnostics: z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">[];
      contractError?: string | undefined;
    };
  } | {
    value: Record<string, {
      path: string;
      source: "project" | "user" | "package";
      content: string | null;
      displayPath?: string | undefined;
    }>;
    kind: "opsx-template-contents";
    evidence: {
      success: boolean;
      stdout: string;
      stderr: string;
      exitCode: number | null;
      payload: CliJsonValue;
      diagnostics: z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">[];
      contractError?: string | undefined;
    };
  } | {
    kind: "spec-catalog";
    value?: unknown;
  } | {
    kind: "spec-document";
    value?: unknown;
  }>;
  freshness: z.ZodLiteral<"current">;
  snapshotGeneration: z.ZodNumber;
  error: z.ZodNull;
  identity: z.ZodString;
  workGeneration: z.ZodNumber;
  invalidationCause: z.ZodEnum<["initial", "dependency", "explicit-refresh", "subscriber-resume"]>;
}, "strip", z.ZodTypeAny, {
  error: null;
  state: "ready";
  data: {
    value: {
      changeName: string;
      schemaName: string;
      isPlanningComplete: boolean;
      applyRequires: string[];
      artifacts: {
        status: "ready" | "done" | "skipped" | "blocked";
        id: string;
        outputPath: string;
        requires: string[];
        missingDeps?: string[] | undefined;
        relativePath?: string | undefined;
      }[];
      provenance: {
        root: {
          path: string;
          source: "store" | "declared" | "nearest" | "global_default" | "implicit";
          store_id?: string | undefined;
        } & {
          [k: string]: unknown;
        };
        kind: "cli";
        evidence: {
          success: boolean;
          stdout: string;
          stderr: string;
          exitCode: number | null;
          payload: CliJsonValue;
          diagnostics: z.objectOutputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">[];
          command: "status";
          selector: {
            store?: string | undefined;
          };
          root?: z.objectOutputType<{
            path: z.ZodString;
            source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
            store_id: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough"> | undefined;
          contractError?: string | undefined;
        } & {
          [k: string]: unknown;
        };
        planningHome: {
          root: string;
          kind: "repo";
          changesDir: string;
          defaultSchema: string;
        } & {
          [k: string]: unknown;
        };
        changeRoot: string;
        artifactPaths: Record<string, z.objectOutputType<{
          outputPath: z.ZodString;
          resolvedOutputPath: z.ZodString;
          existingOutputPaths: z.ZodArray<z.ZodString, "many">;
        }, z.ZodTypeAny, "passthrough">>;
        nextSteps: string[];
        actionContext: {
          mode: "repo-local";
          sourceOfTruth: "repo";
          planningArtifacts: string[];
          linkedContext: z.objectOutputType<{
            name: z.ZodString;
          }, z.ZodTypeAny, "passthrough">[];
          allowedEditRoots: string[];
          requiresAffectedAreaSelection: boolean;
          constraints: string[];
        } & {
          [k: string]: unknown;
        };
      } | {
        kind: "static";
      };
    };
    kind: "opsx-status";
  } | {
    value: string[];
    entries: {
      status: "no-tasks" | "complete" | "in-progress";
      name: string;
      completedTasks: number;
      totalTasks: number;
      lastModified: string;
    }[];
    kind: "opsx-change-list";
    evidence: {
      success: boolean;
      stdout: string;
      stderr: string;
      exitCode: number | null;
      payload: CliJsonValue;
      diagnostics: z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">[];
      contractError?: string | undefined;
    };
  } | {
    value: {
      changeName: string;
      schemaName: string;
      isPlanningComplete: boolean;
      applyRequires: string[];
      artifacts: {
        status: "ready" | "done" | "skipped" | "blocked";
        id: string;
        outputPath: string;
        requires: string[];
        missingDeps?: string[] | undefined;
        relativePath?: string | undefined;
      }[];
      provenance: {
        root: {
          path: string;
          source: "store" | "declared" | "nearest" | "global_default" | "implicit";
          store_id?: string | undefined;
        } & {
          [k: string]: unknown;
        };
        kind: "cli";
        evidence: {
          success: boolean;
          stdout: string;
          stderr: string;
          exitCode: number | null;
          payload: CliJsonValue;
          diagnostics: z.objectOutputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">[];
          command: "status";
          selector: {
            store?: string | undefined;
          };
          root?: z.objectOutputType<{
            path: z.ZodString;
            source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
            store_id: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough"> | undefined;
          contractError?: string | undefined;
        } & {
          [k: string]: unknown;
        };
        planningHome: {
          root: string;
          kind: "repo";
          changesDir: string;
          defaultSchema: string;
        } & {
          [k: string]: unknown;
        };
        changeRoot: string;
        artifactPaths: Record<string, z.objectOutputType<{
          outputPath: z.ZodString;
          resolvedOutputPath: z.ZodString;
          existingOutputPaths: z.ZodArray<z.ZodString, "many">;
        }, z.ZodTypeAny, "passthrough">>;
        nextSteps: string[];
        actionContext: {
          mode: "repo-local";
          sourceOfTruth: "repo";
          planningArtifacts: string[];
          linkedContext: z.objectOutputType<{
            name: z.ZodString;
          }, z.ZodTypeAny, "passthrough">[];
          allowedEditRoots: string[];
          requiresAffectedAreaSelection: boolean;
          constraints: string[];
        } & {
          [k: string]: unknown;
        };
      } | {
        kind: "static";
      };
    }[];
    kind: "opsx-status-list";
    evidence: {
      success: boolean;
      stdout: string;
      stderr: string;
      exitCode: number | null;
      payload: CliJsonValue;
      diagnostics: z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">[];
      contractError?: string | undefined;
    };
  } | {
    value: {
      description: string;
      template: string;
      evidence: {
        success: boolean;
        stdout: string;
        stderr: string;
        exitCode: number | null;
        payload: CliJsonValue;
        diagnostics: z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">[];
        command: "instructions";
        selector: {
          store?: string | undefined;
        };
        root?: z.objectOutputType<{
          path: z.ZodString;
          source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
          store_id: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough"> | undefined;
        contractError?: string | undefined;
      } & {
        [k: string]: unknown;
      };
      changeName: string;
      schemaName: string;
      outputPath: string;
      artifactId: string;
      changeDir: string;
      dependencies: {
        path: string;
        id: string;
        description: string;
        done: boolean;
        skipped?: boolean | undefined;
      }[];
      unlocks: string[];
      context?: string | null | undefined;
      instruction?: string | null | undefined;
      rules?: string[] | null | undefined;
      references?: z.objectOutputType<{
        store_id: z.ZodString;
        root: z.ZodOptional<z.ZodString>;
        status: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
      } & {
        specs: z.ZodOptional<z.ZodArray<z.ZodObject<{
          id: z.ZodString;
          summary: z.ZodString;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          id: z.ZodString;
          summary: z.ZodString;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          id: z.ZodString;
          summary: z.ZodString;
        }, z.ZodTypeAny, "passthrough">>, "many">>;
        fetch: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">[] | undefined;
    };
    kind: "opsx-instructions";
  } | {
    value: {
      state: "ready" | "blocked" | "all_done";
      evidence: {
        success: boolean;
        stdout: string;
        stderr: string;
        exitCode: number | null;
        payload: CliJsonValue;
        diagnostics: z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">[];
        command: "instructions apply";
        selector: {
          store?: string | undefined;
        };
        root?: z.objectOutputType<{
          path: z.ZodString;
          source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
          store_id: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough"> | undefined;
        contractError?: string | undefined;
      } & {
        [k: string]: unknown;
      };
      changeName: string;
      schemaName: string;
      changeDir: string;
      instruction: string;
      contextFiles: Record<string, string[]>;
      tasks: {
        id: string;
        description: string;
        done: boolean;
      }[];
      applyInstructionProgress: {
        source: "openspec-instructions-apply";
        state: "ready" | "blocked" | "all_done";
        complete: number;
        total: number;
        remaining: number;
        divergence: {
          message: string;
          kind: "tracked-task-mismatch";
          apply: {
            complete: number;
            total: number;
            remaining: number;
          };
          tracked: {
            total: number;
            remaining: number;
            completed: number;
            phase: "no-tasks" | "complete" | "in-progress";
          };
        } | null;
      };
      context?: string | undefined;
      references?: z.objectOutputType<{
        store_id: z.ZodString;
        root: z.ZodOptional<z.ZodString>;
        status: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
      } & {
        specs: z.ZodOptional<z.ZodArray<z.ZodObject<{
          id: z.ZodString;
          summary: z.ZodString;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          id: z.ZodString;
          summary: z.ZodString;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          id: z.ZodString;
          summary: z.ZodString;
        }, z.ZodTypeAny, "passthrough">>, "many">>;
        fetch: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">[] | undefined;
      missingArtifacts?: string[] | undefined;
      operationGuidance?: string[] | undefined;
    };
    kind: "opsx-apply-instructions";
  } | {
    value: {
      evidence: {
        success: boolean;
        stdout: string;
        stderr: string;
        exitCode: number | null;
        payload: CliJsonValue;
        diagnostics: z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">[];
        command: "instructions archive";
        selector: {
          store?: string | undefined;
        };
        root?: z.objectOutputType<{
          path: z.ZodString;
          source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
          store_id: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough"> | undefined;
        contractError?: string | undefined;
      } & {
        [k: string]: unknown;
      };
      changeName: string;
      context?: string | undefined;
      operationGuidance?: string[] | undefined;
    };
    kind: "opsx-archive-instructions";
    rootGeneration: string;
  } | {
    value: {
      schemas: z.objectOutputType<{
        name: z.ZodString;
        description: z.ZodOptional<z.ZodString>;
        artifacts: z.ZodArray<z.ZodString, "many">;
        source: z.ZodEnum<["project", "user", "package"]>;
      }, z.ZodTypeAny, "passthrough">[];
      schemaDetails: Record<string, {
        name: string;
        applyRequires: string[];
        artifacts: {
          id: string;
          outputPath: string;
          requires: string[];
          description?: string | undefined;
          template?: string | undefined;
          instruction?: string | undefined;
        }[];
        version?: string | number | undefined;
        description?: string | undefined;
        applyTracks?: string | undefined;
        applyInstruction?: string | undefined;
      } | null>;
      schemaResolutions: Record<string, z.objectOutputType<{
        name: z.ZodString;
        source: z.ZodEnum<["project", "user", "package"]>;
        path: z.ZodString;
      } & {
        displayPath: z.ZodOptional<z.ZodString>;
        shadows: z.ZodArray<z.ZodObject<{
          source: z.ZodEnum<["project", "user", "package"]>;
          path: z.ZodString;
        } & {
          displayPath: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          source: z.ZodEnum<["project", "user", "package"]>;
          path: z.ZodString;
        } & {
          displayPath: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          source: z.ZodEnum<["project", "user", "package"]>;
          path: z.ZodString;
        } & {
          displayPath: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
      }, z.ZodTypeAny, "passthrough"> | null>;
    };
    kind: "opsx-config-bundle";
    evidence: {
      schemas: {
        success: boolean;
        stdout: string;
        stderr: string;
        exitCode: number | null;
        payload: CliJsonValue;
        diagnostics: z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">[];
        contractError?: string | undefined;
      };
      schemaResolutions: Record<string, {
        success: boolean;
        stdout: string;
        stderr: string;
        exitCode: number | null;
        payload: CliJsonValue;
        diagnostics: z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">[];
        contractError?: string | undefined;
      }>;
    };
  } | {
    value: Record<string, z.objectOutputType<{
      path: z.ZodString;
      source: z.ZodEnum<["project", "user", "package"]>;
    } & {
      displayPath: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">>;
    kind: "opsx-templates";
    evidence: {
      success: boolean;
      stdout: string;
      stderr: string;
      exitCode: number | null;
      payload: CliJsonValue;
      diagnostics: z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">[];
      contractError?: string | undefined;
    };
  } | {
    value: Record<string, {
      path: string;
      source: "project" | "user" | "package";
      content: string | null;
      displayPath?: string | undefined;
    }>;
    kind: "opsx-template-contents";
    evidence: {
      success: boolean;
      stdout: string;
      stderr: string;
      exitCode: number | null;
      payload: CliJsonValue;
      diagnostics: z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">[];
      contractError?: string | undefined;
    };
  } | {
    value: SpecCatalog;
    kind: "spec-catalog";
  } | {
    value: SpecDocumentProjection;
    kind: "spec-document";
  };
  freshness: "current";
  snapshotGeneration: number;
  identity: string;
  workGeneration: number;
  invalidationCause: "dependency" | "initial" | "explicit-refresh" | "subscriber-resume";
}, {
  error: null;
  state: "ready";
  data: {
    value: {
      changeName: string;
      schemaName: string;
      isPlanningComplete: boolean;
      applyRequires: string[];
      artifacts: {
        status: "ready" | "done" | "skipped" | "blocked";
        id: string;
        outputPath: string;
        requires: string[];
        missingDeps?: string[] | undefined;
        relativePath?: string | undefined;
      }[];
      provenance: {
        root: {
          path: string;
          source: "store" | "declared" | "nearest" | "global_default" | "implicit";
          store_id?: string | undefined;
        } & {
          [k: string]: unknown;
        };
        kind: "cli";
        evidence: {
          success: boolean;
          stdout: string;
          stderr: string;
          exitCode: number | null;
          payload: CliJsonValue;
          diagnostics: z.objectInputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">[];
          command: "status";
          selector: {
            store?: string | undefined;
          };
          root?: z.objectInputType<{
            path: z.ZodString;
            source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
            store_id: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough"> | undefined;
          contractError?: string | undefined;
        } & {
          [k: string]: unknown;
        };
        planningHome: {
          root: string;
          kind: "repo";
          changesDir: string;
          defaultSchema: string;
        } & {
          [k: string]: unknown;
        };
        changeRoot: string;
        artifactPaths: Record<string, z.objectInputType<{
          outputPath: z.ZodString;
          resolvedOutputPath: z.ZodString;
          existingOutputPaths: z.ZodArray<z.ZodString, "many">;
        }, z.ZodTypeAny, "passthrough">>;
        nextSteps: string[];
        actionContext: {
          mode: "repo-local";
          sourceOfTruth: "repo";
          planningArtifacts: string[];
          linkedContext: z.objectInputType<{
            name: z.ZodString;
          }, z.ZodTypeAny, "passthrough">[];
          allowedEditRoots: string[];
          requiresAffectedAreaSelection: boolean;
          constraints: string[];
        } & {
          [k: string]: unknown;
        };
      } | {
        kind: "static";
      };
    };
    kind: "opsx-status";
  } | {
    value: string[];
    entries: {
      status: "no-tasks" | "complete" | "in-progress";
      name: string;
      completedTasks: number;
      totalTasks: number;
      lastModified: string;
    }[];
    kind: "opsx-change-list";
    evidence: {
      success: boolean;
      stdout: string;
      stderr: string;
      exitCode: number | null;
      payload: CliJsonValue;
      diagnostics: z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">[];
      contractError?: string | undefined;
    };
  } | {
    value: {
      changeName: string;
      schemaName: string;
      isPlanningComplete: boolean;
      applyRequires: string[];
      artifacts: {
        status: "ready" | "done" | "skipped" | "blocked";
        id: string;
        outputPath: string;
        requires: string[];
        missingDeps?: string[] | undefined;
        relativePath?: string | undefined;
      }[];
      provenance: {
        root: {
          path: string;
          source: "store" | "declared" | "nearest" | "global_default" | "implicit";
          store_id?: string | undefined;
        } & {
          [k: string]: unknown;
        };
        kind: "cli";
        evidence: {
          success: boolean;
          stdout: string;
          stderr: string;
          exitCode: number | null;
          payload: CliJsonValue;
          diagnostics: z.objectInputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">[];
          command: "status";
          selector: {
            store?: string | undefined;
          };
          root?: z.objectInputType<{
            path: z.ZodString;
            source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
            store_id: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough"> | undefined;
          contractError?: string | undefined;
        } & {
          [k: string]: unknown;
        };
        planningHome: {
          root: string;
          kind: "repo";
          changesDir: string;
          defaultSchema: string;
        } & {
          [k: string]: unknown;
        };
        changeRoot: string;
        artifactPaths: Record<string, z.objectInputType<{
          outputPath: z.ZodString;
          resolvedOutputPath: z.ZodString;
          existingOutputPaths: z.ZodArray<z.ZodString, "many">;
        }, z.ZodTypeAny, "passthrough">>;
        nextSteps: string[];
        actionContext: {
          mode: "repo-local";
          sourceOfTruth: "repo";
          planningArtifacts: string[];
          linkedContext: z.objectInputType<{
            name: z.ZodString;
          }, z.ZodTypeAny, "passthrough">[];
          allowedEditRoots: string[];
          requiresAffectedAreaSelection: boolean;
          constraints: string[];
        } & {
          [k: string]: unknown;
        };
      } | {
        kind: "static";
      };
    }[];
    kind: "opsx-status-list";
    evidence: {
      success: boolean;
      stdout: string;
      stderr: string;
      exitCode: number | null;
      payload: CliJsonValue;
      diagnostics: z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">[];
      contractError?: string | undefined;
    };
  } | {
    value: {
      description: string;
      template: string;
      evidence: {
        success: boolean;
        stdout: string;
        stderr: string;
        exitCode: number | null;
        payload: CliJsonValue;
        diagnostics: z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">[];
        command: "instructions";
        selector: {
          store?: string | undefined;
        };
        root?: z.objectInputType<{
          path: z.ZodString;
          source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
          store_id: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough"> | undefined;
        contractError?: string | undefined;
      } & {
        [k: string]: unknown;
      };
      changeName: string;
      schemaName: string;
      outputPath: string;
      artifactId: string;
      changeDir: string;
      dependencies: {
        path: string;
        id: string;
        description: string;
        done: boolean;
        skipped?: boolean | undefined;
      }[];
      unlocks: string[];
      context?: string | null | undefined;
      instruction?: string | null | undefined;
      rules?: string[] | null | undefined;
      references?: z.objectInputType<{
        store_id: z.ZodString;
        root: z.ZodOptional<z.ZodString>;
        status: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
      } & {
        specs: z.ZodOptional<z.ZodArray<z.ZodObject<{
          id: z.ZodString;
          summary: z.ZodString;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          id: z.ZodString;
          summary: z.ZodString;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          id: z.ZodString;
          summary: z.ZodString;
        }, z.ZodTypeAny, "passthrough">>, "many">>;
        fetch: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">[] | undefined;
    };
    kind: "opsx-instructions";
  } | {
    value: {
      state: "ready" | "blocked" | "all_done";
      evidence: {
        success: boolean;
        stdout: string;
        stderr: string;
        exitCode: number | null;
        payload: CliJsonValue;
        diagnostics: z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">[];
        command: "instructions apply";
        selector: {
          store?: string | undefined;
        };
        root?: z.objectInputType<{
          path: z.ZodString;
          source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
          store_id: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough"> | undefined;
        contractError?: string | undefined;
      } & {
        [k: string]: unknown;
      };
      changeName: string;
      schemaName: string;
      changeDir: string;
      instruction: string;
      contextFiles: Record<string, string | string[]>;
      tasks: {
        id: string;
        description: string;
        done: boolean;
      }[];
      applyInstructionProgress: {
        source: "openspec-instructions-apply";
        state: "ready" | "blocked" | "all_done";
        complete: number;
        total: number;
        remaining: number;
        divergence: {
          message: string;
          kind: "tracked-task-mismatch";
          apply: {
            complete: number;
            total: number;
            remaining: number;
          };
          tracked: {
            total: number;
            remaining: number;
            completed: number;
            phase: "no-tasks" | "complete" | "in-progress";
          };
        } | null;
      };
      context?: string | undefined;
      references?: z.objectInputType<{
        store_id: z.ZodString;
        root: z.ZodOptional<z.ZodString>;
        status: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
      } & {
        specs: z.ZodOptional<z.ZodArray<z.ZodObject<{
          id: z.ZodString;
          summary: z.ZodString;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          id: z.ZodString;
          summary: z.ZodString;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          id: z.ZodString;
          summary: z.ZodString;
        }, z.ZodTypeAny, "passthrough">>, "many">>;
        fetch: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">[] | undefined;
      missingArtifacts?: string[] | undefined;
      operationGuidance?: string[] | undefined;
    };
    kind: "opsx-apply-instructions";
  } | {
    value: {
      evidence: {
        success: boolean;
        stdout: string;
        stderr: string;
        exitCode: number | null;
        payload: CliJsonValue;
        diagnostics: z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">[];
        command: "instructions archive";
        selector: {
          store?: string | undefined;
        };
        root?: z.objectInputType<{
          path: z.ZodString;
          source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
          store_id: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough"> | undefined;
        contractError?: string | undefined;
      } & {
        [k: string]: unknown;
      };
      changeName: string;
      context?: string | undefined;
      operationGuidance?: string[] | undefined;
    };
    kind: "opsx-archive-instructions";
    rootGeneration: string;
  } | {
    value: {
      schemas: z.objectInputType<{
        name: z.ZodString;
        description: z.ZodOptional<z.ZodString>;
        artifacts: z.ZodArray<z.ZodString, "many">;
        source: z.ZodEnum<["project", "user", "package"]>;
      }, z.ZodTypeAny, "passthrough">[];
      schemaDetails: Record<string, {
        name: string;
        applyRequires: string[];
        artifacts: {
          id: string;
          outputPath: string;
          requires: string[];
          description?: string | undefined;
          template?: string | undefined;
          instruction?: string | undefined;
        }[];
        version?: string | number | undefined;
        description?: string | undefined;
        applyTracks?: string | undefined;
        applyInstruction?: string | undefined;
      } | null>;
      schemaResolutions: Record<string, z.objectInputType<{
        name: z.ZodString;
        source: z.ZodEnum<["project", "user", "package"]>;
        path: z.ZodString;
      } & {
        displayPath: z.ZodOptional<z.ZodString>;
        shadows: z.ZodArray<z.ZodObject<{
          source: z.ZodEnum<["project", "user", "package"]>;
          path: z.ZodString;
        } & {
          displayPath: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          source: z.ZodEnum<["project", "user", "package"]>;
          path: z.ZodString;
        } & {
          displayPath: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          source: z.ZodEnum<["project", "user", "package"]>;
          path: z.ZodString;
        } & {
          displayPath: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
      }, z.ZodTypeAny, "passthrough"> | null>;
    };
    kind: "opsx-config-bundle";
    evidence: {
      schemas: {
        success: boolean;
        stdout: string;
        stderr: string;
        exitCode: number | null;
        payload: CliJsonValue;
        diagnostics: z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">[];
        contractError?: string | undefined;
      };
      schemaResolutions: Record<string, {
        success: boolean;
        stdout: string;
        stderr: string;
        exitCode: number | null;
        payload: CliJsonValue;
        diagnostics: z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">[];
        contractError?: string | undefined;
      }>;
    };
  } | {
    value: Record<string, z.objectInputType<{
      path: z.ZodString;
      source: z.ZodEnum<["project", "user", "package"]>;
    } & {
      displayPath: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">>;
    kind: "opsx-templates";
    evidence: {
      success: boolean;
      stdout: string;
      stderr: string;
      exitCode: number | null;
      payload: CliJsonValue;
      diagnostics: z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">[];
      contractError?: string | undefined;
    };
  } | {
    value: Record<string, {
      path: string;
      source: "project" | "user" | "package";
      content: string | null;
      displayPath?: string | undefined;
    }>;
    kind: "opsx-template-contents";
    evidence: {
      success: boolean;
      stdout: string;
      stderr: string;
      exitCode: number | null;
      payload: CliJsonValue;
      diagnostics: z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">[];
      contractError?: string | undefined;
    };
  } | {
    kind: "spec-catalog";
    value?: unknown;
  } | {
    kind: "spec-document";
    value?: unknown;
  };
  freshness: "current";
  snapshotGeneration: number;
  identity: string;
  workGeneration: number;
  invalidationCause: "dependency" | "initial" | "explicit-refresh" | "subscriber-resume";
}>, z.ZodObject<{
  state: z.ZodLiteral<"revalidating">;
  data: z.ZodType<{
    value: {
      changeName: string;
      schemaName: string;
      isPlanningComplete: boolean;
      applyRequires: string[];
      artifacts: {
        status: "ready" | "done" | "skipped" | "blocked";
        id: string;
        outputPath: string;
        requires: string[];
        missingDeps?: string[] | undefined;
        relativePath?: string | undefined;
      }[];
      provenance: {
        root: {
          path: string;
          source: "store" | "declared" | "nearest" | "global_default" | "implicit";
          store_id?: string | undefined;
        } & {
          [k: string]: unknown;
        };
        kind: "cli";
        evidence: {
          success: boolean;
          stdout: string;
          stderr: string;
          exitCode: number | null;
          payload: CliJsonValue;
          diagnostics: z.objectOutputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">[];
          command: "status";
          selector: {
            store?: string | undefined;
          };
          root?: z.objectOutputType<{
            path: z.ZodString;
            source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
            store_id: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough"> | undefined;
          contractError?: string | undefined;
        } & {
          [k: string]: unknown;
        };
        planningHome: {
          root: string;
          kind: "repo";
          changesDir: string;
          defaultSchema: string;
        } & {
          [k: string]: unknown;
        };
        changeRoot: string;
        artifactPaths: Record<string, z.objectOutputType<{
          outputPath: z.ZodString;
          resolvedOutputPath: z.ZodString;
          existingOutputPaths: z.ZodArray<z.ZodString, "many">;
        }, z.ZodTypeAny, "passthrough">>;
        nextSteps: string[];
        actionContext: {
          mode: "repo-local";
          sourceOfTruth: "repo";
          planningArtifacts: string[];
          linkedContext: z.objectOutputType<{
            name: z.ZodString;
          }, z.ZodTypeAny, "passthrough">[];
          allowedEditRoots: string[];
          requiresAffectedAreaSelection: boolean;
          constraints: string[];
        } & {
          [k: string]: unknown;
        };
      } | {
        kind: "static";
      };
    };
    kind: "opsx-status";
  } | {
    value: string[];
    entries: {
      status: "no-tasks" | "complete" | "in-progress";
      name: string;
      completedTasks: number;
      totalTasks: number;
      lastModified: string;
    }[];
    kind: "opsx-change-list";
    evidence: {
      success: boolean;
      stdout: string;
      stderr: string;
      exitCode: number | null;
      payload: CliJsonValue;
      diagnostics: z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">[];
      contractError?: string | undefined;
    };
  } | {
    value: {
      changeName: string;
      schemaName: string;
      isPlanningComplete: boolean;
      applyRequires: string[];
      artifacts: {
        status: "ready" | "done" | "skipped" | "blocked";
        id: string;
        outputPath: string;
        requires: string[];
        missingDeps?: string[] | undefined;
        relativePath?: string | undefined;
      }[];
      provenance: {
        root: {
          path: string;
          source: "store" | "declared" | "nearest" | "global_default" | "implicit";
          store_id?: string | undefined;
        } & {
          [k: string]: unknown;
        };
        kind: "cli";
        evidence: {
          success: boolean;
          stdout: string;
          stderr: string;
          exitCode: number | null;
          payload: CliJsonValue;
          diagnostics: z.objectOutputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">[];
          command: "status";
          selector: {
            store?: string | undefined;
          };
          root?: z.objectOutputType<{
            path: z.ZodString;
            source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
            store_id: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough"> | undefined;
          contractError?: string | undefined;
        } & {
          [k: string]: unknown;
        };
        planningHome: {
          root: string;
          kind: "repo";
          changesDir: string;
          defaultSchema: string;
        } & {
          [k: string]: unknown;
        };
        changeRoot: string;
        artifactPaths: Record<string, z.objectOutputType<{
          outputPath: z.ZodString;
          resolvedOutputPath: z.ZodString;
          existingOutputPaths: z.ZodArray<z.ZodString, "many">;
        }, z.ZodTypeAny, "passthrough">>;
        nextSteps: string[];
        actionContext: {
          mode: "repo-local";
          sourceOfTruth: "repo";
          planningArtifacts: string[];
          linkedContext: z.objectOutputType<{
            name: z.ZodString;
          }, z.ZodTypeAny, "passthrough">[];
          allowedEditRoots: string[];
          requiresAffectedAreaSelection: boolean;
          constraints: string[];
        } & {
          [k: string]: unknown;
        };
      } | {
        kind: "static";
      };
    }[];
    kind: "opsx-status-list";
    evidence: {
      success: boolean;
      stdout: string;
      stderr: string;
      exitCode: number | null;
      payload: CliJsonValue;
      diagnostics: z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">[];
      contractError?: string | undefined;
    };
  } | {
    value: {
      description: string;
      template: string;
      evidence: {
        success: boolean;
        stdout: string;
        stderr: string;
        exitCode: number | null;
        payload: CliJsonValue;
        diagnostics: z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">[];
        command: "instructions";
        selector: {
          store?: string | undefined;
        };
        root?: z.objectOutputType<{
          path: z.ZodString;
          source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
          store_id: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough"> | undefined;
        contractError?: string | undefined;
      } & {
        [k: string]: unknown;
      };
      changeName: string;
      schemaName: string;
      outputPath: string;
      artifactId: string;
      changeDir: string;
      dependencies: {
        path: string;
        id: string;
        description: string;
        done: boolean;
        skipped?: boolean | undefined;
      }[];
      unlocks: string[];
      context?: string | null | undefined;
      instruction?: string | null | undefined;
      rules?: string[] | null | undefined;
      references?: z.objectOutputType<{
        store_id: z.ZodString;
        root: z.ZodOptional<z.ZodString>;
        status: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
      } & {
        specs: z.ZodOptional<z.ZodArray<z.ZodObject<{
          id: z.ZodString;
          summary: z.ZodString;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          id: z.ZodString;
          summary: z.ZodString;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          id: z.ZodString;
          summary: z.ZodString;
        }, z.ZodTypeAny, "passthrough">>, "many">>;
        fetch: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">[] | undefined;
    };
    kind: "opsx-instructions";
  } | {
    value: {
      state: "ready" | "blocked" | "all_done";
      evidence: {
        success: boolean;
        stdout: string;
        stderr: string;
        exitCode: number | null;
        payload: CliJsonValue;
        diagnostics: z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">[];
        command: "instructions apply";
        selector: {
          store?: string | undefined;
        };
        root?: z.objectOutputType<{
          path: z.ZodString;
          source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
          store_id: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough"> | undefined;
        contractError?: string | undefined;
      } & {
        [k: string]: unknown;
      };
      changeName: string;
      schemaName: string;
      changeDir: string;
      instruction: string;
      contextFiles: Record<string, string[]>;
      tasks: {
        id: string;
        description: string;
        done: boolean;
      }[];
      applyInstructionProgress: {
        source: "openspec-instructions-apply";
        state: "ready" | "blocked" | "all_done";
        complete: number;
        total: number;
        remaining: number;
        divergence: {
          message: string;
          kind: "tracked-task-mismatch";
          apply: {
            complete: number;
            total: number;
            remaining: number;
          };
          tracked: {
            total: number;
            remaining: number;
            completed: number;
            phase: "no-tasks" | "complete" | "in-progress";
          };
        } | null;
      };
      context?: string | undefined;
      references?: z.objectOutputType<{
        store_id: z.ZodString;
        root: z.ZodOptional<z.ZodString>;
        status: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
      } & {
        specs: z.ZodOptional<z.ZodArray<z.ZodObject<{
          id: z.ZodString;
          summary: z.ZodString;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          id: z.ZodString;
          summary: z.ZodString;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          id: z.ZodString;
          summary: z.ZodString;
        }, z.ZodTypeAny, "passthrough">>, "many">>;
        fetch: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">[] | undefined;
      missingArtifacts?: string[] | undefined;
      operationGuidance?: string[] | undefined;
    };
    kind: "opsx-apply-instructions";
  } | {
    value: {
      evidence: {
        success: boolean;
        stdout: string;
        stderr: string;
        exitCode: number | null;
        payload: CliJsonValue;
        diagnostics: z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">[];
        command: "instructions archive";
        selector: {
          store?: string | undefined;
        };
        root?: z.objectOutputType<{
          path: z.ZodString;
          source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
          store_id: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough"> | undefined;
        contractError?: string | undefined;
      } & {
        [k: string]: unknown;
      };
      changeName: string;
      context?: string | undefined;
      operationGuidance?: string[] | undefined;
    };
    kind: "opsx-archive-instructions";
    rootGeneration: string;
  } | {
    value: {
      schemas: z.objectOutputType<{
        name: z.ZodString;
        description: z.ZodOptional<z.ZodString>;
        artifacts: z.ZodArray<z.ZodString, "many">;
        source: z.ZodEnum<["project", "user", "package"]>;
      }, z.ZodTypeAny, "passthrough">[];
      schemaDetails: Record<string, {
        name: string;
        applyRequires: string[];
        artifacts: {
          id: string;
          outputPath: string;
          requires: string[];
          description?: string | undefined;
          template?: string | undefined;
          instruction?: string | undefined;
        }[];
        version?: string | number | undefined;
        description?: string | undefined;
        applyTracks?: string | undefined;
        applyInstruction?: string | undefined;
      } | null>;
      schemaResolutions: Record<string, z.objectOutputType<{
        name: z.ZodString;
        source: z.ZodEnum<["project", "user", "package"]>;
        path: z.ZodString;
      } & {
        displayPath: z.ZodOptional<z.ZodString>;
        shadows: z.ZodArray<z.ZodObject<{
          source: z.ZodEnum<["project", "user", "package"]>;
          path: z.ZodString;
        } & {
          displayPath: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          source: z.ZodEnum<["project", "user", "package"]>;
          path: z.ZodString;
        } & {
          displayPath: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          source: z.ZodEnum<["project", "user", "package"]>;
          path: z.ZodString;
        } & {
          displayPath: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
      }, z.ZodTypeAny, "passthrough"> | null>;
    };
    kind: "opsx-config-bundle";
    evidence: {
      schemas: {
        success: boolean;
        stdout: string;
        stderr: string;
        exitCode: number | null;
        payload: CliJsonValue;
        diagnostics: z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">[];
        contractError?: string | undefined;
      };
      schemaResolutions: Record<string, {
        success: boolean;
        stdout: string;
        stderr: string;
        exitCode: number | null;
        payload: CliJsonValue;
        diagnostics: z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">[];
        contractError?: string | undefined;
      }>;
    };
  } | {
    value: Record<string, z.objectOutputType<{
      path: z.ZodString;
      source: z.ZodEnum<["project", "user", "package"]>;
    } & {
      displayPath: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">>;
    kind: "opsx-templates";
    evidence: {
      success: boolean;
      stdout: string;
      stderr: string;
      exitCode: number | null;
      payload: CliJsonValue;
      diagnostics: z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">[];
      contractError?: string | undefined;
    };
  } | {
    value: Record<string, {
      path: string;
      source: "project" | "user" | "package";
      content: string | null;
      displayPath?: string | undefined;
    }>;
    kind: "opsx-template-contents";
    evidence: {
      success: boolean;
      stdout: string;
      stderr: string;
      exitCode: number | null;
      payload: CliJsonValue;
      diagnostics: z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">[];
      contractError?: string | undefined;
    };
  } | {
    value: SpecCatalog;
    kind: "spec-catalog";
  } | {
    value: SpecDocumentProjection;
    kind: "spec-document";
  }, z.ZodTypeDef, {
    value: {
      changeName: string;
      schemaName: string;
      isPlanningComplete: boolean;
      applyRequires: string[];
      artifacts: {
        status: "ready" | "done" | "skipped" | "blocked";
        id: string;
        outputPath: string;
        requires: string[];
        missingDeps?: string[] | undefined;
        relativePath?: string | undefined;
      }[];
      provenance: {
        root: {
          path: string;
          source: "store" | "declared" | "nearest" | "global_default" | "implicit";
          store_id?: string | undefined;
        } & {
          [k: string]: unknown;
        };
        kind: "cli";
        evidence: {
          success: boolean;
          stdout: string;
          stderr: string;
          exitCode: number | null;
          payload: CliJsonValue;
          diagnostics: z.objectInputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">[];
          command: "status";
          selector: {
            store?: string | undefined;
          };
          root?: z.objectInputType<{
            path: z.ZodString;
            source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
            store_id: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough"> | undefined;
          contractError?: string | undefined;
        } & {
          [k: string]: unknown;
        };
        planningHome: {
          root: string;
          kind: "repo";
          changesDir: string;
          defaultSchema: string;
        } & {
          [k: string]: unknown;
        };
        changeRoot: string;
        artifactPaths: Record<string, z.objectInputType<{
          outputPath: z.ZodString;
          resolvedOutputPath: z.ZodString;
          existingOutputPaths: z.ZodArray<z.ZodString, "many">;
        }, z.ZodTypeAny, "passthrough">>;
        nextSteps: string[];
        actionContext: {
          mode: "repo-local";
          sourceOfTruth: "repo";
          planningArtifacts: string[];
          linkedContext: z.objectInputType<{
            name: z.ZodString;
          }, z.ZodTypeAny, "passthrough">[];
          allowedEditRoots: string[];
          requiresAffectedAreaSelection: boolean;
          constraints: string[];
        } & {
          [k: string]: unknown;
        };
      } | {
        kind: "static";
      };
    };
    kind: "opsx-status";
  } | {
    value: string[];
    entries: {
      status: "no-tasks" | "complete" | "in-progress";
      name: string;
      completedTasks: number;
      totalTasks: number;
      lastModified: string;
    }[];
    kind: "opsx-change-list";
    evidence: {
      success: boolean;
      stdout: string;
      stderr: string;
      exitCode: number | null;
      payload: CliJsonValue;
      diagnostics: z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">[];
      contractError?: string | undefined;
    };
  } | {
    value: {
      changeName: string;
      schemaName: string;
      isPlanningComplete: boolean;
      applyRequires: string[];
      artifacts: {
        status: "ready" | "done" | "skipped" | "blocked";
        id: string;
        outputPath: string;
        requires: string[];
        missingDeps?: string[] | undefined;
        relativePath?: string | undefined;
      }[];
      provenance: {
        root: {
          path: string;
          source: "store" | "declared" | "nearest" | "global_default" | "implicit";
          store_id?: string | undefined;
        } & {
          [k: string]: unknown;
        };
        kind: "cli";
        evidence: {
          success: boolean;
          stdout: string;
          stderr: string;
          exitCode: number | null;
          payload: CliJsonValue;
          diagnostics: z.objectInputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">[];
          command: "status";
          selector: {
            store?: string | undefined;
          };
          root?: z.objectInputType<{
            path: z.ZodString;
            source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
            store_id: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough"> | undefined;
          contractError?: string | undefined;
        } & {
          [k: string]: unknown;
        };
        planningHome: {
          root: string;
          kind: "repo";
          changesDir: string;
          defaultSchema: string;
        } & {
          [k: string]: unknown;
        };
        changeRoot: string;
        artifactPaths: Record<string, z.objectInputType<{
          outputPath: z.ZodString;
          resolvedOutputPath: z.ZodString;
          existingOutputPaths: z.ZodArray<z.ZodString, "many">;
        }, z.ZodTypeAny, "passthrough">>;
        nextSteps: string[];
        actionContext: {
          mode: "repo-local";
          sourceOfTruth: "repo";
          planningArtifacts: string[];
          linkedContext: z.objectInputType<{
            name: z.ZodString;
          }, z.ZodTypeAny, "passthrough">[];
          allowedEditRoots: string[];
          requiresAffectedAreaSelection: boolean;
          constraints: string[];
        } & {
          [k: string]: unknown;
        };
      } | {
        kind: "static";
      };
    }[];
    kind: "opsx-status-list";
    evidence: {
      success: boolean;
      stdout: string;
      stderr: string;
      exitCode: number | null;
      payload: CliJsonValue;
      diagnostics: z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">[];
      contractError?: string | undefined;
    };
  } | {
    value: {
      description: string;
      template: string;
      evidence: {
        success: boolean;
        stdout: string;
        stderr: string;
        exitCode: number | null;
        payload: CliJsonValue;
        diagnostics: z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">[];
        command: "instructions";
        selector: {
          store?: string | undefined;
        };
        root?: z.objectInputType<{
          path: z.ZodString;
          source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
          store_id: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough"> | undefined;
        contractError?: string | undefined;
      } & {
        [k: string]: unknown;
      };
      changeName: string;
      schemaName: string;
      outputPath: string;
      artifactId: string;
      changeDir: string;
      dependencies: {
        path: string;
        id: string;
        description: string;
        done: boolean;
        skipped?: boolean | undefined;
      }[];
      unlocks: string[];
      context?: string | null | undefined;
      instruction?: string | null | undefined;
      rules?: string[] | null | undefined;
      references?: z.objectInputType<{
        store_id: z.ZodString;
        root: z.ZodOptional<z.ZodString>;
        status: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
      } & {
        specs: z.ZodOptional<z.ZodArray<z.ZodObject<{
          id: z.ZodString;
          summary: z.ZodString;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          id: z.ZodString;
          summary: z.ZodString;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          id: z.ZodString;
          summary: z.ZodString;
        }, z.ZodTypeAny, "passthrough">>, "many">>;
        fetch: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">[] | undefined;
    };
    kind: "opsx-instructions";
  } | {
    value: {
      state: "ready" | "blocked" | "all_done";
      evidence: {
        success: boolean;
        stdout: string;
        stderr: string;
        exitCode: number | null;
        payload: CliJsonValue;
        diagnostics: z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">[];
        command: "instructions apply";
        selector: {
          store?: string | undefined;
        };
        root?: z.objectInputType<{
          path: z.ZodString;
          source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
          store_id: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough"> | undefined;
        contractError?: string | undefined;
      } & {
        [k: string]: unknown;
      };
      changeName: string;
      schemaName: string;
      changeDir: string;
      instruction: string;
      contextFiles: Record<string, string | string[]>;
      tasks: {
        id: string;
        description: string;
        done: boolean;
      }[];
      applyInstructionProgress: {
        source: "openspec-instructions-apply";
        state: "ready" | "blocked" | "all_done";
        complete: number;
        total: number;
        remaining: number;
        divergence: {
          message: string;
          kind: "tracked-task-mismatch";
          apply: {
            complete: number;
            total: number;
            remaining: number;
          };
          tracked: {
            total: number;
            remaining: number;
            completed: number;
            phase: "no-tasks" | "complete" | "in-progress";
          };
        } | null;
      };
      context?: string | undefined;
      references?: z.objectInputType<{
        store_id: z.ZodString;
        root: z.ZodOptional<z.ZodString>;
        status: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
      } & {
        specs: z.ZodOptional<z.ZodArray<z.ZodObject<{
          id: z.ZodString;
          summary: z.ZodString;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          id: z.ZodString;
          summary: z.ZodString;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          id: z.ZodString;
          summary: z.ZodString;
        }, z.ZodTypeAny, "passthrough">>, "many">>;
        fetch: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">[] | undefined;
      missingArtifacts?: string[] | undefined;
      operationGuidance?: string[] | undefined;
    };
    kind: "opsx-apply-instructions";
  } | {
    value: {
      evidence: {
        success: boolean;
        stdout: string;
        stderr: string;
        exitCode: number | null;
        payload: CliJsonValue;
        diagnostics: z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">[];
        command: "instructions archive";
        selector: {
          store?: string | undefined;
        };
        root?: z.objectInputType<{
          path: z.ZodString;
          source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
          store_id: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough"> | undefined;
        contractError?: string | undefined;
      } & {
        [k: string]: unknown;
      };
      changeName: string;
      context?: string | undefined;
      operationGuidance?: string[] | undefined;
    };
    kind: "opsx-archive-instructions";
    rootGeneration: string;
  } | {
    value: {
      schemas: z.objectInputType<{
        name: z.ZodString;
        description: z.ZodOptional<z.ZodString>;
        artifacts: z.ZodArray<z.ZodString, "many">;
        source: z.ZodEnum<["project", "user", "package"]>;
      }, z.ZodTypeAny, "passthrough">[];
      schemaDetails: Record<string, {
        name: string;
        applyRequires: string[];
        artifacts: {
          id: string;
          outputPath: string;
          requires: string[];
          description?: string | undefined;
          template?: string | undefined;
          instruction?: string | undefined;
        }[];
        version?: string | number | undefined;
        description?: string | undefined;
        applyTracks?: string | undefined;
        applyInstruction?: string | undefined;
      } | null>;
      schemaResolutions: Record<string, z.objectInputType<{
        name: z.ZodString;
        source: z.ZodEnum<["project", "user", "package"]>;
        path: z.ZodString;
      } & {
        displayPath: z.ZodOptional<z.ZodString>;
        shadows: z.ZodArray<z.ZodObject<{
          source: z.ZodEnum<["project", "user", "package"]>;
          path: z.ZodString;
        } & {
          displayPath: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          source: z.ZodEnum<["project", "user", "package"]>;
          path: z.ZodString;
        } & {
          displayPath: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          source: z.ZodEnum<["project", "user", "package"]>;
          path: z.ZodString;
        } & {
          displayPath: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
      }, z.ZodTypeAny, "passthrough"> | null>;
    };
    kind: "opsx-config-bundle";
    evidence: {
      schemas: {
        success: boolean;
        stdout: string;
        stderr: string;
        exitCode: number | null;
        payload: CliJsonValue;
        diagnostics: z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">[];
        contractError?: string | undefined;
      };
      schemaResolutions: Record<string, {
        success: boolean;
        stdout: string;
        stderr: string;
        exitCode: number | null;
        payload: CliJsonValue;
        diagnostics: z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">[];
        contractError?: string | undefined;
      }>;
    };
  } | {
    value: Record<string, z.objectInputType<{
      path: z.ZodString;
      source: z.ZodEnum<["project", "user", "package"]>;
    } & {
      displayPath: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">>;
    kind: "opsx-templates";
    evidence: {
      success: boolean;
      stdout: string;
      stderr: string;
      exitCode: number | null;
      payload: CliJsonValue;
      diagnostics: z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">[];
      contractError?: string | undefined;
    };
  } | {
    value: Record<string, {
      path: string;
      source: "project" | "user" | "package";
      content: string | null;
      displayPath?: string | undefined;
    }>;
    kind: "opsx-template-contents";
    evidence: {
      success: boolean;
      stdout: string;
      stderr: string;
      exitCode: number | null;
      payload: CliJsonValue;
      diagnostics: z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">[];
      contractError?: string | undefined;
    };
  } | {
    kind: "spec-catalog";
    value?: unknown;
  } | {
    kind: "spec-document";
    value?: unknown;
  }>;
  freshness: z.ZodLiteral<"stale-display-only">;
  snapshotGeneration: z.ZodNumber;
  error: z.ZodNull;
  identity: z.ZodString;
  workGeneration: z.ZodNumber;
  invalidationCause: z.ZodEnum<["initial", "dependency", "explicit-refresh", "subscriber-resume"]>;
}, "strip", z.ZodTypeAny, {
  error: null;
  state: "revalidating";
  data: {
    value: {
      changeName: string;
      schemaName: string;
      isPlanningComplete: boolean;
      applyRequires: string[];
      artifacts: {
        status: "ready" | "done" | "skipped" | "blocked";
        id: string;
        outputPath: string;
        requires: string[];
        missingDeps?: string[] | undefined;
        relativePath?: string | undefined;
      }[];
      provenance: {
        root: {
          path: string;
          source: "store" | "declared" | "nearest" | "global_default" | "implicit";
          store_id?: string | undefined;
        } & {
          [k: string]: unknown;
        };
        kind: "cli";
        evidence: {
          success: boolean;
          stdout: string;
          stderr: string;
          exitCode: number | null;
          payload: CliJsonValue;
          diagnostics: z.objectOutputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">[];
          command: "status";
          selector: {
            store?: string | undefined;
          };
          root?: z.objectOutputType<{
            path: z.ZodString;
            source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
            store_id: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough"> | undefined;
          contractError?: string | undefined;
        } & {
          [k: string]: unknown;
        };
        planningHome: {
          root: string;
          kind: "repo";
          changesDir: string;
          defaultSchema: string;
        } & {
          [k: string]: unknown;
        };
        changeRoot: string;
        artifactPaths: Record<string, z.objectOutputType<{
          outputPath: z.ZodString;
          resolvedOutputPath: z.ZodString;
          existingOutputPaths: z.ZodArray<z.ZodString, "many">;
        }, z.ZodTypeAny, "passthrough">>;
        nextSteps: string[];
        actionContext: {
          mode: "repo-local";
          sourceOfTruth: "repo";
          planningArtifacts: string[];
          linkedContext: z.objectOutputType<{
            name: z.ZodString;
          }, z.ZodTypeAny, "passthrough">[];
          allowedEditRoots: string[];
          requiresAffectedAreaSelection: boolean;
          constraints: string[];
        } & {
          [k: string]: unknown;
        };
      } | {
        kind: "static";
      };
    };
    kind: "opsx-status";
  } | {
    value: string[];
    entries: {
      status: "no-tasks" | "complete" | "in-progress";
      name: string;
      completedTasks: number;
      totalTasks: number;
      lastModified: string;
    }[];
    kind: "opsx-change-list";
    evidence: {
      success: boolean;
      stdout: string;
      stderr: string;
      exitCode: number | null;
      payload: CliJsonValue;
      diagnostics: z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">[];
      contractError?: string | undefined;
    };
  } | {
    value: {
      changeName: string;
      schemaName: string;
      isPlanningComplete: boolean;
      applyRequires: string[];
      artifacts: {
        status: "ready" | "done" | "skipped" | "blocked";
        id: string;
        outputPath: string;
        requires: string[];
        missingDeps?: string[] | undefined;
        relativePath?: string | undefined;
      }[];
      provenance: {
        root: {
          path: string;
          source: "store" | "declared" | "nearest" | "global_default" | "implicit";
          store_id?: string | undefined;
        } & {
          [k: string]: unknown;
        };
        kind: "cli";
        evidence: {
          success: boolean;
          stdout: string;
          stderr: string;
          exitCode: number | null;
          payload: CliJsonValue;
          diagnostics: z.objectOutputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">[];
          command: "status";
          selector: {
            store?: string | undefined;
          };
          root?: z.objectOutputType<{
            path: z.ZodString;
            source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
            store_id: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough"> | undefined;
          contractError?: string | undefined;
        } & {
          [k: string]: unknown;
        };
        planningHome: {
          root: string;
          kind: "repo";
          changesDir: string;
          defaultSchema: string;
        } & {
          [k: string]: unknown;
        };
        changeRoot: string;
        artifactPaths: Record<string, z.objectOutputType<{
          outputPath: z.ZodString;
          resolvedOutputPath: z.ZodString;
          existingOutputPaths: z.ZodArray<z.ZodString, "many">;
        }, z.ZodTypeAny, "passthrough">>;
        nextSteps: string[];
        actionContext: {
          mode: "repo-local";
          sourceOfTruth: "repo";
          planningArtifacts: string[];
          linkedContext: z.objectOutputType<{
            name: z.ZodString;
          }, z.ZodTypeAny, "passthrough">[];
          allowedEditRoots: string[];
          requiresAffectedAreaSelection: boolean;
          constraints: string[];
        } & {
          [k: string]: unknown;
        };
      } | {
        kind: "static";
      };
    }[];
    kind: "opsx-status-list";
    evidence: {
      success: boolean;
      stdout: string;
      stderr: string;
      exitCode: number | null;
      payload: CliJsonValue;
      diagnostics: z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">[];
      contractError?: string | undefined;
    };
  } | {
    value: {
      description: string;
      template: string;
      evidence: {
        success: boolean;
        stdout: string;
        stderr: string;
        exitCode: number | null;
        payload: CliJsonValue;
        diagnostics: z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">[];
        command: "instructions";
        selector: {
          store?: string | undefined;
        };
        root?: z.objectOutputType<{
          path: z.ZodString;
          source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
          store_id: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough"> | undefined;
        contractError?: string | undefined;
      } & {
        [k: string]: unknown;
      };
      changeName: string;
      schemaName: string;
      outputPath: string;
      artifactId: string;
      changeDir: string;
      dependencies: {
        path: string;
        id: string;
        description: string;
        done: boolean;
        skipped?: boolean | undefined;
      }[];
      unlocks: string[];
      context?: string | null | undefined;
      instruction?: string | null | undefined;
      rules?: string[] | null | undefined;
      references?: z.objectOutputType<{
        store_id: z.ZodString;
        root: z.ZodOptional<z.ZodString>;
        status: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
      } & {
        specs: z.ZodOptional<z.ZodArray<z.ZodObject<{
          id: z.ZodString;
          summary: z.ZodString;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          id: z.ZodString;
          summary: z.ZodString;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          id: z.ZodString;
          summary: z.ZodString;
        }, z.ZodTypeAny, "passthrough">>, "many">>;
        fetch: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">[] | undefined;
    };
    kind: "opsx-instructions";
  } | {
    value: {
      state: "ready" | "blocked" | "all_done";
      evidence: {
        success: boolean;
        stdout: string;
        stderr: string;
        exitCode: number | null;
        payload: CliJsonValue;
        diagnostics: z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">[];
        command: "instructions apply";
        selector: {
          store?: string | undefined;
        };
        root?: z.objectOutputType<{
          path: z.ZodString;
          source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
          store_id: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough"> | undefined;
        contractError?: string | undefined;
      } & {
        [k: string]: unknown;
      };
      changeName: string;
      schemaName: string;
      changeDir: string;
      instruction: string;
      contextFiles: Record<string, string[]>;
      tasks: {
        id: string;
        description: string;
        done: boolean;
      }[];
      applyInstructionProgress: {
        source: "openspec-instructions-apply";
        state: "ready" | "blocked" | "all_done";
        complete: number;
        total: number;
        remaining: number;
        divergence: {
          message: string;
          kind: "tracked-task-mismatch";
          apply: {
            complete: number;
            total: number;
            remaining: number;
          };
          tracked: {
            total: number;
            remaining: number;
            completed: number;
            phase: "no-tasks" | "complete" | "in-progress";
          };
        } | null;
      };
      context?: string | undefined;
      references?: z.objectOutputType<{
        store_id: z.ZodString;
        root: z.ZodOptional<z.ZodString>;
        status: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
      } & {
        specs: z.ZodOptional<z.ZodArray<z.ZodObject<{
          id: z.ZodString;
          summary: z.ZodString;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          id: z.ZodString;
          summary: z.ZodString;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          id: z.ZodString;
          summary: z.ZodString;
        }, z.ZodTypeAny, "passthrough">>, "many">>;
        fetch: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">[] | undefined;
      missingArtifacts?: string[] | undefined;
      operationGuidance?: string[] | undefined;
    };
    kind: "opsx-apply-instructions";
  } | {
    value: {
      evidence: {
        success: boolean;
        stdout: string;
        stderr: string;
        exitCode: number | null;
        payload: CliJsonValue;
        diagnostics: z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">[];
        command: "instructions archive";
        selector: {
          store?: string | undefined;
        };
        root?: z.objectOutputType<{
          path: z.ZodString;
          source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
          store_id: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough"> | undefined;
        contractError?: string | undefined;
      } & {
        [k: string]: unknown;
      };
      changeName: string;
      context?: string | undefined;
      operationGuidance?: string[] | undefined;
    };
    kind: "opsx-archive-instructions";
    rootGeneration: string;
  } | {
    value: {
      schemas: z.objectOutputType<{
        name: z.ZodString;
        description: z.ZodOptional<z.ZodString>;
        artifacts: z.ZodArray<z.ZodString, "many">;
        source: z.ZodEnum<["project", "user", "package"]>;
      }, z.ZodTypeAny, "passthrough">[];
      schemaDetails: Record<string, {
        name: string;
        applyRequires: string[];
        artifacts: {
          id: string;
          outputPath: string;
          requires: string[];
          description?: string | undefined;
          template?: string | undefined;
          instruction?: string | undefined;
        }[];
        version?: string | number | undefined;
        description?: string | undefined;
        applyTracks?: string | undefined;
        applyInstruction?: string | undefined;
      } | null>;
      schemaResolutions: Record<string, z.objectOutputType<{
        name: z.ZodString;
        source: z.ZodEnum<["project", "user", "package"]>;
        path: z.ZodString;
      } & {
        displayPath: z.ZodOptional<z.ZodString>;
        shadows: z.ZodArray<z.ZodObject<{
          source: z.ZodEnum<["project", "user", "package"]>;
          path: z.ZodString;
        } & {
          displayPath: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          source: z.ZodEnum<["project", "user", "package"]>;
          path: z.ZodString;
        } & {
          displayPath: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          source: z.ZodEnum<["project", "user", "package"]>;
          path: z.ZodString;
        } & {
          displayPath: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
      }, z.ZodTypeAny, "passthrough"> | null>;
    };
    kind: "opsx-config-bundle";
    evidence: {
      schemas: {
        success: boolean;
        stdout: string;
        stderr: string;
        exitCode: number | null;
        payload: CliJsonValue;
        diagnostics: z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">[];
        contractError?: string | undefined;
      };
      schemaResolutions: Record<string, {
        success: boolean;
        stdout: string;
        stderr: string;
        exitCode: number | null;
        payload: CliJsonValue;
        diagnostics: z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">[];
        contractError?: string | undefined;
      }>;
    };
  } | {
    value: Record<string, z.objectOutputType<{
      path: z.ZodString;
      source: z.ZodEnum<["project", "user", "package"]>;
    } & {
      displayPath: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">>;
    kind: "opsx-templates";
    evidence: {
      success: boolean;
      stdout: string;
      stderr: string;
      exitCode: number | null;
      payload: CliJsonValue;
      diagnostics: z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">[];
      contractError?: string | undefined;
    };
  } | {
    value: Record<string, {
      path: string;
      source: "project" | "user" | "package";
      content: string | null;
      displayPath?: string | undefined;
    }>;
    kind: "opsx-template-contents";
    evidence: {
      success: boolean;
      stdout: string;
      stderr: string;
      exitCode: number | null;
      payload: CliJsonValue;
      diagnostics: z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">[];
      contractError?: string | undefined;
    };
  } | {
    value: SpecCatalog;
    kind: "spec-catalog";
  } | {
    value: SpecDocumentProjection;
    kind: "spec-document";
  };
  freshness: "stale-display-only";
  snapshotGeneration: number;
  identity: string;
  workGeneration: number;
  invalidationCause: "dependency" | "initial" | "explicit-refresh" | "subscriber-resume";
}, {
  error: null;
  state: "revalidating";
  data: {
    value: {
      changeName: string;
      schemaName: string;
      isPlanningComplete: boolean;
      applyRequires: string[];
      artifacts: {
        status: "ready" | "done" | "skipped" | "blocked";
        id: string;
        outputPath: string;
        requires: string[];
        missingDeps?: string[] | undefined;
        relativePath?: string | undefined;
      }[];
      provenance: {
        root: {
          path: string;
          source: "store" | "declared" | "nearest" | "global_default" | "implicit";
          store_id?: string | undefined;
        } & {
          [k: string]: unknown;
        };
        kind: "cli";
        evidence: {
          success: boolean;
          stdout: string;
          stderr: string;
          exitCode: number | null;
          payload: CliJsonValue;
          diagnostics: z.objectInputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">[];
          command: "status";
          selector: {
            store?: string | undefined;
          };
          root?: z.objectInputType<{
            path: z.ZodString;
            source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
            store_id: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough"> | undefined;
          contractError?: string | undefined;
        } & {
          [k: string]: unknown;
        };
        planningHome: {
          root: string;
          kind: "repo";
          changesDir: string;
          defaultSchema: string;
        } & {
          [k: string]: unknown;
        };
        changeRoot: string;
        artifactPaths: Record<string, z.objectInputType<{
          outputPath: z.ZodString;
          resolvedOutputPath: z.ZodString;
          existingOutputPaths: z.ZodArray<z.ZodString, "many">;
        }, z.ZodTypeAny, "passthrough">>;
        nextSteps: string[];
        actionContext: {
          mode: "repo-local";
          sourceOfTruth: "repo";
          planningArtifacts: string[];
          linkedContext: z.objectInputType<{
            name: z.ZodString;
          }, z.ZodTypeAny, "passthrough">[];
          allowedEditRoots: string[];
          requiresAffectedAreaSelection: boolean;
          constraints: string[];
        } & {
          [k: string]: unknown;
        };
      } | {
        kind: "static";
      };
    };
    kind: "opsx-status";
  } | {
    value: string[];
    entries: {
      status: "no-tasks" | "complete" | "in-progress";
      name: string;
      completedTasks: number;
      totalTasks: number;
      lastModified: string;
    }[];
    kind: "opsx-change-list";
    evidence: {
      success: boolean;
      stdout: string;
      stderr: string;
      exitCode: number | null;
      payload: CliJsonValue;
      diagnostics: z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">[];
      contractError?: string | undefined;
    };
  } | {
    value: {
      changeName: string;
      schemaName: string;
      isPlanningComplete: boolean;
      applyRequires: string[];
      artifacts: {
        status: "ready" | "done" | "skipped" | "blocked";
        id: string;
        outputPath: string;
        requires: string[];
        missingDeps?: string[] | undefined;
        relativePath?: string | undefined;
      }[];
      provenance: {
        root: {
          path: string;
          source: "store" | "declared" | "nearest" | "global_default" | "implicit";
          store_id?: string | undefined;
        } & {
          [k: string]: unknown;
        };
        kind: "cli";
        evidence: {
          success: boolean;
          stdout: string;
          stderr: string;
          exitCode: number | null;
          payload: CliJsonValue;
          diagnostics: z.objectInputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">[];
          command: "status";
          selector: {
            store?: string | undefined;
          };
          root?: z.objectInputType<{
            path: z.ZodString;
            source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
            store_id: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough"> | undefined;
          contractError?: string | undefined;
        } & {
          [k: string]: unknown;
        };
        planningHome: {
          root: string;
          kind: "repo";
          changesDir: string;
          defaultSchema: string;
        } & {
          [k: string]: unknown;
        };
        changeRoot: string;
        artifactPaths: Record<string, z.objectInputType<{
          outputPath: z.ZodString;
          resolvedOutputPath: z.ZodString;
          existingOutputPaths: z.ZodArray<z.ZodString, "many">;
        }, z.ZodTypeAny, "passthrough">>;
        nextSteps: string[];
        actionContext: {
          mode: "repo-local";
          sourceOfTruth: "repo";
          planningArtifacts: string[];
          linkedContext: z.objectInputType<{
            name: z.ZodString;
          }, z.ZodTypeAny, "passthrough">[];
          allowedEditRoots: string[];
          requiresAffectedAreaSelection: boolean;
          constraints: string[];
        } & {
          [k: string]: unknown;
        };
      } | {
        kind: "static";
      };
    }[];
    kind: "opsx-status-list";
    evidence: {
      success: boolean;
      stdout: string;
      stderr: string;
      exitCode: number | null;
      payload: CliJsonValue;
      diagnostics: z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">[];
      contractError?: string | undefined;
    };
  } | {
    value: {
      description: string;
      template: string;
      evidence: {
        success: boolean;
        stdout: string;
        stderr: string;
        exitCode: number | null;
        payload: CliJsonValue;
        diagnostics: z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">[];
        command: "instructions";
        selector: {
          store?: string | undefined;
        };
        root?: z.objectInputType<{
          path: z.ZodString;
          source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
          store_id: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough"> | undefined;
        contractError?: string | undefined;
      } & {
        [k: string]: unknown;
      };
      changeName: string;
      schemaName: string;
      outputPath: string;
      artifactId: string;
      changeDir: string;
      dependencies: {
        path: string;
        id: string;
        description: string;
        done: boolean;
        skipped?: boolean | undefined;
      }[];
      unlocks: string[];
      context?: string | null | undefined;
      instruction?: string | null | undefined;
      rules?: string[] | null | undefined;
      references?: z.objectInputType<{
        store_id: z.ZodString;
        root: z.ZodOptional<z.ZodString>;
        status: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
      } & {
        specs: z.ZodOptional<z.ZodArray<z.ZodObject<{
          id: z.ZodString;
          summary: z.ZodString;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          id: z.ZodString;
          summary: z.ZodString;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          id: z.ZodString;
          summary: z.ZodString;
        }, z.ZodTypeAny, "passthrough">>, "many">>;
        fetch: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">[] | undefined;
    };
    kind: "opsx-instructions";
  } | {
    value: {
      state: "ready" | "blocked" | "all_done";
      evidence: {
        success: boolean;
        stdout: string;
        stderr: string;
        exitCode: number | null;
        payload: CliJsonValue;
        diagnostics: z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">[];
        command: "instructions apply";
        selector: {
          store?: string | undefined;
        };
        root?: z.objectInputType<{
          path: z.ZodString;
          source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
          store_id: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough"> | undefined;
        contractError?: string | undefined;
      } & {
        [k: string]: unknown;
      };
      changeName: string;
      schemaName: string;
      changeDir: string;
      instruction: string;
      contextFiles: Record<string, string | string[]>;
      tasks: {
        id: string;
        description: string;
        done: boolean;
      }[];
      applyInstructionProgress: {
        source: "openspec-instructions-apply";
        state: "ready" | "blocked" | "all_done";
        complete: number;
        total: number;
        remaining: number;
        divergence: {
          message: string;
          kind: "tracked-task-mismatch";
          apply: {
            complete: number;
            total: number;
            remaining: number;
          };
          tracked: {
            total: number;
            remaining: number;
            completed: number;
            phase: "no-tasks" | "complete" | "in-progress";
          };
        } | null;
      };
      context?: string | undefined;
      references?: z.objectInputType<{
        store_id: z.ZodString;
        root: z.ZodOptional<z.ZodString>;
        status: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
      } & {
        specs: z.ZodOptional<z.ZodArray<z.ZodObject<{
          id: z.ZodString;
          summary: z.ZodString;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          id: z.ZodString;
          summary: z.ZodString;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          id: z.ZodString;
          summary: z.ZodString;
        }, z.ZodTypeAny, "passthrough">>, "many">>;
        fetch: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">[] | undefined;
      missingArtifacts?: string[] | undefined;
      operationGuidance?: string[] | undefined;
    };
    kind: "opsx-apply-instructions";
  } | {
    value: {
      evidence: {
        success: boolean;
        stdout: string;
        stderr: string;
        exitCode: number | null;
        payload: CliJsonValue;
        diagnostics: z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">[];
        command: "instructions archive";
        selector: {
          store?: string | undefined;
        };
        root?: z.objectInputType<{
          path: z.ZodString;
          source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
          store_id: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough"> | undefined;
        contractError?: string | undefined;
      } & {
        [k: string]: unknown;
      };
      changeName: string;
      context?: string | undefined;
      operationGuidance?: string[] | undefined;
    };
    kind: "opsx-archive-instructions";
    rootGeneration: string;
  } | {
    value: {
      schemas: z.objectInputType<{
        name: z.ZodString;
        description: z.ZodOptional<z.ZodString>;
        artifacts: z.ZodArray<z.ZodString, "many">;
        source: z.ZodEnum<["project", "user", "package"]>;
      }, z.ZodTypeAny, "passthrough">[];
      schemaDetails: Record<string, {
        name: string;
        applyRequires: string[];
        artifacts: {
          id: string;
          outputPath: string;
          requires: string[];
          description?: string | undefined;
          template?: string | undefined;
          instruction?: string | undefined;
        }[];
        version?: string | number | undefined;
        description?: string | undefined;
        applyTracks?: string | undefined;
        applyInstruction?: string | undefined;
      } | null>;
      schemaResolutions: Record<string, z.objectInputType<{
        name: z.ZodString;
        source: z.ZodEnum<["project", "user", "package"]>;
        path: z.ZodString;
      } & {
        displayPath: z.ZodOptional<z.ZodString>;
        shadows: z.ZodArray<z.ZodObject<{
          source: z.ZodEnum<["project", "user", "package"]>;
          path: z.ZodString;
        } & {
          displayPath: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          source: z.ZodEnum<["project", "user", "package"]>;
          path: z.ZodString;
        } & {
          displayPath: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          source: z.ZodEnum<["project", "user", "package"]>;
          path: z.ZodString;
        } & {
          displayPath: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
      }, z.ZodTypeAny, "passthrough"> | null>;
    };
    kind: "opsx-config-bundle";
    evidence: {
      schemas: {
        success: boolean;
        stdout: string;
        stderr: string;
        exitCode: number | null;
        payload: CliJsonValue;
        diagnostics: z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">[];
        contractError?: string | undefined;
      };
      schemaResolutions: Record<string, {
        success: boolean;
        stdout: string;
        stderr: string;
        exitCode: number | null;
        payload: CliJsonValue;
        diagnostics: z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">[];
        contractError?: string | undefined;
      }>;
    };
  } | {
    value: Record<string, z.objectInputType<{
      path: z.ZodString;
      source: z.ZodEnum<["project", "user", "package"]>;
    } & {
      displayPath: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">>;
    kind: "opsx-templates";
    evidence: {
      success: boolean;
      stdout: string;
      stderr: string;
      exitCode: number | null;
      payload: CliJsonValue;
      diagnostics: z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">[];
      contractError?: string | undefined;
    };
  } | {
    value: Record<string, {
      path: string;
      source: "project" | "user" | "package";
      content: string | null;
      displayPath?: string | undefined;
    }>;
    kind: "opsx-template-contents";
    evidence: {
      success: boolean;
      stdout: string;
      stderr: string;
      exitCode: number | null;
      payload: CliJsonValue;
      diagnostics: z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">[];
      contractError?: string | undefined;
    };
  } | {
    kind: "spec-catalog";
    value?: unknown;
  } | {
    kind: "spec-document";
    value?: unknown;
  };
  freshness: "stale-display-only";
  snapshotGeneration: number;
  identity: string;
  workGeneration: number;
  invalidationCause: "dependency" | "initial" | "explicit-refresh" | "subscriber-resume";
}>, z.ZodObject<{
  state: z.ZodLiteral<"error">;
  data: z.ZodNull;
  freshness: z.ZodNull;
  snapshotGeneration: z.ZodNull;
  error: z.ZodObject<{
    name: z.ZodString;
    message: z.ZodString;
    cliEvidence: z.ZodNullable<z.ZodObject<{
      success: z.ZodBoolean;
      stdout: z.ZodString;
      stderr: z.ZodString;
      exitCode: z.ZodNullable<z.ZodNumber>;
      payload: z.ZodNullable<z.ZodType<CliJsonValue, z.ZodTypeDef, CliJsonValue>>;
      diagnostics: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
      contractError: z.ZodOptional<z.ZodString>;
    }, "strip", z.ZodTypeAny, {
      success: boolean;
      stdout: string;
      stderr: string;
      exitCode: number | null;
      payload: CliJsonValue;
      diagnostics: z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">[];
      contractError?: string | undefined;
    }, {
      success: boolean;
      stdout: string;
      stderr: string;
      exitCode: number | null;
      payload: CliJsonValue;
      diagnostics: z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">[];
      contractError?: string | undefined;
    }>>;
  }, "strip", z.ZodTypeAny, {
    message: string;
    name: string;
    cliEvidence: {
      success: boolean;
      stdout: string;
      stderr: string;
      exitCode: number | null;
      payload: CliJsonValue;
      diagnostics: z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">[];
      contractError?: string | undefined;
    } | null;
  }, {
    message: string;
    name: string;
    cliEvidence: {
      success: boolean;
      stdout: string;
      stderr: string;
      exitCode: number | null;
      payload: CliJsonValue;
      diagnostics: z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">[];
      contractError?: string | undefined;
    } | null;
  }>;
  identity: z.ZodString;
  workGeneration: z.ZodNumber;
  invalidationCause: z.ZodEnum<["initial", "dependency", "explicit-refresh", "subscriber-resume"]>;
}, "strip", z.ZodTypeAny, {
  error: {
    message: string;
    name: string;
    cliEvidence: {
      success: boolean;
      stdout: string;
      stderr: string;
      exitCode: number | null;
      payload: CliJsonValue;
      diagnostics: z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">[];
      contractError?: string | undefined;
    } | null;
  };
  state: "error";
  data: null;
  freshness: null;
  snapshotGeneration: null;
  identity: string;
  workGeneration: number;
  invalidationCause: "dependency" | "initial" | "explicit-refresh" | "subscriber-resume";
}, {
  error: {
    message: string;
    name: string;
    cliEvidence: {
      success: boolean;
      stdout: string;
      stderr: string;
      exitCode: number | null;
      payload: CliJsonValue;
      diagnostics: z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">[];
      contractError?: string | undefined;
    } | null;
  };
  state: "error";
  data: null;
  freshness: null;
  snapshotGeneration: null;
  identity: string;
  workGeneration: number;
  invalidationCause: "dependency" | "initial" | "explicit-refresh" | "subscriber-resume";
}>, z.ZodObject<{
  state: z.ZodLiteral<"refresh-error">;
  data: z.ZodType<{
    value: {
      changeName: string;
      schemaName: string;
      isPlanningComplete: boolean;
      applyRequires: string[];
      artifacts: {
        status: "ready" | "done" | "skipped" | "blocked";
        id: string;
        outputPath: string;
        requires: string[];
        missingDeps?: string[] | undefined;
        relativePath?: string | undefined;
      }[];
      provenance: {
        root: {
          path: string;
          source: "store" | "declared" | "nearest" | "global_default" | "implicit";
          store_id?: string | undefined;
        } & {
          [k: string]: unknown;
        };
        kind: "cli";
        evidence: {
          success: boolean;
          stdout: string;
          stderr: string;
          exitCode: number | null;
          payload: CliJsonValue;
          diagnostics: z.objectOutputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">[];
          command: "status";
          selector: {
            store?: string | undefined;
          };
          root?: z.objectOutputType<{
            path: z.ZodString;
            source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
            store_id: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough"> | undefined;
          contractError?: string | undefined;
        } & {
          [k: string]: unknown;
        };
        planningHome: {
          root: string;
          kind: "repo";
          changesDir: string;
          defaultSchema: string;
        } & {
          [k: string]: unknown;
        };
        changeRoot: string;
        artifactPaths: Record<string, z.objectOutputType<{
          outputPath: z.ZodString;
          resolvedOutputPath: z.ZodString;
          existingOutputPaths: z.ZodArray<z.ZodString, "many">;
        }, z.ZodTypeAny, "passthrough">>;
        nextSteps: string[];
        actionContext: {
          mode: "repo-local";
          sourceOfTruth: "repo";
          planningArtifacts: string[];
          linkedContext: z.objectOutputType<{
            name: z.ZodString;
          }, z.ZodTypeAny, "passthrough">[];
          allowedEditRoots: string[];
          requiresAffectedAreaSelection: boolean;
          constraints: string[];
        } & {
          [k: string]: unknown;
        };
      } | {
        kind: "static";
      };
    };
    kind: "opsx-status";
  } | {
    value: string[];
    entries: {
      status: "no-tasks" | "complete" | "in-progress";
      name: string;
      completedTasks: number;
      totalTasks: number;
      lastModified: string;
    }[];
    kind: "opsx-change-list";
    evidence: {
      success: boolean;
      stdout: string;
      stderr: string;
      exitCode: number | null;
      payload: CliJsonValue;
      diagnostics: z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">[];
      contractError?: string | undefined;
    };
  } | {
    value: {
      changeName: string;
      schemaName: string;
      isPlanningComplete: boolean;
      applyRequires: string[];
      artifacts: {
        status: "ready" | "done" | "skipped" | "blocked";
        id: string;
        outputPath: string;
        requires: string[];
        missingDeps?: string[] | undefined;
        relativePath?: string | undefined;
      }[];
      provenance: {
        root: {
          path: string;
          source: "store" | "declared" | "nearest" | "global_default" | "implicit";
          store_id?: string | undefined;
        } & {
          [k: string]: unknown;
        };
        kind: "cli";
        evidence: {
          success: boolean;
          stdout: string;
          stderr: string;
          exitCode: number | null;
          payload: CliJsonValue;
          diagnostics: z.objectOutputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">[];
          command: "status";
          selector: {
            store?: string | undefined;
          };
          root?: z.objectOutputType<{
            path: z.ZodString;
            source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
            store_id: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough"> | undefined;
          contractError?: string | undefined;
        } & {
          [k: string]: unknown;
        };
        planningHome: {
          root: string;
          kind: "repo";
          changesDir: string;
          defaultSchema: string;
        } & {
          [k: string]: unknown;
        };
        changeRoot: string;
        artifactPaths: Record<string, z.objectOutputType<{
          outputPath: z.ZodString;
          resolvedOutputPath: z.ZodString;
          existingOutputPaths: z.ZodArray<z.ZodString, "many">;
        }, z.ZodTypeAny, "passthrough">>;
        nextSteps: string[];
        actionContext: {
          mode: "repo-local";
          sourceOfTruth: "repo";
          planningArtifacts: string[];
          linkedContext: z.objectOutputType<{
            name: z.ZodString;
          }, z.ZodTypeAny, "passthrough">[];
          allowedEditRoots: string[];
          requiresAffectedAreaSelection: boolean;
          constraints: string[];
        } & {
          [k: string]: unknown;
        };
      } | {
        kind: "static";
      };
    }[];
    kind: "opsx-status-list";
    evidence: {
      success: boolean;
      stdout: string;
      stderr: string;
      exitCode: number | null;
      payload: CliJsonValue;
      diagnostics: z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">[];
      contractError?: string | undefined;
    };
  } | {
    value: {
      description: string;
      template: string;
      evidence: {
        success: boolean;
        stdout: string;
        stderr: string;
        exitCode: number | null;
        payload: CliJsonValue;
        diagnostics: z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">[];
        command: "instructions";
        selector: {
          store?: string | undefined;
        };
        root?: z.objectOutputType<{
          path: z.ZodString;
          source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
          store_id: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough"> | undefined;
        contractError?: string | undefined;
      } & {
        [k: string]: unknown;
      };
      changeName: string;
      schemaName: string;
      outputPath: string;
      artifactId: string;
      changeDir: string;
      dependencies: {
        path: string;
        id: string;
        description: string;
        done: boolean;
        skipped?: boolean | undefined;
      }[];
      unlocks: string[];
      context?: string | null | undefined;
      instruction?: string | null | undefined;
      rules?: string[] | null | undefined;
      references?: z.objectOutputType<{
        store_id: z.ZodString;
        root: z.ZodOptional<z.ZodString>;
        status: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
      } & {
        specs: z.ZodOptional<z.ZodArray<z.ZodObject<{
          id: z.ZodString;
          summary: z.ZodString;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          id: z.ZodString;
          summary: z.ZodString;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          id: z.ZodString;
          summary: z.ZodString;
        }, z.ZodTypeAny, "passthrough">>, "many">>;
        fetch: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">[] | undefined;
    };
    kind: "opsx-instructions";
  } | {
    value: {
      state: "ready" | "blocked" | "all_done";
      evidence: {
        success: boolean;
        stdout: string;
        stderr: string;
        exitCode: number | null;
        payload: CliJsonValue;
        diagnostics: z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">[];
        command: "instructions apply";
        selector: {
          store?: string | undefined;
        };
        root?: z.objectOutputType<{
          path: z.ZodString;
          source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
          store_id: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough"> | undefined;
        contractError?: string | undefined;
      } & {
        [k: string]: unknown;
      };
      changeName: string;
      schemaName: string;
      changeDir: string;
      instruction: string;
      contextFiles: Record<string, string[]>;
      tasks: {
        id: string;
        description: string;
        done: boolean;
      }[];
      applyInstructionProgress: {
        source: "openspec-instructions-apply";
        state: "ready" | "blocked" | "all_done";
        complete: number;
        total: number;
        remaining: number;
        divergence: {
          message: string;
          kind: "tracked-task-mismatch";
          apply: {
            complete: number;
            total: number;
            remaining: number;
          };
          tracked: {
            total: number;
            remaining: number;
            completed: number;
            phase: "no-tasks" | "complete" | "in-progress";
          };
        } | null;
      };
      context?: string | undefined;
      references?: z.objectOutputType<{
        store_id: z.ZodString;
        root: z.ZodOptional<z.ZodString>;
        status: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
      } & {
        specs: z.ZodOptional<z.ZodArray<z.ZodObject<{
          id: z.ZodString;
          summary: z.ZodString;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          id: z.ZodString;
          summary: z.ZodString;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          id: z.ZodString;
          summary: z.ZodString;
        }, z.ZodTypeAny, "passthrough">>, "many">>;
        fetch: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">[] | undefined;
      missingArtifacts?: string[] | undefined;
      operationGuidance?: string[] | undefined;
    };
    kind: "opsx-apply-instructions";
  } | {
    value: {
      evidence: {
        success: boolean;
        stdout: string;
        stderr: string;
        exitCode: number | null;
        payload: CliJsonValue;
        diagnostics: z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">[];
        command: "instructions archive";
        selector: {
          store?: string | undefined;
        };
        root?: z.objectOutputType<{
          path: z.ZodString;
          source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
          store_id: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough"> | undefined;
        contractError?: string | undefined;
      } & {
        [k: string]: unknown;
      };
      changeName: string;
      context?: string | undefined;
      operationGuidance?: string[] | undefined;
    };
    kind: "opsx-archive-instructions";
    rootGeneration: string;
  } | {
    value: {
      schemas: z.objectOutputType<{
        name: z.ZodString;
        description: z.ZodOptional<z.ZodString>;
        artifacts: z.ZodArray<z.ZodString, "many">;
        source: z.ZodEnum<["project", "user", "package"]>;
      }, z.ZodTypeAny, "passthrough">[];
      schemaDetails: Record<string, {
        name: string;
        applyRequires: string[];
        artifacts: {
          id: string;
          outputPath: string;
          requires: string[];
          description?: string | undefined;
          template?: string | undefined;
          instruction?: string | undefined;
        }[];
        version?: string | number | undefined;
        description?: string | undefined;
        applyTracks?: string | undefined;
        applyInstruction?: string | undefined;
      } | null>;
      schemaResolutions: Record<string, z.objectOutputType<{
        name: z.ZodString;
        source: z.ZodEnum<["project", "user", "package"]>;
        path: z.ZodString;
      } & {
        displayPath: z.ZodOptional<z.ZodString>;
        shadows: z.ZodArray<z.ZodObject<{
          source: z.ZodEnum<["project", "user", "package"]>;
          path: z.ZodString;
        } & {
          displayPath: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          source: z.ZodEnum<["project", "user", "package"]>;
          path: z.ZodString;
        } & {
          displayPath: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          source: z.ZodEnum<["project", "user", "package"]>;
          path: z.ZodString;
        } & {
          displayPath: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
      }, z.ZodTypeAny, "passthrough"> | null>;
    };
    kind: "opsx-config-bundle";
    evidence: {
      schemas: {
        success: boolean;
        stdout: string;
        stderr: string;
        exitCode: number | null;
        payload: CliJsonValue;
        diagnostics: z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">[];
        contractError?: string | undefined;
      };
      schemaResolutions: Record<string, {
        success: boolean;
        stdout: string;
        stderr: string;
        exitCode: number | null;
        payload: CliJsonValue;
        diagnostics: z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">[];
        contractError?: string | undefined;
      }>;
    };
  } | {
    value: Record<string, z.objectOutputType<{
      path: z.ZodString;
      source: z.ZodEnum<["project", "user", "package"]>;
    } & {
      displayPath: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">>;
    kind: "opsx-templates";
    evidence: {
      success: boolean;
      stdout: string;
      stderr: string;
      exitCode: number | null;
      payload: CliJsonValue;
      diagnostics: z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">[];
      contractError?: string | undefined;
    };
  } | {
    value: Record<string, {
      path: string;
      source: "project" | "user" | "package";
      content: string | null;
      displayPath?: string | undefined;
    }>;
    kind: "opsx-template-contents";
    evidence: {
      success: boolean;
      stdout: string;
      stderr: string;
      exitCode: number | null;
      payload: CliJsonValue;
      diagnostics: z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">[];
      contractError?: string | undefined;
    };
  } | {
    value: SpecCatalog;
    kind: "spec-catalog";
  } | {
    value: SpecDocumentProjection;
    kind: "spec-document";
  }, z.ZodTypeDef, {
    value: {
      changeName: string;
      schemaName: string;
      isPlanningComplete: boolean;
      applyRequires: string[];
      artifacts: {
        status: "ready" | "done" | "skipped" | "blocked";
        id: string;
        outputPath: string;
        requires: string[];
        missingDeps?: string[] | undefined;
        relativePath?: string | undefined;
      }[];
      provenance: {
        root: {
          path: string;
          source: "store" | "declared" | "nearest" | "global_default" | "implicit";
          store_id?: string | undefined;
        } & {
          [k: string]: unknown;
        };
        kind: "cli";
        evidence: {
          success: boolean;
          stdout: string;
          stderr: string;
          exitCode: number | null;
          payload: CliJsonValue;
          diagnostics: z.objectInputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">[];
          command: "status";
          selector: {
            store?: string | undefined;
          };
          root?: z.objectInputType<{
            path: z.ZodString;
            source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
            store_id: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough"> | undefined;
          contractError?: string | undefined;
        } & {
          [k: string]: unknown;
        };
        planningHome: {
          root: string;
          kind: "repo";
          changesDir: string;
          defaultSchema: string;
        } & {
          [k: string]: unknown;
        };
        changeRoot: string;
        artifactPaths: Record<string, z.objectInputType<{
          outputPath: z.ZodString;
          resolvedOutputPath: z.ZodString;
          existingOutputPaths: z.ZodArray<z.ZodString, "many">;
        }, z.ZodTypeAny, "passthrough">>;
        nextSteps: string[];
        actionContext: {
          mode: "repo-local";
          sourceOfTruth: "repo";
          planningArtifacts: string[];
          linkedContext: z.objectInputType<{
            name: z.ZodString;
          }, z.ZodTypeAny, "passthrough">[];
          allowedEditRoots: string[];
          requiresAffectedAreaSelection: boolean;
          constraints: string[];
        } & {
          [k: string]: unknown;
        };
      } | {
        kind: "static";
      };
    };
    kind: "opsx-status";
  } | {
    value: string[];
    entries: {
      status: "no-tasks" | "complete" | "in-progress";
      name: string;
      completedTasks: number;
      totalTasks: number;
      lastModified: string;
    }[];
    kind: "opsx-change-list";
    evidence: {
      success: boolean;
      stdout: string;
      stderr: string;
      exitCode: number | null;
      payload: CliJsonValue;
      diagnostics: z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">[];
      contractError?: string | undefined;
    };
  } | {
    value: {
      changeName: string;
      schemaName: string;
      isPlanningComplete: boolean;
      applyRequires: string[];
      artifacts: {
        status: "ready" | "done" | "skipped" | "blocked";
        id: string;
        outputPath: string;
        requires: string[];
        missingDeps?: string[] | undefined;
        relativePath?: string | undefined;
      }[];
      provenance: {
        root: {
          path: string;
          source: "store" | "declared" | "nearest" | "global_default" | "implicit";
          store_id?: string | undefined;
        } & {
          [k: string]: unknown;
        };
        kind: "cli";
        evidence: {
          success: boolean;
          stdout: string;
          stderr: string;
          exitCode: number | null;
          payload: CliJsonValue;
          diagnostics: z.objectInputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">[];
          command: "status";
          selector: {
            store?: string | undefined;
          };
          root?: z.objectInputType<{
            path: z.ZodString;
            source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
            store_id: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough"> | undefined;
          contractError?: string | undefined;
        } & {
          [k: string]: unknown;
        };
        planningHome: {
          root: string;
          kind: "repo";
          changesDir: string;
          defaultSchema: string;
        } & {
          [k: string]: unknown;
        };
        changeRoot: string;
        artifactPaths: Record<string, z.objectInputType<{
          outputPath: z.ZodString;
          resolvedOutputPath: z.ZodString;
          existingOutputPaths: z.ZodArray<z.ZodString, "many">;
        }, z.ZodTypeAny, "passthrough">>;
        nextSteps: string[];
        actionContext: {
          mode: "repo-local";
          sourceOfTruth: "repo";
          planningArtifacts: string[];
          linkedContext: z.objectInputType<{
            name: z.ZodString;
          }, z.ZodTypeAny, "passthrough">[];
          allowedEditRoots: string[];
          requiresAffectedAreaSelection: boolean;
          constraints: string[];
        } & {
          [k: string]: unknown;
        };
      } | {
        kind: "static";
      };
    }[];
    kind: "opsx-status-list";
    evidence: {
      success: boolean;
      stdout: string;
      stderr: string;
      exitCode: number | null;
      payload: CliJsonValue;
      diagnostics: z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">[];
      contractError?: string | undefined;
    };
  } | {
    value: {
      description: string;
      template: string;
      evidence: {
        success: boolean;
        stdout: string;
        stderr: string;
        exitCode: number | null;
        payload: CliJsonValue;
        diagnostics: z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">[];
        command: "instructions";
        selector: {
          store?: string | undefined;
        };
        root?: z.objectInputType<{
          path: z.ZodString;
          source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
          store_id: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough"> | undefined;
        contractError?: string | undefined;
      } & {
        [k: string]: unknown;
      };
      changeName: string;
      schemaName: string;
      outputPath: string;
      artifactId: string;
      changeDir: string;
      dependencies: {
        path: string;
        id: string;
        description: string;
        done: boolean;
        skipped?: boolean | undefined;
      }[];
      unlocks: string[];
      context?: string | null | undefined;
      instruction?: string | null | undefined;
      rules?: string[] | null | undefined;
      references?: z.objectInputType<{
        store_id: z.ZodString;
        root: z.ZodOptional<z.ZodString>;
        status: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
      } & {
        specs: z.ZodOptional<z.ZodArray<z.ZodObject<{
          id: z.ZodString;
          summary: z.ZodString;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          id: z.ZodString;
          summary: z.ZodString;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          id: z.ZodString;
          summary: z.ZodString;
        }, z.ZodTypeAny, "passthrough">>, "many">>;
        fetch: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">[] | undefined;
    };
    kind: "opsx-instructions";
  } | {
    value: {
      state: "ready" | "blocked" | "all_done";
      evidence: {
        success: boolean;
        stdout: string;
        stderr: string;
        exitCode: number | null;
        payload: CliJsonValue;
        diagnostics: z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">[];
        command: "instructions apply";
        selector: {
          store?: string | undefined;
        };
        root?: z.objectInputType<{
          path: z.ZodString;
          source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
          store_id: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough"> | undefined;
        contractError?: string | undefined;
      } & {
        [k: string]: unknown;
      };
      changeName: string;
      schemaName: string;
      changeDir: string;
      instruction: string;
      contextFiles: Record<string, string | string[]>;
      tasks: {
        id: string;
        description: string;
        done: boolean;
      }[];
      applyInstructionProgress: {
        source: "openspec-instructions-apply";
        state: "ready" | "blocked" | "all_done";
        complete: number;
        total: number;
        remaining: number;
        divergence: {
          message: string;
          kind: "tracked-task-mismatch";
          apply: {
            complete: number;
            total: number;
            remaining: number;
          };
          tracked: {
            total: number;
            remaining: number;
            completed: number;
            phase: "no-tasks" | "complete" | "in-progress";
          };
        } | null;
      };
      context?: string | undefined;
      references?: z.objectInputType<{
        store_id: z.ZodString;
        root: z.ZodOptional<z.ZodString>;
        status: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
      } & {
        specs: z.ZodOptional<z.ZodArray<z.ZodObject<{
          id: z.ZodString;
          summary: z.ZodString;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          id: z.ZodString;
          summary: z.ZodString;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          id: z.ZodString;
          summary: z.ZodString;
        }, z.ZodTypeAny, "passthrough">>, "many">>;
        fetch: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">[] | undefined;
      missingArtifacts?: string[] | undefined;
      operationGuidance?: string[] | undefined;
    };
    kind: "opsx-apply-instructions";
  } | {
    value: {
      evidence: {
        success: boolean;
        stdout: string;
        stderr: string;
        exitCode: number | null;
        payload: CliJsonValue;
        diagnostics: z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">[];
        command: "instructions archive";
        selector: {
          store?: string | undefined;
        };
        root?: z.objectInputType<{
          path: z.ZodString;
          source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
          store_id: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough"> | undefined;
        contractError?: string | undefined;
      } & {
        [k: string]: unknown;
      };
      changeName: string;
      context?: string | undefined;
      operationGuidance?: string[] | undefined;
    };
    kind: "opsx-archive-instructions";
    rootGeneration: string;
  } | {
    value: {
      schemas: z.objectInputType<{
        name: z.ZodString;
        description: z.ZodOptional<z.ZodString>;
        artifacts: z.ZodArray<z.ZodString, "many">;
        source: z.ZodEnum<["project", "user", "package"]>;
      }, z.ZodTypeAny, "passthrough">[];
      schemaDetails: Record<string, {
        name: string;
        applyRequires: string[];
        artifacts: {
          id: string;
          outputPath: string;
          requires: string[];
          description?: string | undefined;
          template?: string | undefined;
          instruction?: string | undefined;
        }[];
        version?: string | number | undefined;
        description?: string | undefined;
        applyTracks?: string | undefined;
        applyInstruction?: string | undefined;
      } | null>;
      schemaResolutions: Record<string, z.objectInputType<{
        name: z.ZodString;
        source: z.ZodEnum<["project", "user", "package"]>;
        path: z.ZodString;
      } & {
        displayPath: z.ZodOptional<z.ZodString>;
        shadows: z.ZodArray<z.ZodObject<{
          source: z.ZodEnum<["project", "user", "package"]>;
          path: z.ZodString;
        } & {
          displayPath: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          source: z.ZodEnum<["project", "user", "package"]>;
          path: z.ZodString;
        } & {
          displayPath: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          source: z.ZodEnum<["project", "user", "package"]>;
          path: z.ZodString;
        } & {
          displayPath: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
      }, z.ZodTypeAny, "passthrough"> | null>;
    };
    kind: "opsx-config-bundle";
    evidence: {
      schemas: {
        success: boolean;
        stdout: string;
        stderr: string;
        exitCode: number | null;
        payload: CliJsonValue;
        diagnostics: z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">[];
        contractError?: string | undefined;
      };
      schemaResolutions: Record<string, {
        success: boolean;
        stdout: string;
        stderr: string;
        exitCode: number | null;
        payload: CliJsonValue;
        diagnostics: z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">[];
        contractError?: string | undefined;
      }>;
    };
  } | {
    value: Record<string, z.objectInputType<{
      path: z.ZodString;
      source: z.ZodEnum<["project", "user", "package"]>;
    } & {
      displayPath: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">>;
    kind: "opsx-templates";
    evidence: {
      success: boolean;
      stdout: string;
      stderr: string;
      exitCode: number | null;
      payload: CliJsonValue;
      diagnostics: z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">[];
      contractError?: string | undefined;
    };
  } | {
    value: Record<string, {
      path: string;
      source: "project" | "user" | "package";
      content: string | null;
      displayPath?: string | undefined;
    }>;
    kind: "opsx-template-contents";
    evidence: {
      success: boolean;
      stdout: string;
      stderr: string;
      exitCode: number | null;
      payload: CliJsonValue;
      diagnostics: z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">[];
      contractError?: string | undefined;
    };
  } | {
    kind: "spec-catalog";
    value?: unknown;
  } | {
    kind: "spec-document";
    value?: unknown;
  }>;
  freshness: z.ZodLiteral<"stale-display-only">;
  snapshotGeneration: z.ZodNumber;
  error: z.ZodObject<{
    name: z.ZodString;
    message: z.ZodString;
    cliEvidence: z.ZodNullable<z.ZodObject<{
      success: z.ZodBoolean;
      stdout: z.ZodString;
      stderr: z.ZodString;
      exitCode: z.ZodNullable<z.ZodNumber>;
      payload: z.ZodNullable<z.ZodType<CliJsonValue, z.ZodTypeDef, CliJsonValue>>;
      diagnostics: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
      contractError: z.ZodOptional<z.ZodString>;
    }, "strip", z.ZodTypeAny, {
      success: boolean;
      stdout: string;
      stderr: string;
      exitCode: number | null;
      payload: CliJsonValue;
      diagnostics: z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">[];
      contractError?: string | undefined;
    }, {
      success: boolean;
      stdout: string;
      stderr: string;
      exitCode: number | null;
      payload: CliJsonValue;
      diagnostics: z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">[];
      contractError?: string | undefined;
    }>>;
  }, "strip", z.ZodTypeAny, {
    message: string;
    name: string;
    cliEvidence: {
      success: boolean;
      stdout: string;
      stderr: string;
      exitCode: number | null;
      payload: CliJsonValue;
      diagnostics: z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">[];
      contractError?: string | undefined;
    } | null;
  }, {
    message: string;
    name: string;
    cliEvidence: {
      success: boolean;
      stdout: string;
      stderr: string;
      exitCode: number | null;
      payload: CliJsonValue;
      diagnostics: z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">[];
      contractError?: string | undefined;
    } | null;
  }>;
  identity: z.ZodString;
  workGeneration: z.ZodNumber;
  invalidationCause: z.ZodEnum<["initial", "dependency", "explicit-refresh", "subscriber-resume"]>;
}, "strip", z.ZodTypeAny, {
  error: {
    message: string;
    name: string;
    cliEvidence: {
      success: boolean;
      stdout: string;
      stderr: string;
      exitCode: number | null;
      payload: CliJsonValue;
      diagnostics: z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">[];
      contractError?: string | undefined;
    } | null;
  };
  state: "refresh-error";
  data: {
    value: {
      changeName: string;
      schemaName: string;
      isPlanningComplete: boolean;
      applyRequires: string[];
      artifacts: {
        status: "ready" | "done" | "skipped" | "blocked";
        id: string;
        outputPath: string;
        requires: string[];
        missingDeps?: string[] | undefined;
        relativePath?: string | undefined;
      }[];
      provenance: {
        root: {
          path: string;
          source: "store" | "declared" | "nearest" | "global_default" | "implicit";
          store_id?: string | undefined;
        } & {
          [k: string]: unknown;
        };
        kind: "cli";
        evidence: {
          success: boolean;
          stdout: string;
          stderr: string;
          exitCode: number | null;
          payload: CliJsonValue;
          diagnostics: z.objectOutputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">[];
          command: "status";
          selector: {
            store?: string | undefined;
          };
          root?: z.objectOutputType<{
            path: z.ZodString;
            source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
            store_id: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough"> | undefined;
          contractError?: string | undefined;
        } & {
          [k: string]: unknown;
        };
        planningHome: {
          root: string;
          kind: "repo";
          changesDir: string;
          defaultSchema: string;
        } & {
          [k: string]: unknown;
        };
        changeRoot: string;
        artifactPaths: Record<string, z.objectOutputType<{
          outputPath: z.ZodString;
          resolvedOutputPath: z.ZodString;
          existingOutputPaths: z.ZodArray<z.ZodString, "many">;
        }, z.ZodTypeAny, "passthrough">>;
        nextSteps: string[];
        actionContext: {
          mode: "repo-local";
          sourceOfTruth: "repo";
          planningArtifacts: string[];
          linkedContext: z.objectOutputType<{
            name: z.ZodString;
          }, z.ZodTypeAny, "passthrough">[];
          allowedEditRoots: string[];
          requiresAffectedAreaSelection: boolean;
          constraints: string[];
        } & {
          [k: string]: unknown;
        };
      } | {
        kind: "static";
      };
    };
    kind: "opsx-status";
  } | {
    value: string[];
    entries: {
      status: "no-tasks" | "complete" | "in-progress";
      name: string;
      completedTasks: number;
      totalTasks: number;
      lastModified: string;
    }[];
    kind: "opsx-change-list";
    evidence: {
      success: boolean;
      stdout: string;
      stderr: string;
      exitCode: number | null;
      payload: CliJsonValue;
      diagnostics: z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">[];
      contractError?: string | undefined;
    };
  } | {
    value: {
      changeName: string;
      schemaName: string;
      isPlanningComplete: boolean;
      applyRequires: string[];
      artifacts: {
        status: "ready" | "done" | "skipped" | "blocked";
        id: string;
        outputPath: string;
        requires: string[];
        missingDeps?: string[] | undefined;
        relativePath?: string | undefined;
      }[];
      provenance: {
        root: {
          path: string;
          source: "store" | "declared" | "nearest" | "global_default" | "implicit";
          store_id?: string | undefined;
        } & {
          [k: string]: unknown;
        };
        kind: "cli";
        evidence: {
          success: boolean;
          stdout: string;
          stderr: string;
          exitCode: number | null;
          payload: CliJsonValue;
          diagnostics: z.objectOutputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">[];
          command: "status";
          selector: {
            store?: string | undefined;
          };
          root?: z.objectOutputType<{
            path: z.ZodString;
            source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
            store_id: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough"> | undefined;
          contractError?: string | undefined;
        } & {
          [k: string]: unknown;
        };
        planningHome: {
          root: string;
          kind: "repo";
          changesDir: string;
          defaultSchema: string;
        } & {
          [k: string]: unknown;
        };
        changeRoot: string;
        artifactPaths: Record<string, z.objectOutputType<{
          outputPath: z.ZodString;
          resolvedOutputPath: z.ZodString;
          existingOutputPaths: z.ZodArray<z.ZodString, "many">;
        }, z.ZodTypeAny, "passthrough">>;
        nextSteps: string[];
        actionContext: {
          mode: "repo-local";
          sourceOfTruth: "repo";
          planningArtifacts: string[];
          linkedContext: z.objectOutputType<{
            name: z.ZodString;
          }, z.ZodTypeAny, "passthrough">[];
          allowedEditRoots: string[];
          requiresAffectedAreaSelection: boolean;
          constraints: string[];
        } & {
          [k: string]: unknown;
        };
      } | {
        kind: "static";
      };
    }[];
    kind: "opsx-status-list";
    evidence: {
      success: boolean;
      stdout: string;
      stderr: string;
      exitCode: number | null;
      payload: CliJsonValue;
      diagnostics: z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">[];
      contractError?: string | undefined;
    };
  } | {
    value: {
      description: string;
      template: string;
      evidence: {
        success: boolean;
        stdout: string;
        stderr: string;
        exitCode: number | null;
        payload: CliJsonValue;
        diagnostics: z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">[];
        command: "instructions";
        selector: {
          store?: string | undefined;
        };
        root?: z.objectOutputType<{
          path: z.ZodString;
          source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
          store_id: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough"> | undefined;
        contractError?: string | undefined;
      } & {
        [k: string]: unknown;
      };
      changeName: string;
      schemaName: string;
      outputPath: string;
      artifactId: string;
      changeDir: string;
      dependencies: {
        path: string;
        id: string;
        description: string;
        done: boolean;
        skipped?: boolean | undefined;
      }[];
      unlocks: string[];
      context?: string | null | undefined;
      instruction?: string | null | undefined;
      rules?: string[] | null | undefined;
      references?: z.objectOutputType<{
        store_id: z.ZodString;
        root: z.ZodOptional<z.ZodString>;
        status: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
      } & {
        specs: z.ZodOptional<z.ZodArray<z.ZodObject<{
          id: z.ZodString;
          summary: z.ZodString;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          id: z.ZodString;
          summary: z.ZodString;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          id: z.ZodString;
          summary: z.ZodString;
        }, z.ZodTypeAny, "passthrough">>, "many">>;
        fetch: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">[] | undefined;
    };
    kind: "opsx-instructions";
  } | {
    value: {
      state: "ready" | "blocked" | "all_done";
      evidence: {
        success: boolean;
        stdout: string;
        stderr: string;
        exitCode: number | null;
        payload: CliJsonValue;
        diagnostics: z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">[];
        command: "instructions apply";
        selector: {
          store?: string | undefined;
        };
        root?: z.objectOutputType<{
          path: z.ZodString;
          source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
          store_id: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough"> | undefined;
        contractError?: string | undefined;
      } & {
        [k: string]: unknown;
      };
      changeName: string;
      schemaName: string;
      changeDir: string;
      instruction: string;
      contextFiles: Record<string, string[]>;
      tasks: {
        id: string;
        description: string;
        done: boolean;
      }[];
      applyInstructionProgress: {
        source: "openspec-instructions-apply";
        state: "ready" | "blocked" | "all_done";
        complete: number;
        total: number;
        remaining: number;
        divergence: {
          message: string;
          kind: "tracked-task-mismatch";
          apply: {
            complete: number;
            total: number;
            remaining: number;
          };
          tracked: {
            total: number;
            remaining: number;
            completed: number;
            phase: "no-tasks" | "complete" | "in-progress";
          };
        } | null;
      };
      context?: string | undefined;
      references?: z.objectOutputType<{
        store_id: z.ZodString;
        root: z.ZodOptional<z.ZodString>;
        status: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
      } & {
        specs: z.ZodOptional<z.ZodArray<z.ZodObject<{
          id: z.ZodString;
          summary: z.ZodString;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          id: z.ZodString;
          summary: z.ZodString;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          id: z.ZodString;
          summary: z.ZodString;
        }, z.ZodTypeAny, "passthrough">>, "many">>;
        fetch: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">[] | undefined;
      missingArtifacts?: string[] | undefined;
      operationGuidance?: string[] | undefined;
    };
    kind: "opsx-apply-instructions";
  } | {
    value: {
      evidence: {
        success: boolean;
        stdout: string;
        stderr: string;
        exitCode: number | null;
        payload: CliJsonValue;
        diagnostics: z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">[];
        command: "instructions archive";
        selector: {
          store?: string | undefined;
        };
        root?: z.objectOutputType<{
          path: z.ZodString;
          source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
          store_id: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough"> | undefined;
        contractError?: string | undefined;
      } & {
        [k: string]: unknown;
      };
      changeName: string;
      context?: string | undefined;
      operationGuidance?: string[] | undefined;
    };
    kind: "opsx-archive-instructions";
    rootGeneration: string;
  } | {
    value: {
      schemas: z.objectOutputType<{
        name: z.ZodString;
        description: z.ZodOptional<z.ZodString>;
        artifacts: z.ZodArray<z.ZodString, "many">;
        source: z.ZodEnum<["project", "user", "package"]>;
      }, z.ZodTypeAny, "passthrough">[];
      schemaDetails: Record<string, {
        name: string;
        applyRequires: string[];
        artifacts: {
          id: string;
          outputPath: string;
          requires: string[];
          description?: string | undefined;
          template?: string | undefined;
          instruction?: string | undefined;
        }[];
        version?: string | number | undefined;
        description?: string | undefined;
        applyTracks?: string | undefined;
        applyInstruction?: string | undefined;
      } | null>;
      schemaResolutions: Record<string, z.objectOutputType<{
        name: z.ZodString;
        source: z.ZodEnum<["project", "user", "package"]>;
        path: z.ZodString;
      } & {
        displayPath: z.ZodOptional<z.ZodString>;
        shadows: z.ZodArray<z.ZodObject<{
          source: z.ZodEnum<["project", "user", "package"]>;
          path: z.ZodString;
        } & {
          displayPath: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          source: z.ZodEnum<["project", "user", "package"]>;
          path: z.ZodString;
        } & {
          displayPath: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          source: z.ZodEnum<["project", "user", "package"]>;
          path: z.ZodString;
        } & {
          displayPath: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
      }, z.ZodTypeAny, "passthrough"> | null>;
    };
    kind: "opsx-config-bundle";
    evidence: {
      schemas: {
        success: boolean;
        stdout: string;
        stderr: string;
        exitCode: number | null;
        payload: CliJsonValue;
        diagnostics: z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">[];
        contractError?: string | undefined;
      };
      schemaResolutions: Record<string, {
        success: boolean;
        stdout: string;
        stderr: string;
        exitCode: number | null;
        payload: CliJsonValue;
        diagnostics: z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">[];
        contractError?: string | undefined;
      }>;
    };
  } | {
    value: Record<string, z.objectOutputType<{
      path: z.ZodString;
      source: z.ZodEnum<["project", "user", "package"]>;
    } & {
      displayPath: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">>;
    kind: "opsx-templates";
    evidence: {
      success: boolean;
      stdout: string;
      stderr: string;
      exitCode: number | null;
      payload: CliJsonValue;
      diagnostics: z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">[];
      contractError?: string | undefined;
    };
  } | {
    value: Record<string, {
      path: string;
      source: "project" | "user" | "package";
      content: string | null;
      displayPath?: string | undefined;
    }>;
    kind: "opsx-template-contents";
    evidence: {
      success: boolean;
      stdout: string;
      stderr: string;
      exitCode: number | null;
      payload: CliJsonValue;
      diagnostics: z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">[];
      contractError?: string | undefined;
    };
  } | {
    value: SpecCatalog;
    kind: "spec-catalog";
  } | {
    value: SpecDocumentProjection;
    kind: "spec-document";
  };
  freshness: "stale-display-only";
  snapshotGeneration: number;
  identity: string;
  workGeneration: number;
  invalidationCause: "dependency" | "initial" | "explicit-refresh" | "subscriber-resume";
}, {
  error: {
    message: string;
    name: string;
    cliEvidence: {
      success: boolean;
      stdout: string;
      stderr: string;
      exitCode: number | null;
      payload: CliJsonValue;
      diagnostics: z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">[];
      contractError?: string | undefined;
    } | null;
  };
  state: "refresh-error";
  data: {
    value: {
      changeName: string;
      schemaName: string;
      isPlanningComplete: boolean;
      applyRequires: string[];
      artifacts: {
        status: "ready" | "done" | "skipped" | "blocked";
        id: string;
        outputPath: string;
        requires: string[];
        missingDeps?: string[] | undefined;
        relativePath?: string | undefined;
      }[];
      provenance: {
        root: {
          path: string;
          source: "store" | "declared" | "nearest" | "global_default" | "implicit";
          store_id?: string | undefined;
        } & {
          [k: string]: unknown;
        };
        kind: "cli";
        evidence: {
          success: boolean;
          stdout: string;
          stderr: string;
          exitCode: number | null;
          payload: CliJsonValue;
          diagnostics: z.objectInputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">[];
          command: "status";
          selector: {
            store?: string | undefined;
          };
          root?: z.objectInputType<{
            path: z.ZodString;
            source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
            store_id: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough"> | undefined;
          contractError?: string | undefined;
        } & {
          [k: string]: unknown;
        };
        planningHome: {
          root: string;
          kind: "repo";
          changesDir: string;
          defaultSchema: string;
        } & {
          [k: string]: unknown;
        };
        changeRoot: string;
        artifactPaths: Record<string, z.objectInputType<{
          outputPath: z.ZodString;
          resolvedOutputPath: z.ZodString;
          existingOutputPaths: z.ZodArray<z.ZodString, "many">;
        }, z.ZodTypeAny, "passthrough">>;
        nextSteps: string[];
        actionContext: {
          mode: "repo-local";
          sourceOfTruth: "repo";
          planningArtifacts: string[];
          linkedContext: z.objectInputType<{
            name: z.ZodString;
          }, z.ZodTypeAny, "passthrough">[];
          allowedEditRoots: string[];
          requiresAffectedAreaSelection: boolean;
          constraints: string[];
        } & {
          [k: string]: unknown;
        };
      } | {
        kind: "static";
      };
    };
    kind: "opsx-status";
  } | {
    value: string[];
    entries: {
      status: "no-tasks" | "complete" | "in-progress";
      name: string;
      completedTasks: number;
      totalTasks: number;
      lastModified: string;
    }[];
    kind: "opsx-change-list";
    evidence: {
      success: boolean;
      stdout: string;
      stderr: string;
      exitCode: number | null;
      payload: CliJsonValue;
      diagnostics: z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">[];
      contractError?: string | undefined;
    };
  } | {
    value: {
      changeName: string;
      schemaName: string;
      isPlanningComplete: boolean;
      applyRequires: string[];
      artifacts: {
        status: "ready" | "done" | "skipped" | "blocked";
        id: string;
        outputPath: string;
        requires: string[];
        missingDeps?: string[] | undefined;
        relativePath?: string | undefined;
      }[];
      provenance: {
        root: {
          path: string;
          source: "store" | "declared" | "nearest" | "global_default" | "implicit";
          store_id?: string | undefined;
        } & {
          [k: string]: unknown;
        };
        kind: "cli";
        evidence: {
          success: boolean;
          stdout: string;
          stderr: string;
          exitCode: number | null;
          payload: CliJsonValue;
          diagnostics: z.objectInputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">[];
          command: "status";
          selector: {
            store?: string | undefined;
          };
          root?: z.objectInputType<{
            path: z.ZodString;
            source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
            store_id: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough"> | undefined;
          contractError?: string | undefined;
        } & {
          [k: string]: unknown;
        };
        planningHome: {
          root: string;
          kind: "repo";
          changesDir: string;
          defaultSchema: string;
        } & {
          [k: string]: unknown;
        };
        changeRoot: string;
        artifactPaths: Record<string, z.objectInputType<{
          outputPath: z.ZodString;
          resolvedOutputPath: z.ZodString;
          existingOutputPaths: z.ZodArray<z.ZodString, "many">;
        }, z.ZodTypeAny, "passthrough">>;
        nextSteps: string[];
        actionContext: {
          mode: "repo-local";
          sourceOfTruth: "repo";
          planningArtifacts: string[];
          linkedContext: z.objectInputType<{
            name: z.ZodString;
          }, z.ZodTypeAny, "passthrough">[];
          allowedEditRoots: string[];
          requiresAffectedAreaSelection: boolean;
          constraints: string[];
        } & {
          [k: string]: unknown;
        };
      } | {
        kind: "static";
      };
    }[];
    kind: "opsx-status-list";
    evidence: {
      success: boolean;
      stdout: string;
      stderr: string;
      exitCode: number | null;
      payload: CliJsonValue;
      diagnostics: z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">[];
      contractError?: string | undefined;
    };
  } | {
    value: {
      description: string;
      template: string;
      evidence: {
        success: boolean;
        stdout: string;
        stderr: string;
        exitCode: number | null;
        payload: CliJsonValue;
        diagnostics: z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">[];
        command: "instructions";
        selector: {
          store?: string | undefined;
        };
        root?: z.objectInputType<{
          path: z.ZodString;
          source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
          store_id: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough"> | undefined;
        contractError?: string | undefined;
      } & {
        [k: string]: unknown;
      };
      changeName: string;
      schemaName: string;
      outputPath: string;
      artifactId: string;
      changeDir: string;
      dependencies: {
        path: string;
        id: string;
        description: string;
        done: boolean;
        skipped?: boolean | undefined;
      }[];
      unlocks: string[];
      context?: string | null | undefined;
      instruction?: string | null | undefined;
      rules?: string[] | null | undefined;
      references?: z.objectInputType<{
        store_id: z.ZodString;
        root: z.ZodOptional<z.ZodString>;
        status: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
      } & {
        specs: z.ZodOptional<z.ZodArray<z.ZodObject<{
          id: z.ZodString;
          summary: z.ZodString;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          id: z.ZodString;
          summary: z.ZodString;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          id: z.ZodString;
          summary: z.ZodString;
        }, z.ZodTypeAny, "passthrough">>, "many">>;
        fetch: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">[] | undefined;
    };
    kind: "opsx-instructions";
  } | {
    value: {
      state: "ready" | "blocked" | "all_done";
      evidence: {
        success: boolean;
        stdout: string;
        stderr: string;
        exitCode: number | null;
        payload: CliJsonValue;
        diagnostics: z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">[];
        command: "instructions apply";
        selector: {
          store?: string | undefined;
        };
        root?: z.objectInputType<{
          path: z.ZodString;
          source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
          store_id: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough"> | undefined;
        contractError?: string | undefined;
      } & {
        [k: string]: unknown;
      };
      changeName: string;
      schemaName: string;
      changeDir: string;
      instruction: string;
      contextFiles: Record<string, string | string[]>;
      tasks: {
        id: string;
        description: string;
        done: boolean;
      }[];
      applyInstructionProgress: {
        source: "openspec-instructions-apply";
        state: "ready" | "blocked" | "all_done";
        complete: number;
        total: number;
        remaining: number;
        divergence: {
          message: string;
          kind: "tracked-task-mismatch";
          apply: {
            complete: number;
            total: number;
            remaining: number;
          };
          tracked: {
            total: number;
            remaining: number;
            completed: number;
            phase: "no-tasks" | "complete" | "in-progress";
          };
        } | null;
      };
      context?: string | undefined;
      references?: z.objectInputType<{
        store_id: z.ZodString;
        root: z.ZodOptional<z.ZodString>;
        status: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
      } & {
        specs: z.ZodOptional<z.ZodArray<z.ZodObject<{
          id: z.ZodString;
          summary: z.ZodString;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          id: z.ZodString;
          summary: z.ZodString;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          id: z.ZodString;
          summary: z.ZodString;
        }, z.ZodTypeAny, "passthrough">>, "many">>;
        fetch: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">[] | undefined;
      missingArtifacts?: string[] | undefined;
      operationGuidance?: string[] | undefined;
    };
    kind: "opsx-apply-instructions";
  } | {
    value: {
      evidence: {
        success: boolean;
        stdout: string;
        stderr: string;
        exitCode: number | null;
        payload: CliJsonValue;
        diagnostics: z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">[];
        command: "instructions archive";
        selector: {
          store?: string | undefined;
        };
        root?: z.objectInputType<{
          path: z.ZodString;
          source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
          store_id: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough"> | undefined;
        contractError?: string | undefined;
      } & {
        [k: string]: unknown;
      };
      changeName: string;
      context?: string | undefined;
      operationGuidance?: string[] | undefined;
    };
    kind: "opsx-archive-instructions";
    rootGeneration: string;
  } | {
    value: {
      schemas: z.objectInputType<{
        name: z.ZodString;
        description: z.ZodOptional<z.ZodString>;
        artifacts: z.ZodArray<z.ZodString, "many">;
        source: z.ZodEnum<["project", "user", "package"]>;
      }, z.ZodTypeAny, "passthrough">[];
      schemaDetails: Record<string, {
        name: string;
        applyRequires: string[];
        artifacts: {
          id: string;
          outputPath: string;
          requires: string[];
          description?: string | undefined;
          template?: string | undefined;
          instruction?: string | undefined;
        }[];
        version?: string | number | undefined;
        description?: string | undefined;
        applyTracks?: string | undefined;
        applyInstruction?: string | undefined;
      } | null>;
      schemaResolutions: Record<string, z.objectInputType<{
        name: z.ZodString;
        source: z.ZodEnum<["project", "user", "package"]>;
        path: z.ZodString;
      } & {
        displayPath: z.ZodOptional<z.ZodString>;
        shadows: z.ZodArray<z.ZodObject<{
          source: z.ZodEnum<["project", "user", "package"]>;
          path: z.ZodString;
        } & {
          displayPath: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          source: z.ZodEnum<["project", "user", "package"]>;
          path: z.ZodString;
        } & {
          displayPath: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          source: z.ZodEnum<["project", "user", "package"]>;
          path: z.ZodString;
        } & {
          displayPath: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
      }, z.ZodTypeAny, "passthrough"> | null>;
    };
    kind: "opsx-config-bundle";
    evidence: {
      schemas: {
        success: boolean;
        stdout: string;
        stderr: string;
        exitCode: number | null;
        payload: CliJsonValue;
        diagnostics: z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">[];
        contractError?: string | undefined;
      };
      schemaResolutions: Record<string, {
        success: boolean;
        stdout: string;
        stderr: string;
        exitCode: number | null;
        payload: CliJsonValue;
        diagnostics: z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">[];
        contractError?: string | undefined;
      }>;
    };
  } | {
    value: Record<string, z.objectInputType<{
      path: z.ZodString;
      source: z.ZodEnum<["project", "user", "package"]>;
    } & {
      displayPath: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">>;
    kind: "opsx-templates";
    evidence: {
      success: boolean;
      stdout: string;
      stderr: string;
      exitCode: number | null;
      payload: CliJsonValue;
      diagnostics: z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">[];
      contractError?: string | undefined;
    };
  } | {
    value: Record<string, {
      path: string;
      source: "project" | "user" | "package";
      content: string | null;
      displayPath?: string | undefined;
    }>;
    kind: "opsx-template-contents";
    evidence: {
      success: boolean;
      stdout: string;
      stderr: string;
      exitCode: number | null;
      payload: CliJsonValue;
      diagnostics: z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">[];
      contractError?: string | undefined;
    };
  } | {
    kind: "spec-catalog";
    value?: unknown;
  } | {
    kind: "spec-document";
    value?: unknown;
  };
  freshness: "stale-display-only";
  snapshotGeneration: number;
  identity: string;
  workGeneration: number;
  invalidationCause: "dependency" | "initial" | "explicit-refresh" | "subscriber-resume";
}>]>;
type PlanningCliProjectionState = z.infer<typeof PlanningCliProjectionStateSchema>;
/** Browser-safe runtime schema for the CLI-owned Environment Global projection. */
declare const EnvironmentGlobalProjectionDataSchema: z.ZodObject<{
  kind: z.ZodLiteral<"environment-global">;
  owner: z.ZodObject<{
    kind: z.ZodLiteral<"runtime-environment">;
    dataScope: z.ZodObject<{
      path: z.ZodString;
      source: z.ZodEnum<["xdg-data-home", "local-app-data", "user-home-default"]>;
      environmentVariable: z.ZodNullable<z.ZodEnum<["XDG_DATA_HOME", "LOCALAPPDATA"]>>;
    }, "strip", z.ZodTypeAny, {
      path: string;
      source: "xdg-data-home" | "local-app-data" | "user-home-default";
      environmentVariable: "XDG_DATA_HOME" | "LOCALAPPDATA" | null;
    }, {
      path: string;
      source: "xdg-data-home" | "local-app-data" | "user-home-default";
      environmentVariable: "XDG_DATA_HOME" | "LOCALAPPDATA" | null;
    }>;
  }, "strip", z.ZodTypeAny, {
    kind: "runtime-environment";
    dataScope: {
      path: string;
      source: "xdg-data-home" | "local-app-data" | "user-home-default";
      environmentVariable: "XDG_DATA_HOME" | "LOCALAPPDATA" | null;
    };
  }, {
    kind: "runtime-environment";
    dataScope: {
      path: string;
      source: "xdg-data-home" | "local-app-data" | "user-home-default";
      environmentVariable: "XDG_DATA_HOME" | "LOCALAPPDATA" | null;
    };
  }>;
  configPath: z.ZodNullable<z.ZodString>;
  config: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodType<CliJsonValue, z.ZodTypeDef, CliJsonValue>>>;
  defaultStore: z.ZodDiscriminatedUnion<"state", [z.ZodObject<{
    state: z.ZodLiteral<"absent">;
    id: z.ZodNull;
  }, "strip", z.ZodTypeAny, {
    id: null;
    state: "absent";
  }, {
    id: null;
    state: "absent";
  }>, z.ZodObject<{
    state: z.ZodLiteral<"configured">;
    id: z.ZodString;
  }, "strip", z.ZodTypeAny, {
    id: string;
    state: "configured";
  }, {
    id: string;
    state: "configured";
  }>, z.ZodObject<{
    state: z.ZodLiteral<"invalid">;
    id: z.ZodNull;
    value: z.ZodType<CliJsonValue, z.ZodTypeDef, CliJsonValue>;
  }, "strip", z.ZodTypeAny, {
    value: CliJsonValue;
    id: null;
    state: "invalid";
  }, {
    value: CliJsonValue;
    id: null;
    state: "invalid";
  }>]>;
  profileState: z.ZodObject<{
    available: z.ZodBoolean;
    profile: z.ZodNullable<z.ZodEnum<["core", "custom"]>>;
    delivery: z.ZodNullable<z.ZodEnum<["both", "skills", "commands"]>>;
    workflows: z.ZodArray<z.ZodString, "many">;
    driftStatus: z.ZodEnum<["in-sync", "drift", "unknown"]>;
    warningText: z.ZodNullable<z.ZodString>;
    error: z.ZodOptional<z.ZodString>;
  }, "strip", z.ZodTypeAny, {
    profile: "custom" | "core" | null;
    available: boolean;
    delivery: "both" | "skills" | "commands" | null;
    workflows: string[];
    driftStatus: "unknown" | "in-sync" | "drift";
    warningText: string | null;
    error?: string | undefined;
  }, {
    profile: "custom" | "core" | null;
    available: boolean;
    delivery: "both" | "skills" | "commands" | null;
    workflows: string[];
    driftStatus: "unknown" | "in-sync" | "drift";
    warningText: string | null;
    error?: string | undefined;
  }>;
  evidence: z.ZodObject<{
    path: z.ZodObject<{
      success: z.ZodBoolean;
      stdout: z.ZodString;
      stderr: z.ZodString;
      exitCode: z.ZodNullable<z.ZodNumber>;
    }, "strip", z.ZodTypeAny, {
      success: boolean;
      stdout: string;
      stderr: string;
      exitCode: number | null;
    }, {
      success: boolean;
      stdout: string;
      stderr: string;
      exitCode: number | null;
    }>;
    config: z.ZodObject<{
      success: z.ZodBoolean;
      stdout: z.ZodString;
      stderr: z.ZodString;
      exitCode: z.ZodNullable<z.ZodNumber>;
    } & {
      data: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodType<CliJsonValue, z.ZodTypeDef, CliJsonValue>>>;
      payload: z.ZodNullable<z.ZodType<CliJsonValue, z.ZodTypeDef, CliJsonValue>>;
      diagnostics: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
      contractError: z.ZodOptional<z.ZodString>;
    }, "strip", z.ZodTypeAny, {
      success: boolean;
      stdout: string;
      stderr: string;
      exitCode: number | null;
      payload: CliJsonValue;
      diagnostics: z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">[];
      data: Record<string, CliJsonValue> | null;
      contractError?: string | undefined;
    }, {
      success: boolean;
      stdout: string;
      stderr: string;
      exitCode: number | null;
      payload: CliJsonValue;
      diagnostics: z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">[];
      data: Record<string, CliJsonValue> | null;
      contractError?: string | undefined;
    }>;
    drift: z.ZodObject<{
      success: z.ZodBoolean;
      stdout: z.ZodString;
      stderr: z.ZodString;
      exitCode: z.ZodNullable<z.ZodNumber>;
    }, "strip", z.ZodTypeAny, {
      success: boolean;
      stdout: string;
      stderr: string;
      exitCode: number | null;
    }, {
      success: boolean;
      stdout: string;
      stderr: string;
      exitCode: number | null;
    }>;
  }, "strip", z.ZodTypeAny, {
    path: {
      success: boolean;
      stdout: string;
      stderr: string;
      exitCode: number | null;
    };
    config: {
      success: boolean;
      stdout: string;
      stderr: string;
      exitCode: number | null;
      payload: CliJsonValue;
      diagnostics: z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">[];
      data: Record<string, CliJsonValue> | null;
      contractError?: string | undefined;
    };
    drift: {
      success: boolean;
      stdout: string;
      stderr: string;
      exitCode: number | null;
    };
  }, {
    path: {
      success: boolean;
      stdout: string;
      stderr: string;
      exitCode: number | null;
    };
    config: {
      success: boolean;
      stdout: string;
      stderr: string;
      exitCode: number | null;
      payload: CliJsonValue;
      diagnostics: z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">[];
      data: Record<string, CliJsonValue> | null;
      contractError?: string | undefined;
    };
    drift: {
      success: boolean;
      stdout: string;
      stderr: string;
      exitCode: number | null;
    };
  }>;
}, "strip", z.ZodTypeAny, {
  kind: "environment-global";
  evidence: {
    path: {
      success: boolean;
      stdout: string;
      stderr: string;
      exitCode: number | null;
    };
    config: {
      success: boolean;
      stdout: string;
      stderr: string;
      exitCode: number | null;
      payload: CliJsonValue;
      diagnostics: z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">[];
      data: Record<string, CliJsonValue> | null;
      contractError?: string | undefined;
    };
    drift: {
      success: boolean;
      stdout: string;
      stderr: string;
      exitCode: number | null;
    };
  };
  owner: {
    kind: "runtime-environment";
    dataScope: {
      path: string;
      source: "xdg-data-home" | "local-app-data" | "user-home-default";
      environmentVariable: "XDG_DATA_HOME" | "LOCALAPPDATA" | null;
    };
  };
  configPath: string | null;
  config: Record<string, CliJsonValue> | null;
  defaultStore: {
    id: null;
    state: "absent";
  } | {
    id: string;
    state: "configured";
  } | {
    value: CliJsonValue;
    id: null;
    state: "invalid";
  };
  profileState: {
    profile: "custom" | "core" | null;
    available: boolean;
    delivery: "both" | "skills" | "commands" | null;
    workflows: string[];
    driftStatus: "unknown" | "in-sync" | "drift";
    warningText: string | null;
    error?: string | undefined;
  };
}, {
  kind: "environment-global";
  evidence: {
    path: {
      success: boolean;
      stdout: string;
      stderr: string;
      exitCode: number | null;
    };
    config: {
      success: boolean;
      stdout: string;
      stderr: string;
      exitCode: number | null;
      payload: CliJsonValue;
      diagnostics: z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">[];
      data: Record<string, CliJsonValue> | null;
      contractError?: string | undefined;
    };
    drift: {
      success: boolean;
      stdout: string;
      stderr: string;
      exitCode: number | null;
    };
  };
  owner: {
    kind: "runtime-environment";
    dataScope: {
      path: string;
      source: "xdg-data-home" | "local-app-data" | "user-home-default";
      environmentVariable: "XDG_DATA_HOME" | "LOCALAPPDATA" | null;
    };
  };
  configPath: string | null;
  config: Record<string, CliJsonValue> | null;
  defaultStore: {
    id: null;
    state: "absent";
  } | {
    id: string;
    state: "configured";
  } | {
    value: CliJsonValue;
    id: null;
    state: "invalid";
  };
  profileState: {
    profile: "custom" | "core" | null;
    available: boolean;
    delivery: "both" | "skills" | "commands" | null;
    workflows: string[];
    driftStatus: "unknown" | "in-sync" | "drift";
    warningText: string | null;
    error?: string | undefined;
  };
}>;
type EnvironmentGlobalProjectionData = z.infer<typeof EnvironmentGlobalProjectionDataSchema>;
/** Browser-safe file-native projection for the CLI-selected editable config document. */
declare const EnvironmentGlobalFileProjectionDataSchema: z.ZodObject<{
  kind: z.ZodLiteral<"environment-global-file">;
  owner: z.ZodObject<{
    kind: z.ZodLiteral<"runtime-environment">;
    dataScope: z.ZodObject<{
      path: z.ZodString;
      source: z.ZodEnum<["xdg-data-home", "local-app-data", "user-home-default"]>;
      environmentVariable: z.ZodNullable<z.ZodEnum<["XDG_DATA_HOME", "LOCALAPPDATA"]>>;
    }, "strip", z.ZodTypeAny, {
      path: string;
      source: "xdg-data-home" | "local-app-data" | "user-home-default";
      environmentVariable: "XDG_DATA_HOME" | "LOCALAPPDATA" | null;
    }, {
      path: string;
      source: "xdg-data-home" | "local-app-data" | "user-home-default";
      environmentVariable: "XDG_DATA_HOME" | "LOCALAPPDATA" | null;
    }>;
  }, "strip", z.ZodTypeAny, {
    kind: "runtime-environment";
    dataScope: {
      path: string;
      source: "xdg-data-home" | "local-app-data" | "user-home-default";
      environmentVariable: "XDG_DATA_HOME" | "LOCALAPPDATA" | null;
    };
  }, {
    kind: "runtime-environment";
    dataScope: {
      path: string;
      source: "xdg-data-home" | "local-app-data" | "user-home-default";
      environmentVariable: "XDG_DATA_HOME" | "LOCALAPPDATA" | null;
    };
  }>;
  file: z.ZodObject<{
    path: z.ZodNullable<z.ZodString>;
    format: z.ZodLiteral<"json">;
    exists: z.ZodBoolean;
    content: z.ZodNullable<z.ZodString>;
  }, "strip", z.ZodTypeAny, {
    path: string | null;
    content: string | null;
    format: "json";
    exists: boolean;
  }, {
    path: string | null;
    content: string | null;
    format: "json";
    exists: boolean;
  }>;
}, "strip", z.ZodTypeAny, {
  kind: "environment-global-file";
  owner: {
    kind: "runtime-environment";
    dataScope: {
      path: string;
      source: "xdg-data-home" | "local-app-data" | "user-home-default";
      environmentVariable: "XDG_DATA_HOME" | "LOCALAPPDATA" | null;
    };
  };
  file: {
    path: string | null;
    content: string | null;
    format: "json";
    exists: boolean;
  };
}, {
  kind: "environment-global-file";
  owner: {
    kind: "runtime-environment";
    dataScope: {
      path: string;
      source: "xdg-data-home" | "local-app-data" | "user-home-default";
      environmentVariable: "XDG_DATA_HOME" | "LOCALAPPDATA" | null;
    };
  };
  file: {
    path: string | null;
    content: string | null;
    format: "json";
    exists: boolean;
  };
}>;
type EnvironmentGlobalFileProjectionData = z.infer<typeof EnvironmentGlobalFileProjectionDataSchema>;
/** Browser-safe lifecycle Pull schema for the file-native config owner. */
declare const EnvironmentGlobalFileProjectionStateSchema: z.ZodDiscriminatedUnion<"state", [z.ZodObject<{
  state: z.ZodLiteral<"loading">;
  data: z.ZodNull;
  freshness: z.ZodNull;
  snapshotGeneration: z.ZodNull;
  error: z.ZodNull;
  identity: z.ZodString;
  workGeneration: z.ZodNumber;
  invalidationCause: z.ZodEnum<["initial", "dependency", "explicit-refresh", "subscriber-resume"]>;
}, "strip", z.ZodTypeAny, {
  error: null;
  state: "loading";
  data: null;
  freshness: null;
  snapshotGeneration: null;
  identity: string;
  workGeneration: number;
  invalidationCause: "dependency" | "initial" | "explicit-refresh" | "subscriber-resume";
}, {
  error: null;
  state: "loading";
  data: null;
  freshness: null;
  snapshotGeneration: null;
  identity: string;
  workGeneration: number;
  invalidationCause: "dependency" | "initial" | "explicit-refresh" | "subscriber-resume";
}>, z.ZodObject<{
  state: z.ZodLiteral<"ready">;
  data: z.ZodType<{
    kind: "environment-global-file";
    owner: {
      kind: "runtime-environment";
      dataScope: {
        path: string;
        source: "xdg-data-home" | "local-app-data" | "user-home-default";
        environmentVariable: "XDG_DATA_HOME" | "LOCALAPPDATA" | null;
      };
    };
    file: {
      path: string | null;
      content: string | null;
      format: "json";
      exists: boolean;
    };
  }, z.ZodTypeDef, {
    kind: "environment-global-file";
    owner: {
      kind: "runtime-environment";
      dataScope: {
        path: string;
        source: "xdg-data-home" | "local-app-data" | "user-home-default";
        environmentVariable: "XDG_DATA_HOME" | "LOCALAPPDATA" | null;
      };
    };
    file: {
      path: string | null;
      content: string | null;
      format: "json";
      exists: boolean;
    };
  }>;
  freshness: z.ZodLiteral<"current">;
  snapshotGeneration: z.ZodNumber;
  error: z.ZodNull;
  identity: z.ZodString;
  workGeneration: z.ZodNumber;
  invalidationCause: z.ZodEnum<["initial", "dependency", "explicit-refresh", "subscriber-resume"]>;
}, "strip", z.ZodTypeAny, {
  error: null;
  state: "ready";
  data: {
    kind: "environment-global-file";
    owner: {
      kind: "runtime-environment";
      dataScope: {
        path: string;
        source: "xdg-data-home" | "local-app-data" | "user-home-default";
        environmentVariable: "XDG_DATA_HOME" | "LOCALAPPDATA" | null;
      };
    };
    file: {
      path: string | null;
      content: string | null;
      format: "json";
      exists: boolean;
    };
  };
  freshness: "current";
  snapshotGeneration: number;
  identity: string;
  workGeneration: number;
  invalidationCause: "dependency" | "initial" | "explicit-refresh" | "subscriber-resume";
}, {
  error: null;
  state: "ready";
  data: {
    kind: "environment-global-file";
    owner: {
      kind: "runtime-environment";
      dataScope: {
        path: string;
        source: "xdg-data-home" | "local-app-data" | "user-home-default";
        environmentVariable: "XDG_DATA_HOME" | "LOCALAPPDATA" | null;
      };
    };
    file: {
      path: string | null;
      content: string | null;
      format: "json";
      exists: boolean;
    };
  };
  freshness: "current";
  snapshotGeneration: number;
  identity: string;
  workGeneration: number;
  invalidationCause: "dependency" | "initial" | "explicit-refresh" | "subscriber-resume";
}>, z.ZodObject<{
  state: z.ZodLiteral<"revalidating">;
  data: z.ZodType<{
    kind: "environment-global-file";
    owner: {
      kind: "runtime-environment";
      dataScope: {
        path: string;
        source: "xdg-data-home" | "local-app-data" | "user-home-default";
        environmentVariable: "XDG_DATA_HOME" | "LOCALAPPDATA" | null;
      };
    };
    file: {
      path: string | null;
      content: string | null;
      format: "json";
      exists: boolean;
    };
  }, z.ZodTypeDef, {
    kind: "environment-global-file";
    owner: {
      kind: "runtime-environment";
      dataScope: {
        path: string;
        source: "xdg-data-home" | "local-app-data" | "user-home-default";
        environmentVariable: "XDG_DATA_HOME" | "LOCALAPPDATA" | null;
      };
    };
    file: {
      path: string | null;
      content: string | null;
      format: "json";
      exists: boolean;
    };
  }>;
  freshness: z.ZodLiteral<"stale-display-only">;
  snapshotGeneration: z.ZodNumber;
  error: z.ZodNull;
  identity: z.ZodString;
  workGeneration: z.ZodNumber;
  invalidationCause: z.ZodEnum<["initial", "dependency", "explicit-refresh", "subscriber-resume"]>;
}, "strip", z.ZodTypeAny, {
  error: null;
  state: "revalidating";
  data: {
    kind: "environment-global-file";
    owner: {
      kind: "runtime-environment";
      dataScope: {
        path: string;
        source: "xdg-data-home" | "local-app-data" | "user-home-default";
        environmentVariable: "XDG_DATA_HOME" | "LOCALAPPDATA" | null;
      };
    };
    file: {
      path: string | null;
      content: string | null;
      format: "json";
      exists: boolean;
    };
  };
  freshness: "stale-display-only";
  snapshotGeneration: number;
  identity: string;
  workGeneration: number;
  invalidationCause: "dependency" | "initial" | "explicit-refresh" | "subscriber-resume";
}, {
  error: null;
  state: "revalidating";
  data: {
    kind: "environment-global-file";
    owner: {
      kind: "runtime-environment";
      dataScope: {
        path: string;
        source: "xdg-data-home" | "local-app-data" | "user-home-default";
        environmentVariable: "XDG_DATA_HOME" | "LOCALAPPDATA" | null;
      };
    };
    file: {
      path: string | null;
      content: string | null;
      format: "json";
      exists: boolean;
    };
  };
  freshness: "stale-display-only";
  snapshotGeneration: number;
  identity: string;
  workGeneration: number;
  invalidationCause: "dependency" | "initial" | "explicit-refresh" | "subscriber-resume";
}>, z.ZodObject<{
  state: z.ZodLiteral<"error">;
  data: z.ZodNull;
  freshness: z.ZodNull;
  snapshotGeneration: z.ZodNull;
  error: z.ZodObject<{
    name: z.ZodString;
    message: z.ZodString;
    cliEvidence: z.ZodNullable<z.ZodObject<{
      success: z.ZodBoolean;
      stdout: z.ZodString;
      stderr: z.ZodString;
      exitCode: z.ZodNullable<z.ZodNumber>;
      payload: z.ZodNullable<z.ZodType<CliJsonValue, z.ZodTypeDef, CliJsonValue>>;
      diagnostics: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
      contractError: z.ZodOptional<z.ZodString>;
    }, "strip", z.ZodTypeAny, {
      success: boolean;
      stdout: string;
      stderr: string;
      exitCode: number | null;
      payload: CliJsonValue;
      diagnostics: z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">[];
      contractError?: string | undefined;
    }, {
      success: boolean;
      stdout: string;
      stderr: string;
      exitCode: number | null;
      payload: CliJsonValue;
      diagnostics: z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">[];
      contractError?: string | undefined;
    }>>;
  }, "strip", z.ZodTypeAny, {
    message: string;
    name: string;
    cliEvidence: {
      success: boolean;
      stdout: string;
      stderr: string;
      exitCode: number | null;
      payload: CliJsonValue;
      diagnostics: z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">[];
      contractError?: string | undefined;
    } | null;
  }, {
    message: string;
    name: string;
    cliEvidence: {
      success: boolean;
      stdout: string;
      stderr: string;
      exitCode: number | null;
      payload: CliJsonValue;
      diagnostics: z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">[];
      contractError?: string | undefined;
    } | null;
  }>;
  identity: z.ZodString;
  workGeneration: z.ZodNumber;
  invalidationCause: z.ZodEnum<["initial", "dependency", "explicit-refresh", "subscriber-resume"]>;
}, "strip", z.ZodTypeAny, {
  error: {
    message: string;
    name: string;
    cliEvidence: {
      success: boolean;
      stdout: string;
      stderr: string;
      exitCode: number | null;
      payload: CliJsonValue;
      diagnostics: z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">[];
      contractError?: string | undefined;
    } | null;
  };
  state: "error";
  data: null;
  freshness: null;
  snapshotGeneration: null;
  identity: string;
  workGeneration: number;
  invalidationCause: "dependency" | "initial" | "explicit-refresh" | "subscriber-resume";
}, {
  error: {
    message: string;
    name: string;
    cliEvidence: {
      success: boolean;
      stdout: string;
      stderr: string;
      exitCode: number | null;
      payload: CliJsonValue;
      diagnostics: z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">[];
      contractError?: string | undefined;
    } | null;
  };
  state: "error";
  data: null;
  freshness: null;
  snapshotGeneration: null;
  identity: string;
  workGeneration: number;
  invalidationCause: "dependency" | "initial" | "explicit-refresh" | "subscriber-resume";
}>, z.ZodObject<{
  state: z.ZodLiteral<"refresh-error">;
  data: z.ZodType<{
    kind: "environment-global-file";
    owner: {
      kind: "runtime-environment";
      dataScope: {
        path: string;
        source: "xdg-data-home" | "local-app-data" | "user-home-default";
        environmentVariable: "XDG_DATA_HOME" | "LOCALAPPDATA" | null;
      };
    };
    file: {
      path: string | null;
      content: string | null;
      format: "json";
      exists: boolean;
    };
  }, z.ZodTypeDef, {
    kind: "environment-global-file";
    owner: {
      kind: "runtime-environment";
      dataScope: {
        path: string;
        source: "xdg-data-home" | "local-app-data" | "user-home-default";
        environmentVariable: "XDG_DATA_HOME" | "LOCALAPPDATA" | null;
      };
    };
    file: {
      path: string | null;
      content: string | null;
      format: "json";
      exists: boolean;
    };
  }>;
  freshness: z.ZodLiteral<"stale-display-only">;
  snapshotGeneration: z.ZodNumber;
  error: z.ZodObject<{
    name: z.ZodString;
    message: z.ZodString;
    cliEvidence: z.ZodNullable<z.ZodObject<{
      success: z.ZodBoolean;
      stdout: z.ZodString;
      stderr: z.ZodString;
      exitCode: z.ZodNullable<z.ZodNumber>;
      payload: z.ZodNullable<z.ZodType<CliJsonValue, z.ZodTypeDef, CliJsonValue>>;
      diagnostics: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
      contractError: z.ZodOptional<z.ZodString>;
    }, "strip", z.ZodTypeAny, {
      success: boolean;
      stdout: string;
      stderr: string;
      exitCode: number | null;
      payload: CliJsonValue;
      diagnostics: z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">[];
      contractError?: string | undefined;
    }, {
      success: boolean;
      stdout: string;
      stderr: string;
      exitCode: number | null;
      payload: CliJsonValue;
      diagnostics: z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">[];
      contractError?: string | undefined;
    }>>;
  }, "strip", z.ZodTypeAny, {
    message: string;
    name: string;
    cliEvidence: {
      success: boolean;
      stdout: string;
      stderr: string;
      exitCode: number | null;
      payload: CliJsonValue;
      diagnostics: z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">[];
      contractError?: string | undefined;
    } | null;
  }, {
    message: string;
    name: string;
    cliEvidence: {
      success: boolean;
      stdout: string;
      stderr: string;
      exitCode: number | null;
      payload: CliJsonValue;
      diagnostics: z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">[];
      contractError?: string | undefined;
    } | null;
  }>;
  identity: z.ZodString;
  workGeneration: z.ZodNumber;
  invalidationCause: z.ZodEnum<["initial", "dependency", "explicit-refresh", "subscriber-resume"]>;
}, "strip", z.ZodTypeAny, {
  error: {
    message: string;
    name: string;
    cliEvidence: {
      success: boolean;
      stdout: string;
      stderr: string;
      exitCode: number | null;
      payload: CliJsonValue;
      diagnostics: z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">[];
      contractError?: string | undefined;
    } | null;
  };
  state: "refresh-error";
  data: {
    kind: "environment-global-file";
    owner: {
      kind: "runtime-environment";
      dataScope: {
        path: string;
        source: "xdg-data-home" | "local-app-data" | "user-home-default";
        environmentVariable: "XDG_DATA_HOME" | "LOCALAPPDATA" | null;
      };
    };
    file: {
      path: string | null;
      content: string | null;
      format: "json";
      exists: boolean;
    };
  };
  freshness: "stale-display-only";
  snapshotGeneration: number;
  identity: string;
  workGeneration: number;
  invalidationCause: "dependency" | "initial" | "explicit-refresh" | "subscriber-resume";
}, {
  error: {
    message: string;
    name: string;
    cliEvidence: {
      success: boolean;
      stdout: string;
      stderr: string;
      exitCode: number | null;
      payload: CliJsonValue;
      diagnostics: z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">[];
      contractError?: string | undefined;
    } | null;
  };
  state: "refresh-error";
  data: {
    kind: "environment-global-file";
    owner: {
      kind: "runtime-environment";
      dataScope: {
        path: string;
        source: "xdg-data-home" | "local-app-data" | "user-home-default";
        environmentVariable: "XDG_DATA_HOME" | "LOCALAPPDATA" | null;
      };
    };
    file: {
      path: string | null;
      content: string | null;
      format: "json";
      exists: boolean;
    };
  };
  freshness: "stale-display-only";
  snapshotGeneration: number;
  identity: string;
  workGeneration: number;
  invalidationCause: "dependency" | "initial" | "explicit-refresh" | "subscriber-resume";
}>]>;
type EnvironmentGlobalFileProjectionState = z.infer<typeof EnvironmentGlobalFileProjectionStateSchema>;
/** Browser-safe lifecycle Pull schema for the runtime-environment config/profile projection. */
declare const EnvironmentGlobalProjectionStateSchema: z.ZodDiscriminatedUnion<"state", [z.ZodObject<{
  state: z.ZodLiteral<"loading">;
  data: z.ZodNull;
  freshness: z.ZodNull;
  snapshotGeneration: z.ZodNull;
  error: z.ZodNull;
  identity: z.ZodString;
  workGeneration: z.ZodNumber;
  invalidationCause: z.ZodEnum<["initial", "dependency", "explicit-refresh", "subscriber-resume"]>;
}, "strip", z.ZodTypeAny, {
  error: null;
  state: "loading";
  data: null;
  freshness: null;
  snapshotGeneration: null;
  identity: string;
  workGeneration: number;
  invalidationCause: "dependency" | "initial" | "explicit-refresh" | "subscriber-resume";
}, {
  error: null;
  state: "loading";
  data: null;
  freshness: null;
  snapshotGeneration: null;
  identity: string;
  workGeneration: number;
  invalidationCause: "dependency" | "initial" | "explicit-refresh" | "subscriber-resume";
}>, z.ZodObject<{
  state: z.ZodLiteral<"ready">;
  data: z.ZodType<{
    kind: "environment-global";
    evidence: {
      path: {
        success: boolean;
        stdout: string;
        stderr: string;
        exitCode: number | null;
      };
      config: {
        success: boolean;
        stdout: string;
        stderr: string;
        exitCode: number | null;
        payload: CliJsonValue;
        diagnostics: z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">[];
        data: Record<string, CliJsonValue> | null;
        contractError?: string | undefined;
      };
      drift: {
        success: boolean;
        stdout: string;
        stderr: string;
        exitCode: number | null;
      };
    };
    owner: {
      kind: "runtime-environment";
      dataScope: {
        path: string;
        source: "xdg-data-home" | "local-app-data" | "user-home-default";
        environmentVariable: "XDG_DATA_HOME" | "LOCALAPPDATA" | null;
      };
    };
    configPath: string | null;
    config: Record<string, CliJsonValue> | null;
    defaultStore: {
      id: null;
      state: "absent";
    } | {
      id: string;
      state: "configured";
    } | {
      value: CliJsonValue;
      id: null;
      state: "invalid";
    };
    profileState: {
      profile: "custom" | "core" | null;
      available: boolean;
      delivery: "both" | "skills" | "commands" | null;
      workflows: string[];
      driftStatus: "unknown" | "in-sync" | "drift";
      warningText: string | null;
      error?: string | undefined;
    };
  }, z.ZodTypeDef, {
    kind: "environment-global";
    evidence: {
      path: {
        success: boolean;
        stdout: string;
        stderr: string;
        exitCode: number | null;
      };
      config: {
        success: boolean;
        stdout: string;
        stderr: string;
        exitCode: number | null;
        payload: CliJsonValue;
        diagnostics: z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">[];
        data: Record<string, CliJsonValue> | null;
        contractError?: string | undefined;
      };
      drift: {
        success: boolean;
        stdout: string;
        stderr: string;
        exitCode: number | null;
      };
    };
    owner: {
      kind: "runtime-environment";
      dataScope: {
        path: string;
        source: "xdg-data-home" | "local-app-data" | "user-home-default";
        environmentVariable: "XDG_DATA_HOME" | "LOCALAPPDATA" | null;
      };
    };
    configPath: string | null;
    config: Record<string, CliJsonValue> | null;
    defaultStore: {
      id: null;
      state: "absent";
    } | {
      id: string;
      state: "configured";
    } | {
      value: CliJsonValue;
      id: null;
      state: "invalid";
    };
    profileState: {
      profile: "custom" | "core" | null;
      available: boolean;
      delivery: "both" | "skills" | "commands" | null;
      workflows: string[];
      driftStatus: "unknown" | "in-sync" | "drift";
      warningText: string | null;
      error?: string | undefined;
    };
  }>;
  freshness: z.ZodLiteral<"current">;
  snapshotGeneration: z.ZodNumber;
  error: z.ZodNull;
  identity: z.ZodString;
  workGeneration: z.ZodNumber;
  invalidationCause: z.ZodEnum<["initial", "dependency", "explicit-refresh", "subscriber-resume"]>;
}, "strip", z.ZodTypeAny, {
  error: null;
  state: "ready";
  data: {
    kind: "environment-global";
    evidence: {
      path: {
        success: boolean;
        stdout: string;
        stderr: string;
        exitCode: number | null;
      };
      config: {
        success: boolean;
        stdout: string;
        stderr: string;
        exitCode: number | null;
        payload: CliJsonValue;
        diagnostics: z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">[];
        data: Record<string, CliJsonValue> | null;
        contractError?: string | undefined;
      };
      drift: {
        success: boolean;
        stdout: string;
        stderr: string;
        exitCode: number | null;
      };
    };
    owner: {
      kind: "runtime-environment";
      dataScope: {
        path: string;
        source: "xdg-data-home" | "local-app-data" | "user-home-default";
        environmentVariable: "XDG_DATA_HOME" | "LOCALAPPDATA" | null;
      };
    };
    configPath: string | null;
    config: Record<string, CliJsonValue> | null;
    defaultStore: {
      id: null;
      state: "absent";
    } | {
      id: string;
      state: "configured";
    } | {
      value: CliJsonValue;
      id: null;
      state: "invalid";
    };
    profileState: {
      profile: "custom" | "core" | null;
      available: boolean;
      delivery: "both" | "skills" | "commands" | null;
      workflows: string[];
      driftStatus: "unknown" | "in-sync" | "drift";
      warningText: string | null;
      error?: string | undefined;
    };
  };
  freshness: "current";
  snapshotGeneration: number;
  identity: string;
  workGeneration: number;
  invalidationCause: "dependency" | "initial" | "explicit-refresh" | "subscriber-resume";
}, {
  error: null;
  state: "ready";
  data: {
    kind: "environment-global";
    evidence: {
      path: {
        success: boolean;
        stdout: string;
        stderr: string;
        exitCode: number | null;
      };
      config: {
        success: boolean;
        stdout: string;
        stderr: string;
        exitCode: number | null;
        payload: CliJsonValue;
        diagnostics: z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">[];
        data: Record<string, CliJsonValue> | null;
        contractError?: string | undefined;
      };
      drift: {
        success: boolean;
        stdout: string;
        stderr: string;
        exitCode: number | null;
      };
    };
    owner: {
      kind: "runtime-environment";
      dataScope: {
        path: string;
        source: "xdg-data-home" | "local-app-data" | "user-home-default";
        environmentVariable: "XDG_DATA_HOME" | "LOCALAPPDATA" | null;
      };
    };
    configPath: string | null;
    config: Record<string, CliJsonValue> | null;
    defaultStore: {
      id: null;
      state: "absent";
    } | {
      id: string;
      state: "configured";
    } | {
      value: CliJsonValue;
      id: null;
      state: "invalid";
    };
    profileState: {
      profile: "custom" | "core" | null;
      available: boolean;
      delivery: "both" | "skills" | "commands" | null;
      workflows: string[];
      driftStatus: "unknown" | "in-sync" | "drift";
      warningText: string | null;
      error?: string | undefined;
    };
  };
  freshness: "current";
  snapshotGeneration: number;
  identity: string;
  workGeneration: number;
  invalidationCause: "dependency" | "initial" | "explicit-refresh" | "subscriber-resume";
}>, z.ZodObject<{
  state: z.ZodLiteral<"revalidating">;
  data: z.ZodType<{
    kind: "environment-global";
    evidence: {
      path: {
        success: boolean;
        stdout: string;
        stderr: string;
        exitCode: number | null;
      };
      config: {
        success: boolean;
        stdout: string;
        stderr: string;
        exitCode: number | null;
        payload: CliJsonValue;
        diagnostics: z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">[];
        data: Record<string, CliJsonValue> | null;
        contractError?: string | undefined;
      };
      drift: {
        success: boolean;
        stdout: string;
        stderr: string;
        exitCode: number | null;
      };
    };
    owner: {
      kind: "runtime-environment";
      dataScope: {
        path: string;
        source: "xdg-data-home" | "local-app-data" | "user-home-default";
        environmentVariable: "XDG_DATA_HOME" | "LOCALAPPDATA" | null;
      };
    };
    configPath: string | null;
    config: Record<string, CliJsonValue> | null;
    defaultStore: {
      id: null;
      state: "absent";
    } | {
      id: string;
      state: "configured";
    } | {
      value: CliJsonValue;
      id: null;
      state: "invalid";
    };
    profileState: {
      profile: "custom" | "core" | null;
      available: boolean;
      delivery: "both" | "skills" | "commands" | null;
      workflows: string[];
      driftStatus: "unknown" | "in-sync" | "drift";
      warningText: string | null;
      error?: string | undefined;
    };
  }, z.ZodTypeDef, {
    kind: "environment-global";
    evidence: {
      path: {
        success: boolean;
        stdout: string;
        stderr: string;
        exitCode: number | null;
      };
      config: {
        success: boolean;
        stdout: string;
        stderr: string;
        exitCode: number | null;
        payload: CliJsonValue;
        diagnostics: z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">[];
        data: Record<string, CliJsonValue> | null;
        contractError?: string | undefined;
      };
      drift: {
        success: boolean;
        stdout: string;
        stderr: string;
        exitCode: number | null;
      };
    };
    owner: {
      kind: "runtime-environment";
      dataScope: {
        path: string;
        source: "xdg-data-home" | "local-app-data" | "user-home-default";
        environmentVariable: "XDG_DATA_HOME" | "LOCALAPPDATA" | null;
      };
    };
    configPath: string | null;
    config: Record<string, CliJsonValue> | null;
    defaultStore: {
      id: null;
      state: "absent";
    } | {
      id: string;
      state: "configured";
    } | {
      value: CliJsonValue;
      id: null;
      state: "invalid";
    };
    profileState: {
      profile: "custom" | "core" | null;
      available: boolean;
      delivery: "both" | "skills" | "commands" | null;
      workflows: string[];
      driftStatus: "unknown" | "in-sync" | "drift";
      warningText: string | null;
      error?: string | undefined;
    };
  }>;
  freshness: z.ZodLiteral<"stale-display-only">;
  snapshotGeneration: z.ZodNumber;
  error: z.ZodNull;
  identity: z.ZodString;
  workGeneration: z.ZodNumber;
  invalidationCause: z.ZodEnum<["initial", "dependency", "explicit-refresh", "subscriber-resume"]>;
}, "strip", z.ZodTypeAny, {
  error: null;
  state: "revalidating";
  data: {
    kind: "environment-global";
    evidence: {
      path: {
        success: boolean;
        stdout: string;
        stderr: string;
        exitCode: number | null;
      };
      config: {
        success: boolean;
        stdout: string;
        stderr: string;
        exitCode: number | null;
        payload: CliJsonValue;
        diagnostics: z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">[];
        data: Record<string, CliJsonValue> | null;
        contractError?: string | undefined;
      };
      drift: {
        success: boolean;
        stdout: string;
        stderr: string;
        exitCode: number | null;
      };
    };
    owner: {
      kind: "runtime-environment";
      dataScope: {
        path: string;
        source: "xdg-data-home" | "local-app-data" | "user-home-default";
        environmentVariable: "XDG_DATA_HOME" | "LOCALAPPDATA" | null;
      };
    };
    configPath: string | null;
    config: Record<string, CliJsonValue> | null;
    defaultStore: {
      id: null;
      state: "absent";
    } | {
      id: string;
      state: "configured";
    } | {
      value: CliJsonValue;
      id: null;
      state: "invalid";
    };
    profileState: {
      profile: "custom" | "core" | null;
      available: boolean;
      delivery: "both" | "skills" | "commands" | null;
      workflows: string[];
      driftStatus: "unknown" | "in-sync" | "drift";
      warningText: string | null;
      error?: string | undefined;
    };
  };
  freshness: "stale-display-only";
  snapshotGeneration: number;
  identity: string;
  workGeneration: number;
  invalidationCause: "dependency" | "initial" | "explicit-refresh" | "subscriber-resume";
}, {
  error: null;
  state: "revalidating";
  data: {
    kind: "environment-global";
    evidence: {
      path: {
        success: boolean;
        stdout: string;
        stderr: string;
        exitCode: number | null;
      };
      config: {
        success: boolean;
        stdout: string;
        stderr: string;
        exitCode: number | null;
        payload: CliJsonValue;
        diagnostics: z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">[];
        data: Record<string, CliJsonValue> | null;
        contractError?: string | undefined;
      };
      drift: {
        success: boolean;
        stdout: string;
        stderr: string;
        exitCode: number | null;
      };
    };
    owner: {
      kind: "runtime-environment";
      dataScope: {
        path: string;
        source: "xdg-data-home" | "local-app-data" | "user-home-default";
        environmentVariable: "XDG_DATA_HOME" | "LOCALAPPDATA" | null;
      };
    };
    configPath: string | null;
    config: Record<string, CliJsonValue> | null;
    defaultStore: {
      id: null;
      state: "absent";
    } | {
      id: string;
      state: "configured";
    } | {
      value: CliJsonValue;
      id: null;
      state: "invalid";
    };
    profileState: {
      profile: "custom" | "core" | null;
      available: boolean;
      delivery: "both" | "skills" | "commands" | null;
      workflows: string[];
      driftStatus: "unknown" | "in-sync" | "drift";
      warningText: string | null;
      error?: string | undefined;
    };
  };
  freshness: "stale-display-only";
  snapshotGeneration: number;
  identity: string;
  workGeneration: number;
  invalidationCause: "dependency" | "initial" | "explicit-refresh" | "subscriber-resume";
}>, z.ZodObject<{
  state: z.ZodLiteral<"error">;
  data: z.ZodNull;
  freshness: z.ZodNull;
  snapshotGeneration: z.ZodNull;
  error: z.ZodObject<{
    name: z.ZodString;
    message: z.ZodString;
    cliEvidence: z.ZodNullable<z.ZodObject<{
      success: z.ZodBoolean;
      stdout: z.ZodString;
      stderr: z.ZodString;
      exitCode: z.ZodNullable<z.ZodNumber>;
      payload: z.ZodNullable<z.ZodType<CliJsonValue, z.ZodTypeDef, CliJsonValue>>;
      diagnostics: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
      contractError: z.ZodOptional<z.ZodString>;
    }, "strip", z.ZodTypeAny, {
      success: boolean;
      stdout: string;
      stderr: string;
      exitCode: number | null;
      payload: CliJsonValue;
      diagnostics: z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">[];
      contractError?: string | undefined;
    }, {
      success: boolean;
      stdout: string;
      stderr: string;
      exitCode: number | null;
      payload: CliJsonValue;
      diagnostics: z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">[];
      contractError?: string | undefined;
    }>>;
  }, "strip", z.ZodTypeAny, {
    message: string;
    name: string;
    cliEvidence: {
      success: boolean;
      stdout: string;
      stderr: string;
      exitCode: number | null;
      payload: CliJsonValue;
      diagnostics: z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">[];
      contractError?: string | undefined;
    } | null;
  }, {
    message: string;
    name: string;
    cliEvidence: {
      success: boolean;
      stdout: string;
      stderr: string;
      exitCode: number | null;
      payload: CliJsonValue;
      diagnostics: z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">[];
      contractError?: string | undefined;
    } | null;
  }>;
  identity: z.ZodString;
  workGeneration: z.ZodNumber;
  invalidationCause: z.ZodEnum<["initial", "dependency", "explicit-refresh", "subscriber-resume"]>;
}, "strip", z.ZodTypeAny, {
  error: {
    message: string;
    name: string;
    cliEvidence: {
      success: boolean;
      stdout: string;
      stderr: string;
      exitCode: number | null;
      payload: CliJsonValue;
      diagnostics: z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">[];
      contractError?: string | undefined;
    } | null;
  };
  state: "error";
  data: null;
  freshness: null;
  snapshotGeneration: null;
  identity: string;
  workGeneration: number;
  invalidationCause: "dependency" | "initial" | "explicit-refresh" | "subscriber-resume";
}, {
  error: {
    message: string;
    name: string;
    cliEvidence: {
      success: boolean;
      stdout: string;
      stderr: string;
      exitCode: number | null;
      payload: CliJsonValue;
      diagnostics: z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">[];
      contractError?: string | undefined;
    } | null;
  };
  state: "error";
  data: null;
  freshness: null;
  snapshotGeneration: null;
  identity: string;
  workGeneration: number;
  invalidationCause: "dependency" | "initial" | "explicit-refresh" | "subscriber-resume";
}>, z.ZodObject<{
  state: z.ZodLiteral<"refresh-error">;
  data: z.ZodType<{
    kind: "environment-global";
    evidence: {
      path: {
        success: boolean;
        stdout: string;
        stderr: string;
        exitCode: number | null;
      };
      config: {
        success: boolean;
        stdout: string;
        stderr: string;
        exitCode: number | null;
        payload: CliJsonValue;
        diagnostics: z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">[];
        data: Record<string, CliJsonValue> | null;
        contractError?: string | undefined;
      };
      drift: {
        success: boolean;
        stdout: string;
        stderr: string;
        exitCode: number | null;
      };
    };
    owner: {
      kind: "runtime-environment";
      dataScope: {
        path: string;
        source: "xdg-data-home" | "local-app-data" | "user-home-default";
        environmentVariable: "XDG_DATA_HOME" | "LOCALAPPDATA" | null;
      };
    };
    configPath: string | null;
    config: Record<string, CliJsonValue> | null;
    defaultStore: {
      id: null;
      state: "absent";
    } | {
      id: string;
      state: "configured";
    } | {
      value: CliJsonValue;
      id: null;
      state: "invalid";
    };
    profileState: {
      profile: "custom" | "core" | null;
      available: boolean;
      delivery: "both" | "skills" | "commands" | null;
      workflows: string[];
      driftStatus: "unknown" | "in-sync" | "drift";
      warningText: string | null;
      error?: string | undefined;
    };
  }, z.ZodTypeDef, {
    kind: "environment-global";
    evidence: {
      path: {
        success: boolean;
        stdout: string;
        stderr: string;
        exitCode: number | null;
      };
      config: {
        success: boolean;
        stdout: string;
        stderr: string;
        exitCode: number | null;
        payload: CliJsonValue;
        diagnostics: z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">[];
        data: Record<string, CliJsonValue> | null;
        contractError?: string | undefined;
      };
      drift: {
        success: boolean;
        stdout: string;
        stderr: string;
        exitCode: number | null;
      };
    };
    owner: {
      kind: "runtime-environment";
      dataScope: {
        path: string;
        source: "xdg-data-home" | "local-app-data" | "user-home-default";
        environmentVariable: "XDG_DATA_HOME" | "LOCALAPPDATA" | null;
      };
    };
    configPath: string | null;
    config: Record<string, CliJsonValue> | null;
    defaultStore: {
      id: null;
      state: "absent";
    } | {
      id: string;
      state: "configured";
    } | {
      value: CliJsonValue;
      id: null;
      state: "invalid";
    };
    profileState: {
      profile: "custom" | "core" | null;
      available: boolean;
      delivery: "both" | "skills" | "commands" | null;
      workflows: string[];
      driftStatus: "unknown" | "in-sync" | "drift";
      warningText: string | null;
      error?: string | undefined;
    };
  }>;
  freshness: z.ZodLiteral<"stale-display-only">;
  snapshotGeneration: z.ZodNumber;
  error: z.ZodObject<{
    name: z.ZodString;
    message: z.ZodString;
    cliEvidence: z.ZodNullable<z.ZodObject<{
      success: z.ZodBoolean;
      stdout: z.ZodString;
      stderr: z.ZodString;
      exitCode: z.ZodNullable<z.ZodNumber>;
      payload: z.ZodNullable<z.ZodType<CliJsonValue, z.ZodTypeDef, CliJsonValue>>;
      diagnostics: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
      contractError: z.ZodOptional<z.ZodString>;
    }, "strip", z.ZodTypeAny, {
      success: boolean;
      stdout: string;
      stderr: string;
      exitCode: number | null;
      payload: CliJsonValue;
      diagnostics: z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">[];
      contractError?: string | undefined;
    }, {
      success: boolean;
      stdout: string;
      stderr: string;
      exitCode: number | null;
      payload: CliJsonValue;
      diagnostics: z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">[];
      contractError?: string | undefined;
    }>>;
  }, "strip", z.ZodTypeAny, {
    message: string;
    name: string;
    cliEvidence: {
      success: boolean;
      stdout: string;
      stderr: string;
      exitCode: number | null;
      payload: CliJsonValue;
      diagnostics: z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">[];
      contractError?: string | undefined;
    } | null;
  }, {
    message: string;
    name: string;
    cliEvidence: {
      success: boolean;
      stdout: string;
      stderr: string;
      exitCode: number | null;
      payload: CliJsonValue;
      diagnostics: z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">[];
      contractError?: string | undefined;
    } | null;
  }>;
  identity: z.ZodString;
  workGeneration: z.ZodNumber;
  invalidationCause: z.ZodEnum<["initial", "dependency", "explicit-refresh", "subscriber-resume"]>;
}, "strip", z.ZodTypeAny, {
  error: {
    message: string;
    name: string;
    cliEvidence: {
      success: boolean;
      stdout: string;
      stderr: string;
      exitCode: number | null;
      payload: CliJsonValue;
      diagnostics: z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">[];
      contractError?: string | undefined;
    } | null;
  };
  state: "refresh-error";
  data: {
    kind: "environment-global";
    evidence: {
      path: {
        success: boolean;
        stdout: string;
        stderr: string;
        exitCode: number | null;
      };
      config: {
        success: boolean;
        stdout: string;
        stderr: string;
        exitCode: number | null;
        payload: CliJsonValue;
        diagnostics: z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">[];
        data: Record<string, CliJsonValue> | null;
        contractError?: string | undefined;
      };
      drift: {
        success: boolean;
        stdout: string;
        stderr: string;
        exitCode: number | null;
      };
    };
    owner: {
      kind: "runtime-environment";
      dataScope: {
        path: string;
        source: "xdg-data-home" | "local-app-data" | "user-home-default";
        environmentVariable: "XDG_DATA_HOME" | "LOCALAPPDATA" | null;
      };
    };
    configPath: string | null;
    config: Record<string, CliJsonValue> | null;
    defaultStore: {
      id: null;
      state: "absent";
    } | {
      id: string;
      state: "configured";
    } | {
      value: CliJsonValue;
      id: null;
      state: "invalid";
    };
    profileState: {
      profile: "custom" | "core" | null;
      available: boolean;
      delivery: "both" | "skills" | "commands" | null;
      workflows: string[];
      driftStatus: "unknown" | "in-sync" | "drift";
      warningText: string | null;
      error?: string | undefined;
    };
  };
  freshness: "stale-display-only";
  snapshotGeneration: number;
  identity: string;
  workGeneration: number;
  invalidationCause: "dependency" | "initial" | "explicit-refresh" | "subscriber-resume";
}, {
  error: {
    message: string;
    name: string;
    cliEvidence: {
      success: boolean;
      stdout: string;
      stderr: string;
      exitCode: number | null;
      payload: CliJsonValue;
      diagnostics: z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">[];
      contractError?: string | undefined;
    } | null;
  };
  state: "refresh-error";
  data: {
    kind: "environment-global";
    evidence: {
      path: {
        success: boolean;
        stdout: string;
        stderr: string;
        exitCode: number | null;
      };
      config: {
        success: boolean;
        stdout: string;
        stderr: string;
        exitCode: number | null;
        payload: CliJsonValue;
        diagnostics: z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">[];
        data: Record<string, CliJsonValue> | null;
        contractError?: string | undefined;
      };
      drift: {
        success: boolean;
        stdout: string;
        stderr: string;
        exitCode: number | null;
      };
    };
    owner: {
      kind: "runtime-environment";
      dataScope: {
        path: string;
        source: "xdg-data-home" | "local-app-data" | "user-home-default";
        environmentVariable: "XDG_DATA_HOME" | "LOCALAPPDATA" | null;
      };
    };
    configPath: string | null;
    config: Record<string, CliJsonValue> | null;
    defaultStore: {
      id: null;
      state: "absent";
    } | {
      id: string;
      state: "configured";
    } | {
      value: CliJsonValue;
      id: null;
      state: "invalid";
    };
    profileState: {
      profile: "custom" | "core" | null;
      available: boolean;
      delivery: "both" | "skills" | "commands" | null;
      workflows: string[];
      driftStatus: "unknown" | "in-sync" | "drift";
      warningText: string | null;
      error?: string | undefined;
    };
  };
  freshness: "stale-display-only";
  snapshotGeneration: number;
  identity: string;
  workGeneration: number;
  invalidationCause: "dependency" | "initial" | "explicit-refresh" | "subscriber-resume";
}>]>;
type EnvironmentGlobalProjectionState = z.infer<typeof EnvironmentGlobalProjectionStateSchema>;
//#endregion
//#region src/runtime-root-invalidation.d.ts
/** One physical root mapped to the runtime facets it can invalidate. */
interface RuntimeInvalidationRoot {
  rootPath: string;
  referenceCount: number;
}
/** Reference-counted physical-root to runtime-facet invalidation owner. */
interface RuntimeRootInvalidationOwner {
  acquireRoot(rootPath: string): () => void;
}
/** Reference-counted path-to-facet mapping; physical watcher roots remain separately owned. */
declare class RuntimeRootInvalidationRegistry implements RuntimeRootInvalidationOwner {
  private readonly invalidation;
  private readonly facets;
  private readonly records;
  constructor(invalidation: RuntimeInvalidationController, facets: readonly RuntimeInvalidationFacet[]);
  acquireRoot(rootPath: string): () => void;
  getRoots(): RuntimeInvalidationRoot[];
  dispose(): void;
}
//#endregion
//#region src/agent-delivery-registry.d.ts
type AgentCommandSurfaceCapability = 'adapter-backed' | 'skills-invocable' | 'none';
type AgentCommandFormat = 'markdown' | 'toml';
type AgentCommandInvocationStyle = 'flat' | 'namespaced';
type AgentCommandContentFormat = {
  kind: 'markdown';
  frontmatter: {
    kind: 'yaml';
    fields: readonly string[];
  } | {
    kind: 'none';
  };
  bodyLayout: 'direct' | 'headings';
} | {
  kind: 'toml';
  fields: readonly ['description', 'prompt'];
};
interface AgentCommandArtifact {
  scope: 'project';
  format: AgentCommandFormat;
  content: AgentCommandContentFormat;
  pathTemplate: string;
  legacyPathTemplates?: readonly string[];
  invocation: {
    style: AgentCommandInvocationStyle;
    prefix: '@' | '/';
  };
}
interface AgentProjectCleanup {
  kind: 'project-patterns';
  patterns: readonly string[];
}
interface AgentManagedGlobalPromptCleanup {
  kind: 'managed-global-prompts';
  projectPatterns: readonly string[];
  managedFiles: Readonly<Record<string, readonly string[]>>;
  replacementLabel: string;
}
type AgentDeliveryCleanup = AgentProjectCleanup | AgentManagedGlobalPromptCleanup;
interface AgentDeliveryMigration {
  from: string;
  to: string;
  needsConsent: boolean;
}
interface AIToolOption {
  name: string;
  value: string;
  available: boolean;
  successLabel?: string;
  /** Current project-local skills root; null when delivery targets the user-global root only. */
  skillsDir: string | null;
  /** Former project roots read for detection and migrated after replacement. */
  legacySkillsDirs?: readonly string[];
  /** User-global skills root resolved against the home directory (e.g. `.minimax`). */
  globalSkillsDir?: string | null;
  detectionPaths?: readonly string[];
  setupNote?: string;
  /** True when the tool loads generated files through an IDE/editor process that must restart. */
  requiresIdeRestart?: boolean;
  /** First official CLI line declaring `requiresIdeRestart`; earlier lines carry no restart fact. */
  requiresIdeRestartSince?: AgentCliSeries;
  /** First official CLI line shipping this tool; earlier lines never list it. */
  minCliSeries?: AgentCliSeries;
  capability: AgentCommandSurfaceCapability;
  command: AgentCommandArtifact | null;
  aliases?: readonly string[];
  cleanup?: AgentDeliveryCleanup;
  migrations?: readonly AgentDeliveryMigration[];
}
/** Official OpenSpec CLI lines with distinct Agent inventories. */
type AgentCliSeries = '1.8' | '1.9';
/**
 * Select the official Agent delivery inventory for one CLI version string.
 *
 * Only a stable, admitted version — current (1.9.x) or supported non-current (1.8.x) — selects
 * an inventory. Unsupported forms (prereleases, >=1.10, below-range) and unparseable output
 * select none: a page-level version bypass must not manufacture a 1.9 inventory for a CLI the
 * release line refuses to admit.
 */
declare function selectAgentDeliveryRegistry(cliVersion: string | null): ToolConfig[];
interface ToolConfig extends AIToolOption {}
/** Backwards-compatible public name; the registry remains the single physical owner. */
declare const AI_TOOLS: ToolConfig[];
//#endregion
//#region src/tool-config.d.ts
/** Return registry entries available to OpenSpec init/update. */
declare function getAvailableTools(): ToolConfig[];
/** Return available official Tool ids. */
declare function getAvailableToolIds(): string[];
/** Return the complete official registry, including unavailable pseudo-tools. */
declare function getAllTools(): ToolConfig[];
/** Detect configured Agents using the official OpenSpec project and user-global detection rules. */
declare function getDetectedProjectTools(projectDir: string): Promise<ToolConfig[]>;
/** Return every current official Tool id in registry order. */
declare function getAllToolIds(): string[];
/** Resolve one current or retired Tool id to its official registry entry. */
declare function getToolById(toolId: string): ToolConfig | undefined;
/** Detect configured Agents through a retained reactive projection. */
declare function getConfiguredTools(projectDir: string): Promise<string[]>;
/** Check whether a current or retired Tool id resolves to configured skills. */
declare function isToolConfigured(projectDir: string, toolId: string): Promise<boolean>;
//#endregion
//#region src/agent-delivery-policy.d.ts
declare const AgentDeliveryProfileSchema: z.ZodEnum<["core", "custom"]>;
declare const AgentDeliveryModeSchema: z.ZodEnum<["both", "skills", "commands"]>;
declare const AgentDeliveryWorkflowSchema: z.ZodEnum<["propose", "explore", "new", "continue", "apply", "update", "ff", "sync", "archive", "bulk-archive", "verify", "onboard"]>;
declare const AgentDeliveryPolicyUpdateSchema: z.ZodEffects<z.ZodObject<{
  profile: z.ZodEnum<["core", "custom"]>;
  delivery: z.ZodEnum<["both", "skills", "commands"]>;
  workflows: z.ZodArray<z.ZodEnum<["propose", "explore", "new", "continue", "apply", "update", "ff", "sync", "archive", "bulk-archive", "verify", "onboard"]>, "many">;
}, "strip", z.ZodTypeAny, {
  profile: "custom" | "core";
  delivery: "both" | "skills" | "commands";
  workflows: ("apply" | "propose" | "explore" | "new" | "continue" | "update" | "ff" | "sync" | "archive" | "bulk-archive" | "verify" | "onboard")[];
}, {
  profile: "custom" | "core";
  delivery: "both" | "skills" | "commands";
  workflows: ("apply" | "propose" | "explore" | "new" | "continue" | "update" | "ff" | "sync" | "archive" | "bulk-archive" | "verify" | "onboard")[];
}>, {
  profile: "custom" | "core";
  delivery: "both" | "skills" | "commands";
  workflows: ("apply" | "propose" | "explore" | "new" | "continue" | "update" | "ff" | "sync" | "archive" | "bulk-archive" | "verify" | "onboard")[];
}, {
  profile: "custom" | "core";
  delivery: "both" | "skills" | "commands";
  workflows: ("apply" | "propose" | "explore" | "new" | "continue" | "update" | "ff" | "sync" | "archive" | "bulk-archive" | "verify" | "onboard")[];
}>;
type AgentDeliveryProfile = z.infer<typeof AgentDeliveryProfileSchema>;
type AgentDeliveryMode = z.infer<typeof AgentDeliveryModeSchema>;
type AgentDeliveryPolicyUpdate = z.infer<typeof AgentDeliveryPolicyUpdateSchema>;
interface AgentDeliveryPolicy {
  profile: AgentDeliveryProfile;
  delivery: AgentDeliveryMode;
  workflows: (typeof OPSX_ALL_WORKFLOWS)[number][];
}
/** Normalize authored policy through official omitted-value defaults and Core workflow semantics. */
declare function normalizeAgentDeliveryPolicy(input: {
  profile?: string | null;
  delivery?: string | null;
  workflows?: readonly string[] | null;
}): AgentDeliveryPolicy;
/** Update only official Agent policy keys while retaining every team-authored extension field. */
declare function applyAgentDeliveryPolicy(config: Readonly<Record<string, CliJsonValue>> | null, update: AgentDeliveryPolicyUpdate): Record<string, CliJsonValue>;
//#endregion
//#region src/agent-command-content.d.ts
/** Exact generated command contents keyed by official Agent id and OPSX workflow id. */
type AgentCommandContentCatalog = Readonly<Record<string, Readonly<Partial<Record<OpsxWorkflowId, string>>>>>;
/**
 * Command-generation evidence for one CLI runner.
 *
 * `unavailableTools` isolates tools whose command adapter this CLI line never shipped (for
 * example Command Code on OpenSpec 1.8): the tool is unavailable with a version-scoped
 * reason while every independently supported adapter's evidence stays available. The whole
 * result is null only when the runner has no importable generator boundary at all.
 */
interface AgentCommandContentResult {
  catalog: AgentCommandContentCatalog;
  unavailableTools: Readonly<Record<string, string>>;
}
/**
 * Load exact command contents from the configured OpenSpec CLI.
 *
 * The private generator is intentionally treated as optional evidence. When the runner is not an
 * importable local OpenSpec module, callers receive `null` and commands-only installs cannot be
 * declared current from path existence alone.
 */
declare function loadOpenSpecAgentCommandContents(cliCommand: readonly string[], workflows: readonly string[]): Promise<AgentCommandContentResult | null>;
//#endregion
//#region src/tool-init-state.d.ts
type ToolWorkflowId = OpsxWorkflowId;
type ToolInitDelivery = 'both' | 'skills' | 'commands';
type ToolInitStatus = 'unavailable' | 'uninitialized' | 'partial' | 'initialized' | 'stale-version' | 'cleanup-needed' | 'migration-required';
type ToolInitReadiness = 'unavailable' | 'uninitialized' | 'partial' | 'initialized';
type ToolInitIssue = 'stale-version' | 'cleanup-needed' | 'migration-required';
/** Pinned source version used when a runtime CLI version is not supplied by the Server owner. */
declare const PINNED_AGENT_GENERATOR_VERSION = "1.9.0";
/** Physical delivery scope of one tool's skills inventory. */
type ToolSkillsScope = {
  kind: 'project';
  skillsDir: string;
} | {
  kind: 'user-global';
  globalSkillsDir: string;
} | {
  kind: 'none';
};
/** Resolve the physical skills inventory scope for one registry entry. */
declare function resolveToolSkillsScope(tool: ToolConfig): ToolSkillsScope;
/** Resolve the absolute user-global skills inventory directory for a global root (e.g. `.minimax`). */
declare function resolveGlobalSkillsInventoryDir(globalSkillsDir: string): string;
/** External user-global skills inventory roots observed by the Agent delivery projection. */
declare function getExternalAgentSkillsObservationRoots(): string[];
interface ToolInitCleanupState {
  required: boolean;
  kind: 'managed-global-prompts' | 'project-artifacts' | 'mixed';
  paths: string[];
  workflows: ToolWorkflowId[];
  replacementLabel: string;
}
interface ToolInitMigrationState {
  from: string;
  to: string;
  needsConsent: boolean;
  workflows: ToolWorkflowId[];
  skillFiles: number;
  commandFiles: number;
}
interface ToolInitState {
  toolId: string;
  toolName: string;
  status: ToolInitStatus;
  readiness: ToolInitReadiness;
  issues: ToolInitIssue[];
  hasAnyArtifacts: boolean;
  expectedSkillCount: number;
  presentExpectedSkillCount: number;
  detectedSkillCount: number;
  expectedCommandCount: number;
  presentExpectedCommandCount: number;
  detectedCommandCount: number;
  missingSkillWorkflows: ToolWorkflowId[];
  missingCommandWorkflows: ToolWorkflowId[];
  unexpectedSkillWorkflows: ToolWorkflowId[];
  unexpectedCommandWorkflows: ToolWorkflowId[];
  legacyCommandWorkflows: ToolWorkflowId[];
  installedSkillWorkflows: ToolWorkflowId[];
  installedCommandWorkflows: ToolWorkflowId[];
  generatedByVersion: string | null;
  /** Physical delivery scope of this tool's skills; global roots are observed, never mutated here. */
  skillsScope: ToolSkillsScope;
  /** Former project roots still carrying OpenSpec-managed skills (Codex `.codex`). */
  legacySkillRoots: string[];
  /** Declared upstream: the tool needs an IDE/editor restart to load regenerated artifacts. */
  requiresIdeRestart: boolean;
  /** Version-scoped reason when this CLI line never shipped the tool's command adapter. */
  commandSurfaceUnavailableReason: string | null;
  cleanup?: ToolInitCleanupState;
  migration?: ToolInitMigrationState;
}
interface ToolInitProjectionOptions {
  delivery: ToolInitDelivery;
  workflows: readonly string[];
  generatorVersion?: string;
  commandContents?: AgentCommandContentCatalog | null;
  /** Tools whose command adapter this CLI line never shipped, with version-scoped reasons. */
  unavailableCommandTools?: Readonly<Record<string, string>> | null;
  /**
   * Official inventory for the admitted CLI line. Defaults to the newest supported registry;
   * the Agent delivery projection passes the version-selected list so a 1.8 session reports
   * only its own tools' states (no 1.9 restart facts, no unshipped targets).
   */
  registry?: readonly ToolConfig[];
}
/** Return the external directory containing allowlisted managed legacy Codex prompts. */
declare function getExternalCodexCommandObservationRoot(): string;
/** Read a fresh one-shot Project Agent artifact inventory. */
declare function getToolInitStates(projectDir: string, options: ToolInitProjectionOptions): Promise<ToolInitState[]>;
/** Create a retained Agent inventory task executed by one ReactiveContext. */
declare function createToolInitStateProjection(projectDir: string, options: ToolInitProjectionOptions): () => Promise<ToolInitState[]>;
//#endregion
//#region src/dashboard-types.d.ts
declare const DASHBOARD_METRIC_KEYS: readonly ["specifications", "requirements", "activeChanges", "inProgressChanges", "completedChanges", "taskCompletionPercent"];
type DashboardMetricKey = (typeof DASHBOARD_METRIC_KEYS)[number];
interface DashboardTrendPoint {
  ts: number;
  value: number;
}
interface DashboardTriColorTrendPoint {
  ts: number;
  add: number;
  modify: number;
  delete: number;
}
type DashboardTrendKind = 'monotonic' | 'bidirectional';
interface DashboardTrendMeta {
  pointLimit: number;
  lastUpdatedAt: number;
}
type DashboardCardAvailability = {
  state: 'ok';
} | {
  state: 'invalid';
  reason: 'semantic-uncomputable' | 'objective-history-unavailable';
};
interface DashboardSummary {
  specifications: number;
  requirements: number;
  activeChanges: number;
  inProgressChanges: number;
  completedChanges: number;
  archivedTasksCompleted: number;
  tasksTotal: number;
  tasksCompleted: number;
  taskCompletionPercent: number | null;
}
interface DashboardGitDiffStats {
  files: number;
  insertions: number;
  deletions: number;
}
interface DashboardGitCommitEntry {
  type: 'commit';
  hash: string;
  title: string;
  committedAt: number;
  relatedChanges: string[];
  diff: DashboardGitDiffStats;
}
interface DashboardGitUncommittedEntry {
  type: 'uncommitted';
  title: string;
  updatedAt: number | null;
  relatedChanges: string[];
  diff: DashboardGitDiffStats;
}
type DashboardGitEntry = DashboardGitCommitEntry | DashboardGitUncommittedEntry;
interface DashboardGitWorktree {
  path: string;
  relativePath: string;
  pathAvailable: boolean;
  branchName: string;
  detached: boolean;
  isCurrent: boolean;
  ahead: number;
  behind: number;
  diff: DashboardGitDiffStats;
  entries: DashboardGitEntry[];
}
interface DashboardGitSnapshot {
  /** Code binding provenance; null means static data has no live backend binding. */
  bindingToken: string | null;
  defaultBranch: string;
  worktrees: DashboardGitWorktree[];
}
/** Stable first-screen planning facts, intentionally independent from Git and historical trend work. */
interface DashboardSummaryProjection {
  summary: DashboardSummary;
  specifications: Array<{
    id: string;
    name: string;
    requirements: number;
    updatedAt: number;
  }>;
  activeChanges: Array<{
    id: string;
    name: string;
    trackedTaskProgress: TrackedTaskProgress;
    /** Task counts as reported by `openspec list`; null when no CLI list evidence exists. */
    cliTaskSummary: {
      completedTasks: number;
      totalTasks: number;
      status: 'no-tasks' | 'complete' | 'in-progress';
    } | null;
    updatedAt: number;
  }>;
  trackedTaskPhaseCounts: Record<TrackedTaskPhase, number>;
  recentArchives: Array<{
    id: string;
    name: string;
    trackedTaskProgress: TrackedTaskProgress;
    archivedAt: number;
    updatedAt: number;
  }>;
}
/** Optional historical facts whose latency or failure must not hide a stable Dashboard Summary. */
interface DashboardTrendsProjection {
  trends: Record<DashboardMetricKey, DashboardTrendPoint[]>;
  triColorTrends: Record<DashboardMetricKey, DashboardTriColorTrendPoint[]>;
  trendKinds: Record<DashboardMetricKey, DashboardTrendKind>;
  cardAvailability: Record<DashboardMetricKey, DashboardCardAvailability>;
  trendMeta: DashboardTrendMeta;
}
/** Aggregate compatibility projection for static exports and legacy callers. */
interface DashboardOverview extends DashboardSummaryProjection, DashboardTrendsProjection {
  git: DashboardGitSnapshot;
}
declare const DashboardGitSnapshotSchema: z.ZodObject<{
  bindingToken: z.ZodNullable<z.ZodString>;
  defaultBranch: z.ZodString;
  worktrees: z.ZodArray<z.ZodObject<{
    path: z.ZodString;
    relativePath: z.ZodString;
    pathAvailable: z.ZodBoolean;
    branchName: z.ZodString;
    detached: z.ZodBoolean;
    isCurrent: z.ZodBoolean;
    ahead: z.ZodNumber;
    behind: z.ZodNumber;
    diff: z.ZodObject<{
      files: z.ZodNumber;
      insertions: z.ZodNumber;
      deletions: z.ZodNumber;
    }, "strip", z.ZodTypeAny, {
      files: number;
      insertions: number;
      deletions: number;
    }, {
      files: number;
      insertions: number;
      deletions: number;
    }>;
    entries: z.ZodArray<z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
      type: z.ZodLiteral<"commit">;
      hash: z.ZodString;
      title: z.ZodString;
      committedAt: z.ZodNumber;
      relatedChanges: z.ZodArray<z.ZodString, "many">;
      diff: z.ZodObject<{
        files: z.ZodNumber;
        insertions: z.ZodNumber;
        deletions: z.ZodNumber;
      }, "strip", z.ZodTypeAny, {
        files: number;
        insertions: number;
        deletions: number;
      }, {
        files: number;
        insertions: number;
        deletions: number;
      }>;
    }, "strip", z.ZodTypeAny, {
      type: "commit";
      title: string;
      diff: {
        files: number;
        insertions: number;
        deletions: number;
      };
      hash: string;
      committedAt: number;
      relatedChanges: string[];
    }, {
      type: "commit";
      title: string;
      diff: {
        files: number;
        insertions: number;
        deletions: number;
      };
      hash: string;
      committedAt: number;
      relatedChanges: string[];
    }>, z.ZodObject<{
      type: z.ZodLiteral<"uncommitted">;
      title: z.ZodString;
      updatedAt: z.ZodNullable<z.ZodNumber>;
      relatedChanges: z.ZodArray<z.ZodString, "many">;
      diff: z.ZodObject<{
        files: z.ZodNumber;
        insertions: z.ZodNumber;
        deletions: z.ZodNumber;
      }, "strip", z.ZodTypeAny, {
        files: number;
        insertions: number;
        deletions: number;
      }, {
        files: number;
        insertions: number;
        deletions: number;
      }>;
    }, "strip", z.ZodTypeAny, {
      type: "uncommitted";
      updatedAt: number | null;
      title: string;
      diff: {
        files: number;
        insertions: number;
        deletions: number;
      };
      relatedChanges: string[];
    }, {
      type: "uncommitted";
      updatedAt: number | null;
      title: string;
      diff: {
        files: number;
        insertions: number;
        deletions: number;
      };
      relatedChanges: string[];
    }>]>, "many">;
  }, "strip", z.ZodTypeAny, {
    path: string;
    entries: ({
      type: "commit";
      title: string;
      diff: {
        files: number;
        insertions: number;
        deletions: number;
      };
      hash: string;
      committedAt: number;
      relatedChanges: string[];
    } | {
      type: "uncommitted";
      updatedAt: number | null;
      title: string;
      diff: {
        files: number;
        insertions: number;
        deletions: number;
      };
      relatedChanges: string[];
    })[];
    relativePath: string;
    pathAvailable: boolean;
    branchName: string;
    detached: boolean;
    isCurrent: boolean;
    ahead: number;
    behind: number;
    diff: {
      files: number;
      insertions: number;
      deletions: number;
    };
  }, {
    path: string;
    entries: ({
      type: "commit";
      title: string;
      diff: {
        files: number;
        insertions: number;
        deletions: number;
      };
      hash: string;
      committedAt: number;
      relatedChanges: string[];
    } | {
      type: "uncommitted";
      updatedAt: number | null;
      title: string;
      diff: {
        files: number;
        insertions: number;
        deletions: number;
      };
      relatedChanges: string[];
    })[];
    relativePath: string;
    pathAvailable: boolean;
    branchName: string;
    detached: boolean;
    isCurrent: boolean;
    ahead: number;
    behind: number;
    diff: {
      files: number;
      insertions: number;
      deletions: number;
    };
  }>, "many">;
}, "strip", z.ZodTypeAny, {
  bindingToken: string | null;
  defaultBranch: string;
  worktrees: {
    path: string;
    entries: ({
      type: "commit";
      title: string;
      diff: {
        files: number;
        insertions: number;
        deletions: number;
      };
      hash: string;
      committedAt: number;
      relatedChanges: string[];
    } | {
      type: "uncommitted";
      updatedAt: number | null;
      title: string;
      diff: {
        files: number;
        insertions: number;
        deletions: number;
      };
      relatedChanges: string[];
    })[];
    relativePath: string;
    pathAvailable: boolean;
    branchName: string;
    detached: boolean;
    isCurrent: boolean;
    ahead: number;
    behind: number;
    diff: {
      files: number;
      insertions: number;
      deletions: number;
    };
  }[];
}, {
  bindingToken: string | null;
  defaultBranch: string;
  worktrees: {
    path: string;
    entries: ({
      type: "commit";
      title: string;
      diff: {
        files: number;
        insertions: number;
        deletions: number;
      };
      hash: string;
      committedAt: number;
      relatedChanges: string[];
    } | {
      type: "uncommitted";
      updatedAt: number | null;
      title: string;
      diff: {
        files: number;
        insertions: number;
        deletions: number;
      };
      relatedChanges: string[];
    })[];
    relativePath: string;
    pathAvailable: boolean;
    branchName: string;
    detached: boolean;
    isCurrent: boolean;
    ahead: number;
    behind: number;
    diff: {
      files: number;
      insertions: number;
      deletions: number;
    };
  }[];
}>;
declare const DashboardSummaryProjectionSchema: z.ZodObject<{
  summary: z.ZodObject<{
    specifications: z.ZodNumber;
    requirements: z.ZodNumber;
    activeChanges: z.ZodNumber;
    inProgressChanges: z.ZodNumber;
    completedChanges: z.ZodNumber;
    archivedTasksCompleted: z.ZodNumber;
    tasksTotal: z.ZodNumber;
    tasksCompleted: z.ZodNumber;
    taskCompletionPercent: z.ZodNullable<z.ZodNumber>;
  }, "strip", z.ZodTypeAny, {
    specifications: number;
    requirements: number;
    activeChanges: number;
    inProgressChanges: number;
    completedChanges: number;
    archivedTasksCompleted: number;
    tasksTotal: number;
    tasksCompleted: number;
    taskCompletionPercent: number | null;
  }, {
    specifications: number;
    requirements: number;
    activeChanges: number;
    inProgressChanges: number;
    completedChanges: number;
    archivedTasksCompleted: number;
    tasksTotal: number;
    tasksCompleted: number;
    taskCompletionPercent: number | null;
  }>;
  specifications: z.ZodArray<z.ZodObject<{
    id: z.ZodString;
    name: z.ZodString;
    requirements: z.ZodNumber;
    updatedAt: z.ZodNumber;
  }, "strip", z.ZodTypeAny, {
    id: string;
    updatedAt: number;
    name: string;
    requirements: number;
  }, {
    id: string;
    updatedAt: number;
    name: string;
    requirements: number;
  }>, "many">;
  activeChanges: z.ZodArray<z.ZodObject<{
    id: z.ZodString;
    name: z.ZodString;
    trackedTaskProgress: z.ZodObject<{
      tasks: z.ZodArray<z.ZodObject<{
        id: z.ZodString;
        text: z.ZodString;
        completed: z.ZodBoolean;
        section: z.ZodOptional<z.ZodString>;
      } & {
        location: z.ZodObject<{
          filePath: z.ZodString;
          taskIndex: z.ZodNumber;
        }, "strip", z.ZodTypeAny, {
          filePath: string;
          taskIndex: number;
        }, {
          filePath: string;
          taskIndex: number;
        }>;
      }, "strip", z.ZodTypeAny, {
        id: string;
        text: string;
        completed: boolean;
        location: {
          filePath: string;
          taskIndex: number;
        };
        section?: string | undefined;
      }, {
        id: string;
        text: string;
        completed: boolean;
        location: {
          filePath: string;
          taskIndex: number;
        };
        section?: string | undefined;
      }>, "many">;
      total: z.ZodNumber;
      completed: z.ZodNumber;
      remaining: z.ZodNumber;
      phase: z.ZodEnum<["no-tasks", "in-progress", "complete"]>;
      source: z.ZodDiscriminatedUnion<"kind", [z.ZodObject<{
        kind: z.ZodLiteral<"artifact">;
        artifactId: z.ZodString;
        outputPath: z.ZodString;
        filePaths: z.ZodArray<z.ZodString, "many">;
      }, "strip", z.ZodTypeAny, {
        kind: "artifact";
        outputPath: string;
        artifactId: string;
        filePaths: string[];
      }, {
        kind: "artifact";
        outputPath: string;
        artifactId: string;
        filePaths: string[];
      }>, z.ZodObject<{
        kind: z.ZodLiteral<"top-level-fallback">;
        artifactId: z.ZodNull;
        outputPath: z.ZodLiteral<"tasks.md">;
        filePaths: z.ZodTuple<[z.ZodLiteral<"tasks.md">], null>;
      }, "strip", z.ZodTypeAny, {
        kind: "top-level-fallback";
        outputPath: "tasks.md";
        artifactId: null;
        filePaths: ["tasks.md"];
      }, {
        kind: "top-level-fallback";
        outputPath: "tasks.md";
        artifactId: null;
        filePaths: ["tasks.md"];
      }>, z.ZodObject<{
        kind: z.ZodLiteral<"none">;
        artifactId: z.ZodNull;
        outputPath: z.ZodNull;
        filePaths: z.ZodTuple<[], null>;
      }, "strip", z.ZodTypeAny, {
        kind: "none";
        outputPath: null;
        artifactId: null;
        filePaths: [];
      }, {
        kind: "none";
        outputPath: null;
        artifactId: null;
        filePaths: [];
      }>]>;
    }, "strip", z.ZodTypeAny, {
      source: {
        kind: "artifact";
        outputPath: string;
        artifactId: string;
        filePaths: string[];
      } | {
        kind: "top-level-fallback";
        outputPath: "tasks.md";
        artifactId: null;
        filePaths: ["tasks.md"];
      } | {
        kind: "none";
        outputPath: null;
        artifactId: null;
        filePaths: [];
      };
      tasks: {
        id: string;
        text: string;
        completed: boolean;
        location: {
          filePath: string;
          taskIndex: number;
        };
        section?: string | undefined;
      }[];
      total: number;
      remaining: number;
      completed: number;
      phase: "no-tasks" | "complete" | "in-progress";
    }, {
      source: {
        kind: "artifact";
        outputPath: string;
        artifactId: string;
        filePaths: string[];
      } | {
        kind: "top-level-fallback";
        outputPath: "tasks.md";
        artifactId: null;
        filePaths: ["tasks.md"];
      } | {
        kind: "none";
        outputPath: null;
        artifactId: null;
        filePaths: [];
      };
      tasks: {
        id: string;
        text: string;
        completed: boolean;
        location: {
          filePath: string;
          taskIndex: number;
        };
        section?: string | undefined;
      }[];
      total: number;
      remaining: number;
      completed: number;
      phase: "no-tasks" | "complete" | "in-progress";
    }>;
    cliTaskSummary: z.ZodNullable<z.ZodObject<{
      completedTasks: z.ZodNumber;
      totalTasks: z.ZodNumber;
      status: z.ZodEnum<["no-tasks", "complete", "in-progress"]>;
    }, "strip", z.ZodTypeAny, {
      status: "no-tasks" | "complete" | "in-progress";
      completedTasks: number;
      totalTasks: number;
    }, {
      status: "no-tasks" | "complete" | "in-progress";
      completedTasks: number;
      totalTasks: number;
    }>>;
    updatedAt: z.ZodNumber;
  }, "strip", z.ZodTypeAny, {
    id: string;
    updatedAt: number;
    name: string;
    trackedTaskProgress: {
      source: {
        kind: "artifact";
        outputPath: string;
        artifactId: string;
        filePaths: string[];
      } | {
        kind: "top-level-fallback";
        outputPath: "tasks.md";
        artifactId: null;
        filePaths: ["tasks.md"];
      } | {
        kind: "none";
        outputPath: null;
        artifactId: null;
        filePaths: [];
      };
      tasks: {
        id: string;
        text: string;
        completed: boolean;
        location: {
          filePath: string;
          taskIndex: number;
        };
        section?: string | undefined;
      }[];
      total: number;
      remaining: number;
      completed: number;
      phase: "no-tasks" | "complete" | "in-progress";
    };
    cliTaskSummary: {
      status: "no-tasks" | "complete" | "in-progress";
      completedTasks: number;
      totalTasks: number;
    } | null;
  }, {
    id: string;
    updatedAt: number;
    name: string;
    trackedTaskProgress: {
      source: {
        kind: "artifact";
        outputPath: string;
        artifactId: string;
        filePaths: string[];
      } | {
        kind: "top-level-fallback";
        outputPath: "tasks.md";
        artifactId: null;
        filePaths: ["tasks.md"];
      } | {
        kind: "none";
        outputPath: null;
        artifactId: null;
        filePaths: [];
      };
      tasks: {
        id: string;
        text: string;
        completed: boolean;
        location: {
          filePath: string;
          taskIndex: number;
        };
        section?: string | undefined;
      }[];
      total: number;
      remaining: number;
      completed: number;
      phase: "no-tasks" | "complete" | "in-progress";
    };
    cliTaskSummary: {
      status: "no-tasks" | "complete" | "in-progress";
      completedTasks: number;
      totalTasks: number;
    } | null;
  }>, "many">;
  trackedTaskPhaseCounts: z.ZodObject<{
    'no-tasks': z.ZodNumber;
    'in-progress': z.ZodNumber;
    complete: z.ZodNumber;
  }, "strip", z.ZodTypeAny, {
    'no-tasks': number;
    complete: number;
    'in-progress': number;
  }, {
    'no-tasks': number;
    complete: number;
    'in-progress': number;
  }>;
  recentArchives: z.ZodArray<z.ZodObject<{
    id: z.ZodString;
    name: z.ZodString;
    trackedTaskProgress: z.ZodObject<{
      tasks: z.ZodArray<z.ZodObject<{
        id: z.ZodString;
        text: z.ZodString;
        completed: z.ZodBoolean;
        section: z.ZodOptional<z.ZodString>;
      } & {
        location: z.ZodObject<{
          filePath: z.ZodString;
          taskIndex: z.ZodNumber;
        }, "strip", z.ZodTypeAny, {
          filePath: string;
          taskIndex: number;
        }, {
          filePath: string;
          taskIndex: number;
        }>;
      }, "strip", z.ZodTypeAny, {
        id: string;
        text: string;
        completed: boolean;
        location: {
          filePath: string;
          taskIndex: number;
        };
        section?: string | undefined;
      }, {
        id: string;
        text: string;
        completed: boolean;
        location: {
          filePath: string;
          taskIndex: number;
        };
        section?: string | undefined;
      }>, "many">;
      total: z.ZodNumber;
      completed: z.ZodNumber;
      remaining: z.ZodNumber;
      phase: z.ZodEnum<["no-tasks", "in-progress", "complete"]>;
      source: z.ZodDiscriminatedUnion<"kind", [z.ZodObject<{
        kind: z.ZodLiteral<"artifact">;
        artifactId: z.ZodString;
        outputPath: z.ZodString;
        filePaths: z.ZodArray<z.ZodString, "many">;
      }, "strip", z.ZodTypeAny, {
        kind: "artifact";
        outputPath: string;
        artifactId: string;
        filePaths: string[];
      }, {
        kind: "artifact";
        outputPath: string;
        artifactId: string;
        filePaths: string[];
      }>, z.ZodObject<{
        kind: z.ZodLiteral<"top-level-fallback">;
        artifactId: z.ZodNull;
        outputPath: z.ZodLiteral<"tasks.md">;
        filePaths: z.ZodTuple<[z.ZodLiteral<"tasks.md">], null>;
      }, "strip", z.ZodTypeAny, {
        kind: "top-level-fallback";
        outputPath: "tasks.md";
        artifactId: null;
        filePaths: ["tasks.md"];
      }, {
        kind: "top-level-fallback";
        outputPath: "tasks.md";
        artifactId: null;
        filePaths: ["tasks.md"];
      }>, z.ZodObject<{
        kind: z.ZodLiteral<"none">;
        artifactId: z.ZodNull;
        outputPath: z.ZodNull;
        filePaths: z.ZodTuple<[], null>;
      }, "strip", z.ZodTypeAny, {
        kind: "none";
        outputPath: null;
        artifactId: null;
        filePaths: [];
      }, {
        kind: "none";
        outputPath: null;
        artifactId: null;
        filePaths: [];
      }>]>;
    }, "strip", z.ZodTypeAny, {
      source: {
        kind: "artifact";
        outputPath: string;
        artifactId: string;
        filePaths: string[];
      } | {
        kind: "top-level-fallback";
        outputPath: "tasks.md";
        artifactId: null;
        filePaths: ["tasks.md"];
      } | {
        kind: "none";
        outputPath: null;
        artifactId: null;
        filePaths: [];
      };
      tasks: {
        id: string;
        text: string;
        completed: boolean;
        location: {
          filePath: string;
          taskIndex: number;
        };
        section?: string | undefined;
      }[];
      total: number;
      remaining: number;
      completed: number;
      phase: "no-tasks" | "complete" | "in-progress";
    }, {
      source: {
        kind: "artifact";
        outputPath: string;
        artifactId: string;
        filePaths: string[];
      } | {
        kind: "top-level-fallback";
        outputPath: "tasks.md";
        artifactId: null;
        filePaths: ["tasks.md"];
      } | {
        kind: "none";
        outputPath: null;
        artifactId: null;
        filePaths: [];
      };
      tasks: {
        id: string;
        text: string;
        completed: boolean;
        location: {
          filePath: string;
          taskIndex: number;
        };
        section?: string | undefined;
      }[];
      total: number;
      remaining: number;
      completed: number;
      phase: "no-tasks" | "complete" | "in-progress";
    }>;
    archivedAt: z.ZodNumber;
    updatedAt: z.ZodNumber;
  }, "strip", z.ZodTypeAny, {
    id: string;
    updatedAt: number;
    name: string;
    trackedTaskProgress: {
      source: {
        kind: "artifact";
        outputPath: string;
        artifactId: string;
        filePaths: string[];
      } | {
        kind: "top-level-fallback";
        outputPath: "tasks.md";
        artifactId: null;
        filePaths: ["tasks.md"];
      } | {
        kind: "none";
        outputPath: null;
        artifactId: null;
        filePaths: [];
      };
      tasks: {
        id: string;
        text: string;
        completed: boolean;
        location: {
          filePath: string;
          taskIndex: number;
        };
        section?: string | undefined;
      }[];
      total: number;
      remaining: number;
      completed: number;
      phase: "no-tasks" | "complete" | "in-progress";
    };
    archivedAt: number;
  }, {
    id: string;
    updatedAt: number;
    name: string;
    trackedTaskProgress: {
      source: {
        kind: "artifact";
        outputPath: string;
        artifactId: string;
        filePaths: string[];
      } | {
        kind: "top-level-fallback";
        outputPath: "tasks.md";
        artifactId: null;
        filePaths: ["tasks.md"];
      } | {
        kind: "none";
        outputPath: null;
        artifactId: null;
        filePaths: [];
      };
      tasks: {
        id: string;
        text: string;
        completed: boolean;
        location: {
          filePath: string;
          taskIndex: number;
        };
        section?: string | undefined;
      }[];
      total: number;
      remaining: number;
      completed: number;
      phase: "no-tasks" | "complete" | "in-progress";
    };
    archivedAt: number;
  }>, "many">;
}, "strip", z.ZodTypeAny, {
  summary: {
    specifications: number;
    requirements: number;
    activeChanges: number;
    inProgressChanges: number;
    completedChanges: number;
    archivedTasksCompleted: number;
    tasksTotal: number;
    tasksCompleted: number;
    taskCompletionPercent: number | null;
  };
  specifications: {
    id: string;
    updatedAt: number;
    name: string;
    requirements: number;
  }[];
  activeChanges: {
    id: string;
    updatedAt: number;
    name: string;
    trackedTaskProgress: {
      source: {
        kind: "artifact";
        outputPath: string;
        artifactId: string;
        filePaths: string[];
      } | {
        kind: "top-level-fallback";
        outputPath: "tasks.md";
        artifactId: null;
        filePaths: ["tasks.md"];
      } | {
        kind: "none";
        outputPath: null;
        artifactId: null;
        filePaths: [];
      };
      tasks: {
        id: string;
        text: string;
        completed: boolean;
        location: {
          filePath: string;
          taskIndex: number;
        };
        section?: string | undefined;
      }[];
      total: number;
      remaining: number;
      completed: number;
      phase: "no-tasks" | "complete" | "in-progress";
    };
    cliTaskSummary: {
      status: "no-tasks" | "complete" | "in-progress";
      completedTasks: number;
      totalTasks: number;
    } | null;
  }[];
  trackedTaskPhaseCounts: {
    'no-tasks': number;
    complete: number;
    'in-progress': number;
  };
  recentArchives: {
    id: string;
    updatedAt: number;
    name: string;
    trackedTaskProgress: {
      source: {
        kind: "artifact";
        outputPath: string;
        artifactId: string;
        filePaths: string[];
      } | {
        kind: "top-level-fallback";
        outputPath: "tasks.md";
        artifactId: null;
        filePaths: ["tasks.md"];
      } | {
        kind: "none";
        outputPath: null;
        artifactId: null;
        filePaths: [];
      };
      tasks: {
        id: string;
        text: string;
        completed: boolean;
        location: {
          filePath: string;
          taskIndex: number;
        };
        section?: string | undefined;
      }[];
      total: number;
      remaining: number;
      completed: number;
      phase: "no-tasks" | "complete" | "in-progress";
    };
    archivedAt: number;
  }[];
}, {
  summary: {
    specifications: number;
    requirements: number;
    activeChanges: number;
    inProgressChanges: number;
    completedChanges: number;
    archivedTasksCompleted: number;
    tasksTotal: number;
    tasksCompleted: number;
    taskCompletionPercent: number | null;
  };
  specifications: {
    id: string;
    updatedAt: number;
    name: string;
    requirements: number;
  }[];
  activeChanges: {
    id: string;
    updatedAt: number;
    name: string;
    trackedTaskProgress: {
      source: {
        kind: "artifact";
        outputPath: string;
        artifactId: string;
        filePaths: string[];
      } | {
        kind: "top-level-fallback";
        outputPath: "tasks.md";
        artifactId: null;
        filePaths: ["tasks.md"];
      } | {
        kind: "none";
        outputPath: null;
        artifactId: null;
        filePaths: [];
      };
      tasks: {
        id: string;
        text: string;
        completed: boolean;
        location: {
          filePath: string;
          taskIndex: number;
        };
        section?: string | undefined;
      }[];
      total: number;
      remaining: number;
      completed: number;
      phase: "no-tasks" | "complete" | "in-progress";
    };
    cliTaskSummary: {
      status: "no-tasks" | "complete" | "in-progress";
      completedTasks: number;
      totalTasks: number;
    } | null;
  }[];
  trackedTaskPhaseCounts: {
    'no-tasks': number;
    complete: number;
    'in-progress': number;
  };
  recentArchives: {
    id: string;
    updatedAt: number;
    name: string;
    trackedTaskProgress: {
      source: {
        kind: "artifact";
        outputPath: string;
        artifactId: string;
        filePaths: string[];
      } | {
        kind: "top-level-fallback";
        outputPath: "tasks.md";
        artifactId: null;
        filePaths: ["tasks.md"];
      } | {
        kind: "none";
        outputPath: null;
        artifactId: null;
        filePaths: [];
      };
      tasks: {
        id: string;
        text: string;
        completed: boolean;
        location: {
          filePath: string;
          taskIndex: number;
        };
        section?: string | undefined;
      }[];
      total: number;
      remaining: number;
      completed: number;
      phase: "no-tasks" | "complete" | "in-progress";
    };
    archivedAt: number;
  }[];
}>;
declare const DashboardTrendsProjectionSchema: z.ZodObject<{
  trends: z.ZodObject<{
    specifications: z.ZodArray<z.ZodObject<{
      ts: z.ZodNumber;
      value: z.ZodNumber;
    }, "strip", z.ZodTypeAny, {
      value: number;
      ts: number;
    }, {
      value: number;
      ts: number;
    }>, "many">;
    requirements: z.ZodArray<z.ZodObject<{
      ts: z.ZodNumber;
      value: z.ZodNumber;
    }, "strip", z.ZodTypeAny, {
      value: number;
      ts: number;
    }, {
      value: number;
      ts: number;
    }>, "many">;
    activeChanges: z.ZodArray<z.ZodObject<{
      ts: z.ZodNumber;
      value: z.ZodNumber;
    }, "strip", z.ZodTypeAny, {
      value: number;
      ts: number;
    }, {
      value: number;
      ts: number;
    }>, "many">;
    inProgressChanges: z.ZodArray<z.ZodObject<{
      ts: z.ZodNumber;
      value: z.ZodNumber;
    }, "strip", z.ZodTypeAny, {
      value: number;
      ts: number;
    }, {
      value: number;
      ts: number;
    }>, "many">;
    completedChanges: z.ZodArray<z.ZodObject<{
      ts: z.ZodNumber;
      value: z.ZodNumber;
    }, "strip", z.ZodTypeAny, {
      value: number;
      ts: number;
    }, {
      value: number;
      ts: number;
    }>, "many">;
    taskCompletionPercent: z.ZodArray<z.ZodObject<{
      ts: z.ZodNumber;
      value: z.ZodNumber;
    }, "strip", z.ZodTypeAny, {
      value: number;
      ts: number;
    }, {
      value: number;
      ts: number;
    }>, "many">;
  }, "strip", z.ZodTypeAny, {
    specifications: {
      value: number;
      ts: number;
    }[];
    requirements: {
      value: number;
      ts: number;
    }[];
    activeChanges: {
      value: number;
      ts: number;
    }[];
    inProgressChanges: {
      value: number;
      ts: number;
    }[];
    completedChanges: {
      value: number;
      ts: number;
    }[];
    taskCompletionPercent: {
      value: number;
      ts: number;
    }[];
  }, {
    specifications: {
      value: number;
      ts: number;
    }[];
    requirements: {
      value: number;
      ts: number;
    }[];
    activeChanges: {
      value: number;
      ts: number;
    }[];
    inProgressChanges: {
      value: number;
      ts: number;
    }[];
    completedChanges: {
      value: number;
      ts: number;
    }[];
    taskCompletionPercent: {
      value: number;
      ts: number;
    }[];
  }>;
  triColorTrends: z.ZodObject<{
    specifications: z.ZodArray<z.ZodObject<{
      ts: z.ZodNumber;
      add: z.ZodNumber;
      modify: z.ZodNumber;
      delete: z.ZodNumber;
    }, "strip", z.ZodTypeAny, {
      ts: number;
      add: number;
      modify: number;
      delete: number;
    }, {
      ts: number;
      add: number;
      modify: number;
      delete: number;
    }>, "many">;
    requirements: z.ZodArray<z.ZodObject<{
      ts: z.ZodNumber;
      add: z.ZodNumber;
      modify: z.ZodNumber;
      delete: z.ZodNumber;
    }, "strip", z.ZodTypeAny, {
      ts: number;
      add: number;
      modify: number;
      delete: number;
    }, {
      ts: number;
      add: number;
      modify: number;
      delete: number;
    }>, "many">;
    activeChanges: z.ZodArray<z.ZodObject<{
      ts: z.ZodNumber;
      add: z.ZodNumber;
      modify: z.ZodNumber;
      delete: z.ZodNumber;
    }, "strip", z.ZodTypeAny, {
      ts: number;
      add: number;
      modify: number;
      delete: number;
    }, {
      ts: number;
      add: number;
      modify: number;
      delete: number;
    }>, "many">;
    inProgressChanges: z.ZodArray<z.ZodObject<{
      ts: z.ZodNumber;
      add: z.ZodNumber;
      modify: z.ZodNumber;
      delete: z.ZodNumber;
    }, "strip", z.ZodTypeAny, {
      ts: number;
      add: number;
      modify: number;
      delete: number;
    }, {
      ts: number;
      add: number;
      modify: number;
      delete: number;
    }>, "many">;
    completedChanges: z.ZodArray<z.ZodObject<{
      ts: z.ZodNumber;
      add: z.ZodNumber;
      modify: z.ZodNumber;
      delete: z.ZodNumber;
    }, "strip", z.ZodTypeAny, {
      ts: number;
      add: number;
      modify: number;
      delete: number;
    }, {
      ts: number;
      add: number;
      modify: number;
      delete: number;
    }>, "many">;
    taskCompletionPercent: z.ZodArray<z.ZodObject<{
      ts: z.ZodNumber;
      add: z.ZodNumber;
      modify: z.ZodNumber;
      delete: z.ZodNumber;
    }, "strip", z.ZodTypeAny, {
      ts: number;
      add: number;
      modify: number;
      delete: number;
    }, {
      ts: number;
      add: number;
      modify: number;
      delete: number;
    }>, "many">;
  }, "strip", z.ZodTypeAny, {
    specifications: {
      ts: number;
      add: number;
      modify: number;
      delete: number;
    }[];
    requirements: {
      ts: number;
      add: number;
      modify: number;
      delete: number;
    }[];
    activeChanges: {
      ts: number;
      add: number;
      modify: number;
      delete: number;
    }[];
    inProgressChanges: {
      ts: number;
      add: number;
      modify: number;
      delete: number;
    }[];
    completedChanges: {
      ts: number;
      add: number;
      modify: number;
      delete: number;
    }[];
    taskCompletionPercent: {
      ts: number;
      add: number;
      modify: number;
      delete: number;
    }[];
  }, {
    specifications: {
      ts: number;
      add: number;
      modify: number;
      delete: number;
    }[];
    requirements: {
      ts: number;
      add: number;
      modify: number;
      delete: number;
    }[];
    activeChanges: {
      ts: number;
      add: number;
      modify: number;
      delete: number;
    }[];
    inProgressChanges: {
      ts: number;
      add: number;
      modify: number;
      delete: number;
    }[];
    completedChanges: {
      ts: number;
      add: number;
      modify: number;
      delete: number;
    }[];
    taskCompletionPercent: {
      ts: number;
      add: number;
      modify: number;
      delete: number;
    }[];
  }>;
  trendKinds: z.ZodObject<{
    specifications: z.ZodEnum<["monotonic", "bidirectional"]>;
    requirements: z.ZodEnum<["monotonic", "bidirectional"]>;
    activeChanges: z.ZodEnum<["monotonic", "bidirectional"]>;
    inProgressChanges: z.ZodEnum<["monotonic", "bidirectional"]>;
    completedChanges: z.ZodEnum<["monotonic", "bidirectional"]>;
    taskCompletionPercent: z.ZodEnum<["monotonic", "bidirectional"]>;
  }, "strip", z.ZodTypeAny, {
    specifications: "monotonic" | "bidirectional";
    requirements: "monotonic" | "bidirectional";
    activeChanges: "monotonic" | "bidirectional";
    inProgressChanges: "monotonic" | "bidirectional";
    completedChanges: "monotonic" | "bidirectional";
    taskCompletionPercent: "monotonic" | "bidirectional";
  }, {
    specifications: "monotonic" | "bidirectional";
    requirements: "monotonic" | "bidirectional";
    activeChanges: "monotonic" | "bidirectional";
    inProgressChanges: "monotonic" | "bidirectional";
    completedChanges: "monotonic" | "bidirectional";
    taskCompletionPercent: "monotonic" | "bidirectional";
  }>;
  cardAvailability: z.ZodObject<{
    specifications: z.ZodDiscriminatedUnion<"state", [z.ZodObject<{
      state: z.ZodLiteral<"ok">;
    }, "strip", z.ZodTypeAny, {
      state: "ok";
    }, {
      state: "ok";
    }>, z.ZodObject<{
      state: z.ZodLiteral<"invalid">;
      reason: z.ZodEnum<["semantic-uncomputable", "objective-history-unavailable"]>;
    }, "strip", z.ZodTypeAny, {
      state: "invalid";
      reason: "semantic-uncomputable" | "objective-history-unavailable";
    }, {
      state: "invalid";
      reason: "semantic-uncomputable" | "objective-history-unavailable";
    }>]>;
    requirements: z.ZodDiscriminatedUnion<"state", [z.ZodObject<{
      state: z.ZodLiteral<"ok">;
    }, "strip", z.ZodTypeAny, {
      state: "ok";
    }, {
      state: "ok";
    }>, z.ZodObject<{
      state: z.ZodLiteral<"invalid">;
      reason: z.ZodEnum<["semantic-uncomputable", "objective-history-unavailable"]>;
    }, "strip", z.ZodTypeAny, {
      state: "invalid";
      reason: "semantic-uncomputable" | "objective-history-unavailable";
    }, {
      state: "invalid";
      reason: "semantic-uncomputable" | "objective-history-unavailable";
    }>]>;
    activeChanges: z.ZodDiscriminatedUnion<"state", [z.ZodObject<{
      state: z.ZodLiteral<"ok">;
    }, "strip", z.ZodTypeAny, {
      state: "ok";
    }, {
      state: "ok";
    }>, z.ZodObject<{
      state: z.ZodLiteral<"invalid">;
      reason: z.ZodEnum<["semantic-uncomputable", "objective-history-unavailable"]>;
    }, "strip", z.ZodTypeAny, {
      state: "invalid";
      reason: "semantic-uncomputable" | "objective-history-unavailable";
    }, {
      state: "invalid";
      reason: "semantic-uncomputable" | "objective-history-unavailable";
    }>]>;
    inProgressChanges: z.ZodDiscriminatedUnion<"state", [z.ZodObject<{
      state: z.ZodLiteral<"ok">;
    }, "strip", z.ZodTypeAny, {
      state: "ok";
    }, {
      state: "ok";
    }>, z.ZodObject<{
      state: z.ZodLiteral<"invalid">;
      reason: z.ZodEnum<["semantic-uncomputable", "objective-history-unavailable"]>;
    }, "strip", z.ZodTypeAny, {
      state: "invalid";
      reason: "semantic-uncomputable" | "objective-history-unavailable";
    }, {
      state: "invalid";
      reason: "semantic-uncomputable" | "objective-history-unavailable";
    }>]>;
    completedChanges: z.ZodDiscriminatedUnion<"state", [z.ZodObject<{
      state: z.ZodLiteral<"ok">;
    }, "strip", z.ZodTypeAny, {
      state: "ok";
    }, {
      state: "ok";
    }>, z.ZodObject<{
      state: z.ZodLiteral<"invalid">;
      reason: z.ZodEnum<["semantic-uncomputable", "objective-history-unavailable"]>;
    }, "strip", z.ZodTypeAny, {
      state: "invalid";
      reason: "semantic-uncomputable" | "objective-history-unavailable";
    }, {
      state: "invalid";
      reason: "semantic-uncomputable" | "objective-history-unavailable";
    }>]>;
    taskCompletionPercent: z.ZodDiscriminatedUnion<"state", [z.ZodObject<{
      state: z.ZodLiteral<"ok">;
    }, "strip", z.ZodTypeAny, {
      state: "ok";
    }, {
      state: "ok";
    }>, z.ZodObject<{
      state: z.ZodLiteral<"invalid">;
      reason: z.ZodEnum<["semantic-uncomputable", "objective-history-unavailable"]>;
    }, "strip", z.ZodTypeAny, {
      state: "invalid";
      reason: "semantic-uncomputable" | "objective-history-unavailable";
    }, {
      state: "invalid";
      reason: "semantic-uncomputable" | "objective-history-unavailable";
    }>]>;
  }, "strip", z.ZodTypeAny, {
    specifications: {
      state: "ok";
    } | {
      state: "invalid";
      reason: "semantic-uncomputable" | "objective-history-unavailable";
    };
    requirements: {
      state: "ok";
    } | {
      state: "invalid";
      reason: "semantic-uncomputable" | "objective-history-unavailable";
    };
    activeChanges: {
      state: "ok";
    } | {
      state: "invalid";
      reason: "semantic-uncomputable" | "objective-history-unavailable";
    };
    inProgressChanges: {
      state: "ok";
    } | {
      state: "invalid";
      reason: "semantic-uncomputable" | "objective-history-unavailable";
    };
    completedChanges: {
      state: "ok";
    } | {
      state: "invalid";
      reason: "semantic-uncomputable" | "objective-history-unavailable";
    };
    taskCompletionPercent: {
      state: "ok";
    } | {
      state: "invalid";
      reason: "semantic-uncomputable" | "objective-history-unavailable";
    };
  }, {
    specifications: {
      state: "ok";
    } | {
      state: "invalid";
      reason: "semantic-uncomputable" | "objective-history-unavailable";
    };
    requirements: {
      state: "ok";
    } | {
      state: "invalid";
      reason: "semantic-uncomputable" | "objective-history-unavailable";
    };
    activeChanges: {
      state: "ok";
    } | {
      state: "invalid";
      reason: "semantic-uncomputable" | "objective-history-unavailable";
    };
    inProgressChanges: {
      state: "ok";
    } | {
      state: "invalid";
      reason: "semantic-uncomputable" | "objective-history-unavailable";
    };
    completedChanges: {
      state: "ok";
    } | {
      state: "invalid";
      reason: "semantic-uncomputable" | "objective-history-unavailable";
    };
    taskCompletionPercent: {
      state: "ok";
    } | {
      state: "invalid";
      reason: "semantic-uncomputable" | "objective-history-unavailable";
    };
  }>;
  trendMeta: z.ZodObject<{
    pointLimit: z.ZodNumber;
    lastUpdatedAt: z.ZodNumber;
  }, "strip", z.ZodTypeAny, {
    pointLimit: number;
    lastUpdatedAt: number;
  }, {
    pointLimit: number;
    lastUpdatedAt: number;
  }>;
}, "strip", z.ZodTypeAny, {
  trends: {
    specifications: {
      value: number;
      ts: number;
    }[];
    requirements: {
      value: number;
      ts: number;
    }[];
    activeChanges: {
      value: number;
      ts: number;
    }[];
    inProgressChanges: {
      value: number;
      ts: number;
    }[];
    completedChanges: {
      value: number;
      ts: number;
    }[];
    taskCompletionPercent: {
      value: number;
      ts: number;
    }[];
  };
  triColorTrends: {
    specifications: {
      ts: number;
      add: number;
      modify: number;
      delete: number;
    }[];
    requirements: {
      ts: number;
      add: number;
      modify: number;
      delete: number;
    }[];
    activeChanges: {
      ts: number;
      add: number;
      modify: number;
      delete: number;
    }[];
    inProgressChanges: {
      ts: number;
      add: number;
      modify: number;
      delete: number;
    }[];
    completedChanges: {
      ts: number;
      add: number;
      modify: number;
      delete: number;
    }[];
    taskCompletionPercent: {
      ts: number;
      add: number;
      modify: number;
      delete: number;
    }[];
  };
  trendKinds: {
    specifications: "monotonic" | "bidirectional";
    requirements: "monotonic" | "bidirectional";
    activeChanges: "monotonic" | "bidirectional";
    inProgressChanges: "monotonic" | "bidirectional";
    completedChanges: "monotonic" | "bidirectional";
    taskCompletionPercent: "monotonic" | "bidirectional";
  };
  cardAvailability: {
    specifications: {
      state: "ok";
    } | {
      state: "invalid";
      reason: "semantic-uncomputable" | "objective-history-unavailable";
    };
    requirements: {
      state: "ok";
    } | {
      state: "invalid";
      reason: "semantic-uncomputable" | "objective-history-unavailable";
    };
    activeChanges: {
      state: "ok";
    } | {
      state: "invalid";
      reason: "semantic-uncomputable" | "objective-history-unavailable";
    };
    inProgressChanges: {
      state: "ok";
    } | {
      state: "invalid";
      reason: "semantic-uncomputable" | "objective-history-unavailable";
    };
    completedChanges: {
      state: "ok";
    } | {
      state: "invalid";
      reason: "semantic-uncomputable" | "objective-history-unavailable";
    };
    taskCompletionPercent: {
      state: "ok";
    } | {
      state: "invalid";
      reason: "semantic-uncomputable" | "objective-history-unavailable";
    };
  };
  trendMeta: {
    pointLimit: number;
    lastUpdatedAt: number;
  };
}, {
  trends: {
    specifications: {
      value: number;
      ts: number;
    }[];
    requirements: {
      value: number;
      ts: number;
    }[];
    activeChanges: {
      value: number;
      ts: number;
    }[];
    inProgressChanges: {
      value: number;
      ts: number;
    }[];
    completedChanges: {
      value: number;
      ts: number;
    }[];
    taskCompletionPercent: {
      value: number;
      ts: number;
    }[];
  };
  triColorTrends: {
    specifications: {
      ts: number;
      add: number;
      modify: number;
      delete: number;
    }[];
    requirements: {
      ts: number;
      add: number;
      modify: number;
      delete: number;
    }[];
    activeChanges: {
      ts: number;
      add: number;
      modify: number;
      delete: number;
    }[];
    inProgressChanges: {
      ts: number;
      add: number;
      modify: number;
      delete: number;
    }[];
    completedChanges: {
      ts: number;
      add: number;
      modify: number;
      delete: number;
    }[];
    taskCompletionPercent: {
      ts: number;
      add: number;
      modify: number;
      delete: number;
    }[];
  };
  trendKinds: {
    specifications: "monotonic" | "bidirectional";
    requirements: "monotonic" | "bidirectional";
    activeChanges: "monotonic" | "bidirectional";
    inProgressChanges: "monotonic" | "bidirectional";
    completedChanges: "monotonic" | "bidirectional";
    taskCompletionPercent: "monotonic" | "bidirectional";
  };
  cardAvailability: {
    specifications: {
      state: "ok";
    } | {
      state: "invalid";
      reason: "semantic-uncomputable" | "objective-history-unavailable";
    };
    requirements: {
      state: "ok";
    } | {
      state: "invalid";
      reason: "semantic-uncomputable" | "objective-history-unavailable";
    };
    activeChanges: {
      state: "ok";
    } | {
      state: "invalid";
      reason: "semantic-uncomputable" | "objective-history-unavailable";
    };
    inProgressChanges: {
      state: "ok";
    } | {
      state: "invalid";
      reason: "semantic-uncomputable" | "objective-history-unavailable";
    };
    completedChanges: {
      state: "ok";
    } | {
      state: "invalid";
      reason: "semantic-uncomputable" | "objective-history-unavailable";
    };
    taskCompletionPercent: {
      state: "ok";
    } | {
      state: "invalid";
      reason: "semantic-uncomputable" | "objective-history-unavailable";
    };
  };
  trendMeta: {
    pointLimit: number;
    lastUpdatedAt: number;
  };
}>;
declare const DashboardOverviewSchema: z.ZodObject<{
  summary: z.ZodObject<{
    specifications: z.ZodNumber;
    requirements: z.ZodNumber;
    activeChanges: z.ZodNumber;
    inProgressChanges: z.ZodNumber;
    completedChanges: z.ZodNumber;
    archivedTasksCompleted: z.ZodNumber;
    tasksTotal: z.ZodNumber;
    tasksCompleted: z.ZodNumber;
    taskCompletionPercent: z.ZodNullable<z.ZodNumber>;
  }, "strip", z.ZodTypeAny, {
    specifications: number;
    requirements: number;
    activeChanges: number;
    inProgressChanges: number;
    completedChanges: number;
    archivedTasksCompleted: number;
    tasksTotal: number;
    tasksCompleted: number;
    taskCompletionPercent: number | null;
  }, {
    specifications: number;
    requirements: number;
    activeChanges: number;
    inProgressChanges: number;
    completedChanges: number;
    archivedTasksCompleted: number;
    tasksTotal: number;
    tasksCompleted: number;
    taskCompletionPercent: number | null;
  }>;
  specifications: z.ZodArray<z.ZodObject<{
    id: z.ZodString;
    name: z.ZodString;
    requirements: z.ZodNumber;
    updatedAt: z.ZodNumber;
  }, "strip", z.ZodTypeAny, {
    id: string;
    updatedAt: number;
    name: string;
    requirements: number;
  }, {
    id: string;
    updatedAt: number;
    name: string;
    requirements: number;
  }>, "many">;
  activeChanges: z.ZodArray<z.ZodObject<{
    id: z.ZodString;
    name: z.ZodString;
    trackedTaskProgress: z.ZodObject<{
      tasks: z.ZodArray<z.ZodObject<{
        id: z.ZodString;
        text: z.ZodString;
        completed: z.ZodBoolean;
        section: z.ZodOptional<z.ZodString>;
      } & {
        location: z.ZodObject<{
          filePath: z.ZodString;
          taskIndex: z.ZodNumber;
        }, "strip", z.ZodTypeAny, {
          filePath: string;
          taskIndex: number;
        }, {
          filePath: string;
          taskIndex: number;
        }>;
      }, "strip", z.ZodTypeAny, {
        id: string;
        text: string;
        completed: boolean;
        location: {
          filePath: string;
          taskIndex: number;
        };
        section?: string | undefined;
      }, {
        id: string;
        text: string;
        completed: boolean;
        location: {
          filePath: string;
          taskIndex: number;
        };
        section?: string | undefined;
      }>, "many">;
      total: z.ZodNumber;
      completed: z.ZodNumber;
      remaining: z.ZodNumber;
      phase: z.ZodEnum<["no-tasks", "in-progress", "complete"]>;
      source: z.ZodDiscriminatedUnion<"kind", [z.ZodObject<{
        kind: z.ZodLiteral<"artifact">;
        artifactId: z.ZodString;
        outputPath: z.ZodString;
        filePaths: z.ZodArray<z.ZodString, "many">;
      }, "strip", z.ZodTypeAny, {
        kind: "artifact";
        outputPath: string;
        artifactId: string;
        filePaths: string[];
      }, {
        kind: "artifact";
        outputPath: string;
        artifactId: string;
        filePaths: string[];
      }>, z.ZodObject<{
        kind: z.ZodLiteral<"top-level-fallback">;
        artifactId: z.ZodNull;
        outputPath: z.ZodLiteral<"tasks.md">;
        filePaths: z.ZodTuple<[z.ZodLiteral<"tasks.md">], null>;
      }, "strip", z.ZodTypeAny, {
        kind: "top-level-fallback";
        outputPath: "tasks.md";
        artifactId: null;
        filePaths: ["tasks.md"];
      }, {
        kind: "top-level-fallback";
        outputPath: "tasks.md";
        artifactId: null;
        filePaths: ["tasks.md"];
      }>, z.ZodObject<{
        kind: z.ZodLiteral<"none">;
        artifactId: z.ZodNull;
        outputPath: z.ZodNull;
        filePaths: z.ZodTuple<[], null>;
      }, "strip", z.ZodTypeAny, {
        kind: "none";
        outputPath: null;
        artifactId: null;
        filePaths: [];
      }, {
        kind: "none";
        outputPath: null;
        artifactId: null;
        filePaths: [];
      }>]>;
    }, "strip", z.ZodTypeAny, {
      source: {
        kind: "artifact";
        outputPath: string;
        artifactId: string;
        filePaths: string[];
      } | {
        kind: "top-level-fallback";
        outputPath: "tasks.md";
        artifactId: null;
        filePaths: ["tasks.md"];
      } | {
        kind: "none";
        outputPath: null;
        artifactId: null;
        filePaths: [];
      };
      tasks: {
        id: string;
        text: string;
        completed: boolean;
        location: {
          filePath: string;
          taskIndex: number;
        };
        section?: string | undefined;
      }[];
      total: number;
      remaining: number;
      completed: number;
      phase: "no-tasks" | "complete" | "in-progress";
    }, {
      source: {
        kind: "artifact";
        outputPath: string;
        artifactId: string;
        filePaths: string[];
      } | {
        kind: "top-level-fallback";
        outputPath: "tasks.md";
        artifactId: null;
        filePaths: ["tasks.md"];
      } | {
        kind: "none";
        outputPath: null;
        artifactId: null;
        filePaths: [];
      };
      tasks: {
        id: string;
        text: string;
        completed: boolean;
        location: {
          filePath: string;
          taskIndex: number;
        };
        section?: string | undefined;
      }[];
      total: number;
      remaining: number;
      completed: number;
      phase: "no-tasks" | "complete" | "in-progress";
    }>;
    cliTaskSummary: z.ZodNullable<z.ZodObject<{
      completedTasks: z.ZodNumber;
      totalTasks: z.ZodNumber;
      status: z.ZodEnum<["no-tasks", "complete", "in-progress"]>;
    }, "strip", z.ZodTypeAny, {
      status: "no-tasks" | "complete" | "in-progress";
      completedTasks: number;
      totalTasks: number;
    }, {
      status: "no-tasks" | "complete" | "in-progress";
      completedTasks: number;
      totalTasks: number;
    }>>;
    updatedAt: z.ZodNumber;
  }, "strip", z.ZodTypeAny, {
    id: string;
    updatedAt: number;
    name: string;
    trackedTaskProgress: {
      source: {
        kind: "artifact";
        outputPath: string;
        artifactId: string;
        filePaths: string[];
      } | {
        kind: "top-level-fallback";
        outputPath: "tasks.md";
        artifactId: null;
        filePaths: ["tasks.md"];
      } | {
        kind: "none";
        outputPath: null;
        artifactId: null;
        filePaths: [];
      };
      tasks: {
        id: string;
        text: string;
        completed: boolean;
        location: {
          filePath: string;
          taskIndex: number;
        };
        section?: string | undefined;
      }[];
      total: number;
      remaining: number;
      completed: number;
      phase: "no-tasks" | "complete" | "in-progress";
    };
    cliTaskSummary: {
      status: "no-tasks" | "complete" | "in-progress";
      completedTasks: number;
      totalTasks: number;
    } | null;
  }, {
    id: string;
    updatedAt: number;
    name: string;
    trackedTaskProgress: {
      source: {
        kind: "artifact";
        outputPath: string;
        artifactId: string;
        filePaths: string[];
      } | {
        kind: "top-level-fallback";
        outputPath: "tasks.md";
        artifactId: null;
        filePaths: ["tasks.md"];
      } | {
        kind: "none";
        outputPath: null;
        artifactId: null;
        filePaths: [];
      };
      tasks: {
        id: string;
        text: string;
        completed: boolean;
        location: {
          filePath: string;
          taskIndex: number;
        };
        section?: string | undefined;
      }[];
      total: number;
      remaining: number;
      completed: number;
      phase: "no-tasks" | "complete" | "in-progress";
    };
    cliTaskSummary: {
      status: "no-tasks" | "complete" | "in-progress";
      completedTasks: number;
      totalTasks: number;
    } | null;
  }>, "many">;
  trackedTaskPhaseCounts: z.ZodObject<{
    'no-tasks': z.ZodNumber;
    'in-progress': z.ZodNumber;
    complete: z.ZodNumber;
  }, "strip", z.ZodTypeAny, {
    'no-tasks': number;
    complete: number;
    'in-progress': number;
  }, {
    'no-tasks': number;
    complete: number;
    'in-progress': number;
  }>;
  recentArchives: z.ZodArray<z.ZodObject<{
    id: z.ZodString;
    name: z.ZodString;
    trackedTaskProgress: z.ZodObject<{
      tasks: z.ZodArray<z.ZodObject<{
        id: z.ZodString;
        text: z.ZodString;
        completed: z.ZodBoolean;
        section: z.ZodOptional<z.ZodString>;
      } & {
        location: z.ZodObject<{
          filePath: z.ZodString;
          taskIndex: z.ZodNumber;
        }, "strip", z.ZodTypeAny, {
          filePath: string;
          taskIndex: number;
        }, {
          filePath: string;
          taskIndex: number;
        }>;
      }, "strip", z.ZodTypeAny, {
        id: string;
        text: string;
        completed: boolean;
        location: {
          filePath: string;
          taskIndex: number;
        };
        section?: string | undefined;
      }, {
        id: string;
        text: string;
        completed: boolean;
        location: {
          filePath: string;
          taskIndex: number;
        };
        section?: string | undefined;
      }>, "many">;
      total: z.ZodNumber;
      completed: z.ZodNumber;
      remaining: z.ZodNumber;
      phase: z.ZodEnum<["no-tasks", "in-progress", "complete"]>;
      source: z.ZodDiscriminatedUnion<"kind", [z.ZodObject<{
        kind: z.ZodLiteral<"artifact">;
        artifactId: z.ZodString;
        outputPath: z.ZodString;
        filePaths: z.ZodArray<z.ZodString, "many">;
      }, "strip", z.ZodTypeAny, {
        kind: "artifact";
        outputPath: string;
        artifactId: string;
        filePaths: string[];
      }, {
        kind: "artifact";
        outputPath: string;
        artifactId: string;
        filePaths: string[];
      }>, z.ZodObject<{
        kind: z.ZodLiteral<"top-level-fallback">;
        artifactId: z.ZodNull;
        outputPath: z.ZodLiteral<"tasks.md">;
        filePaths: z.ZodTuple<[z.ZodLiteral<"tasks.md">], null>;
      }, "strip", z.ZodTypeAny, {
        kind: "top-level-fallback";
        outputPath: "tasks.md";
        artifactId: null;
        filePaths: ["tasks.md"];
      }, {
        kind: "top-level-fallback";
        outputPath: "tasks.md";
        artifactId: null;
        filePaths: ["tasks.md"];
      }>, z.ZodObject<{
        kind: z.ZodLiteral<"none">;
        artifactId: z.ZodNull;
        outputPath: z.ZodNull;
        filePaths: z.ZodTuple<[], null>;
      }, "strip", z.ZodTypeAny, {
        kind: "none";
        outputPath: null;
        artifactId: null;
        filePaths: [];
      }, {
        kind: "none";
        outputPath: null;
        artifactId: null;
        filePaths: [];
      }>]>;
    }, "strip", z.ZodTypeAny, {
      source: {
        kind: "artifact";
        outputPath: string;
        artifactId: string;
        filePaths: string[];
      } | {
        kind: "top-level-fallback";
        outputPath: "tasks.md";
        artifactId: null;
        filePaths: ["tasks.md"];
      } | {
        kind: "none";
        outputPath: null;
        artifactId: null;
        filePaths: [];
      };
      tasks: {
        id: string;
        text: string;
        completed: boolean;
        location: {
          filePath: string;
          taskIndex: number;
        };
        section?: string | undefined;
      }[];
      total: number;
      remaining: number;
      completed: number;
      phase: "no-tasks" | "complete" | "in-progress";
    }, {
      source: {
        kind: "artifact";
        outputPath: string;
        artifactId: string;
        filePaths: string[];
      } | {
        kind: "top-level-fallback";
        outputPath: "tasks.md";
        artifactId: null;
        filePaths: ["tasks.md"];
      } | {
        kind: "none";
        outputPath: null;
        artifactId: null;
        filePaths: [];
      };
      tasks: {
        id: string;
        text: string;
        completed: boolean;
        location: {
          filePath: string;
          taskIndex: number;
        };
        section?: string | undefined;
      }[];
      total: number;
      remaining: number;
      completed: number;
      phase: "no-tasks" | "complete" | "in-progress";
    }>;
    archivedAt: z.ZodNumber;
    updatedAt: z.ZodNumber;
  }, "strip", z.ZodTypeAny, {
    id: string;
    updatedAt: number;
    name: string;
    trackedTaskProgress: {
      source: {
        kind: "artifact";
        outputPath: string;
        artifactId: string;
        filePaths: string[];
      } | {
        kind: "top-level-fallback";
        outputPath: "tasks.md";
        artifactId: null;
        filePaths: ["tasks.md"];
      } | {
        kind: "none";
        outputPath: null;
        artifactId: null;
        filePaths: [];
      };
      tasks: {
        id: string;
        text: string;
        completed: boolean;
        location: {
          filePath: string;
          taskIndex: number;
        };
        section?: string | undefined;
      }[];
      total: number;
      remaining: number;
      completed: number;
      phase: "no-tasks" | "complete" | "in-progress";
    };
    archivedAt: number;
  }, {
    id: string;
    updatedAt: number;
    name: string;
    trackedTaskProgress: {
      source: {
        kind: "artifact";
        outputPath: string;
        artifactId: string;
        filePaths: string[];
      } | {
        kind: "top-level-fallback";
        outputPath: "tasks.md";
        artifactId: null;
        filePaths: ["tasks.md"];
      } | {
        kind: "none";
        outputPath: null;
        artifactId: null;
        filePaths: [];
      };
      tasks: {
        id: string;
        text: string;
        completed: boolean;
        location: {
          filePath: string;
          taskIndex: number;
        };
        section?: string | undefined;
      }[];
      total: number;
      remaining: number;
      completed: number;
      phase: "no-tasks" | "complete" | "in-progress";
    };
    archivedAt: number;
  }>, "many">;
} & {
  trends: z.ZodObject<{
    specifications: z.ZodArray<z.ZodObject<{
      ts: z.ZodNumber;
      value: z.ZodNumber;
    }, "strip", z.ZodTypeAny, {
      value: number;
      ts: number;
    }, {
      value: number;
      ts: number;
    }>, "many">;
    requirements: z.ZodArray<z.ZodObject<{
      ts: z.ZodNumber;
      value: z.ZodNumber;
    }, "strip", z.ZodTypeAny, {
      value: number;
      ts: number;
    }, {
      value: number;
      ts: number;
    }>, "many">;
    activeChanges: z.ZodArray<z.ZodObject<{
      ts: z.ZodNumber;
      value: z.ZodNumber;
    }, "strip", z.ZodTypeAny, {
      value: number;
      ts: number;
    }, {
      value: number;
      ts: number;
    }>, "many">;
    inProgressChanges: z.ZodArray<z.ZodObject<{
      ts: z.ZodNumber;
      value: z.ZodNumber;
    }, "strip", z.ZodTypeAny, {
      value: number;
      ts: number;
    }, {
      value: number;
      ts: number;
    }>, "many">;
    completedChanges: z.ZodArray<z.ZodObject<{
      ts: z.ZodNumber;
      value: z.ZodNumber;
    }, "strip", z.ZodTypeAny, {
      value: number;
      ts: number;
    }, {
      value: number;
      ts: number;
    }>, "many">;
    taskCompletionPercent: z.ZodArray<z.ZodObject<{
      ts: z.ZodNumber;
      value: z.ZodNumber;
    }, "strip", z.ZodTypeAny, {
      value: number;
      ts: number;
    }, {
      value: number;
      ts: number;
    }>, "many">;
  }, "strip", z.ZodTypeAny, {
    specifications: {
      value: number;
      ts: number;
    }[];
    requirements: {
      value: number;
      ts: number;
    }[];
    activeChanges: {
      value: number;
      ts: number;
    }[];
    inProgressChanges: {
      value: number;
      ts: number;
    }[];
    completedChanges: {
      value: number;
      ts: number;
    }[];
    taskCompletionPercent: {
      value: number;
      ts: number;
    }[];
  }, {
    specifications: {
      value: number;
      ts: number;
    }[];
    requirements: {
      value: number;
      ts: number;
    }[];
    activeChanges: {
      value: number;
      ts: number;
    }[];
    inProgressChanges: {
      value: number;
      ts: number;
    }[];
    completedChanges: {
      value: number;
      ts: number;
    }[];
    taskCompletionPercent: {
      value: number;
      ts: number;
    }[];
  }>;
  triColorTrends: z.ZodObject<{
    specifications: z.ZodArray<z.ZodObject<{
      ts: z.ZodNumber;
      add: z.ZodNumber;
      modify: z.ZodNumber;
      delete: z.ZodNumber;
    }, "strip", z.ZodTypeAny, {
      ts: number;
      add: number;
      modify: number;
      delete: number;
    }, {
      ts: number;
      add: number;
      modify: number;
      delete: number;
    }>, "many">;
    requirements: z.ZodArray<z.ZodObject<{
      ts: z.ZodNumber;
      add: z.ZodNumber;
      modify: z.ZodNumber;
      delete: z.ZodNumber;
    }, "strip", z.ZodTypeAny, {
      ts: number;
      add: number;
      modify: number;
      delete: number;
    }, {
      ts: number;
      add: number;
      modify: number;
      delete: number;
    }>, "many">;
    activeChanges: z.ZodArray<z.ZodObject<{
      ts: z.ZodNumber;
      add: z.ZodNumber;
      modify: z.ZodNumber;
      delete: z.ZodNumber;
    }, "strip", z.ZodTypeAny, {
      ts: number;
      add: number;
      modify: number;
      delete: number;
    }, {
      ts: number;
      add: number;
      modify: number;
      delete: number;
    }>, "many">;
    inProgressChanges: z.ZodArray<z.ZodObject<{
      ts: z.ZodNumber;
      add: z.ZodNumber;
      modify: z.ZodNumber;
      delete: z.ZodNumber;
    }, "strip", z.ZodTypeAny, {
      ts: number;
      add: number;
      modify: number;
      delete: number;
    }, {
      ts: number;
      add: number;
      modify: number;
      delete: number;
    }>, "many">;
    completedChanges: z.ZodArray<z.ZodObject<{
      ts: z.ZodNumber;
      add: z.ZodNumber;
      modify: z.ZodNumber;
      delete: z.ZodNumber;
    }, "strip", z.ZodTypeAny, {
      ts: number;
      add: number;
      modify: number;
      delete: number;
    }, {
      ts: number;
      add: number;
      modify: number;
      delete: number;
    }>, "many">;
    taskCompletionPercent: z.ZodArray<z.ZodObject<{
      ts: z.ZodNumber;
      add: z.ZodNumber;
      modify: z.ZodNumber;
      delete: z.ZodNumber;
    }, "strip", z.ZodTypeAny, {
      ts: number;
      add: number;
      modify: number;
      delete: number;
    }, {
      ts: number;
      add: number;
      modify: number;
      delete: number;
    }>, "many">;
  }, "strip", z.ZodTypeAny, {
    specifications: {
      ts: number;
      add: number;
      modify: number;
      delete: number;
    }[];
    requirements: {
      ts: number;
      add: number;
      modify: number;
      delete: number;
    }[];
    activeChanges: {
      ts: number;
      add: number;
      modify: number;
      delete: number;
    }[];
    inProgressChanges: {
      ts: number;
      add: number;
      modify: number;
      delete: number;
    }[];
    completedChanges: {
      ts: number;
      add: number;
      modify: number;
      delete: number;
    }[];
    taskCompletionPercent: {
      ts: number;
      add: number;
      modify: number;
      delete: number;
    }[];
  }, {
    specifications: {
      ts: number;
      add: number;
      modify: number;
      delete: number;
    }[];
    requirements: {
      ts: number;
      add: number;
      modify: number;
      delete: number;
    }[];
    activeChanges: {
      ts: number;
      add: number;
      modify: number;
      delete: number;
    }[];
    inProgressChanges: {
      ts: number;
      add: number;
      modify: number;
      delete: number;
    }[];
    completedChanges: {
      ts: number;
      add: number;
      modify: number;
      delete: number;
    }[];
    taskCompletionPercent: {
      ts: number;
      add: number;
      modify: number;
      delete: number;
    }[];
  }>;
  trendKinds: z.ZodObject<{
    specifications: z.ZodEnum<["monotonic", "bidirectional"]>;
    requirements: z.ZodEnum<["monotonic", "bidirectional"]>;
    activeChanges: z.ZodEnum<["monotonic", "bidirectional"]>;
    inProgressChanges: z.ZodEnum<["monotonic", "bidirectional"]>;
    completedChanges: z.ZodEnum<["monotonic", "bidirectional"]>;
    taskCompletionPercent: z.ZodEnum<["monotonic", "bidirectional"]>;
  }, "strip", z.ZodTypeAny, {
    specifications: "monotonic" | "bidirectional";
    requirements: "monotonic" | "bidirectional";
    activeChanges: "monotonic" | "bidirectional";
    inProgressChanges: "monotonic" | "bidirectional";
    completedChanges: "monotonic" | "bidirectional";
    taskCompletionPercent: "monotonic" | "bidirectional";
  }, {
    specifications: "monotonic" | "bidirectional";
    requirements: "monotonic" | "bidirectional";
    activeChanges: "monotonic" | "bidirectional";
    inProgressChanges: "monotonic" | "bidirectional";
    completedChanges: "monotonic" | "bidirectional";
    taskCompletionPercent: "monotonic" | "bidirectional";
  }>;
  cardAvailability: z.ZodObject<{
    specifications: z.ZodDiscriminatedUnion<"state", [z.ZodObject<{
      state: z.ZodLiteral<"ok">;
    }, "strip", z.ZodTypeAny, {
      state: "ok";
    }, {
      state: "ok";
    }>, z.ZodObject<{
      state: z.ZodLiteral<"invalid">;
      reason: z.ZodEnum<["semantic-uncomputable", "objective-history-unavailable"]>;
    }, "strip", z.ZodTypeAny, {
      state: "invalid";
      reason: "semantic-uncomputable" | "objective-history-unavailable";
    }, {
      state: "invalid";
      reason: "semantic-uncomputable" | "objective-history-unavailable";
    }>]>;
    requirements: z.ZodDiscriminatedUnion<"state", [z.ZodObject<{
      state: z.ZodLiteral<"ok">;
    }, "strip", z.ZodTypeAny, {
      state: "ok";
    }, {
      state: "ok";
    }>, z.ZodObject<{
      state: z.ZodLiteral<"invalid">;
      reason: z.ZodEnum<["semantic-uncomputable", "objective-history-unavailable"]>;
    }, "strip", z.ZodTypeAny, {
      state: "invalid";
      reason: "semantic-uncomputable" | "objective-history-unavailable";
    }, {
      state: "invalid";
      reason: "semantic-uncomputable" | "objective-history-unavailable";
    }>]>;
    activeChanges: z.ZodDiscriminatedUnion<"state", [z.ZodObject<{
      state: z.ZodLiteral<"ok">;
    }, "strip", z.ZodTypeAny, {
      state: "ok";
    }, {
      state: "ok";
    }>, z.ZodObject<{
      state: z.ZodLiteral<"invalid">;
      reason: z.ZodEnum<["semantic-uncomputable", "objective-history-unavailable"]>;
    }, "strip", z.ZodTypeAny, {
      state: "invalid";
      reason: "semantic-uncomputable" | "objective-history-unavailable";
    }, {
      state: "invalid";
      reason: "semantic-uncomputable" | "objective-history-unavailable";
    }>]>;
    inProgressChanges: z.ZodDiscriminatedUnion<"state", [z.ZodObject<{
      state: z.ZodLiteral<"ok">;
    }, "strip", z.ZodTypeAny, {
      state: "ok";
    }, {
      state: "ok";
    }>, z.ZodObject<{
      state: z.ZodLiteral<"invalid">;
      reason: z.ZodEnum<["semantic-uncomputable", "objective-history-unavailable"]>;
    }, "strip", z.ZodTypeAny, {
      state: "invalid";
      reason: "semantic-uncomputable" | "objective-history-unavailable";
    }, {
      state: "invalid";
      reason: "semantic-uncomputable" | "objective-history-unavailable";
    }>]>;
    completedChanges: z.ZodDiscriminatedUnion<"state", [z.ZodObject<{
      state: z.ZodLiteral<"ok">;
    }, "strip", z.ZodTypeAny, {
      state: "ok";
    }, {
      state: "ok";
    }>, z.ZodObject<{
      state: z.ZodLiteral<"invalid">;
      reason: z.ZodEnum<["semantic-uncomputable", "objective-history-unavailable"]>;
    }, "strip", z.ZodTypeAny, {
      state: "invalid";
      reason: "semantic-uncomputable" | "objective-history-unavailable";
    }, {
      state: "invalid";
      reason: "semantic-uncomputable" | "objective-history-unavailable";
    }>]>;
    taskCompletionPercent: z.ZodDiscriminatedUnion<"state", [z.ZodObject<{
      state: z.ZodLiteral<"ok">;
    }, "strip", z.ZodTypeAny, {
      state: "ok";
    }, {
      state: "ok";
    }>, z.ZodObject<{
      state: z.ZodLiteral<"invalid">;
      reason: z.ZodEnum<["semantic-uncomputable", "objective-history-unavailable"]>;
    }, "strip", z.ZodTypeAny, {
      state: "invalid";
      reason: "semantic-uncomputable" | "objective-history-unavailable";
    }, {
      state: "invalid";
      reason: "semantic-uncomputable" | "objective-history-unavailable";
    }>]>;
  }, "strip", z.ZodTypeAny, {
    specifications: {
      state: "ok";
    } | {
      state: "invalid";
      reason: "semantic-uncomputable" | "objective-history-unavailable";
    };
    requirements: {
      state: "ok";
    } | {
      state: "invalid";
      reason: "semantic-uncomputable" | "objective-history-unavailable";
    };
    activeChanges: {
      state: "ok";
    } | {
      state: "invalid";
      reason: "semantic-uncomputable" | "objective-history-unavailable";
    };
    inProgressChanges: {
      state: "ok";
    } | {
      state: "invalid";
      reason: "semantic-uncomputable" | "objective-history-unavailable";
    };
    completedChanges: {
      state: "ok";
    } | {
      state: "invalid";
      reason: "semantic-uncomputable" | "objective-history-unavailable";
    };
    taskCompletionPercent: {
      state: "ok";
    } | {
      state: "invalid";
      reason: "semantic-uncomputable" | "objective-history-unavailable";
    };
  }, {
    specifications: {
      state: "ok";
    } | {
      state: "invalid";
      reason: "semantic-uncomputable" | "objective-history-unavailable";
    };
    requirements: {
      state: "ok";
    } | {
      state: "invalid";
      reason: "semantic-uncomputable" | "objective-history-unavailable";
    };
    activeChanges: {
      state: "ok";
    } | {
      state: "invalid";
      reason: "semantic-uncomputable" | "objective-history-unavailable";
    };
    inProgressChanges: {
      state: "ok";
    } | {
      state: "invalid";
      reason: "semantic-uncomputable" | "objective-history-unavailable";
    };
    completedChanges: {
      state: "ok";
    } | {
      state: "invalid";
      reason: "semantic-uncomputable" | "objective-history-unavailable";
    };
    taskCompletionPercent: {
      state: "ok";
    } | {
      state: "invalid";
      reason: "semantic-uncomputable" | "objective-history-unavailable";
    };
  }>;
  trendMeta: z.ZodObject<{
    pointLimit: z.ZodNumber;
    lastUpdatedAt: z.ZodNumber;
  }, "strip", z.ZodTypeAny, {
    pointLimit: number;
    lastUpdatedAt: number;
  }, {
    pointLimit: number;
    lastUpdatedAt: number;
  }>;
} & {
  git: z.ZodObject<{
    bindingToken: z.ZodNullable<z.ZodString>;
    defaultBranch: z.ZodString;
    worktrees: z.ZodArray<z.ZodObject<{
      path: z.ZodString;
      relativePath: z.ZodString;
      pathAvailable: z.ZodBoolean;
      branchName: z.ZodString;
      detached: z.ZodBoolean;
      isCurrent: z.ZodBoolean;
      ahead: z.ZodNumber;
      behind: z.ZodNumber;
      diff: z.ZodObject<{
        files: z.ZodNumber;
        insertions: z.ZodNumber;
        deletions: z.ZodNumber;
      }, "strip", z.ZodTypeAny, {
        files: number;
        insertions: number;
        deletions: number;
      }, {
        files: number;
        insertions: number;
        deletions: number;
      }>;
      entries: z.ZodArray<z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
        type: z.ZodLiteral<"commit">;
        hash: z.ZodString;
        title: z.ZodString;
        committedAt: z.ZodNumber;
        relatedChanges: z.ZodArray<z.ZodString, "many">;
        diff: z.ZodObject<{
          files: z.ZodNumber;
          insertions: z.ZodNumber;
          deletions: z.ZodNumber;
        }, "strip", z.ZodTypeAny, {
          files: number;
          insertions: number;
          deletions: number;
        }, {
          files: number;
          insertions: number;
          deletions: number;
        }>;
      }, "strip", z.ZodTypeAny, {
        type: "commit";
        title: string;
        diff: {
          files: number;
          insertions: number;
          deletions: number;
        };
        hash: string;
        committedAt: number;
        relatedChanges: string[];
      }, {
        type: "commit";
        title: string;
        diff: {
          files: number;
          insertions: number;
          deletions: number;
        };
        hash: string;
        committedAt: number;
        relatedChanges: string[];
      }>, z.ZodObject<{
        type: z.ZodLiteral<"uncommitted">;
        title: z.ZodString;
        updatedAt: z.ZodNullable<z.ZodNumber>;
        relatedChanges: z.ZodArray<z.ZodString, "many">;
        diff: z.ZodObject<{
          files: z.ZodNumber;
          insertions: z.ZodNumber;
          deletions: z.ZodNumber;
        }, "strip", z.ZodTypeAny, {
          files: number;
          insertions: number;
          deletions: number;
        }, {
          files: number;
          insertions: number;
          deletions: number;
        }>;
      }, "strip", z.ZodTypeAny, {
        type: "uncommitted";
        updatedAt: number | null;
        title: string;
        diff: {
          files: number;
          insertions: number;
          deletions: number;
        };
        relatedChanges: string[];
      }, {
        type: "uncommitted";
        updatedAt: number | null;
        title: string;
        diff: {
          files: number;
          insertions: number;
          deletions: number;
        };
        relatedChanges: string[];
      }>]>, "many">;
    }, "strip", z.ZodTypeAny, {
      path: string;
      entries: ({
        type: "commit";
        title: string;
        diff: {
          files: number;
          insertions: number;
          deletions: number;
        };
        hash: string;
        committedAt: number;
        relatedChanges: string[];
      } | {
        type: "uncommitted";
        updatedAt: number | null;
        title: string;
        diff: {
          files: number;
          insertions: number;
          deletions: number;
        };
        relatedChanges: string[];
      })[];
      relativePath: string;
      pathAvailable: boolean;
      branchName: string;
      detached: boolean;
      isCurrent: boolean;
      ahead: number;
      behind: number;
      diff: {
        files: number;
        insertions: number;
        deletions: number;
      };
    }, {
      path: string;
      entries: ({
        type: "commit";
        title: string;
        diff: {
          files: number;
          insertions: number;
          deletions: number;
        };
        hash: string;
        committedAt: number;
        relatedChanges: string[];
      } | {
        type: "uncommitted";
        updatedAt: number | null;
        title: string;
        diff: {
          files: number;
          insertions: number;
          deletions: number;
        };
        relatedChanges: string[];
      })[];
      relativePath: string;
      pathAvailable: boolean;
      branchName: string;
      detached: boolean;
      isCurrent: boolean;
      ahead: number;
      behind: number;
      diff: {
        files: number;
        insertions: number;
        deletions: number;
      };
    }>, "many">;
  }, "strip", z.ZodTypeAny, {
    bindingToken: string | null;
    defaultBranch: string;
    worktrees: {
      path: string;
      entries: ({
        type: "commit";
        title: string;
        diff: {
          files: number;
          insertions: number;
          deletions: number;
        };
        hash: string;
        committedAt: number;
        relatedChanges: string[];
      } | {
        type: "uncommitted";
        updatedAt: number | null;
        title: string;
        diff: {
          files: number;
          insertions: number;
          deletions: number;
        };
        relatedChanges: string[];
      })[];
      relativePath: string;
      pathAvailable: boolean;
      branchName: string;
      detached: boolean;
      isCurrent: boolean;
      ahead: number;
      behind: number;
      diff: {
        files: number;
        insertions: number;
        deletions: number;
      };
    }[];
  }, {
    bindingToken: string | null;
    defaultBranch: string;
    worktrees: {
      path: string;
      entries: ({
        type: "commit";
        title: string;
        diff: {
          files: number;
          insertions: number;
          deletions: number;
        };
        hash: string;
        committedAt: number;
        relatedChanges: string[];
      } | {
        type: "uncommitted";
        updatedAt: number | null;
        title: string;
        diff: {
          files: number;
          insertions: number;
          deletions: number;
        };
        relatedChanges: string[];
      })[];
      relativePath: string;
      pathAvailable: boolean;
      branchName: string;
      detached: boolean;
      isCurrent: boolean;
      ahead: number;
      behind: number;
      diff: {
        files: number;
        insertions: number;
        deletions: number;
      };
    }[];
  }>;
}, "strip", z.ZodTypeAny, {
  git: {
    bindingToken: string | null;
    defaultBranch: string;
    worktrees: {
      path: string;
      entries: ({
        type: "commit";
        title: string;
        diff: {
          files: number;
          insertions: number;
          deletions: number;
        };
        hash: string;
        committedAt: number;
        relatedChanges: string[];
      } | {
        type: "uncommitted";
        updatedAt: number | null;
        title: string;
        diff: {
          files: number;
          insertions: number;
          deletions: number;
        };
        relatedChanges: string[];
      })[];
      relativePath: string;
      pathAvailable: boolean;
      branchName: string;
      detached: boolean;
      isCurrent: boolean;
      ahead: number;
      behind: number;
      diff: {
        files: number;
        insertions: number;
        deletions: number;
      };
    }[];
  };
  summary: {
    specifications: number;
    requirements: number;
    activeChanges: number;
    inProgressChanges: number;
    completedChanges: number;
    archivedTasksCompleted: number;
    tasksTotal: number;
    tasksCompleted: number;
    taskCompletionPercent: number | null;
  };
  specifications: {
    id: string;
    updatedAt: number;
    name: string;
    requirements: number;
  }[];
  activeChanges: {
    id: string;
    updatedAt: number;
    name: string;
    trackedTaskProgress: {
      source: {
        kind: "artifact";
        outputPath: string;
        artifactId: string;
        filePaths: string[];
      } | {
        kind: "top-level-fallback";
        outputPath: "tasks.md";
        artifactId: null;
        filePaths: ["tasks.md"];
      } | {
        kind: "none";
        outputPath: null;
        artifactId: null;
        filePaths: [];
      };
      tasks: {
        id: string;
        text: string;
        completed: boolean;
        location: {
          filePath: string;
          taskIndex: number;
        };
        section?: string | undefined;
      }[];
      total: number;
      remaining: number;
      completed: number;
      phase: "no-tasks" | "complete" | "in-progress";
    };
    cliTaskSummary: {
      status: "no-tasks" | "complete" | "in-progress";
      completedTasks: number;
      totalTasks: number;
    } | null;
  }[];
  trackedTaskPhaseCounts: {
    'no-tasks': number;
    complete: number;
    'in-progress': number;
  };
  recentArchives: {
    id: string;
    updatedAt: number;
    name: string;
    trackedTaskProgress: {
      source: {
        kind: "artifact";
        outputPath: string;
        artifactId: string;
        filePaths: string[];
      } | {
        kind: "top-level-fallback";
        outputPath: "tasks.md";
        artifactId: null;
        filePaths: ["tasks.md"];
      } | {
        kind: "none";
        outputPath: null;
        artifactId: null;
        filePaths: [];
      };
      tasks: {
        id: string;
        text: string;
        completed: boolean;
        location: {
          filePath: string;
          taskIndex: number;
        };
        section?: string | undefined;
      }[];
      total: number;
      remaining: number;
      completed: number;
      phase: "no-tasks" | "complete" | "in-progress";
    };
    archivedAt: number;
  }[];
  trends: {
    specifications: {
      value: number;
      ts: number;
    }[];
    requirements: {
      value: number;
      ts: number;
    }[];
    activeChanges: {
      value: number;
      ts: number;
    }[];
    inProgressChanges: {
      value: number;
      ts: number;
    }[];
    completedChanges: {
      value: number;
      ts: number;
    }[];
    taskCompletionPercent: {
      value: number;
      ts: number;
    }[];
  };
  triColorTrends: {
    specifications: {
      ts: number;
      add: number;
      modify: number;
      delete: number;
    }[];
    requirements: {
      ts: number;
      add: number;
      modify: number;
      delete: number;
    }[];
    activeChanges: {
      ts: number;
      add: number;
      modify: number;
      delete: number;
    }[];
    inProgressChanges: {
      ts: number;
      add: number;
      modify: number;
      delete: number;
    }[];
    completedChanges: {
      ts: number;
      add: number;
      modify: number;
      delete: number;
    }[];
    taskCompletionPercent: {
      ts: number;
      add: number;
      modify: number;
      delete: number;
    }[];
  };
  trendKinds: {
    specifications: "monotonic" | "bidirectional";
    requirements: "monotonic" | "bidirectional";
    activeChanges: "monotonic" | "bidirectional";
    inProgressChanges: "monotonic" | "bidirectional";
    completedChanges: "monotonic" | "bidirectional";
    taskCompletionPercent: "monotonic" | "bidirectional";
  };
  cardAvailability: {
    specifications: {
      state: "ok";
    } | {
      state: "invalid";
      reason: "semantic-uncomputable" | "objective-history-unavailable";
    };
    requirements: {
      state: "ok";
    } | {
      state: "invalid";
      reason: "semantic-uncomputable" | "objective-history-unavailable";
    };
    activeChanges: {
      state: "ok";
    } | {
      state: "invalid";
      reason: "semantic-uncomputable" | "objective-history-unavailable";
    };
    inProgressChanges: {
      state: "ok";
    } | {
      state: "invalid";
      reason: "semantic-uncomputable" | "objective-history-unavailable";
    };
    completedChanges: {
      state: "ok";
    } | {
      state: "invalid";
      reason: "semantic-uncomputable" | "objective-history-unavailable";
    };
    taskCompletionPercent: {
      state: "ok";
    } | {
      state: "invalid";
      reason: "semantic-uncomputable" | "objective-history-unavailable";
    };
  };
  trendMeta: {
    pointLimit: number;
    lastUpdatedAt: number;
  };
}, {
  git: {
    bindingToken: string | null;
    defaultBranch: string;
    worktrees: {
      path: string;
      entries: ({
        type: "commit";
        title: string;
        diff: {
          files: number;
          insertions: number;
          deletions: number;
        };
        hash: string;
        committedAt: number;
        relatedChanges: string[];
      } | {
        type: "uncommitted";
        updatedAt: number | null;
        title: string;
        diff: {
          files: number;
          insertions: number;
          deletions: number;
        };
        relatedChanges: string[];
      })[];
      relativePath: string;
      pathAvailable: boolean;
      branchName: string;
      detached: boolean;
      isCurrent: boolean;
      ahead: number;
      behind: number;
      diff: {
        files: number;
        insertions: number;
        deletions: number;
      };
    }[];
  };
  summary: {
    specifications: number;
    requirements: number;
    activeChanges: number;
    inProgressChanges: number;
    completedChanges: number;
    archivedTasksCompleted: number;
    tasksTotal: number;
    tasksCompleted: number;
    taskCompletionPercent: number | null;
  };
  specifications: {
    id: string;
    updatedAt: number;
    name: string;
    requirements: number;
  }[];
  activeChanges: {
    id: string;
    updatedAt: number;
    name: string;
    trackedTaskProgress: {
      source: {
        kind: "artifact";
        outputPath: string;
        artifactId: string;
        filePaths: string[];
      } | {
        kind: "top-level-fallback";
        outputPath: "tasks.md";
        artifactId: null;
        filePaths: ["tasks.md"];
      } | {
        kind: "none";
        outputPath: null;
        artifactId: null;
        filePaths: [];
      };
      tasks: {
        id: string;
        text: string;
        completed: boolean;
        location: {
          filePath: string;
          taskIndex: number;
        };
        section?: string | undefined;
      }[];
      total: number;
      remaining: number;
      completed: number;
      phase: "no-tasks" | "complete" | "in-progress";
    };
    cliTaskSummary: {
      status: "no-tasks" | "complete" | "in-progress";
      completedTasks: number;
      totalTasks: number;
    } | null;
  }[];
  trackedTaskPhaseCounts: {
    'no-tasks': number;
    complete: number;
    'in-progress': number;
  };
  recentArchives: {
    id: string;
    updatedAt: number;
    name: string;
    trackedTaskProgress: {
      source: {
        kind: "artifact";
        outputPath: string;
        artifactId: string;
        filePaths: string[];
      } | {
        kind: "top-level-fallback";
        outputPath: "tasks.md";
        artifactId: null;
        filePaths: ["tasks.md"];
      } | {
        kind: "none";
        outputPath: null;
        artifactId: null;
        filePaths: [];
      };
      tasks: {
        id: string;
        text: string;
        completed: boolean;
        location: {
          filePath: string;
          taskIndex: number;
        };
        section?: string | undefined;
      }[];
      total: number;
      remaining: number;
      completed: number;
      phase: "no-tasks" | "complete" | "in-progress";
    };
    archivedAt: number;
  }[];
  trends: {
    specifications: {
      value: number;
      ts: number;
    }[];
    requirements: {
      value: number;
      ts: number;
    }[];
    activeChanges: {
      value: number;
      ts: number;
    }[];
    inProgressChanges: {
      value: number;
      ts: number;
    }[];
    completedChanges: {
      value: number;
      ts: number;
    }[];
    taskCompletionPercent: {
      value: number;
      ts: number;
    }[];
  };
  triColorTrends: {
    specifications: {
      ts: number;
      add: number;
      modify: number;
      delete: number;
    }[];
    requirements: {
      ts: number;
      add: number;
      modify: number;
      delete: number;
    }[];
    activeChanges: {
      ts: number;
      add: number;
      modify: number;
      delete: number;
    }[];
    inProgressChanges: {
      ts: number;
      add: number;
      modify: number;
      delete: number;
    }[];
    completedChanges: {
      ts: number;
      add: number;
      modify: number;
      delete: number;
    }[];
    taskCompletionPercent: {
      ts: number;
      add: number;
      modify: number;
      delete: number;
    }[];
  };
  trendKinds: {
    specifications: "monotonic" | "bidirectional";
    requirements: "monotonic" | "bidirectional";
    activeChanges: "monotonic" | "bidirectional";
    inProgressChanges: "monotonic" | "bidirectional";
    completedChanges: "monotonic" | "bidirectional";
    taskCompletionPercent: "monotonic" | "bidirectional";
  };
  cardAvailability: {
    specifications: {
      state: "ok";
    } | {
      state: "invalid";
      reason: "semantic-uncomputable" | "objective-history-unavailable";
    };
    requirements: {
      state: "ok";
    } | {
      state: "invalid";
      reason: "semantic-uncomputable" | "objective-history-unavailable";
    };
    activeChanges: {
      state: "ok";
    } | {
      state: "invalid";
      reason: "semantic-uncomputable" | "objective-history-unavailable";
    };
    inProgressChanges: {
      state: "ok";
    } | {
      state: "invalid";
      reason: "semantic-uncomputable" | "objective-history-unavailable";
    };
    completedChanges: {
      state: "ok";
    } | {
      state: "invalid";
      reason: "semantic-uncomputable" | "objective-history-unavailable";
    };
    taskCompletionPercent: {
      state: "ok";
    } | {
      state: "invalid";
      reason: "semantic-uncomputable" | "objective-history-unavailable";
    };
  };
  trendMeta: {
    pointLimit: number;
    lastUpdatedAt: number;
  };
}>;
//#endregion
//#region src/export-types.d.ts
/** Source from which the CLI resolved the exported writable planning root. */
type ExportRootSource = 'nearest' | 'declared' | 'store' | 'global_default' | 'implicit';
/** Root provenance captured by CLI selection instead of an assumed launch projectDir. */
interface ExportRootProvenance {
  /** Display-safe planning-root path; absolute paths are redacted before publication. */
  planningRootPath: string | null;
  /** How the CLI resolved the planning root. */
  rootSource: ExportRootSource;
  /** Effective Store id when the writable root was selected through an explicit Store. */
  storeId: string | null;
}
/**
 * Reference export policy recorded on the snapshot.
 *
 * - `none`: no effective References were observed; owned-only export.
 * - `omit`: References were observed but intentionally excluded; only an aggregate count is retained.
 * - `include`: direct Reference Specs were materialized; per-Store provenance is retained.
 */
type ExportReferencePolicy = {
  kind: 'none';
} | {
  kind: 'omit';
  referenceSourceCount: number;
} | {
  kind: 'include';
  referenceSources: Array<{
    storeId: string;
    state: 'ready' | 'error';
    specCount: number;
  }>;
};
/**
 * Complete snapshot of an OpenSpec project for static export
 */
/** Typed captured failure of the static schemas observation. */
interface StaticSchemasCaptureFailure {
  ok: false;
  /** CLI command whose observation failed. */
  command: 'openspec schemas';
  /** Selected Root selector forwarded for the observation, when captured. */
  selector: {
    store?: string;
  } | null;
  /** Whether the failing payload still carried a resolved Root. */
  rootAvailable: boolean;
  /** Upstream diagnostics from the failing payload's status array. */
  diagnostics: readonly CliDiagnostic[];
  stdout: string;
  stderr: string;
  exitCode: number | null;
  /** Raw parsed JSON payload of the failing observation, when parseable. */
  payload: CliJsonValue | null;
  contractError?: string;
}
interface ExportSnapshot {
  /** Snapshot metadata */
  meta: {
    timestamp: string;
    /** Monotonic observation time of the CLI-resolved snapshot. */
    observedAt: number;
    version: string;
    /**
     * Display-safe project label. Absolute project paths are intentionally NOT retained; publication
     * redaction strips machine-sensitive locations and this field carries only a human-readable name.
     */
    projectName: string;
    /** CLI-resolved writable planning-root provenance (not an absolute launch path). */
    root?: ExportRootProvenance;
    /** Reference export policy observed and applied during this snapshot. */
    referencePolicy?: ExportReferencePolicy;
  };
  /** Dashboard summary data */
  dashboard: {
    specsCount: number;
    changesCount: number;
    archivesCount: number;
  };
  /** Git snapshot used by static dashboard */
  git?: {
    defaultBranch: string;
    repositoryUrl: string | null;
    latestCommitTs: number | null;
    recentCommits: Array<{
      hash: string;
      title: string;
      committedAt: number;
      relatedChanges: string[];
      diff: {
        files: number;
        insertions: number;
        deletions: number;
      };
    }>;
  };
  /** OpenSpecUI runtime config captured during export */
  config?: OpenSpecUIConfig;
  /** All specs with parsed content (compound identity is source-aware). */
  specs: Array<{
    /** Compound identity: owned specs use `(owned, specId)`; referenced specs use `(referenced, storeId, specId)`. */
    identity: SpecIdentity;
    /** Whether this Spec came from the writable root (`owned`) or a read-only direct Reference (`referenced`). */
    source: 'owned' | 'referenced';
    /** Referenced Specs are read-only; owned Specs are writable. */
    readOnly: boolean;
    /** Store id that owns this Spec when `source === 'referenced'`; absent for owned Specs. */
    storeId?: string;
    id: string;
    name: string;
    /** Processed markdown shown by default in static OpenSpecUI. */
    content: string;
    /** Original source markdown, preserved for raw/source views. */
    sourceContent?: string;
    overview: string;
    requirements: Array<{
      id: string;
      title: string;
      bodyMarkdown: string;
      text: string;
      scenarios: Array<{
        title: string;
        bodyMarkdown: string;
        rawText: string;
        steps?: Array<{
          keyword: 'GIVEN' | 'WHEN' | 'THEN' | 'AND' | 'BUT';
          contentMarkdown: string;
          rawText: string;
        }>;
      }>;
    }>;
    createdAt: number;
    updatedAt: number;
  }>;
  /** All active changes with parsed content */
  changes: Array<{
    id: string;
    name: string;
    /** Processed proposal markdown shown by default in static OpenSpecUI. */
    proposal: string;
    /** Original source proposal markdown. */
    sourceProposal?: string;
    tasks?: string;
    sourceTasks?: string;
    design?: string;
    sourceDesign?: string;
    why: string;
    whatChanges: string;
    /** Formal workflow task truth from the tracked artifact glob. */
    trackedTaskProgress: TrackedTaskProgress;
    /** Task counts as reported by `openspec list`, when the export observed them. */
    cliTaskSummary?: {
      completedTasks: number;
      totalTasks: number;
      status: 'no-tasks' | 'complete' | 'in-progress';
    } | null;
    /** Secondary schema-document checkbox analytics. */
    documentChecklistSummary: DocumentChecklistSummary;
    deltas: Array<{
      capability: string;
      /** Processed delta spec markdown. */
      content: string;
      /** Original source delta spec markdown. */
      sourceContent?: string;
    }>;
    createdAt: number;
    updatedAt: number;
  }>;
  /** All archived changes */
  archives: Array<{
    id: string;
    name: string;
    /** Schema-neutral archived entity detail used by archive views, search, and dashboard facts. */
    entity: OpsxEntityDetail;
    trackedTaskProgress: TrackedTaskProgress;
    documentChecklistSummary: DocumentChecklistSummary;
    createdAt: number;
    updatedAt: number;
  }>;
  /** Project.md content */
  projectMd?: string;
  /** OPSX configuration data (for Config view) */
  opsx?: {
    configYaml?: string;
    schemas: SchemaInfo[];
    /**
     * Captured schemas-observation outcome. A failed observation keeps the complete typed
     * CLI evidence (for example the OpenSpec 1.9 selected-Root envelope) so static
     * consumers never read the failure as an empty successful catalog.
     */
    schemasCapture?: {
      ok: true;
    } | StaticSchemasCaptureFailure;
    schemaDetails: Record<string, SchemaDetail>;
    schemaYamls?: Record<string, string>;
    schemaResolutions: Record<string, SchemaResolution>;
    templates: Record<string, TemplatesMap>;
    templateContents?: Record<string, Record<string, {
      content: string | null;
      /** Display-safe relative path; absolute paths are redacted before publication. */
      path: string;
      displayPath?: string;
      source: 'project' | 'user' | 'package';
    }>>;
    changeMetadata: Record<string, string | null>;
  };
}
//#endregion
//#region src/git-panel-types.d.ts
type GitEntryCursor = string;
type GitRepositoryScope = 'code' | 'planning';
interface GitRepositoryIdentity {
  /** Canonical root of the selected Git worktree. */
  topLevel: string;
  /** Canonical common directory shared by linked Git worktrees. */
  commonDir: string;
}
interface GitRepositoryScopeDescriptor {
  scope: GitRepositoryScope;
  /** Opaque backend-issued binding epoch; provenance only, never authorization or a path. */
  bindingToken: string;
  /** Launch-project or planning-root path that requested this repository. */
  rootPath: string;
  /** Null when the requested root does not currently resolve to a Git repository. */
  repository: GitRepositoryIdentity | null;
}
/** Static/export scope descriptor with no live backend provenance. */
interface StaticGitRepositoryScopeDescriptor extends Omit<GitRepositoryScopeDescriptor, 'bindingToken'> {
  bindingToken: null;
}
interface GitRepositoryScopeFailure {
  /** Objective diagnostic retained when Planning binding resolution failed. */
  message: string;
}
interface GitRepositoryScopesBase {
  readonly defaultScope: 'code';
  readonly code: GitRepositoryScopeDescriptor & {
    readonly scope: 'code';
  };
}
/** Current Code/Planning Git scope projection with explicit resolution lifecycle. */
type GitRepositoryScopes = GitRepositoryScopesBase & ({
  /** Planning has not settled; its identity is not authoritative. */
  readonly planningState: 'resolving';
  readonly planning: null;
} | {
  /** Planning resolution completed; null means it is absent or the same identity as Code. */
  readonly planningState: 'settled';
  readonly planning: (GitRepositoryScopeDescriptor & {
    readonly scope: 'planning';
  }) | null;
} | {
  /** Planning resolution failed; Code remains usable but Planning is locked. */
  readonly planningState: 'failed';
  readonly planning: null;
  readonly planningError: GitRepositoryScopeFailure;
});
/** Static Git projection; it is intentionally ineligible for live RPC calls. */
interface StaticGitRepositoryScopes {
  readonly defaultScope: 'code';
  readonly code: StaticGitRepositoryScopeDescriptor & {
    readonly scope: 'code';
  };
  readonly planningState: 'settled';
  readonly planning: null;
}
type GitEntrySelector = {
  type: 'uncommitted';
} | {
  type: 'commit';
  hash: string;
};
type GitFileChangeType = 'added' | 'modified' | 'deleted' | 'renamed' | 'copied' | 'typechanged' | 'unmerged' | 'unknown';
type GitPatchState = 'available' | 'binary' | 'too-large' | 'unavailable';
type GitEntryFileSource = 'tracked' | 'untracked';
type GitEntryFileDiff = ({
  state: 'ready';
} & DashboardGitDiffStats) | {
  state: 'loading' | 'unavailable';
  files: number;
};
type GitWorktreeSummary = Omit<DashboardGitWorktree, 'entries'>;
interface GitEntriesPage {
  items: DashboardGitEntry[];
  nextCursor: GitEntryCursor | null;
}
interface GitEntryFileSummary {
  fileId: string;
  source: GitEntryFileSource;
  path: string;
  displayPath: string;
  previousPath: string | null;
  changeType: GitFileChangeType;
  diff: GitEntryFileDiff;
}
interface GitEntryFilePatch extends GitEntryFileSummary {
  patch: string | null;
  state: GitPatchState;
}
interface GitEntryShell {
  entry: DashboardGitEntry | null;
  files: GitEntryFileSummary[];
}
interface GitEntryFiles {
  files: GitEntryFileSummary[];
  eagerFiles: GitEntryFilePatch[];
  eagerPatchLineBudget: number;
  eagerPatchLineCount: number;
}
interface GitEntryPatch {
  file: GitEntryFilePatch | null;
}
type GitPatchFile = GitEntryFilePatch;
interface GitEntryDetail {
  entry: DashboardGitEntry | null;
  files: GitEntryFilePatch[];
}
interface GitWorktreeOverview {
  defaultBranch: string;
  currentWorktree: GitWorktreeSummary | null;
  otherWorktrees: GitWorktreeSummary[];
}
interface GitWorktreeHandoff {
  /** Canonical project path of the target worktree server. */
  projectDir: string;
  /** Target server URL; never contains repository binding credentials. */
  serverUrl: string;
}
//#endregion
//#region src/hooks.d.ts
declare const OPENSPECUI_DOCUMENT_HOOK_VERSION = 1;
declare const OPENSPECUI_WORKFLOW_HOOK_VERSION = 2;
/** Severity level for diagnostics returned by project hooks. */
type HookDiagnosticLevel = 'info' | 'warning' | 'error';
/** Non-fatal hook diagnostic surfaced with the processed result. */
interface HookDiagnosticV1 {
  level: HookDiagnosticLevel;
  message: string;
}
/** Project-scoped lifecycle helpers available to hooks. */
interface HookLifecycleV1 {
  /**
   * Register cleanup work for the project hook runtime.
   *
   * This lifecycle is project-scoped, not call-scoped, so daemon-style hooks can
   * keep one process alive for the OpenSpecUI session.
   */
  onDispose(cleanup: () => void | Promise<void>): void;
}
/** OpenSpecUI consumer requesting a processed document projection. */
type DocumentConsumerV1 = 'view' | 'search' | 'export';
/** Document read mode; source reads bypass hooks and stay audit-safe. */
type DocumentReadModeV1 = 'source' | 'processed';
/** Stable identity for the OpenSpec document currently being read. */
interface DocumentRefV1 {
  stage: 'project' | 'main' | 'change' | 'archive';
  kind: 'project' | 'spec' | 'proposal' | 'design' | 'tasks' | 'delta-spec' | 'artifact';
  relativePath: string;
  absolutePath: string;
  specId?: string;
  changeId?: string;
  schemaName?: string;
  artifactId?: string;
  artifactOutputPath?: string;
}
/** Context passed to `onReadDocument`. */
interface ReadDocumentContextV1 {
  version: typeof OPENSPECUI_DOCUMENT_HOOK_VERSION;
  projectDir: string;
  consumer: DocumentConsumerV1;
  document: DocumentRefV1;
  signal: AbortSignal;
  lifecycle: HookLifecycleV1;
}
/** Markdown projection returned by document reads and `onReadDocument`. */
interface ReadDocumentResultV1 {
  markdown: string;
  sourceLabel?: string;
  title?: string;
  diagnostics?: HookDiagnosticV1[];
  watchFiles?: string[];
}
/** Intercepts processed OpenSpec markdown reads for view, search, and export. */
type OnReadDocumentHookV1 = (ctx: ReadDocumentContextV1, read: () => Promise<ReadDocumentResultV1>) => Promise<ReadDocumentResultV1>;
/** OPSX workflow action names that can be customized by `onRunWorkflow`. */
type WorkflowActionV1 = OpsxWorkflowId;
/** Invocation mode requested by the UI before action-specific fallback resolution. */
type WorkflowRequestedModeV1 = 'compose' | 'command' | 'direct';
/** Normalized OPSX workflow input passed to `onRunWorkflow`. */
type RunWorkflowInputV1 = {
  action: OpsxTextInputAction;
  text: string;
} | {
  action: 'new';
  changeId: string;
  schema?: string;
  description?: string;
  extraArgs: string[];
} | {
  action: OpsxArtifactInputAction;
  changeId: string;
  artifactId: string;
  schema?: string;
} | {
  action: OpsxChangeInputAction;
  changeId: string;
  schema?: string;
  strict?: boolean;
} | {
  action: 'bulk-archive';
  changeIds?: string[];
  schema?: string;
} | {
  action: 'onboard';
};
/** Actual invocation mode after OpenSpecUI applies action capability rules. */
interface WorkflowInvocationModeResolutionV1 {
  requestedMode: WorkflowRequestedModeV1;
  actualMode: WorkflowRequestedModeV1;
  fallbackReason: string | null;
}
/** Root and CLI evidence that fixes one workflow invocation to one writable planning root. */
interface WorkflowInvocationTargetV2 {
  launchProject: RootContext['launchProject'];
  planningRoot: NonNullable<RootContext['planningRoot']>;
  storeId: string | null;
  /** Opaque Server-owned generation for the active planning-root service lease. */
  generation: string;
  /** Root Context observation that created this target; used to reject stale dispatch. */
  observedAt: RootContext['observedAt'];
  rootSelector: CliRootSelector;
  references: RootContext['references'];
  diagnostics: RootContext['diagnostics'];
  rootEvidence: RootContext['evidence'];
}
/** Command-specific OpenSpec evidence used to prepare one change action. */
type WorkflowActionEvidenceV2 = {
  kind: 'workflow-status';
  options: CliWorkflowOptions;
  result: CliCommandResult<CliWorkflowStatus>;
} | {
  kind: 'artifact-instructions';
  options: CliWorkflowOptions;
  result: CliCommandResult<CliArtifactInstructions>;
} | {
  kind: 'apply-instructions';
  options: CliWorkflowOptions;
  result: CliCommandResult<CliApplyInstructions>;
} | {
  kind: 'archive-instructions';
  options: CliWorkflowOptions;
  result: CliCommandResult<CliArchiveInstructions>;
};
/** Context passed to `onRunWorkflow`. */
interface RunWorkflowContextV2 {
  version: typeof OPENSPECUI_WORKFLOW_HOOK_VERSION;
  target: WorkflowInvocationTargetV2;
  action: WorkflowActionV1;
  requestedMode: WorkflowRequestedModeV1;
  input: RunWorkflowInputV1;
  signal: AbortSignal;
  lifecycle: HookLifecycleV1;
}
interface RunWorkflowResultBaseV2 {
  /** Null only for static-mode fallbacks that have no backend Root Context. */
  target: WorkflowInvocationTargetV2 | null;
  evidence: WorkflowActionEvidenceV2 | null;
  mode?: WorkflowInvocationModeResolutionV1;
  diagnostics?: HookDiagnosticV1[];
}
/** Final OPSX invocation payload produced by OpenSpecUI or `onRunWorkflow`. */
type RunWorkflowResultV2 = RunWorkflowResultBaseV2 & ({
  kind: 'agent-prompt';
  text: string;
  format: 'markdown';
} | {
  kind: 'agent-command';
  text: string;
} | {
  kind: 'cli-command';
  command: string;
  args: string[];
});
/** Intercepts the final OPSX invocation payload before the UI runs it. */
type OnRunWorkflowHookV2 = (ctx: RunWorkflowContextV2, run: () => Promise<RunWorkflowResultV2>) => Promise<RunWorkflowResultV2>;
/** Project hook module shape exported from `openspec/openspecui.hooks.ts`. */
interface OpenSpecUIHooks {
  onReadDocument?: OnReadDocumentHookV1;
  onRunWorkflow?: OnRunWorkflowHookV2;
}
//#endregion
//#region src/hosted-protocol-browser.d.ts
/** Opaque backend-issued runtime-environment identity. Browser code may brand but never compute it. */
type EnvUri = string & {
  readonly __brand: 'EnvUri';
};
/** Mark a backend-issued string as an opaque `EnvUri` without dereferencing or reconstructing it. */
declare function asEnvUri(value: string): EnvUri;
/**
 * Product-level Store/Context compatibility vocabulary. It is not an authorization model.
 *
 * The additive `stores.content.inspect` fact advertises the demand-driven readonly Store-content
 * projection (Specs and active Changes). It authorizes nothing and is not part of the baseline
 * capability set every backend advertises.
 */
type StoreCapability = 'stores.inspect' | 'stores.mutate' | 'contexts.inspect' | 'stores.content.inspect';
/** Read-only backend-advertised Store/Context compatibility facts. */
type StoreCapabilitySet = readonly StoreCapability[];
/** Whether a backend advertises a compatibility fact. This authorizes nothing. */
declare function hasCapability(capabilities: StoreCapabilitySet | undefined, capability: StoreCapability): boolean;
/** Store mutation kind, mirroring the CLI subcommands setup/register/unregister/remove. */
type StoreMutationKind = 'setup' | 'register' | 'unregister' | 'remove';
/** Backend-owned Store mutation lifecycle state. */
type StoreMutationStatus = 'accepted' | 'running' | 'succeeded' | 'failed' | 'indeterminate';
/** Terminal CLI evidence retained by a Store mutation. */
interface StoreMutationResult {
  exitStatus: number | null;
  stdout?: string;
  stderr?: string;
  diagnostics?: CliDiagnostic[];
  payload?: unknown;
  contractError?: string;
}
/** Runtime projection of one backend-owned Store mutation. */
interface StoreMutation {
  requestId: string;
  envUri: EnvUri;
  kind: StoreMutationKind;
  status: StoreMutationStatus;
  storeId?: string;
  result?: StoreMutationResult;
  observedAt: number;
}
/** Whether a Store mutation status is terminal. */
declare function isTerminalMutationStatus(status: StoreMutationStatus): boolean;
//#endregion
//#region src/hosted-contract.d.ts
declare const HOSTED_SHELL_PROTOCOL_VERSION = 1;
declare const OPENSPECUI_RUNTIME_CAPABILITIES: readonly ["notifications.subscribe", "config.notifications"];
declare const HOSTED_STORE_CAPABILITIES: readonly ["stores.inspect", "stores.mutate", "contexts.inspect"];
/**
 * Additive hosted Store-content compatibility fact. A backend advertising it implements the
 * demand-driven typed Spec/active-Change list projection. This authorizes nothing: capability
 * absence is presented as `unsupported`, never as an empty Store or an authorization denial.
 */
declare const HOSTED_STORE_CONTENT_CAPABILITY: "stores.content.inspect";
/**
 * Additive hosted capability vocabulary a backend MAY advertise in `hostedCapabilities`. The
 * baseline `HOSTED_STORE_CAPABILITIES` (Store list/Doctor/mutation + Contexts) is advertised by
 * every Store-capable backend, while the additive `stores.content.inspect` is advertised only by
 * backends that implement the demand-driven readonly Store-content projection. Capability
 * visibility remains a compatibility fact; it authorizes nothing.
 */
declare const HOSTED_STORE_ADVERTISED_CAPABILITIES: readonly ["stores.inspect", "stores.mutate", "contexts.inspect", "stores.content.inspect"];
/** Display-safe summary emitted with a hosted backend health response. */
declare const HostedBackendRootSummarySchema: z.ZodObject<{
  planningRootPath: z.ZodNullable<z.ZodString>;
  rootSource: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
  storeId: z.ZodNullable<z.ZodString>;
  ready: z.ZodBoolean;
}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
  planningRootPath: z.ZodNullable<z.ZodString>;
  rootSource: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
  storeId: z.ZodNullable<z.ZodString>;
  ready: z.ZodBoolean;
}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
  planningRootPath: z.ZodNullable<z.ZodString>;
  rootSource: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
  storeId: z.ZodNullable<z.ZodString>;
  ready: z.ZodBoolean;
}, z.ZodTypeAny, "passthrough">>;
/** Browser-safe runtime contract for one hosted backend health response. */
declare const HostedBackendHealthResponseSchema: z.ZodObject<{
  status: z.ZodLiteral<"ok">;
  projectDir: z.ZodString;
  projectName: z.ZodString;
  watcherEnabled: z.ZodBoolean;
  openspecuiVersion: z.ZodString;
  hostedShellProtocolVersion: z.ZodLiteral<1>;
  embeddedUiUrl: z.ZodString;
  runtimeCapabilities: z.ZodArray<z.ZodEnum<["notifications.subscribe", "config.notifications"]>, "many">;
  apiBaseUrl: z.ZodOptional<z.ZodString>;
  cliVersion: z.ZodOptional<z.ZodNullable<z.ZodString>>;
  envUri: z.ZodOptional<z.ZodString>;
  rootSummary: z.ZodOptional<z.ZodNullable<z.ZodObject<{
    planningRootPath: z.ZodNullable<z.ZodString>;
    rootSource: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
    storeId: z.ZodNullable<z.ZodString>;
    ready: z.ZodBoolean;
  }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
    planningRootPath: z.ZodNullable<z.ZodString>;
    rootSource: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
    storeId: z.ZodNullable<z.ZodString>;
    ready: z.ZodBoolean;
  }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
    planningRootPath: z.ZodNullable<z.ZodString>;
    rootSource: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
    storeId: z.ZodNullable<z.ZodString>;
    ready: z.ZodBoolean;
  }, z.ZodTypeAny, "passthrough">>>>;
  hostedCapabilities: z.ZodOptional<z.ZodArray<z.ZodEnum<["stores.inspect", "stores.mutate", "contexts.inspect", "stores.content.inspect"]>, "many">>;
  accessGateEnabled: z.ZodOptional<z.ZodBoolean>;
}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
  status: z.ZodLiteral<"ok">;
  projectDir: z.ZodString;
  projectName: z.ZodString;
  watcherEnabled: z.ZodBoolean;
  openspecuiVersion: z.ZodString;
  hostedShellProtocolVersion: z.ZodLiteral<1>;
  embeddedUiUrl: z.ZodString;
  runtimeCapabilities: z.ZodArray<z.ZodEnum<["notifications.subscribe", "config.notifications"]>, "many">;
  apiBaseUrl: z.ZodOptional<z.ZodString>;
  cliVersion: z.ZodOptional<z.ZodNullable<z.ZodString>>;
  envUri: z.ZodOptional<z.ZodString>;
  rootSummary: z.ZodOptional<z.ZodNullable<z.ZodObject<{
    planningRootPath: z.ZodNullable<z.ZodString>;
    rootSource: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
    storeId: z.ZodNullable<z.ZodString>;
    ready: z.ZodBoolean;
  }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
    planningRootPath: z.ZodNullable<z.ZodString>;
    rootSource: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
    storeId: z.ZodNullable<z.ZodString>;
    ready: z.ZodBoolean;
  }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
    planningRootPath: z.ZodNullable<z.ZodString>;
    rootSource: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
    storeId: z.ZodNullable<z.ZodString>;
    ready: z.ZodBoolean;
  }, z.ZodTypeAny, "passthrough">>>>;
  hostedCapabilities: z.ZodOptional<z.ZodArray<z.ZodEnum<["stores.inspect", "stores.mutate", "contexts.inspect", "stores.content.inspect"]>, "many">>;
  accessGateEnabled: z.ZodOptional<z.ZodBoolean>;
}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
  status: z.ZodLiteral<"ok">;
  projectDir: z.ZodString;
  projectName: z.ZodString;
  watcherEnabled: z.ZodBoolean;
  openspecuiVersion: z.ZodString;
  hostedShellProtocolVersion: z.ZodLiteral<1>;
  embeddedUiUrl: z.ZodString;
  runtimeCapabilities: z.ZodArray<z.ZodEnum<["notifications.subscribe", "config.notifications"]>, "many">;
  apiBaseUrl: z.ZodOptional<z.ZodString>;
  cliVersion: z.ZodOptional<z.ZodNullable<z.ZodString>>;
  envUri: z.ZodOptional<z.ZodString>;
  rootSummary: z.ZodOptional<z.ZodNullable<z.ZodObject<{
    planningRootPath: z.ZodNullable<z.ZodString>;
    rootSource: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
    storeId: z.ZodNullable<z.ZodString>;
    ready: z.ZodBoolean;
  }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
    planningRootPath: z.ZodNullable<z.ZodString>;
    rootSource: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
    storeId: z.ZodNullable<z.ZodString>;
    ready: z.ZodBoolean;
  }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
    planningRootPath: z.ZodNullable<z.ZodString>;
    rootSource: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
    storeId: z.ZodNullable<z.ZodString>;
    ready: z.ZodBoolean;
  }, z.ZodTypeAny, "passthrough">>>>;
  hostedCapabilities: z.ZodOptional<z.ZodArray<z.ZodEnum<["stores.inspect", "stores.mutate", "contexts.inspect", "stores.content.inspect"]>, "many">>;
  accessGateEnabled: z.ZodOptional<z.ZodBoolean>;
}, z.ZodTypeAny, "passthrough">>;
/** Browser-safe Store-list projection wrapper returned by the hosted router. */
declare const HostedStoreListEnvelopeSchema: z.ZodObject<{
  available: z.ZodBoolean;
  stores: z.ZodArray<z.ZodObject<{
    id: z.ZodString;
    root: z.ZodString;
  }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
    id: z.ZodString;
    root: z.ZodString;
  }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
    id: z.ZodString;
    root: z.ZodString;
  }, z.ZodTypeAny, "passthrough">>, "many">;
  evidence: z.ZodOptional<z.ZodNullable<z.ZodUnknown>>;
  error: z.ZodOptional<z.ZodObject<{
    kind: z.ZodString;
    message: z.ZodString;
    cliVersion: z.ZodOptional<z.ZodString>;
  }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
    kind: z.ZodString;
    message: z.ZodString;
    cliVersion: z.ZodOptional<z.ZodString>;
  }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
    kind: z.ZodString;
    message: z.ZodString;
    cliVersion: z.ZodOptional<z.ZodString>;
  }, z.ZodTypeAny, "passthrough">>>;
  cliVersion: z.ZodOptional<z.ZodString>;
}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
  available: z.ZodBoolean;
  stores: z.ZodArray<z.ZodObject<{
    id: z.ZodString;
    root: z.ZodString;
  }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
    id: z.ZodString;
    root: z.ZodString;
  }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
    id: z.ZodString;
    root: z.ZodString;
  }, z.ZodTypeAny, "passthrough">>, "many">;
  evidence: z.ZodOptional<z.ZodNullable<z.ZodUnknown>>;
  error: z.ZodOptional<z.ZodObject<{
    kind: z.ZodString;
    message: z.ZodString;
    cliVersion: z.ZodOptional<z.ZodString>;
  }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
    kind: z.ZodString;
    message: z.ZodString;
    cliVersion: z.ZodOptional<z.ZodString>;
  }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
    kind: z.ZodString;
    message: z.ZodString;
    cliVersion: z.ZodOptional<z.ZodString>;
  }, z.ZodTypeAny, "passthrough">>>;
  cliVersion: z.ZodOptional<z.ZodString>;
}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
  available: z.ZodBoolean;
  stores: z.ZodArray<z.ZodObject<{
    id: z.ZodString;
    root: z.ZodString;
  }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
    id: z.ZodString;
    root: z.ZodString;
  }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
    id: z.ZodString;
    root: z.ZodString;
  }, z.ZodTypeAny, "passthrough">>, "many">;
  evidence: z.ZodOptional<z.ZodNullable<z.ZodUnknown>>;
  error: z.ZodOptional<z.ZodObject<{
    kind: z.ZodString;
    message: z.ZodString;
    cliVersion: z.ZodOptional<z.ZodString>;
  }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
    kind: z.ZodString;
    message: z.ZodString;
    cliVersion: z.ZodOptional<z.ZodString>;
  }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
    kind: z.ZodString;
    message: z.ZodString;
    cliVersion: z.ZodOptional<z.ZodString>;
  }, z.ZodTypeAny, "passthrough">>>;
  cliVersion: z.ZodOptional<z.ZodString>;
}, z.ZodTypeAny, "passthrough">>;
/** Browser-safe Store-Doctor projection wrapper returned by the hosted router. */
declare const HostedStoreDoctorEnvelopeSchema: z.ZodObject<{
  available: z.ZodBoolean;
  stores: z.ZodArray<z.ZodObject<{
    id: z.ZodOptional<z.ZodString>;
    root: z.ZodOptional<z.ZodString>;
    metadata_path: z.ZodOptional<z.ZodNullable<z.ZodString>>;
    openspec_root: z.ZodOptional<z.ZodObject<{
      present: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
      healthy: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      present: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
      healthy: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      present: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
      healthy: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
    }, z.ZodTypeAny, "passthrough">>>;
    metadata: z.ZodOptional<z.ZodObject<{
      present: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
      valid: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
      id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
      remote: z.ZodOptional<z.ZodNullable<z.ZodString>>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      present: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
      valid: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
      id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
      remote: z.ZodOptional<z.ZodNullable<z.ZodString>>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      present: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
      valid: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
      id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
      remote: z.ZodOptional<z.ZodNullable<z.ZodString>>;
    }, z.ZodTypeAny, "passthrough">>>;
    git: z.ZodOptional<z.ZodObject<{
      is_repository: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
      has_commits: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
      has_uncommitted_changes: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
      has_remote: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
      origin_url: z.ZodOptional<z.ZodNullable<z.ZodString>>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      is_repository: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
      has_commits: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
      has_uncommitted_changes: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
      has_remote: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
      origin_url: z.ZodOptional<z.ZodNullable<z.ZodString>>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      is_repository: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
      has_commits: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
      has_uncommitted_changes: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
      has_remote: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
      origin_url: z.ZodOptional<z.ZodNullable<z.ZodString>>;
    }, z.ZodTypeAny, "passthrough">>>;
    status: z.ZodOptional<z.ZodArray<z.ZodObject<{
      severity: z.ZodOptional<z.ZodString>;
      code: z.ZodOptional<z.ZodString>;
      message: z.ZodOptional<z.ZodString>;
      target: z.ZodOptional<z.ZodString>;
      fix: z.ZodOptional<z.ZodString>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      severity: z.ZodOptional<z.ZodString>;
      code: z.ZodOptional<z.ZodString>;
      message: z.ZodOptional<z.ZodString>;
      target: z.ZodOptional<z.ZodString>;
      fix: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      severity: z.ZodOptional<z.ZodString>;
      code: z.ZodOptional<z.ZodString>;
      message: z.ZodOptional<z.ZodString>;
      target: z.ZodOptional<z.ZodString>;
      fix: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">>, "many">>;
  }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
    id: z.ZodOptional<z.ZodString>;
    root: z.ZodOptional<z.ZodString>;
    metadata_path: z.ZodOptional<z.ZodNullable<z.ZodString>>;
    openspec_root: z.ZodOptional<z.ZodObject<{
      present: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
      healthy: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      present: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
      healthy: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      present: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
      healthy: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
    }, z.ZodTypeAny, "passthrough">>>;
    metadata: z.ZodOptional<z.ZodObject<{
      present: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
      valid: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
      id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
      remote: z.ZodOptional<z.ZodNullable<z.ZodString>>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      present: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
      valid: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
      id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
      remote: z.ZodOptional<z.ZodNullable<z.ZodString>>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      present: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
      valid: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
      id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
      remote: z.ZodOptional<z.ZodNullable<z.ZodString>>;
    }, z.ZodTypeAny, "passthrough">>>;
    git: z.ZodOptional<z.ZodObject<{
      is_repository: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
      has_commits: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
      has_uncommitted_changes: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
      has_remote: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
      origin_url: z.ZodOptional<z.ZodNullable<z.ZodString>>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      is_repository: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
      has_commits: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
      has_uncommitted_changes: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
      has_remote: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
      origin_url: z.ZodOptional<z.ZodNullable<z.ZodString>>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      is_repository: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
      has_commits: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
      has_uncommitted_changes: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
      has_remote: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
      origin_url: z.ZodOptional<z.ZodNullable<z.ZodString>>;
    }, z.ZodTypeAny, "passthrough">>>;
    status: z.ZodOptional<z.ZodArray<z.ZodObject<{
      severity: z.ZodOptional<z.ZodString>;
      code: z.ZodOptional<z.ZodString>;
      message: z.ZodOptional<z.ZodString>;
      target: z.ZodOptional<z.ZodString>;
      fix: z.ZodOptional<z.ZodString>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      severity: z.ZodOptional<z.ZodString>;
      code: z.ZodOptional<z.ZodString>;
      message: z.ZodOptional<z.ZodString>;
      target: z.ZodOptional<z.ZodString>;
      fix: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      severity: z.ZodOptional<z.ZodString>;
      code: z.ZodOptional<z.ZodString>;
      message: z.ZodOptional<z.ZodString>;
      target: z.ZodOptional<z.ZodString>;
      fix: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">>, "many">>;
  }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
    id: z.ZodOptional<z.ZodString>;
    root: z.ZodOptional<z.ZodString>;
    metadata_path: z.ZodOptional<z.ZodNullable<z.ZodString>>;
    openspec_root: z.ZodOptional<z.ZodObject<{
      present: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
      healthy: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      present: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
      healthy: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      present: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
      healthy: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
    }, z.ZodTypeAny, "passthrough">>>;
    metadata: z.ZodOptional<z.ZodObject<{
      present: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
      valid: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
      id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
      remote: z.ZodOptional<z.ZodNullable<z.ZodString>>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      present: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
      valid: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
      id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
      remote: z.ZodOptional<z.ZodNullable<z.ZodString>>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      present: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
      valid: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
      id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
      remote: z.ZodOptional<z.ZodNullable<z.ZodString>>;
    }, z.ZodTypeAny, "passthrough">>>;
    git: z.ZodOptional<z.ZodObject<{
      is_repository: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
      has_commits: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
      has_uncommitted_changes: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
      has_remote: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
      origin_url: z.ZodOptional<z.ZodNullable<z.ZodString>>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      is_repository: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
      has_commits: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
      has_uncommitted_changes: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
      has_remote: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
      origin_url: z.ZodOptional<z.ZodNullable<z.ZodString>>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      is_repository: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
      has_commits: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
      has_uncommitted_changes: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
      has_remote: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
      origin_url: z.ZodOptional<z.ZodNullable<z.ZodString>>;
    }, z.ZodTypeAny, "passthrough">>>;
    status: z.ZodOptional<z.ZodArray<z.ZodObject<{
      severity: z.ZodOptional<z.ZodString>;
      code: z.ZodOptional<z.ZodString>;
      message: z.ZodOptional<z.ZodString>;
      target: z.ZodOptional<z.ZodString>;
      fix: z.ZodOptional<z.ZodString>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      severity: z.ZodOptional<z.ZodString>;
      code: z.ZodOptional<z.ZodString>;
      message: z.ZodOptional<z.ZodString>;
      target: z.ZodOptional<z.ZodString>;
      fix: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      severity: z.ZodOptional<z.ZodString>;
      code: z.ZodOptional<z.ZodString>;
      message: z.ZodOptional<z.ZodString>;
      target: z.ZodOptional<z.ZodString>;
      fix: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">>, "many">>;
  }, z.ZodTypeAny, "passthrough">>, "many">;
  evidence: z.ZodOptional<z.ZodNullable<z.ZodUnknown>>;
  error: z.ZodOptional<z.ZodObject<{
    kind: z.ZodString;
    message: z.ZodString;
    cliVersion: z.ZodOptional<z.ZodString>;
  }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
    kind: z.ZodString;
    message: z.ZodString;
    cliVersion: z.ZodOptional<z.ZodString>;
  }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
    kind: z.ZodString;
    message: z.ZodString;
    cliVersion: z.ZodOptional<z.ZodString>;
  }, z.ZodTypeAny, "passthrough">>>;
  cliVersion: z.ZodOptional<z.ZodString>;
}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
  available: z.ZodBoolean;
  stores: z.ZodArray<z.ZodObject<{
    id: z.ZodOptional<z.ZodString>;
    root: z.ZodOptional<z.ZodString>;
    metadata_path: z.ZodOptional<z.ZodNullable<z.ZodString>>;
    openspec_root: z.ZodOptional<z.ZodObject<{
      present: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
      healthy: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      present: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
      healthy: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      present: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
      healthy: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
    }, z.ZodTypeAny, "passthrough">>>;
    metadata: z.ZodOptional<z.ZodObject<{
      present: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
      valid: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
      id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
      remote: z.ZodOptional<z.ZodNullable<z.ZodString>>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      present: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
      valid: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
      id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
      remote: z.ZodOptional<z.ZodNullable<z.ZodString>>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      present: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
      valid: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
      id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
      remote: z.ZodOptional<z.ZodNullable<z.ZodString>>;
    }, z.ZodTypeAny, "passthrough">>>;
    git: z.ZodOptional<z.ZodObject<{
      is_repository: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
      has_commits: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
      has_uncommitted_changes: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
      has_remote: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
      origin_url: z.ZodOptional<z.ZodNullable<z.ZodString>>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      is_repository: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
      has_commits: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
      has_uncommitted_changes: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
      has_remote: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
      origin_url: z.ZodOptional<z.ZodNullable<z.ZodString>>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      is_repository: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
      has_commits: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
      has_uncommitted_changes: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
      has_remote: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
      origin_url: z.ZodOptional<z.ZodNullable<z.ZodString>>;
    }, z.ZodTypeAny, "passthrough">>>;
    status: z.ZodOptional<z.ZodArray<z.ZodObject<{
      severity: z.ZodOptional<z.ZodString>;
      code: z.ZodOptional<z.ZodString>;
      message: z.ZodOptional<z.ZodString>;
      target: z.ZodOptional<z.ZodString>;
      fix: z.ZodOptional<z.ZodString>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      severity: z.ZodOptional<z.ZodString>;
      code: z.ZodOptional<z.ZodString>;
      message: z.ZodOptional<z.ZodString>;
      target: z.ZodOptional<z.ZodString>;
      fix: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      severity: z.ZodOptional<z.ZodString>;
      code: z.ZodOptional<z.ZodString>;
      message: z.ZodOptional<z.ZodString>;
      target: z.ZodOptional<z.ZodString>;
      fix: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">>, "many">>;
  }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
    id: z.ZodOptional<z.ZodString>;
    root: z.ZodOptional<z.ZodString>;
    metadata_path: z.ZodOptional<z.ZodNullable<z.ZodString>>;
    openspec_root: z.ZodOptional<z.ZodObject<{
      present: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
      healthy: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      present: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
      healthy: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      present: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
      healthy: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
    }, z.ZodTypeAny, "passthrough">>>;
    metadata: z.ZodOptional<z.ZodObject<{
      present: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
      valid: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
      id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
      remote: z.ZodOptional<z.ZodNullable<z.ZodString>>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      present: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
      valid: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
      id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
      remote: z.ZodOptional<z.ZodNullable<z.ZodString>>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      present: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
      valid: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
      id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
      remote: z.ZodOptional<z.ZodNullable<z.ZodString>>;
    }, z.ZodTypeAny, "passthrough">>>;
    git: z.ZodOptional<z.ZodObject<{
      is_repository: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
      has_commits: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
      has_uncommitted_changes: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
      has_remote: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
      origin_url: z.ZodOptional<z.ZodNullable<z.ZodString>>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      is_repository: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
      has_commits: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
      has_uncommitted_changes: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
      has_remote: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
      origin_url: z.ZodOptional<z.ZodNullable<z.ZodString>>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      is_repository: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
      has_commits: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
      has_uncommitted_changes: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
      has_remote: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
      origin_url: z.ZodOptional<z.ZodNullable<z.ZodString>>;
    }, z.ZodTypeAny, "passthrough">>>;
    status: z.ZodOptional<z.ZodArray<z.ZodObject<{
      severity: z.ZodOptional<z.ZodString>;
      code: z.ZodOptional<z.ZodString>;
      message: z.ZodOptional<z.ZodString>;
      target: z.ZodOptional<z.ZodString>;
      fix: z.ZodOptional<z.ZodString>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      severity: z.ZodOptional<z.ZodString>;
      code: z.ZodOptional<z.ZodString>;
      message: z.ZodOptional<z.ZodString>;
      target: z.ZodOptional<z.ZodString>;
      fix: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      severity: z.ZodOptional<z.ZodString>;
      code: z.ZodOptional<z.ZodString>;
      message: z.ZodOptional<z.ZodString>;
      target: z.ZodOptional<z.ZodString>;
      fix: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">>, "many">>;
  }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
    id: z.ZodOptional<z.ZodString>;
    root: z.ZodOptional<z.ZodString>;
    metadata_path: z.ZodOptional<z.ZodNullable<z.ZodString>>;
    openspec_root: z.ZodOptional<z.ZodObject<{
      present: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
      healthy: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      present: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
      healthy: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      present: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
      healthy: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
    }, z.ZodTypeAny, "passthrough">>>;
    metadata: z.ZodOptional<z.ZodObject<{
      present: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
      valid: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
      id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
      remote: z.ZodOptional<z.ZodNullable<z.ZodString>>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      present: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
      valid: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
      id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
      remote: z.ZodOptional<z.ZodNullable<z.ZodString>>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      present: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
      valid: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
      id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
      remote: z.ZodOptional<z.ZodNullable<z.ZodString>>;
    }, z.ZodTypeAny, "passthrough">>>;
    git: z.ZodOptional<z.ZodObject<{
      is_repository: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
      has_commits: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
      has_uncommitted_changes: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
      has_remote: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
      origin_url: z.ZodOptional<z.ZodNullable<z.ZodString>>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      is_repository: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
      has_commits: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
      has_uncommitted_changes: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
      has_remote: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
      origin_url: z.ZodOptional<z.ZodNullable<z.ZodString>>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      is_repository: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
      has_commits: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
      has_uncommitted_changes: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
      has_remote: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
      origin_url: z.ZodOptional<z.ZodNullable<z.ZodString>>;
    }, z.ZodTypeAny, "passthrough">>>;
    status: z.ZodOptional<z.ZodArray<z.ZodObject<{
      severity: z.ZodOptional<z.ZodString>;
      code: z.ZodOptional<z.ZodString>;
      message: z.ZodOptional<z.ZodString>;
      target: z.ZodOptional<z.ZodString>;
      fix: z.ZodOptional<z.ZodString>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      severity: z.ZodOptional<z.ZodString>;
      code: z.ZodOptional<z.ZodString>;
      message: z.ZodOptional<z.ZodString>;
      target: z.ZodOptional<z.ZodString>;
      fix: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      severity: z.ZodOptional<z.ZodString>;
      code: z.ZodOptional<z.ZodString>;
      message: z.ZodOptional<z.ZodString>;
      target: z.ZodOptional<z.ZodString>;
      fix: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">>, "many">>;
  }, z.ZodTypeAny, "passthrough">>, "many">;
  evidence: z.ZodOptional<z.ZodNullable<z.ZodUnknown>>;
  error: z.ZodOptional<z.ZodObject<{
    kind: z.ZodString;
    message: z.ZodString;
    cliVersion: z.ZodOptional<z.ZodString>;
  }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
    kind: z.ZodString;
    message: z.ZodString;
    cliVersion: z.ZodOptional<z.ZodString>;
  }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
    kind: z.ZodString;
    message: z.ZodString;
    cliVersion: z.ZodOptional<z.ZodString>;
  }, z.ZodTypeAny, "passthrough">>>;
  cliVersion: z.ZodOptional<z.ZodString>;
}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
  available: z.ZodBoolean;
  stores: z.ZodArray<z.ZodObject<{
    id: z.ZodOptional<z.ZodString>;
    root: z.ZodOptional<z.ZodString>;
    metadata_path: z.ZodOptional<z.ZodNullable<z.ZodString>>;
    openspec_root: z.ZodOptional<z.ZodObject<{
      present: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
      healthy: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      present: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
      healthy: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      present: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
      healthy: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
    }, z.ZodTypeAny, "passthrough">>>;
    metadata: z.ZodOptional<z.ZodObject<{
      present: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
      valid: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
      id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
      remote: z.ZodOptional<z.ZodNullable<z.ZodString>>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      present: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
      valid: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
      id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
      remote: z.ZodOptional<z.ZodNullable<z.ZodString>>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      present: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
      valid: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
      id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
      remote: z.ZodOptional<z.ZodNullable<z.ZodString>>;
    }, z.ZodTypeAny, "passthrough">>>;
    git: z.ZodOptional<z.ZodObject<{
      is_repository: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
      has_commits: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
      has_uncommitted_changes: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
      has_remote: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
      origin_url: z.ZodOptional<z.ZodNullable<z.ZodString>>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      is_repository: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
      has_commits: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
      has_uncommitted_changes: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
      has_remote: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
      origin_url: z.ZodOptional<z.ZodNullable<z.ZodString>>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      is_repository: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
      has_commits: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
      has_uncommitted_changes: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
      has_remote: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
      origin_url: z.ZodOptional<z.ZodNullable<z.ZodString>>;
    }, z.ZodTypeAny, "passthrough">>>;
    status: z.ZodOptional<z.ZodArray<z.ZodObject<{
      severity: z.ZodOptional<z.ZodString>;
      code: z.ZodOptional<z.ZodString>;
      message: z.ZodOptional<z.ZodString>;
      target: z.ZodOptional<z.ZodString>;
      fix: z.ZodOptional<z.ZodString>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      severity: z.ZodOptional<z.ZodString>;
      code: z.ZodOptional<z.ZodString>;
      message: z.ZodOptional<z.ZodString>;
      target: z.ZodOptional<z.ZodString>;
      fix: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      severity: z.ZodOptional<z.ZodString>;
      code: z.ZodOptional<z.ZodString>;
      message: z.ZodOptional<z.ZodString>;
      target: z.ZodOptional<z.ZodString>;
      fix: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">>, "many">>;
  }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
    id: z.ZodOptional<z.ZodString>;
    root: z.ZodOptional<z.ZodString>;
    metadata_path: z.ZodOptional<z.ZodNullable<z.ZodString>>;
    openspec_root: z.ZodOptional<z.ZodObject<{
      present: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
      healthy: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      present: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
      healthy: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      present: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
      healthy: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
    }, z.ZodTypeAny, "passthrough">>>;
    metadata: z.ZodOptional<z.ZodObject<{
      present: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
      valid: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
      id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
      remote: z.ZodOptional<z.ZodNullable<z.ZodString>>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      present: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
      valid: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
      id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
      remote: z.ZodOptional<z.ZodNullable<z.ZodString>>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      present: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
      valid: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
      id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
      remote: z.ZodOptional<z.ZodNullable<z.ZodString>>;
    }, z.ZodTypeAny, "passthrough">>>;
    git: z.ZodOptional<z.ZodObject<{
      is_repository: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
      has_commits: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
      has_uncommitted_changes: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
      has_remote: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
      origin_url: z.ZodOptional<z.ZodNullable<z.ZodString>>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      is_repository: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
      has_commits: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
      has_uncommitted_changes: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
      has_remote: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
      origin_url: z.ZodOptional<z.ZodNullable<z.ZodString>>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      is_repository: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
      has_commits: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
      has_uncommitted_changes: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
      has_remote: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
      origin_url: z.ZodOptional<z.ZodNullable<z.ZodString>>;
    }, z.ZodTypeAny, "passthrough">>>;
    status: z.ZodOptional<z.ZodArray<z.ZodObject<{
      severity: z.ZodOptional<z.ZodString>;
      code: z.ZodOptional<z.ZodString>;
      message: z.ZodOptional<z.ZodString>;
      target: z.ZodOptional<z.ZodString>;
      fix: z.ZodOptional<z.ZodString>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      severity: z.ZodOptional<z.ZodString>;
      code: z.ZodOptional<z.ZodString>;
      message: z.ZodOptional<z.ZodString>;
      target: z.ZodOptional<z.ZodString>;
      fix: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      severity: z.ZodOptional<z.ZodString>;
      code: z.ZodOptional<z.ZodString>;
      message: z.ZodOptional<z.ZodString>;
      target: z.ZodOptional<z.ZodString>;
      fix: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">>, "many">>;
  }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
    id: z.ZodOptional<z.ZodString>;
    root: z.ZodOptional<z.ZodString>;
    metadata_path: z.ZodOptional<z.ZodNullable<z.ZodString>>;
    openspec_root: z.ZodOptional<z.ZodObject<{
      present: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
      healthy: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      present: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
      healthy: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      present: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
      healthy: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
    }, z.ZodTypeAny, "passthrough">>>;
    metadata: z.ZodOptional<z.ZodObject<{
      present: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
      valid: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
      id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
      remote: z.ZodOptional<z.ZodNullable<z.ZodString>>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      present: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
      valid: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
      id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
      remote: z.ZodOptional<z.ZodNullable<z.ZodString>>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      present: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
      valid: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
      id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
      remote: z.ZodOptional<z.ZodNullable<z.ZodString>>;
    }, z.ZodTypeAny, "passthrough">>>;
    git: z.ZodOptional<z.ZodObject<{
      is_repository: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
      has_commits: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
      has_uncommitted_changes: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
      has_remote: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
      origin_url: z.ZodOptional<z.ZodNullable<z.ZodString>>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      is_repository: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
      has_commits: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
      has_uncommitted_changes: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
      has_remote: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
      origin_url: z.ZodOptional<z.ZodNullable<z.ZodString>>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      is_repository: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
      has_commits: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
      has_uncommitted_changes: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
      has_remote: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
      origin_url: z.ZodOptional<z.ZodNullable<z.ZodString>>;
    }, z.ZodTypeAny, "passthrough">>>;
    status: z.ZodOptional<z.ZodArray<z.ZodObject<{
      severity: z.ZodOptional<z.ZodString>;
      code: z.ZodOptional<z.ZodString>;
      message: z.ZodOptional<z.ZodString>;
      target: z.ZodOptional<z.ZodString>;
      fix: z.ZodOptional<z.ZodString>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      severity: z.ZodOptional<z.ZodString>;
      code: z.ZodOptional<z.ZodString>;
      message: z.ZodOptional<z.ZodString>;
      target: z.ZodOptional<z.ZodString>;
      fix: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      severity: z.ZodOptional<z.ZodString>;
      code: z.ZodOptional<z.ZodString>;
      message: z.ZodOptional<z.ZodString>;
      target: z.ZodOptional<z.ZodString>;
      fix: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">>, "many">>;
  }, z.ZodTypeAny, "passthrough">>, "many">;
  evidence: z.ZodOptional<z.ZodNullable<z.ZodUnknown>>;
  error: z.ZodOptional<z.ZodObject<{
    kind: z.ZodString;
    message: z.ZodString;
    cliVersion: z.ZodOptional<z.ZodString>;
  }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
    kind: z.ZodString;
    message: z.ZodString;
    cliVersion: z.ZodOptional<z.ZodString>;
  }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
    kind: z.ZodString;
    message: z.ZodString;
    cliVersion: z.ZodOptional<z.ZodString>;
  }, z.ZodTypeAny, "passthrough">>>;
  cliVersion: z.ZodOptional<z.ZodString>;
}, z.ZodTypeAny, "passthrough">>;
/** Browser-safe Pull state for Store Inventory CLI Projection Work. */
declare const HostedStoreListProjectionStateSchema: z.ZodDiscriminatedUnion<"state", [z.ZodObject<{
  state: z.ZodLiteral<"loading">;
  data: z.ZodNull;
  freshness: z.ZodNull;
  snapshotGeneration: z.ZodNull;
  error: z.ZodNull;
  identity: z.ZodString;
  workGeneration: z.ZodNumber;
  invalidationCause: z.ZodEnum<["initial", "dependency", "explicit-refresh", "subscriber-resume"]>;
}, "strip", z.ZodTypeAny, {
  error: null;
  state: "loading";
  data: null;
  freshness: null;
  snapshotGeneration: null;
  identity: string;
  workGeneration: number;
  invalidationCause: "dependency" | "initial" | "explicit-refresh" | "subscriber-resume";
}, {
  error: null;
  state: "loading";
  data: null;
  freshness: null;
  snapshotGeneration: null;
  identity: string;
  workGeneration: number;
  invalidationCause: "dependency" | "initial" | "explicit-refresh" | "subscriber-resume";
}>, z.ZodObject<{
  state: z.ZodLiteral<"ready">;
  data: z.ZodType<z.objectOutputType<{
    available: z.ZodBoolean;
    stores: z.ZodArray<z.ZodObject<{
      id: z.ZodString;
      root: z.ZodString;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      id: z.ZodString;
      root: z.ZodString;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      id: z.ZodString;
      root: z.ZodString;
    }, z.ZodTypeAny, "passthrough">>, "many">;
    evidence: z.ZodOptional<z.ZodNullable<z.ZodUnknown>>;
    error: z.ZodOptional<z.ZodObject<{
      kind: z.ZodString;
      message: z.ZodString;
      cliVersion: z.ZodOptional<z.ZodString>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      kind: z.ZodString;
      message: z.ZodString;
      cliVersion: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      kind: z.ZodString;
      message: z.ZodString;
      cliVersion: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">>>;
    cliVersion: z.ZodOptional<z.ZodString>;
  }, z.ZodTypeAny, "passthrough">, z.ZodTypeDef, z.objectInputType<{
    available: z.ZodBoolean;
    stores: z.ZodArray<z.ZodObject<{
      id: z.ZodString;
      root: z.ZodString;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      id: z.ZodString;
      root: z.ZodString;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      id: z.ZodString;
      root: z.ZodString;
    }, z.ZodTypeAny, "passthrough">>, "many">;
    evidence: z.ZodOptional<z.ZodNullable<z.ZodUnknown>>;
    error: z.ZodOptional<z.ZodObject<{
      kind: z.ZodString;
      message: z.ZodString;
      cliVersion: z.ZodOptional<z.ZodString>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      kind: z.ZodString;
      message: z.ZodString;
      cliVersion: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      kind: z.ZodString;
      message: z.ZodString;
      cliVersion: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">>>;
    cliVersion: z.ZodOptional<z.ZodString>;
  }, z.ZodTypeAny, "passthrough">>;
  freshness: z.ZodLiteral<"current">;
  snapshotGeneration: z.ZodNumber;
  error: z.ZodNull;
  identity: z.ZodString;
  workGeneration: z.ZodNumber;
  invalidationCause: z.ZodEnum<["initial", "dependency", "explicit-refresh", "subscriber-resume"]>;
}, "strip", z.ZodTypeAny, {
  error: null;
  state: "ready";
  data: {
    stores: z.objectOutputType<{
      id: z.ZodString;
      root: z.ZodString;
    }, z.ZodTypeAny, "passthrough">[];
    available: boolean;
    error?: z.objectOutputType<{
      kind: z.ZodString;
      message: z.ZodString;
      cliVersion: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough"> | undefined;
    evidence?: unknown;
    cliVersion?: string | undefined;
  } & {
    [k: string]: unknown;
  };
  freshness: "current";
  snapshotGeneration: number;
  identity: string;
  workGeneration: number;
  invalidationCause: "dependency" | "initial" | "explicit-refresh" | "subscriber-resume";
}, {
  error: null;
  state: "ready";
  data: {
    stores: z.objectInputType<{
      id: z.ZodString;
      root: z.ZodString;
    }, z.ZodTypeAny, "passthrough">[];
    available: boolean;
    error?: z.objectInputType<{
      kind: z.ZodString;
      message: z.ZodString;
      cliVersion: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough"> | undefined;
    evidence?: unknown;
    cliVersion?: string | undefined;
  } & {
    [k: string]: unknown;
  };
  freshness: "current";
  snapshotGeneration: number;
  identity: string;
  workGeneration: number;
  invalidationCause: "dependency" | "initial" | "explicit-refresh" | "subscriber-resume";
}>, z.ZodObject<{
  state: z.ZodLiteral<"revalidating">;
  data: z.ZodType<z.objectOutputType<{
    available: z.ZodBoolean;
    stores: z.ZodArray<z.ZodObject<{
      id: z.ZodString;
      root: z.ZodString;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      id: z.ZodString;
      root: z.ZodString;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      id: z.ZodString;
      root: z.ZodString;
    }, z.ZodTypeAny, "passthrough">>, "many">;
    evidence: z.ZodOptional<z.ZodNullable<z.ZodUnknown>>;
    error: z.ZodOptional<z.ZodObject<{
      kind: z.ZodString;
      message: z.ZodString;
      cliVersion: z.ZodOptional<z.ZodString>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      kind: z.ZodString;
      message: z.ZodString;
      cliVersion: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      kind: z.ZodString;
      message: z.ZodString;
      cliVersion: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">>>;
    cliVersion: z.ZodOptional<z.ZodString>;
  }, z.ZodTypeAny, "passthrough">, z.ZodTypeDef, z.objectInputType<{
    available: z.ZodBoolean;
    stores: z.ZodArray<z.ZodObject<{
      id: z.ZodString;
      root: z.ZodString;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      id: z.ZodString;
      root: z.ZodString;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      id: z.ZodString;
      root: z.ZodString;
    }, z.ZodTypeAny, "passthrough">>, "many">;
    evidence: z.ZodOptional<z.ZodNullable<z.ZodUnknown>>;
    error: z.ZodOptional<z.ZodObject<{
      kind: z.ZodString;
      message: z.ZodString;
      cliVersion: z.ZodOptional<z.ZodString>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      kind: z.ZodString;
      message: z.ZodString;
      cliVersion: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      kind: z.ZodString;
      message: z.ZodString;
      cliVersion: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">>>;
    cliVersion: z.ZodOptional<z.ZodString>;
  }, z.ZodTypeAny, "passthrough">>;
  freshness: z.ZodLiteral<"stale-display-only">;
  snapshotGeneration: z.ZodNumber;
  error: z.ZodNull;
  identity: z.ZodString;
  workGeneration: z.ZodNumber;
  invalidationCause: z.ZodEnum<["initial", "dependency", "explicit-refresh", "subscriber-resume"]>;
}, "strip", z.ZodTypeAny, {
  error: null;
  state: "revalidating";
  data: {
    stores: z.objectOutputType<{
      id: z.ZodString;
      root: z.ZodString;
    }, z.ZodTypeAny, "passthrough">[];
    available: boolean;
    error?: z.objectOutputType<{
      kind: z.ZodString;
      message: z.ZodString;
      cliVersion: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough"> | undefined;
    evidence?: unknown;
    cliVersion?: string | undefined;
  } & {
    [k: string]: unknown;
  };
  freshness: "stale-display-only";
  snapshotGeneration: number;
  identity: string;
  workGeneration: number;
  invalidationCause: "dependency" | "initial" | "explicit-refresh" | "subscriber-resume";
}, {
  error: null;
  state: "revalidating";
  data: {
    stores: z.objectInputType<{
      id: z.ZodString;
      root: z.ZodString;
    }, z.ZodTypeAny, "passthrough">[];
    available: boolean;
    error?: z.objectInputType<{
      kind: z.ZodString;
      message: z.ZodString;
      cliVersion: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough"> | undefined;
    evidence?: unknown;
    cliVersion?: string | undefined;
  } & {
    [k: string]: unknown;
  };
  freshness: "stale-display-only";
  snapshotGeneration: number;
  identity: string;
  workGeneration: number;
  invalidationCause: "dependency" | "initial" | "explicit-refresh" | "subscriber-resume";
}>, z.ZodObject<{
  state: z.ZodLiteral<"error">;
  data: z.ZodNull;
  freshness: z.ZodNull;
  snapshotGeneration: z.ZodNull;
  error: z.ZodObject<{
    name: z.ZodString;
    message: z.ZodString;
    cliEvidence: z.ZodNullable<z.ZodObject<{
      success: z.ZodBoolean;
      stdout: z.ZodString;
      stderr: z.ZodString;
      exitCode: z.ZodNullable<z.ZodNumber>;
      payload: z.ZodNullable<z.ZodType<CliJsonValue, z.ZodTypeDef, CliJsonValue>>;
      diagnostics: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
      contractError: z.ZodOptional<z.ZodString>;
    }, "strip", z.ZodTypeAny, {
      success: boolean;
      stdout: string;
      stderr: string;
      exitCode: number | null;
      payload: CliJsonValue;
      diagnostics: z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">[];
      contractError?: string | undefined;
    }, {
      success: boolean;
      stdout: string;
      stderr: string;
      exitCode: number | null;
      payload: CliJsonValue;
      diagnostics: z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">[];
      contractError?: string | undefined;
    }>>;
  }, "strip", z.ZodTypeAny, {
    message: string;
    name: string;
    cliEvidence: {
      success: boolean;
      stdout: string;
      stderr: string;
      exitCode: number | null;
      payload: CliJsonValue;
      diagnostics: z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">[];
      contractError?: string | undefined;
    } | null;
  }, {
    message: string;
    name: string;
    cliEvidence: {
      success: boolean;
      stdout: string;
      stderr: string;
      exitCode: number | null;
      payload: CliJsonValue;
      diagnostics: z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">[];
      contractError?: string | undefined;
    } | null;
  }>;
  identity: z.ZodString;
  workGeneration: z.ZodNumber;
  invalidationCause: z.ZodEnum<["initial", "dependency", "explicit-refresh", "subscriber-resume"]>;
}, "strip", z.ZodTypeAny, {
  error: {
    message: string;
    name: string;
    cliEvidence: {
      success: boolean;
      stdout: string;
      stderr: string;
      exitCode: number | null;
      payload: CliJsonValue;
      diagnostics: z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">[];
      contractError?: string | undefined;
    } | null;
  };
  state: "error";
  data: null;
  freshness: null;
  snapshotGeneration: null;
  identity: string;
  workGeneration: number;
  invalidationCause: "dependency" | "initial" | "explicit-refresh" | "subscriber-resume";
}, {
  error: {
    message: string;
    name: string;
    cliEvidence: {
      success: boolean;
      stdout: string;
      stderr: string;
      exitCode: number | null;
      payload: CliJsonValue;
      diagnostics: z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">[];
      contractError?: string | undefined;
    } | null;
  };
  state: "error";
  data: null;
  freshness: null;
  snapshotGeneration: null;
  identity: string;
  workGeneration: number;
  invalidationCause: "dependency" | "initial" | "explicit-refresh" | "subscriber-resume";
}>, z.ZodObject<{
  state: z.ZodLiteral<"refresh-error">;
  data: z.ZodType<z.objectOutputType<{
    available: z.ZodBoolean;
    stores: z.ZodArray<z.ZodObject<{
      id: z.ZodString;
      root: z.ZodString;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      id: z.ZodString;
      root: z.ZodString;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      id: z.ZodString;
      root: z.ZodString;
    }, z.ZodTypeAny, "passthrough">>, "many">;
    evidence: z.ZodOptional<z.ZodNullable<z.ZodUnknown>>;
    error: z.ZodOptional<z.ZodObject<{
      kind: z.ZodString;
      message: z.ZodString;
      cliVersion: z.ZodOptional<z.ZodString>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      kind: z.ZodString;
      message: z.ZodString;
      cliVersion: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      kind: z.ZodString;
      message: z.ZodString;
      cliVersion: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">>>;
    cliVersion: z.ZodOptional<z.ZodString>;
  }, z.ZodTypeAny, "passthrough">, z.ZodTypeDef, z.objectInputType<{
    available: z.ZodBoolean;
    stores: z.ZodArray<z.ZodObject<{
      id: z.ZodString;
      root: z.ZodString;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      id: z.ZodString;
      root: z.ZodString;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      id: z.ZodString;
      root: z.ZodString;
    }, z.ZodTypeAny, "passthrough">>, "many">;
    evidence: z.ZodOptional<z.ZodNullable<z.ZodUnknown>>;
    error: z.ZodOptional<z.ZodObject<{
      kind: z.ZodString;
      message: z.ZodString;
      cliVersion: z.ZodOptional<z.ZodString>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      kind: z.ZodString;
      message: z.ZodString;
      cliVersion: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      kind: z.ZodString;
      message: z.ZodString;
      cliVersion: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">>>;
    cliVersion: z.ZodOptional<z.ZodString>;
  }, z.ZodTypeAny, "passthrough">>;
  freshness: z.ZodLiteral<"stale-display-only">;
  snapshotGeneration: z.ZodNumber;
  error: z.ZodObject<{
    name: z.ZodString;
    message: z.ZodString;
    cliEvidence: z.ZodNullable<z.ZodObject<{
      success: z.ZodBoolean;
      stdout: z.ZodString;
      stderr: z.ZodString;
      exitCode: z.ZodNullable<z.ZodNumber>;
      payload: z.ZodNullable<z.ZodType<CliJsonValue, z.ZodTypeDef, CliJsonValue>>;
      diagnostics: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
      contractError: z.ZodOptional<z.ZodString>;
    }, "strip", z.ZodTypeAny, {
      success: boolean;
      stdout: string;
      stderr: string;
      exitCode: number | null;
      payload: CliJsonValue;
      diagnostics: z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">[];
      contractError?: string | undefined;
    }, {
      success: boolean;
      stdout: string;
      stderr: string;
      exitCode: number | null;
      payload: CliJsonValue;
      diagnostics: z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">[];
      contractError?: string | undefined;
    }>>;
  }, "strip", z.ZodTypeAny, {
    message: string;
    name: string;
    cliEvidence: {
      success: boolean;
      stdout: string;
      stderr: string;
      exitCode: number | null;
      payload: CliJsonValue;
      diagnostics: z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">[];
      contractError?: string | undefined;
    } | null;
  }, {
    message: string;
    name: string;
    cliEvidence: {
      success: boolean;
      stdout: string;
      stderr: string;
      exitCode: number | null;
      payload: CliJsonValue;
      diagnostics: z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">[];
      contractError?: string | undefined;
    } | null;
  }>;
  identity: z.ZodString;
  workGeneration: z.ZodNumber;
  invalidationCause: z.ZodEnum<["initial", "dependency", "explicit-refresh", "subscriber-resume"]>;
}, "strip", z.ZodTypeAny, {
  error: {
    message: string;
    name: string;
    cliEvidence: {
      success: boolean;
      stdout: string;
      stderr: string;
      exitCode: number | null;
      payload: CliJsonValue;
      diagnostics: z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">[];
      contractError?: string | undefined;
    } | null;
  };
  state: "refresh-error";
  data: {
    stores: z.objectOutputType<{
      id: z.ZodString;
      root: z.ZodString;
    }, z.ZodTypeAny, "passthrough">[];
    available: boolean;
    error?: z.objectOutputType<{
      kind: z.ZodString;
      message: z.ZodString;
      cliVersion: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough"> | undefined;
    evidence?: unknown;
    cliVersion?: string | undefined;
  } & {
    [k: string]: unknown;
  };
  freshness: "stale-display-only";
  snapshotGeneration: number;
  identity: string;
  workGeneration: number;
  invalidationCause: "dependency" | "initial" | "explicit-refresh" | "subscriber-resume";
}, {
  error: {
    message: string;
    name: string;
    cliEvidence: {
      success: boolean;
      stdout: string;
      stderr: string;
      exitCode: number | null;
      payload: CliJsonValue;
      diagnostics: z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">[];
      contractError?: string | undefined;
    } | null;
  };
  state: "refresh-error";
  data: {
    stores: z.objectInputType<{
      id: z.ZodString;
      root: z.ZodString;
    }, z.ZodTypeAny, "passthrough">[];
    available: boolean;
    error?: z.objectInputType<{
      kind: z.ZodString;
      message: z.ZodString;
      cliVersion: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough"> | undefined;
    evidence?: unknown;
    cliVersion?: string | undefined;
  } & {
    [k: string]: unknown;
  };
  freshness: "stale-display-only";
  snapshotGeneration: number;
  identity: string;
  workGeneration: number;
  invalidationCause: "dependency" | "initial" | "explicit-refresh" | "subscriber-resume";
}>]>;
/** Browser-safe Pull state for Store Doctor CLI Projection Work. */
declare const HostedStoreDoctorProjectionStateSchema: z.ZodDiscriminatedUnion<"state", [z.ZodObject<{
  state: z.ZodLiteral<"loading">;
  data: z.ZodNull;
  freshness: z.ZodNull;
  snapshotGeneration: z.ZodNull;
  error: z.ZodNull;
  identity: z.ZodString;
  workGeneration: z.ZodNumber;
  invalidationCause: z.ZodEnum<["initial", "dependency", "explicit-refresh", "subscriber-resume"]>;
}, "strip", z.ZodTypeAny, {
  error: null;
  state: "loading";
  data: null;
  freshness: null;
  snapshotGeneration: null;
  identity: string;
  workGeneration: number;
  invalidationCause: "dependency" | "initial" | "explicit-refresh" | "subscriber-resume";
}, {
  error: null;
  state: "loading";
  data: null;
  freshness: null;
  snapshotGeneration: null;
  identity: string;
  workGeneration: number;
  invalidationCause: "dependency" | "initial" | "explicit-refresh" | "subscriber-resume";
}>, z.ZodObject<{
  state: z.ZodLiteral<"ready">;
  data: z.ZodType<z.objectOutputType<{
    available: z.ZodBoolean;
    stores: z.ZodArray<z.ZodObject<{
      id: z.ZodOptional<z.ZodString>;
      root: z.ZodOptional<z.ZodString>;
      metadata_path: z.ZodOptional<z.ZodNullable<z.ZodString>>;
      openspec_root: z.ZodOptional<z.ZodObject<{
        present: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        healthy: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        present: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        healthy: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        present: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        healthy: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
      }, z.ZodTypeAny, "passthrough">>>;
      metadata: z.ZodOptional<z.ZodObject<{
        present: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        valid: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
        remote: z.ZodOptional<z.ZodNullable<z.ZodString>>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        present: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        valid: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
        remote: z.ZodOptional<z.ZodNullable<z.ZodString>>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        present: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        valid: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
        remote: z.ZodOptional<z.ZodNullable<z.ZodString>>;
      }, z.ZodTypeAny, "passthrough">>>;
      git: z.ZodOptional<z.ZodObject<{
        is_repository: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        has_commits: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        has_uncommitted_changes: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        has_remote: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        origin_url: z.ZodOptional<z.ZodNullable<z.ZodString>>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        is_repository: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        has_commits: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        has_uncommitted_changes: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        has_remote: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        origin_url: z.ZodOptional<z.ZodNullable<z.ZodString>>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        is_repository: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        has_commits: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        has_uncommitted_changes: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        has_remote: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        origin_url: z.ZodOptional<z.ZodNullable<z.ZodString>>;
      }, z.ZodTypeAny, "passthrough">>>;
      status: z.ZodOptional<z.ZodArray<z.ZodObject<{
        severity: z.ZodOptional<z.ZodString>;
        code: z.ZodOptional<z.ZodString>;
        message: z.ZodOptional<z.ZodString>;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodOptional<z.ZodString>;
        code: z.ZodOptional<z.ZodString>;
        message: z.ZodOptional<z.ZodString>;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodOptional<z.ZodString>;
        code: z.ZodOptional<z.ZodString>;
        message: z.ZodOptional<z.ZodString>;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      id: z.ZodOptional<z.ZodString>;
      root: z.ZodOptional<z.ZodString>;
      metadata_path: z.ZodOptional<z.ZodNullable<z.ZodString>>;
      openspec_root: z.ZodOptional<z.ZodObject<{
        present: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        healthy: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        present: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        healthy: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        present: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        healthy: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
      }, z.ZodTypeAny, "passthrough">>>;
      metadata: z.ZodOptional<z.ZodObject<{
        present: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        valid: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
        remote: z.ZodOptional<z.ZodNullable<z.ZodString>>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        present: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        valid: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
        remote: z.ZodOptional<z.ZodNullable<z.ZodString>>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        present: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        valid: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
        remote: z.ZodOptional<z.ZodNullable<z.ZodString>>;
      }, z.ZodTypeAny, "passthrough">>>;
      git: z.ZodOptional<z.ZodObject<{
        is_repository: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        has_commits: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        has_uncommitted_changes: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        has_remote: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        origin_url: z.ZodOptional<z.ZodNullable<z.ZodString>>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        is_repository: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        has_commits: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        has_uncommitted_changes: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        has_remote: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        origin_url: z.ZodOptional<z.ZodNullable<z.ZodString>>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        is_repository: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        has_commits: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        has_uncommitted_changes: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        has_remote: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        origin_url: z.ZodOptional<z.ZodNullable<z.ZodString>>;
      }, z.ZodTypeAny, "passthrough">>>;
      status: z.ZodOptional<z.ZodArray<z.ZodObject<{
        severity: z.ZodOptional<z.ZodString>;
        code: z.ZodOptional<z.ZodString>;
        message: z.ZodOptional<z.ZodString>;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodOptional<z.ZodString>;
        code: z.ZodOptional<z.ZodString>;
        message: z.ZodOptional<z.ZodString>;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodOptional<z.ZodString>;
        code: z.ZodOptional<z.ZodString>;
        message: z.ZodOptional<z.ZodString>;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      id: z.ZodOptional<z.ZodString>;
      root: z.ZodOptional<z.ZodString>;
      metadata_path: z.ZodOptional<z.ZodNullable<z.ZodString>>;
      openspec_root: z.ZodOptional<z.ZodObject<{
        present: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        healthy: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        present: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        healthy: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        present: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        healthy: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
      }, z.ZodTypeAny, "passthrough">>>;
      metadata: z.ZodOptional<z.ZodObject<{
        present: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        valid: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
        remote: z.ZodOptional<z.ZodNullable<z.ZodString>>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        present: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        valid: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
        remote: z.ZodOptional<z.ZodNullable<z.ZodString>>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        present: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        valid: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
        remote: z.ZodOptional<z.ZodNullable<z.ZodString>>;
      }, z.ZodTypeAny, "passthrough">>>;
      git: z.ZodOptional<z.ZodObject<{
        is_repository: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        has_commits: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        has_uncommitted_changes: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        has_remote: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        origin_url: z.ZodOptional<z.ZodNullable<z.ZodString>>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        is_repository: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        has_commits: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        has_uncommitted_changes: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        has_remote: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        origin_url: z.ZodOptional<z.ZodNullable<z.ZodString>>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        is_repository: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        has_commits: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        has_uncommitted_changes: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        has_remote: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        origin_url: z.ZodOptional<z.ZodNullable<z.ZodString>>;
      }, z.ZodTypeAny, "passthrough">>>;
      status: z.ZodOptional<z.ZodArray<z.ZodObject<{
        severity: z.ZodOptional<z.ZodString>;
        code: z.ZodOptional<z.ZodString>;
        message: z.ZodOptional<z.ZodString>;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodOptional<z.ZodString>;
        code: z.ZodOptional<z.ZodString>;
        message: z.ZodOptional<z.ZodString>;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodOptional<z.ZodString>;
        code: z.ZodOptional<z.ZodString>;
        message: z.ZodOptional<z.ZodString>;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">>;
    }, z.ZodTypeAny, "passthrough">>, "many">;
    evidence: z.ZodOptional<z.ZodNullable<z.ZodUnknown>>;
    error: z.ZodOptional<z.ZodObject<{
      kind: z.ZodString;
      message: z.ZodString;
      cliVersion: z.ZodOptional<z.ZodString>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      kind: z.ZodString;
      message: z.ZodString;
      cliVersion: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      kind: z.ZodString;
      message: z.ZodString;
      cliVersion: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">>>;
    cliVersion: z.ZodOptional<z.ZodString>;
  }, z.ZodTypeAny, "passthrough">, z.ZodTypeDef, z.objectInputType<{
    available: z.ZodBoolean;
    stores: z.ZodArray<z.ZodObject<{
      id: z.ZodOptional<z.ZodString>;
      root: z.ZodOptional<z.ZodString>;
      metadata_path: z.ZodOptional<z.ZodNullable<z.ZodString>>;
      openspec_root: z.ZodOptional<z.ZodObject<{
        present: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        healthy: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        present: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        healthy: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        present: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        healthy: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
      }, z.ZodTypeAny, "passthrough">>>;
      metadata: z.ZodOptional<z.ZodObject<{
        present: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        valid: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
        remote: z.ZodOptional<z.ZodNullable<z.ZodString>>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        present: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        valid: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
        remote: z.ZodOptional<z.ZodNullable<z.ZodString>>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        present: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        valid: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
        remote: z.ZodOptional<z.ZodNullable<z.ZodString>>;
      }, z.ZodTypeAny, "passthrough">>>;
      git: z.ZodOptional<z.ZodObject<{
        is_repository: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        has_commits: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        has_uncommitted_changes: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        has_remote: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        origin_url: z.ZodOptional<z.ZodNullable<z.ZodString>>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        is_repository: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        has_commits: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        has_uncommitted_changes: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        has_remote: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        origin_url: z.ZodOptional<z.ZodNullable<z.ZodString>>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        is_repository: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        has_commits: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        has_uncommitted_changes: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        has_remote: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        origin_url: z.ZodOptional<z.ZodNullable<z.ZodString>>;
      }, z.ZodTypeAny, "passthrough">>>;
      status: z.ZodOptional<z.ZodArray<z.ZodObject<{
        severity: z.ZodOptional<z.ZodString>;
        code: z.ZodOptional<z.ZodString>;
        message: z.ZodOptional<z.ZodString>;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodOptional<z.ZodString>;
        code: z.ZodOptional<z.ZodString>;
        message: z.ZodOptional<z.ZodString>;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodOptional<z.ZodString>;
        code: z.ZodOptional<z.ZodString>;
        message: z.ZodOptional<z.ZodString>;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      id: z.ZodOptional<z.ZodString>;
      root: z.ZodOptional<z.ZodString>;
      metadata_path: z.ZodOptional<z.ZodNullable<z.ZodString>>;
      openspec_root: z.ZodOptional<z.ZodObject<{
        present: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        healthy: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        present: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        healthy: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        present: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        healthy: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
      }, z.ZodTypeAny, "passthrough">>>;
      metadata: z.ZodOptional<z.ZodObject<{
        present: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        valid: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
        remote: z.ZodOptional<z.ZodNullable<z.ZodString>>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        present: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        valid: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
        remote: z.ZodOptional<z.ZodNullable<z.ZodString>>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        present: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        valid: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
        remote: z.ZodOptional<z.ZodNullable<z.ZodString>>;
      }, z.ZodTypeAny, "passthrough">>>;
      git: z.ZodOptional<z.ZodObject<{
        is_repository: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        has_commits: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        has_uncommitted_changes: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        has_remote: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        origin_url: z.ZodOptional<z.ZodNullable<z.ZodString>>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        is_repository: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        has_commits: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        has_uncommitted_changes: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        has_remote: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        origin_url: z.ZodOptional<z.ZodNullable<z.ZodString>>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        is_repository: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        has_commits: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        has_uncommitted_changes: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        has_remote: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        origin_url: z.ZodOptional<z.ZodNullable<z.ZodString>>;
      }, z.ZodTypeAny, "passthrough">>>;
      status: z.ZodOptional<z.ZodArray<z.ZodObject<{
        severity: z.ZodOptional<z.ZodString>;
        code: z.ZodOptional<z.ZodString>;
        message: z.ZodOptional<z.ZodString>;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodOptional<z.ZodString>;
        code: z.ZodOptional<z.ZodString>;
        message: z.ZodOptional<z.ZodString>;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodOptional<z.ZodString>;
        code: z.ZodOptional<z.ZodString>;
        message: z.ZodOptional<z.ZodString>;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      id: z.ZodOptional<z.ZodString>;
      root: z.ZodOptional<z.ZodString>;
      metadata_path: z.ZodOptional<z.ZodNullable<z.ZodString>>;
      openspec_root: z.ZodOptional<z.ZodObject<{
        present: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        healthy: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        present: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        healthy: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        present: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        healthy: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
      }, z.ZodTypeAny, "passthrough">>>;
      metadata: z.ZodOptional<z.ZodObject<{
        present: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        valid: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
        remote: z.ZodOptional<z.ZodNullable<z.ZodString>>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        present: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        valid: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
        remote: z.ZodOptional<z.ZodNullable<z.ZodString>>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        present: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        valid: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
        remote: z.ZodOptional<z.ZodNullable<z.ZodString>>;
      }, z.ZodTypeAny, "passthrough">>>;
      git: z.ZodOptional<z.ZodObject<{
        is_repository: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        has_commits: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        has_uncommitted_changes: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        has_remote: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        origin_url: z.ZodOptional<z.ZodNullable<z.ZodString>>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        is_repository: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        has_commits: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        has_uncommitted_changes: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        has_remote: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        origin_url: z.ZodOptional<z.ZodNullable<z.ZodString>>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        is_repository: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        has_commits: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        has_uncommitted_changes: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        has_remote: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        origin_url: z.ZodOptional<z.ZodNullable<z.ZodString>>;
      }, z.ZodTypeAny, "passthrough">>>;
      status: z.ZodOptional<z.ZodArray<z.ZodObject<{
        severity: z.ZodOptional<z.ZodString>;
        code: z.ZodOptional<z.ZodString>;
        message: z.ZodOptional<z.ZodString>;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodOptional<z.ZodString>;
        code: z.ZodOptional<z.ZodString>;
        message: z.ZodOptional<z.ZodString>;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodOptional<z.ZodString>;
        code: z.ZodOptional<z.ZodString>;
        message: z.ZodOptional<z.ZodString>;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">>;
    }, z.ZodTypeAny, "passthrough">>, "many">;
    evidence: z.ZodOptional<z.ZodNullable<z.ZodUnknown>>;
    error: z.ZodOptional<z.ZodObject<{
      kind: z.ZodString;
      message: z.ZodString;
      cliVersion: z.ZodOptional<z.ZodString>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      kind: z.ZodString;
      message: z.ZodString;
      cliVersion: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      kind: z.ZodString;
      message: z.ZodString;
      cliVersion: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">>>;
    cliVersion: z.ZodOptional<z.ZodString>;
  }, z.ZodTypeAny, "passthrough">>;
  freshness: z.ZodLiteral<"current">;
  snapshotGeneration: z.ZodNumber;
  error: z.ZodNull;
  identity: z.ZodString;
  workGeneration: z.ZodNumber;
  invalidationCause: z.ZodEnum<["initial", "dependency", "explicit-refresh", "subscriber-resume"]>;
}, "strip", z.ZodTypeAny, {
  error: null;
  state: "ready";
  data: {
    stores: z.objectOutputType<{
      id: z.ZodOptional<z.ZodString>;
      root: z.ZodOptional<z.ZodString>;
      metadata_path: z.ZodOptional<z.ZodNullable<z.ZodString>>;
      openspec_root: z.ZodOptional<z.ZodObject<{
        present: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        healthy: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        present: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        healthy: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        present: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        healthy: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
      }, z.ZodTypeAny, "passthrough">>>;
      metadata: z.ZodOptional<z.ZodObject<{
        present: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        valid: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
        remote: z.ZodOptional<z.ZodNullable<z.ZodString>>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        present: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        valid: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
        remote: z.ZodOptional<z.ZodNullable<z.ZodString>>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        present: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        valid: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
        remote: z.ZodOptional<z.ZodNullable<z.ZodString>>;
      }, z.ZodTypeAny, "passthrough">>>;
      git: z.ZodOptional<z.ZodObject<{
        is_repository: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        has_commits: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        has_uncommitted_changes: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        has_remote: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        origin_url: z.ZodOptional<z.ZodNullable<z.ZodString>>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        is_repository: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        has_commits: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        has_uncommitted_changes: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        has_remote: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        origin_url: z.ZodOptional<z.ZodNullable<z.ZodString>>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        is_repository: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        has_commits: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        has_uncommitted_changes: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        has_remote: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        origin_url: z.ZodOptional<z.ZodNullable<z.ZodString>>;
      }, z.ZodTypeAny, "passthrough">>>;
      status: z.ZodOptional<z.ZodArray<z.ZodObject<{
        severity: z.ZodOptional<z.ZodString>;
        code: z.ZodOptional<z.ZodString>;
        message: z.ZodOptional<z.ZodString>;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodOptional<z.ZodString>;
        code: z.ZodOptional<z.ZodString>;
        message: z.ZodOptional<z.ZodString>;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodOptional<z.ZodString>;
        code: z.ZodOptional<z.ZodString>;
        message: z.ZodOptional<z.ZodString>;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">>;
    }, z.ZodTypeAny, "passthrough">[];
    available: boolean;
    error?: z.objectOutputType<{
      kind: z.ZodString;
      message: z.ZodString;
      cliVersion: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough"> | undefined;
    evidence?: unknown;
    cliVersion?: string | undefined;
  } & {
    [k: string]: unknown;
  };
  freshness: "current";
  snapshotGeneration: number;
  identity: string;
  workGeneration: number;
  invalidationCause: "dependency" | "initial" | "explicit-refresh" | "subscriber-resume";
}, {
  error: null;
  state: "ready";
  data: {
    stores: z.objectInputType<{
      id: z.ZodOptional<z.ZodString>;
      root: z.ZodOptional<z.ZodString>;
      metadata_path: z.ZodOptional<z.ZodNullable<z.ZodString>>;
      openspec_root: z.ZodOptional<z.ZodObject<{
        present: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        healthy: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        present: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        healthy: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        present: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        healthy: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
      }, z.ZodTypeAny, "passthrough">>>;
      metadata: z.ZodOptional<z.ZodObject<{
        present: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        valid: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
        remote: z.ZodOptional<z.ZodNullable<z.ZodString>>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        present: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        valid: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
        remote: z.ZodOptional<z.ZodNullable<z.ZodString>>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        present: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        valid: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
        remote: z.ZodOptional<z.ZodNullable<z.ZodString>>;
      }, z.ZodTypeAny, "passthrough">>>;
      git: z.ZodOptional<z.ZodObject<{
        is_repository: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        has_commits: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        has_uncommitted_changes: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        has_remote: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        origin_url: z.ZodOptional<z.ZodNullable<z.ZodString>>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        is_repository: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        has_commits: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        has_uncommitted_changes: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        has_remote: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        origin_url: z.ZodOptional<z.ZodNullable<z.ZodString>>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        is_repository: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        has_commits: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        has_uncommitted_changes: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        has_remote: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        origin_url: z.ZodOptional<z.ZodNullable<z.ZodString>>;
      }, z.ZodTypeAny, "passthrough">>>;
      status: z.ZodOptional<z.ZodArray<z.ZodObject<{
        severity: z.ZodOptional<z.ZodString>;
        code: z.ZodOptional<z.ZodString>;
        message: z.ZodOptional<z.ZodString>;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodOptional<z.ZodString>;
        code: z.ZodOptional<z.ZodString>;
        message: z.ZodOptional<z.ZodString>;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodOptional<z.ZodString>;
        code: z.ZodOptional<z.ZodString>;
        message: z.ZodOptional<z.ZodString>;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">>;
    }, z.ZodTypeAny, "passthrough">[];
    available: boolean;
    error?: z.objectInputType<{
      kind: z.ZodString;
      message: z.ZodString;
      cliVersion: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough"> | undefined;
    evidence?: unknown;
    cliVersion?: string | undefined;
  } & {
    [k: string]: unknown;
  };
  freshness: "current";
  snapshotGeneration: number;
  identity: string;
  workGeneration: number;
  invalidationCause: "dependency" | "initial" | "explicit-refresh" | "subscriber-resume";
}>, z.ZodObject<{
  state: z.ZodLiteral<"revalidating">;
  data: z.ZodType<z.objectOutputType<{
    available: z.ZodBoolean;
    stores: z.ZodArray<z.ZodObject<{
      id: z.ZodOptional<z.ZodString>;
      root: z.ZodOptional<z.ZodString>;
      metadata_path: z.ZodOptional<z.ZodNullable<z.ZodString>>;
      openspec_root: z.ZodOptional<z.ZodObject<{
        present: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        healthy: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        present: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        healthy: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        present: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        healthy: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
      }, z.ZodTypeAny, "passthrough">>>;
      metadata: z.ZodOptional<z.ZodObject<{
        present: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        valid: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
        remote: z.ZodOptional<z.ZodNullable<z.ZodString>>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        present: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        valid: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
        remote: z.ZodOptional<z.ZodNullable<z.ZodString>>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        present: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        valid: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
        remote: z.ZodOptional<z.ZodNullable<z.ZodString>>;
      }, z.ZodTypeAny, "passthrough">>>;
      git: z.ZodOptional<z.ZodObject<{
        is_repository: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        has_commits: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        has_uncommitted_changes: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        has_remote: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        origin_url: z.ZodOptional<z.ZodNullable<z.ZodString>>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        is_repository: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        has_commits: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        has_uncommitted_changes: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        has_remote: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        origin_url: z.ZodOptional<z.ZodNullable<z.ZodString>>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        is_repository: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        has_commits: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        has_uncommitted_changes: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        has_remote: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        origin_url: z.ZodOptional<z.ZodNullable<z.ZodString>>;
      }, z.ZodTypeAny, "passthrough">>>;
      status: z.ZodOptional<z.ZodArray<z.ZodObject<{
        severity: z.ZodOptional<z.ZodString>;
        code: z.ZodOptional<z.ZodString>;
        message: z.ZodOptional<z.ZodString>;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodOptional<z.ZodString>;
        code: z.ZodOptional<z.ZodString>;
        message: z.ZodOptional<z.ZodString>;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodOptional<z.ZodString>;
        code: z.ZodOptional<z.ZodString>;
        message: z.ZodOptional<z.ZodString>;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      id: z.ZodOptional<z.ZodString>;
      root: z.ZodOptional<z.ZodString>;
      metadata_path: z.ZodOptional<z.ZodNullable<z.ZodString>>;
      openspec_root: z.ZodOptional<z.ZodObject<{
        present: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        healthy: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        present: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        healthy: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        present: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        healthy: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
      }, z.ZodTypeAny, "passthrough">>>;
      metadata: z.ZodOptional<z.ZodObject<{
        present: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        valid: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
        remote: z.ZodOptional<z.ZodNullable<z.ZodString>>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        present: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        valid: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
        remote: z.ZodOptional<z.ZodNullable<z.ZodString>>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        present: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        valid: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
        remote: z.ZodOptional<z.ZodNullable<z.ZodString>>;
      }, z.ZodTypeAny, "passthrough">>>;
      git: z.ZodOptional<z.ZodObject<{
        is_repository: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        has_commits: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        has_uncommitted_changes: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        has_remote: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        origin_url: z.ZodOptional<z.ZodNullable<z.ZodString>>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        is_repository: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        has_commits: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        has_uncommitted_changes: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        has_remote: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        origin_url: z.ZodOptional<z.ZodNullable<z.ZodString>>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        is_repository: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        has_commits: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        has_uncommitted_changes: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        has_remote: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        origin_url: z.ZodOptional<z.ZodNullable<z.ZodString>>;
      }, z.ZodTypeAny, "passthrough">>>;
      status: z.ZodOptional<z.ZodArray<z.ZodObject<{
        severity: z.ZodOptional<z.ZodString>;
        code: z.ZodOptional<z.ZodString>;
        message: z.ZodOptional<z.ZodString>;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodOptional<z.ZodString>;
        code: z.ZodOptional<z.ZodString>;
        message: z.ZodOptional<z.ZodString>;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodOptional<z.ZodString>;
        code: z.ZodOptional<z.ZodString>;
        message: z.ZodOptional<z.ZodString>;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      id: z.ZodOptional<z.ZodString>;
      root: z.ZodOptional<z.ZodString>;
      metadata_path: z.ZodOptional<z.ZodNullable<z.ZodString>>;
      openspec_root: z.ZodOptional<z.ZodObject<{
        present: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        healthy: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        present: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        healthy: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        present: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        healthy: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
      }, z.ZodTypeAny, "passthrough">>>;
      metadata: z.ZodOptional<z.ZodObject<{
        present: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        valid: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
        remote: z.ZodOptional<z.ZodNullable<z.ZodString>>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        present: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        valid: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
        remote: z.ZodOptional<z.ZodNullable<z.ZodString>>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        present: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        valid: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
        remote: z.ZodOptional<z.ZodNullable<z.ZodString>>;
      }, z.ZodTypeAny, "passthrough">>>;
      git: z.ZodOptional<z.ZodObject<{
        is_repository: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        has_commits: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        has_uncommitted_changes: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        has_remote: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        origin_url: z.ZodOptional<z.ZodNullable<z.ZodString>>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        is_repository: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        has_commits: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        has_uncommitted_changes: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        has_remote: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        origin_url: z.ZodOptional<z.ZodNullable<z.ZodString>>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        is_repository: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        has_commits: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        has_uncommitted_changes: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        has_remote: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        origin_url: z.ZodOptional<z.ZodNullable<z.ZodString>>;
      }, z.ZodTypeAny, "passthrough">>>;
      status: z.ZodOptional<z.ZodArray<z.ZodObject<{
        severity: z.ZodOptional<z.ZodString>;
        code: z.ZodOptional<z.ZodString>;
        message: z.ZodOptional<z.ZodString>;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodOptional<z.ZodString>;
        code: z.ZodOptional<z.ZodString>;
        message: z.ZodOptional<z.ZodString>;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodOptional<z.ZodString>;
        code: z.ZodOptional<z.ZodString>;
        message: z.ZodOptional<z.ZodString>;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">>;
    }, z.ZodTypeAny, "passthrough">>, "many">;
    evidence: z.ZodOptional<z.ZodNullable<z.ZodUnknown>>;
    error: z.ZodOptional<z.ZodObject<{
      kind: z.ZodString;
      message: z.ZodString;
      cliVersion: z.ZodOptional<z.ZodString>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      kind: z.ZodString;
      message: z.ZodString;
      cliVersion: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      kind: z.ZodString;
      message: z.ZodString;
      cliVersion: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">>>;
    cliVersion: z.ZodOptional<z.ZodString>;
  }, z.ZodTypeAny, "passthrough">, z.ZodTypeDef, z.objectInputType<{
    available: z.ZodBoolean;
    stores: z.ZodArray<z.ZodObject<{
      id: z.ZodOptional<z.ZodString>;
      root: z.ZodOptional<z.ZodString>;
      metadata_path: z.ZodOptional<z.ZodNullable<z.ZodString>>;
      openspec_root: z.ZodOptional<z.ZodObject<{
        present: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        healthy: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        present: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        healthy: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        present: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        healthy: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
      }, z.ZodTypeAny, "passthrough">>>;
      metadata: z.ZodOptional<z.ZodObject<{
        present: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        valid: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
        remote: z.ZodOptional<z.ZodNullable<z.ZodString>>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        present: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        valid: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
        remote: z.ZodOptional<z.ZodNullable<z.ZodString>>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        present: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        valid: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
        remote: z.ZodOptional<z.ZodNullable<z.ZodString>>;
      }, z.ZodTypeAny, "passthrough">>>;
      git: z.ZodOptional<z.ZodObject<{
        is_repository: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        has_commits: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        has_uncommitted_changes: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        has_remote: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        origin_url: z.ZodOptional<z.ZodNullable<z.ZodString>>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        is_repository: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        has_commits: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        has_uncommitted_changes: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        has_remote: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        origin_url: z.ZodOptional<z.ZodNullable<z.ZodString>>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        is_repository: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        has_commits: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        has_uncommitted_changes: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        has_remote: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        origin_url: z.ZodOptional<z.ZodNullable<z.ZodString>>;
      }, z.ZodTypeAny, "passthrough">>>;
      status: z.ZodOptional<z.ZodArray<z.ZodObject<{
        severity: z.ZodOptional<z.ZodString>;
        code: z.ZodOptional<z.ZodString>;
        message: z.ZodOptional<z.ZodString>;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodOptional<z.ZodString>;
        code: z.ZodOptional<z.ZodString>;
        message: z.ZodOptional<z.ZodString>;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodOptional<z.ZodString>;
        code: z.ZodOptional<z.ZodString>;
        message: z.ZodOptional<z.ZodString>;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      id: z.ZodOptional<z.ZodString>;
      root: z.ZodOptional<z.ZodString>;
      metadata_path: z.ZodOptional<z.ZodNullable<z.ZodString>>;
      openspec_root: z.ZodOptional<z.ZodObject<{
        present: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        healthy: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        present: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        healthy: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        present: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        healthy: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
      }, z.ZodTypeAny, "passthrough">>>;
      metadata: z.ZodOptional<z.ZodObject<{
        present: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        valid: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
        remote: z.ZodOptional<z.ZodNullable<z.ZodString>>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        present: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        valid: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
        remote: z.ZodOptional<z.ZodNullable<z.ZodString>>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        present: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        valid: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
        remote: z.ZodOptional<z.ZodNullable<z.ZodString>>;
      }, z.ZodTypeAny, "passthrough">>>;
      git: z.ZodOptional<z.ZodObject<{
        is_repository: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        has_commits: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        has_uncommitted_changes: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        has_remote: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        origin_url: z.ZodOptional<z.ZodNullable<z.ZodString>>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        is_repository: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        has_commits: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        has_uncommitted_changes: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        has_remote: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        origin_url: z.ZodOptional<z.ZodNullable<z.ZodString>>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        is_repository: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        has_commits: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        has_uncommitted_changes: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        has_remote: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        origin_url: z.ZodOptional<z.ZodNullable<z.ZodString>>;
      }, z.ZodTypeAny, "passthrough">>>;
      status: z.ZodOptional<z.ZodArray<z.ZodObject<{
        severity: z.ZodOptional<z.ZodString>;
        code: z.ZodOptional<z.ZodString>;
        message: z.ZodOptional<z.ZodString>;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodOptional<z.ZodString>;
        code: z.ZodOptional<z.ZodString>;
        message: z.ZodOptional<z.ZodString>;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodOptional<z.ZodString>;
        code: z.ZodOptional<z.ZodString>;
        message: z.ZodOptional<z.ZodString>;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      id: z.ZodOptional<z.ZodString>;
      root: z.ZodOptional<z.ZodString>;
      metadata_path: z.ZodOptional<z.ZodNullable<z.ZodString>>;
      openspec_root: z.ZodOptional<z.ZodObject<{
        present: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        healthy: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        present: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        healthy: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        present: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        healthy: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
      }, z.ZodTypeAny, "passthrough">>>;
      metadata: z.ZodOptional<z.ZodObject<{
        present: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        valid: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
        remote: z.ZodOptional<z.ZodNullable<z.ZodString>>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        present: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        valid: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
        remote: z.ZodOptional<z.ZodNullable<z.ZodString>>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        present: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        valid: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
        remote: z.ZodOptional<z.ZodNullable<z.ZodString>>;
      }, z.ZodTypeAny, "passthrough">>>;
      git: z.ZodOptional<z.ZodObject<{
        is_repository: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        has_commits: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        has_uncommitted_changes: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        has_remote: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        origin_url: z.ZodOptional<z.ZodNullable<z.ZodString>>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        is_repository: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        has_commits: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        has_uncommitted_changes: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        has_remote: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        origin_url: z.ZodOptional<z.ZodNullable<z.ZodString>>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        is_repository: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        has_commits: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        has_uncommitted_changes: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        has_remote: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        origin_url: z.ZodOptional<z.ZodNullable<z.ZodString>>;
      }, z.ZodTypeAny, "passthrough">>>;
      status: z.ZodOptional<z.ZodArray<z.ZodObject<{
        severity: z.ZodOptional<z.ZodString>;
        code: z.ZodOptional<z.ZodString>;
        message: z.ZodOptional<z.ZodString>;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodOptional<z.ZodString>;
        code: z.ZodOptional<z.ZodString>;
        message: z.ZodOptional<z.ZodString>;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodOptional<z.ZodString>;
        code: z.ZodOptional<z.ZodString>;
        message: z.ZodOptional<z.ZodString>;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">>;
    }, z.ZodTypeAny, "passthrough">>, "many">;
    evidence: z.ZodOptional<z.ZodNullable<z.ZodUnknown>>;
    error: z.ZodOptional<z.ZodObject<{
      kind: z.ZodString;
      message: z.ZodString;
      cliVersion: z.ZodOptional<z.ZodString>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      kind: z.ZodString;
      message: z.ZodString;
      cliVersion: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      kind: z.ZodString;
      message: z.ZodString;
      cliVersion: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">>>;
    cliVersion: z.ZodOptional<z.ZodString>;
  }, z.ZodTypeAny, "passthrough">>;
  freshness: z.ZodLiteral<"stale-display-only">;
  snapshotGeneration: z.ZodNumber;
  error: z.ZodNull;
  identity: z.ZodString;
  workGeneration: z.ZodNumber;
  invalidationCause: z.ZodEnum<["initial", "dependency", "explicit-refresh", "subscriber-resume"]>;
}, "strip", z.ZodTypeAny, {
  error: null;
  state: "revalidating";
  data: {
    stores: z.objectOutputType<{
      id: z.ZodOptional<z.ZodString>;
      root: z.ZodOptional<z.ZodString>;
      metadata_path: z.ZodOptional<z.ZodNullable<z.ZodString>>;
      openspec_root: z.ZodOptional<z.ZodObject<{
        present: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        healthy: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        present: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        healthy: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        present: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        healthy: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
      }, z.ZodTypeAny, "passthrough">>>;
      metadata: z.ZodOptional<z.ZodObject<{
        present: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        valid: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
        remote: z.ZodOptional<z.ZodNullable<z.ZodString>>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        present: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        valid: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
        remote: z.ZodOptional<z.ZodNullable<z.ZodString>>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        present: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        valid: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
        remote: z.ZodOptional<z.ZodNullable<z.ZodString>>;
      }, z.ZodTypeAny, "passthrough">>>;
      git: z.ZodOptional<z.ZodObject<{
        is_repository: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        has_commits: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        has_uncommitted_changes: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        has_remote: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        origin_url: z.ZodOptional<z.ZodNullable<z.ZodString>>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        is_repository: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        has_commits: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        has_uncommitted_changes: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        has_remote: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        origin_url: z.ZodOptional<z.ZodNullable<z.ZodString>>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        is_repository: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        has_commits: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        has_uncommitted_changes: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        has_remote: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        origin_url: z.ZodOptional<z.ZodNullable<z.ZodString>>;
      }, z.ZodTypeAny, "passthrough">>>;
      status: z.ZodOptional<z.ZodArray<z.ZodObject<{
        severity: z.ZodOptional<z.ZodString>;
        code: z.ZodOptional<z.ZodString>;
        message: z.ZodOptional<z.ZodString>;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodOptional<z.ZodString>;
        code: z.ZodOptional<z.ZodString>;
        message: z.ZodOptional<z.ZodString>;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodOptional<z.ZodString>;
        code: z.ZodOptional<z.ZodString>;
        message: z.ZodOptional<z.ZodString>;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">>;
    }, z.ZodTypeAny, "passthrough">[];
    available: boolean;
    error?: z.objectOutputType<{
      kind: z.ZodString;
      message: z.ZodString;
      cliVersion: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough"> | undefined;
    evidence?: unknown;
    cliVersion?: string | undefined;
  } & {
    [k: string]: unknown;
  };
  freshness: "stale-display-only";
  snapshotGeneration: number;
  identity: string;
  workGeneration: number;
  invalidationCause: "dependency" | "initial" | "explicit-refresh" | "subscriber-resume";
}, {
  error: null;
  state: "revalidating";
  data: {
    stores: z.objectInputType<{
      id: z.ZodOptional<z.ZodString>;
      root: z.ZodOptional<z.ZodString>;
      metadata_path: z.ZodOptional<z.ZodNullable<z.ZodString>>;
      openspec_root: z.ZodOptional<z.ZodObject<{
        present: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        healthy: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        present: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        healthy: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        present: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        healthy: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
      }, z.ZodTypeAny, "passthrough">>>;
      metadata: z.ZodOptional<z.ZodObject<{
        present: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        valid: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
        remote: z.ZodOptional<z.ZodNullable<z.ZodString>>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        present: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        valid: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
        remote: z.ZodOptional<z.ZodNullable<z.ZodString>>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        present: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        valid: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
        remote: z.ZodOptional<z.ZodNullable<z.ZodString>>;
      }, z.ZodTypeAny, "passthrough">>>;
      git: z.ZodOptional<z.ZodObject<{
        is_repository: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        has_commits: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        has_uncommitted_changes: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        has_remote: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        origin_url: z.ZodOptional<z.ZodNullable<z.ZodString>>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        is_repository: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        has_commits: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        has_uncommitted_changes: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        has_remote: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        origin_url: z.ZodOptional<z.ZodNullable<z.ZodString>>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        is_repository: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        has_commits: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        has_uncommitted_changes: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        has_remote: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        origin_url: z.ZodOptional<z.ZodNullable<z.ZodString>>;
      }, z.ZodTypeAny, "passthrough">>>;
      status: z.ZodOptional<z.ZodArray<z.ZodObject<{
        severity: z.ZodOptional<z.ZodString>;
        code: z.ZodOptional<z.ZodString>;
        message: z.ZodOptional<z.ZodString>;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodOptional<z.ZodString>;
        code: z.ZodOptional<z.ZodString>;
        message: z.ZodOptional<z.ZodString>;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodOptional<z.ZodString>;
        code: z.ZodOptional<z.ZodString>;
        message: z.ZodOptional<z.ZodString>;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">>;
    }, z.ZodTypeAny, "passthrough">[];
    available: boolean;
    error?: z.objectInputType<{
      kind: z.ZodString;
      message: z.ZodString;
      cliVersion: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough"> | undefined;
    evidence?: unknown;
    cliVersion?: string | undefined;
  } & {
    [k: string]: unknown;
  };
  freshness: "stale-display-only";
  snapshotGeneration: number;
  identity: string;
  workGeneration: number;
  invalidationCause: "dependency" | "initial" | "explicit-refresh" | "subscriber-resume";
}>, z.ZodObject<{
  state: z.ZodLiteral<"error">;
  data: z.ZodNull;
  freshness: z.ZodNull;
  snapshotGeneration: z.ZodNull;
  error: z.ZodObject<{
    name: z.ZodString;
    message: z.ZodString;
    cliEvidence: z.ZodNullable<z.ZodObject<{
      success: z.ZodBoolean;
      stdout: z.ZodString;
      stderr: z.ZodString;
      exitCode: z.ZodNullable<z.ZodNumber>;
      payload: z.ZodNullable<z.ZodType<CliJsonValue, z.ZodTypeDef, CliJsonValue>>;
      diagnostics: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
      contractError: z.ZodOptional<z.ZodString>;
    }, "strip", z.ZodTypeAny, {
      success: boolean;
      stdout: string;
      stderr: string;
      exitCode: number | null;
      payload: CliJsonValue;
      diagnostics: z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">[];
      contractError?: string | undefined;
    }, {
      success: boolean;
      stdout: string;
      stderr: string;
      exitCode: number | null;
      payload: CliJsonValue;
      diagnostics: z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">[];
      contractError?: string | undefined;
    }>>;
  }, "strip", z.ZodTypeAny, {
    message: string;
    name: string;
    cliEvidence: {
      success: boolean;
      stdout: string;
      stderr: string;
      exitCode: number | null;
      payload: CliJsonValue;
      diagnostics: z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">[];
      contractError?: string | undefined;
    } | null;
  }, {
    message: string;
    name: string;
    cliEvidence: {
      success: boolean;
      stdout: string;
      stderr: string;
      exitCode: number | null;
      payload: CliJsonValue;
      diagnostics: z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">[];
      contractError?: string | undefined;
    } | null;
  }>;
  identity: z.ZodString;
  workGeneration: z.ZodNumber;
  invalidationCause: z.ZodEnum<["initial", "dependency", "explicit-refresh", "subscriber-resume"]>;
}, "strip", z.ZodTypeAny, {
  error: {
    message: string;
    name: string;
    cliEvidence: {
      success: boolean;
      stdout: string;
      stderr: string;
      exitCode: number | null;
      payload: CliJsonValue;
      diagnostics: z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">[];
      contractError?: string | undefined;
    } | null;
  };
  state: "error";
  data: null;
  freshness: null;
  snapshotGeneration: null;
  identity: string;
  workGeneration: number;
  invalidationCause: "dependency" | "initial" | "explicit-refresh" | "subscriber-resume";
}, {
  error: {
    message: string;
    name: string;
    cliEvidence: {
      success: boolean;
      stdout: string;
      stderr: string;
      exitCode: number | null;
      payload: CliJsonValue;
      diagnostics: z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">[];
      contractError?: string | undefined;
    } | null;
  };
  state: "error";
  data: null;
  freshness: null;
  snapshotGeneration: null;
  identity: string;
  workGeneration: number;
  invalidationCause: "dependency" | "initial" | "explicit-refresh" | "subscriber-resume";
}>, z.ZodObject<{
  state: z.ZodLiteral<"refresh-error">;
  data: z.ZodType<z.objectOutputType<{
    available: z.ZodBoolean;
    stores: z.ZodArray<z.ZodObject<{
      id: z.ZodOptional<z.ZodString>;
      root: z.ZodOptional<z.ZodString>;
      metadata_path: z.ZodOptional<z.ZodNullable<z.ZodString>>;
      openspec_root: z.ZodOptional<z.ZodObject<{
        present: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        healthy: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        present: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        healthy: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        present: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        healthy: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
      }, z.ZodTypeAny, "passthrough">>>;
      metadata: z.ZodOptional<z.ZodObject<{
        present: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        valid: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
        remote: z.ZodOptional<z.ZodNullable<z.ZodString>>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        present: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        valid: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
        remote: z.ZodOptional<z.ZodNullable<z.ZodString>>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        present: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        valid: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
        remote: z.ZodOptional<z.ZodNullable<z.ZodString>>;
      }, z.ZodTypeAny, "passthrough">>>;
      git: z.ZodOptional<z.ZodObject<{
        is_repository: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        has_commits: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        has_uncommitted_changes: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        has_remote: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        origin_url: z.ZodOptional<z.ZodNullable<z.ZodString>>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        is_repository: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        has_commits: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        has_uncommitted_changes: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        has_remote: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        origin_url: z.ZodOptional<z.ZodNullable<z.ZodString>>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        is_repository: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        has_commits: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        has_uncommitted_changes: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        has_remote: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        origin_url: z.ZodOptional<z.ZodNullable<z.ZodString>>;
      }, z.ZodTypeAny, "passthrough">>>;
      status: z.ZodOptional<z.ZodArray<z.ZodObject<{
        severity: z.ZodOptional<z.ZodString>;
        code: z.ZodOptional<z.ZodString>;
        message: z.ZodOptional<z.ZodString>;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodOptional<z.ZodString>;
        code: z.ZodOptional<z.ZodString>;
        message: z.ZodOptional<z.ZodString>;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodOptional<z.ZodString>;
        code: z.ZodOptional<z.ZodString>;
        message: z.ZodOptional<z.ZodString>;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      id: z.ZodOptional<z.ZodString>;
      root: z.ZodOptional<z.ZodString>;
      metadata_path: z.ZodOptional<z.ZodNullable<z.ZodString>>;
      openspec_root: z.ZodOptional<z.ZodObject<{
        present: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        healthy: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        present: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        healthy: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        present: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        healthy: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
      }, z.ZodTypeAny, "passthrough">>>;
      metadata: z.ZodOptional<z.ZodObject<{
        present: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        valid: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
        remote: z.ZodOptional<z.ZodNullable<z.ZodString>>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        present: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        valid: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
        remote: z.ZodOptional<z.ZodNullable<z.ZodString>>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        present: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        valid: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
        remote: z.ZodOptional<z.ZodNullable<z.ZodString>>;
      }, z.ZodTypeAny, "passthrough">>>;
      git: z.ZodOptional<z.ZodObject<{
        is_repository: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        has_commits: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        has_uncommitted_changes: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        has_remote: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        origin_url: z.ZodOptional<z.ZodNullable<z.ZodString>>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        is_repository: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        has_commits: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        has_uncommitted_changes: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        has_remote: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        origin_url: z.ZodOptional<z.ZodNullable<z.ZodString>>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        is_repository: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        has_commits: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        has_uncommitted_changes: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        has_remote: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        origin_url: z.ZodOptional<z.ZodNullable<z.ZodString>>;
      }, z.ZodTypeAny, "passthrough">>>;
      status: z.ZodOptional<z.ZodArray<z.ZodObject<{
        severity: z.ZodOptional<z.ZodString>;
        code: z.ZodOptional<z.ZodString>;
        message: z.ZodOptional<z.ZodString>;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodOptional<z.ZodString>;
        code: z.ZodOptional<z.ZodString>;
        message: z.ZodOptional<z.ZodString>;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodOptional<z.ZodString>;
        code: z.ZodOptional<z.ZodString>;
        message: z.ZodOptional<z.ZodString>;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      id: z.ZodOptional<z.ZodString>;
      root: z.ZodOptional<z.ZodString>;
      metadata_path: z.ZodOptional<z.ZodNullable<z.ZodString>>;
      openspec_root: z.ZodOptional<z.ZodObject<{
        present: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        healthy: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        present: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        healthy: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        present: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        healthy: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
      }, z.ZodTypeAny, "passthrough">>>;
      metadata: z.ZodOptional<z.ZodObject<{
        present: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        valid: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
        remote: z.ZodOptional<z.ZodNullable<z.ZodString>>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        present: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        valid: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
        remote: z.ZodOptional<z.ZodNullable<z.ZodString>>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        present: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        valid: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
        remote: z.ZodOptional<z.ZodNullable<z.ZodString>>;
      }, z.ZodTypeAny, "passthrough">>>;
      git: z.ZodOptional<z.ZodObject<{
        is_repository: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        has_commits: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        has_uncommitted_changes: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        has_remote: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        origin_url: z.ZodOptional<z.ZodNullable<z.ZodString>>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        is_repository: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        has_commits: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        has_uncommitted_changes: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        has_remote: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        origin_url: z.ZodOptional<z.ZodNullable<z.ZodString>>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        is_repository: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        has_commits: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        has_uncommitted_changes: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        has_remote: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        origin_url: z.ZodOptional<z.ZodNullable<z.ZodString>>;
      }, z.ZodTypeAny, "passthrough">>>;
      status: z.ZodOptional<z.ZodArray<z.ZodObject<{
        severity: z.ZodOptional<z.ZodString>;
        code: z.ZodOptional<z.ZodString>;
        message: z.ZodOptional<z.ZodString>;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodOptional<z.ZodString>;
        code: z.ZodOptional<z.ZodString>;
        message: z.ZodOptional<z.ZodString>;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodOptional<z.ZodString>;
        code: z.ZodOptional<z.ZodString>;
        message: z.ZodOptional<z.ZodString>;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">>;
    }, z.ZodTypeAny, "passthrough">>, "many">;
    evidence: z.ZodOptional<z.ZodNullable<z.ZodUnknown>>;
    error: z.ZodOptional<z.ZodObject<{
      kind: z.ZodString;
      message: z.ZodString;
      cliVersion: z.ZodOptional<z.ZodString>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      kind: z.ZodString;
      message: z.ZodString;
      cliVersion: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      kind: z.ZodString;
      message: z.ZodString;
      cliVersion: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">>>;
    cliVersion: z.ZodOptional<z.ZodString>;
  }, z.ZodTypeAny, "passthrough">, z.ZodTypeDef, z.objectInputType<{
    available: z.ZodBoolean;
    stores: z.ZodArray<z.ZodObject<{
      id: z.ZodOptional<z.ZodString>;
      root: z.ZodOptional<z.ZodString>;
      metadata_path: z.ZodOptional<z.ZodNullable<z.ZodString>>;
      openspec_root: z.ZodOptional<z.ZodObject<{
        present: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        healthy: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        present: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        healthy: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        present: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        healthy: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
      }, z.ZodTypeAny, "passthrough">>>;
      metadata: z.ZodOptional<z.ZodObject<{
        present: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        valid: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
        remote: z.ZodOptional<z.ZodNullable<z.ZodString>>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        present: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        valid: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
        remote: z.ZodOptional<z.ZodNullable<z.ZodString>>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        present: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        valid: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
        remote: z.ZodOptional<z.ZodNullable<z.ZodString>>;
      }, z.ZodTypeAny, "passthrough">>>;
      git: z.ZodOptional<z.ZodObject<{
        is_repository: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        has_commits: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        has_uncommitted_changes: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        has_remote: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        origin_url: z.ZodOptional<z.ZodNullable<z.ZodString>>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        is_repository: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        has_commits: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        has_uncommitted_changes: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        has_remote: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        origin_url: z.ZodOptional<z.ZodNullable<z.ZodString>>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        is_repository: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        has_commits: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        has_uncommitted_changes: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        has_remote: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        origin_url: z.ZodOptional<z.ZodNullable<z.ZodString>>;
      }, z.ZodTypeAny, "passthrough">>>;
      status: z.ZodOptional<z.ZodArray<z.ZodObject<{
        severity: z.ZodOptional<z.ZodString>;
        code: z.ZodOptional<z.ZodString>;
        message: z.ZodOptional<z.ZodString>;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodOptional<z.ZodString>;
        code: z.ZodOptional<z.ZodString>;
        message: z.ZodOptional<z.ZodString>;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodOptional<z.ZodString>;
        code: z.ZodOptional<z.ZodString>;
        message: z.ZodOptional<z.ZodString>;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      id: z.ZodOptional<z.ZodString>;
      root: z.ZodOptional<z.ZodString>;
      metadata_path: z.ZodOptional<z.ZodNullable<z.ZodString>>;
      openspec_root: z.ZodOptional<z.ZodObject<{
        present: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        healthy: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        present: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        healthy: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        present: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        healthy: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
      }, z.ZodTypeAny, "passthrough">>>;
      metadata: z.ZodOptional<z.ZodObject<{
        present: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        valid: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
        remote: z.ZodOptional<z.ZodNullable<z.ZodString>>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        present: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        valid: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
        remote: z.ZodOptional<z.ZodNullable<z.ZodString>>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        present: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        valid: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
        remote: z.ZodOptional<z.ZodNullable<z.ZodString>>;
      }, z.ZodTypeAny, "passthrough">>>;
      git: z.ZodOptional<z.ZodObject<{
        is_repository: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        has_commits: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        has_uncommitted_changes: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        has_remote: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        origin_url: z.ZodOptional<z.ZodNullable<z.ZodString>>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        is_repository: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        has_commits: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        has_uncommitted_changes: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        has_remote: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        origin_url: z.ZodOptional<z.ZodNullable<z.ZodString>>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        is_repository: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        has_commits: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        has_uncommitted_changes: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        has_remote: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        origin_url: z.ZodOptional<z.ZodNullable<z.ZodString>>;
      }, z.ZodTypeAny, "passthrough">>>;
      status: z.ZodOptional<z.ZodArray<z.ZodObject<{
        severity: z.ZodOptional<z.ZodString>;
        code: z.ZodOptional<z.ZodString>;
        message: z.ZodOptional<z.ZodString>;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodOptional<z.ZodString>;
        code: z.ZodOptional<z.ZodString>;
        message: z.ZodOptional<z.ZodString>;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodOptional<z.ZodString>;
        code: z.ZodOptional<z.ZodString>;
        message: z.ZodOptional<z.ZodString>;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      id: z.ZodOptional<z.ZodString>;
      root: z.ZodOptional<z.ZodString>;
      metadata_path: z.ZodOptional<z.ZodNullable<z.ZodString>>;
      openspec_root: z.ZodOptional<z.ZodObject<{
        present: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        healthy: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        present: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        healthy: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        present: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        healthy: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
      }, z.ZodTypeAny, "passthrough">>>;
      metadata: z.ZodOptional<z.ZodObject<{
        present: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        valid: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
        remote: z.ZodOptional<z.ZodNullable<z.ZodString>>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        present: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        valid: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
        remote: z.ZodOptional<z.ZodNullable<z.ZodString>>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        present: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        valid: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
        remote: z.ZodOptional<z.ZodNullable<z.ZodString>>;
      }, z.ZodTypeAny, "passthrough">>>;
      git: z.ZodOptional<z.ZodObject<{
        is_repository: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        has_commits: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        has_uncommitted_changes: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        has_remote: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        origin_url: z.ZodOptional<z.ZodNullable<z.ZodString>>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        is_repository: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        has_commits: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        has_uncommitted_changes: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        has_remote: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        origin_url: z.ZodOptional<z.ZodNullable<z.ZodString>>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        is_repository: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        has_commits: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        has_uncommitted_changes: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        has_remote: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        origin_url: z.ZodOptional<z.ZodNullable<z.ZodString>>;
      }, z.ZodTypeAny, "passthrough">>>;
      status: z.ZodOptional<z.ZodArray<z.ZodObject<{
        severity: z.ZodOptional<z.ZodString>;
        code: z.ZodOptional<z.ZodString>;
        message: z.ZodOptional<z.ZodString>;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodOptional<z.ZodString>;
        code: z.ZodOptional<z.ZodString>;
        message: z.ZodOptional<z.ZodString>;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodOptional<z.ZodString>;
        code: z.ZodOptional<z.ZodString>;
        message: z.ZodOptional<z.ZodString>;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">>;
    }, z.ZodTypeAny, "passthrough">>, "many">;
    evidence: z.ZodOptional<z.ZodNullable<z.ZodUnknown>>;
    error: z.ZodOptional<z.ZodObject<{
      kind: z.ZodString;
      message: z.ZodString;
      cliVersion: z.ZodOptional<z.ZodString>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      kind: z.ZodString;
      message: z.ZodString;
      cliVersion: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      kind: z.ZodString;
      message: z.ZodString;
      cliVersion: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">>>;
    cliVersion: z.ZodOptional<z.ZodString>;
  }, z.ZodTypeAny, "passthrough">>;
  freshness: z.ZodLiteral<"stale-display-only">;
  snapshotGeneration: z.ZodNumber;
  error: z.ZodObject<{
    name: z.ZodString;
    message: z.ZodString;
    cliEvidence: z.ZodNullable<z.ZodObject<{
      success: z.ZodBoolean;
      stdout: z.ZodString;
      stderr: z.ZodString;
      exitCode: z.ZodNullable<z.ZodNumber>;
      payload: z.ZodNullable<z.ZodType<CliJsonValue, z.ZodTypeDef, CliJsonValue>>;
      diagnostics: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
      contractError: z.ZodOptional<z.ZodString>;
    }, "strip", z.ZodTypeAny, {
      success: boolean;
      stdout: string;
      stderr: string;
      exitCode: number | null;
      payload: CliJsonValue;
      diagnostics: z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">[];
      contractError?: string | undefined;
    }, {
      success: boolean;
      stdout: string;
      stderr: string;
      exitCode: number | null;
      payload: CliJsonValue;
      diagnostics: z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">[];
      contractError?: string | undefined;
    }>>;
  }, "strip", z.ZodTypeAny, {
    message: string;
    name: string;
    cliEvidence: {
      success: boolean;
      stdout: string;
      stderr: string;
      exitCode: number | null;
      payload: CliJsonValue;
      diagnostics: z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">[];
      contractError?: string | undefined;
    } | null;
  }, {
    message: string;
    name: string;
    cliEvidence: {
      success: boolean;
      stdout: string;
      stderr: string;
      exitCode: number | null;
      payload: CliJsonValue;
      diagnostics: z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">[];
      contractError?: string | undefined;
    } | null;
  }>;
  identity: z.ZodString;
  workGeneration: z.ZodNumber;
  invalidationCause: z.ZodEnum<["initial", "dependency", "explicit-refresh", "subscriber-resume"]>;
}, "strip", z.ZodTypeAny, {
  error: {
    message: string;
    name: string;
    cliEvidence: {
      success: boolean;
      stdout: string;
      stderr: string;
      exitCode: number | null;
      payload: CliJsonValue;
      diagnostics: z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">[];
      contractError?: string | undefined;
    } | null;
  };
  state: "refresh-error";
  data: {
    stores: z.objectOutputType<{
      id: z.ZodOptional<z.ZodString>;
      root: z.ZodOptional<z.ZodString>;
      metadata_path: z.ZodOptional<z.ZodNullable<z.ZodString>>;
      openspec_root: z.ZodOptional<z.ZodObject<{
        present: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        healthy: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        present: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        healthy: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        present: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        healthy: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
      }, z.ZodTypeAny, "passthrough">>>;
      metadata: z.ZodOptional<z.ZodObject<{
        present: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        valid: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
        remote: z.ZodOptional<z.ZodNullable<z.ZodString>>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        present: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        valid: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
        remote: z.ZodOptional<z.ZodNullable<z.ZodString>>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        present: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        valid: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
        remote: z.ZodOptional<z.ZodNullable<z.ZodString>>;
      }, z.ZodTypeAny, "passthrough">>>;
      git: z.ZodOptional<z.ZodObject<{
        is_repository: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        has_commits: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        has_uncommitted_changes: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        has_remote: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        origin_url: z.ZodOptional<z.ZodNullable<z.ZodString>>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        is_repository: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        has_commits: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        has_uncommitted_changes: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        has_remote: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        origin_url: z.ZodOptional<z.ZodNullable<z.ZodString>>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        is_repository: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        has_commits: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        has_uncommitted_changes: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        has_remote: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        origin_url: z.ZodOptional<z.ZodNullable<z.ZodString>>;
      }, z.ZodTypeAny, "passthrough">>>;
      status: z.ZodOptional<z.ZodArray<z.ZodObject<{
        severity: z.ZodOptional<z.ZodString>;
        code: z.ZodOptional<z.ZodString>;
        message: z.ZodOptional<z.ZodString>;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodOptional<z.ZodString>;
        code: z.ZodOptional<z.ZodString>;
        message: z.ZodOptional<z.ZodString>;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodOptional<z.ZodString>;
        code: z.ZodOptional<z.ZodString>;
        message: z.ZodOptional<z.ZodString>;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">>;
    }, z.ZodTypeAny, "passthrough">[];
    available: boolean;
    error?: z.objectOutputType<{
      kind: z.ZodString;
      message: z.ZodString;
      cliVersion: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough"> | undefined;
    evidence?: unknown;
    cliVersion?: string | undefined;
  } & {
    [k: string]: unknown;
  };
  freshness: "stale-display-only";
  snapshotGeneration: number;
  identity: string;
  workGeneration: number;
  invalidationCause: "dependency" | "initial" | "explicit-refresh" | "subscriber-resume";
}, {
  error: {
    message: string;
    name: string;
    cliEvidence: {
      success: boolean;
      stdout: string;
      stderr: string;
      exitCode: number | null;
      payload: CliJsonValue;
      diagnostics: z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">[];
      contractError?: string | undefined;
    } | null;
  };
  state: "refresh-error";
  data: {
    stores: z.objectInputType<{
      id: z.ZodOptional<z.ZodString>;
      root: z.ZodOptional<z.ZodString>;
      metadata_path: z.ZodOptional<z.ZodNullable<z.ZodString>>;
      openspec_root: z.ZodOptional<z.ZodObject<{
        present: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        healthy: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        present: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        healthy: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        present: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        healthy: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
      }, z.ZodTypeAny, "passthrough">>>;
      metadata: z.ZodOptional<z.ZodObject<{
        present: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        valid: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
        remote: z.ZodOptional<z.ZodNullable<z.ZodString>>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        present: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        valid: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
        remote: z.ZodOptional<z.ZodNullable<z.ZodString>>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        present: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        valid: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
        remote: z.ZodOptional<z.ZodNullable<z.ZodString>>;
      }, z.ZodTypeAny, "passthrough">>>;
      git: z.ZodOptional<z.ZodObject<{
        is_repository: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        has_commits: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        has_uncommitted_changes: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        has_remote: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        origin_url: z.ZodOptional<z.ZodNullable<z.ZodString>>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        is_repository: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        has_commits: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        has_uncommitted_changes: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        has_remote: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        origin_url: z.ZodOptional<z.ZodNullable<z.ZodString>>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        is_repository: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        has_commits: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        has_uncommitted_changes: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        has_remote: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
        origin_url: z.ZodOptional<z.ZodNullable<z.ZodString>>;
      }, z.ZodTypeAny, "passthrough">>>;
      status: z.ZodOptional<z.ZodArray<z.ZodObject<{
        severity: z.ZodOptional<z.ZodString>;
        code: z.ZodOptional<z.ZodString>;
        message: z.ZodOptional<z.ZodString>;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodOptional<z.ZodString>;
        code: z.ZodOptional<z.ZodString>;
        message: z.ZodOptional<z.ZodString>;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodOptional<z.ZodString>;
        code: z.ZodOptional<z.ZodString>;
        message: z.ZodOptional<z.ZodString>;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">>;
    }, z.ZodTypeAny, "passthrough">[];
    available: boolean;
    error?: z.objectInputType<{
      kind: z.ZodString;
      message: z.ZodString;
      cliVersion: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough"> | undefined;
    evidence?: unknown;
    cliVersion?: string | undefined;
  } & {
    [k: string]: unknown;
  };
  freshness: "stale-display-only";
  snapshotGeneration: number;
  identity: string;
  workGeneration: number;
  invalidationCause: "dependency" | "initial" | "explicit-refresh" | "subscriber-resume";
}>]>;
/** Demand-driven readonly Store content kind carried by every Store-content request/response. */
declare const HostedStoreContentKindSchema: z.ZodEnum<["specs", "changes"]>;
type HostedStoreContentKind = z.infer<typeof HostedStoreContentKindSchema>;
/** Browser-safe Pull state for Store Specs-content CLI Projection Work (one composite identity). */
declare const HostedStoreContentSpecsProjectionStateSchema: z.ZodDiscriminatedUnion<"state", [z.ZodObject<{
  state: z.ZodLiteral<"loading">;
  data: z.ZodNull;
  freshness: z.ZodNull;
  snapshotGeneration: z.ZodNull;
  error: z.ZodNull;
  identity: z.ZodString;
  workGeneration: z.ZodNumber;
  invalidationCause: z.ZodEnum<["initial", "dependency", "explicit-refresh", "subscriber-resume"]>;
}, "strip", z.ZodTypeAny, {
  error: null;
  state: "loading";
  data: null;
  freshness: null;
  snapshotGeneration: null;
  identity: string;
  workGeneration: number;
  invalidationCause: "dependency" | "initial" | "explicit-refresh" | "subscriber-resume";
}, {
  error: null;
  state: "loading";
  data: null;
  freshness: null;
  snapshotGeneration: null;
  identity: string;
  workGeneration: number;
  invalidationCause: "dependency" | "initial" | "explicit-refresh" | "subscriber-resume";
}>, z.ZodObject<{
  state: z.ZodLiteral<"ready">;
  data: z.ZodType<z.objectOutputType<{
    available: z.ZodBoolean;
    specs: z.ZodArray<z.ZodObject<{
      id: z.ZodString;
      requirementCount: z.ZodNumber;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      id: z.ZodString;
      requirementCount: z.ZodNumber;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      id: z.ZodString;
      requirementCount: z.ZodNumber;
    }, z.ZodTypeAny, "passthrough">>, "many">;
    storeId: z.ZodString;
    evidence: z.ZodOptional<z.ZodNullable<z.ZodUnknown>>;
    error: z.ZodOptional<z.ZodObject<{
      kind: z.ZodString;
      message: z.ZodString;
      cliVersion: z.ZodOptional<z.ZodString>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      kind: z.ZodString;
      message: z.ZodString;
      cliVersion: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      kind: z.ZodString;
      message: z.ZodString;
      cliVersion: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">>>;
    cliVersion: z.ZodOptional<z.ZodString>;
  }, z.ZodTypeAny, "passthrough">, z.ZodTypeDef, z.objectInputType<{
    available: z.ZodBoolean;
    specs: z.ZodArray<z.ZodObject<{
      id: z.ZodString;
      requirementCount: z.ZodNumber;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      id: z.ZodString;
      requirementCount: z.ZodNumber;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      id: z.ZodString;
      requirementCount: z.ZodNumber;
    }, z.ZodTypeAny, "passthrough">>, "many">;
    storeId: z.ZodString;
    evidence: z.ZodOptional<z.ZodNullable<z.ZodUnknown>>;
    error: z.ZodOptional<z.ZodObject<{
      kind: z.ZodString;
      message: z.ZodString;
      cliVersion: z.ZodOptional<z.ZodString>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      kind: z.ZodString;
      message: z.ZodString;
      cliVersion: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      kind: z.ZodString;
      message: z.ZodString;
      cliVersion: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">>>;
    cliVersion: z.ZodOptional<z.ZodString>;
  }, z.ZodTypeAny, "passthrough">>;
  freshness: z.ZodLiteral<"current">;
  snapshotGeneration: z.ZodNumber;
  error: z.ZodNull;
  identity: z.ZodString;
  workGeneration: z.ZodNumber;
  invalidationCause: z.ZodEnum<["initial", "dependency", "explicit-refresh", "subscriber-resume"]>;
}, "strip", z.ZodTypeAny, {
  error: null;
  state: "ready";
  data: {
    storeId: string;
    specs: z.objectOutputType<{
      id: z.ZodString;
      requirementCount: z.ZodNumber;
    }, z.ZodTypeAny, "passthrough">[];
    available: boolean;
    error?: z.objectOutputType<{
      kind: z.ZodString;
      message: z.ZodString;
      cliVersion: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough"> | undefined;
    evidence?: unknown;
    cliVersion?: string | undefined;
  } & {
    [k: string]: unknown;
  };
  freshness: "current";
  snapshotGeneration: number;
  identity: string;
  workGeneration: number;
  invalidationCause: "dependency" | "initial" | "explicit-refresh" | "subscriber-resume";
}, {
  error: null;
  state: "ready";
  data: {
    storeId: string;
    specs: z.objectInputType<{
      id: z.ZodString;
      requirementCount: z.ZodNumber;
    }, z.ZodTypeAny, "passthrough">[];
    available: boolean;
    error?: z.objectInputType<{
      kind: z.ZodString;
      message: z.ZodString;
      cliVersion: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough"> | undefined;
    evidence?: unknown;
    cliVersion?: string | undefined;
  } & {
    [k: string]: unknown;
  };
  freshness: "current";
  snapshotGeneration: number;
  identity: string;
  workGeneration: number;
  invalidationCause: "dependency" | "initial" | "explicit-refresh" | "subscriber-resume";
}>, z.ZodObject<{
  state: z.ZodLiteral<"revalidating">;
  data: z.ZodType<z.objectOutputType<{
    available: z.ZodBoolean;
    specs: z.ZodArray<z.ZodObject<{
      id: z.ZodString;
      requirementCount: z.ZodNumber;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      id: z.ZodString;
      requirementCount: z.ZodNumber;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      id: z.ZodString;
      requirementCount: z.ZodNumber;
    }, z.ZodTypeAny, "passthrough">>, "many">;
    storeId: z.ZodString;
    evidence: z.ZodOptional<z.ZodNullable<z.ZodUnknown>>;
    error: z.ZodOptional<z.ZodObject<{
      kind: z.ZodString;
      message: z.ZodString;
      cliVersion: z.ZodOptional<z.ZodString>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      kind: z.ZodString;
      message: z.ZodString;
      cliVersion: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      kind: z.ZodString;
      message: z.ZodString;
      cliVersion: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">>>;
    cliVersion: z.ZodOptional<z.ZodString>;
  }, z.ZodTypeAny, "passthrough">, z.ZodTypeDef, z.objectInputType<{
    available: z.ZodBoolean;
    specs: z.ZodArray<z.ZodObject<{
      id: z.ZodString;
      requirementCount: z.ZodNumber;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      id: z.ZodString;
      requirementCount: z.ZodNumber;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      id: z.ZodString;
      requirementCount: z.ZodNumber;
    }, z.ZodTypeAny, "passthrough">>, "many">;
    storeId: z.ZodString;
    evidence: z.ZodOptional<z.ZodNullable<z.ZodUnknown>>;
    error: z.ZodOptional<z.ZodObject<{
      kind: z.ZodString;
      message: z.ZodString;
      cliVersion: z.ZodOptional<z.ZodString>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      kind: z.ZodString;
      message: z.ZodString;
      cliVersion: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      kind: z.ZodString;
      message: z.ZodString;
      cliVersion: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">>>;
    cliVersion: z.ZodOptional<z.ZodString>;
  }, z.ZodTypeAny, "passthrough">>;
  freshness: z.ZodLiteral<"stale-display-only">;
  snapshotGeneration: z.ZodNumber;
  error: z.ZodNull;
  identity: z.ZodString;
  workGeneration: z.ZodNumber;
  invalidationCause: z.ZodEnum<["initial", "dependency", "explicit-refresh", "subscriber-resume"]>;
}, "strip", z.ZodTypeAny, {
  error: null;
  state: "revalidating";
  data: {
    storeId: string;
    specs: z.objectOutputType<{
      id: z.ZodString;
      requirementCount: z.ZodNumber;
    }, z.ZodTypeAny, "passthrough">[];
    available: boolean;
    error?: z.objectOutputType<{
      kind: z.ZodString;
      message: z.ZodString;
      cliVersion: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough"> | undefined;
    evidence?: unknown;
    cliVersion?: string | undefined;
  } & {
    [k: string]: unknown;
  };
  freshness: "stale-display-only";
  snapshotGeneration: number;
  identity: string;
  workGeneration: number;
  invalidationCause: "dependency" | "initial" | "explicit-refresh" | "subscriber-resume";
}, {
  error: null;
  state: "revalidating";
  data: {
    storeId: string;
    specs: z.objectInputType<{
      id: z.ZodString;
      requirementCount: z.ZodNumber;
    }, z.ZodTypeAny, "passthrough">[];
    available: boolean;
    error?: z.objectInputType<{
      kind: z.ZodString;
      message: z.ZodString;
      cliVersion: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough"> | undefined;
    evidence?: unknown;
    cliVersion?: string | undefined;
  } & {
    [k: string]: unknown;
  };
  freshness: "stale-display-only";
  snapshotGeneration: number;
  identity: string;
  workGeneration: number;
  invalidationCause: "dependency" | "initial" | "explicit-refresh" | "subscriber-resume";
}>, z.ZodObject<{
  state: z.ZodLiteral<"error">;
  data: z.ZodNull;
  freshness: z.ZodNull;
  snapshotGeneration: z.ZodNull;
  error: z.ZodObject<{
    name: z.ZodString;
    message: z.ZodString;
    cliEvidence: z.ZodNullable<z.ZodObject<{
      success: z.ZodBoolean;
      stdout: z.ZodString;
      stderr: z.ZodString;
      exitCode: z.ZodNullable<z.ZodNumber>;
      payload: z.ZodNullable<z.ZodType<CliJsonValue, z.ZodTypeDef, CliJsonValue>>;
      diagnostics: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
      contractError: z.ZodOptional<z.ZodString>;
    }, "strip", z.ZodTypeAny, {
      success: boolean;
      stdout: string;
      stderr: string;
      exitCode: number | null;
      payload: CliJsonValue;
      diagnostics: z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">[];
      contractError?: string | undefined;
    }, {
      success: boolean;
      stdout: string;
      stderr: string;
      exitCode: number | null;
      payload: CliJsonValue;
      diagnostics: z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">[];
      contractError?: string | undefined;
    }>>;
  }, "strip", z.ZodTypeAny, {
    message: string;
    name: string;
    cliEvidence: {
      success: boolean;
      stdout: string;
      stderr: string;
      exitCode: number | null;
      payload: CliJsonValue;
      diagnostics: z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">[];
      contractError?: string | undefined;
    } | null;
  }, {
    message: string;
    name: string;
    cliEvidence: {
      success: boolean;
      stdout: string;
      stderr: string;
      exitCode: number | null;
      payload: CliJsonValue;
      diagnostics: z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">[];
      contractError?: string | undefined;
    } | null;
  }>;
  identity: z.ZodString;
  workGeneration: z.ZodNumber;
  invalidationCause: z.ZodEnum<["initial", "dependency", "explicit-refresh", "subscriber-resume"]>;
}, "strip", z.ZodTypeAny, {
  error: {
    message: string;
    name: string;
    cliEvidence: {
      success: boolean;
      stdout: string;
      stderr: string;
      exitCode: number | null;
      payload: CliJsonValue;
      diagnostics: z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">[];
      contractError?: string | undefined;
    } | null;
  };
  state: "error";
  data: null;
  freshness: null;
  snapshotGeneration: null;
  identity: string;
  workGeneration: number;
  invalidationCause: "dependency" | "initial" | "explicit-refresh" | "subscriber-resume";
}, {
  error: {
    message: string;
    name: string;
    cliEvidence: {
      success: boolean;
      stdout: string;
      stderr: string;
      exitCode: number | null;
      payload: CliJsonValue;
      diagnostics: z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">[];
      contractError?: string | undefined;
    } | null;
  };
  state: "error";
  data: null;
  freshness: null;
  snapshotGeneration: null;
  identity: string;
  workGeneration: number;
  invalidationCause: "dependency" | "initial" | "explicit-refresh" | "subscriber-resume";
}>, z.ZodObject<{
  state: z.ZodLiteral<"refresh-error">;
  data: z.ZodType<z.objectOutputType<{
    available: z.ZodBoolean;
    specs: z.ZodArray<z.ZodObject<{
      id: z.ZodString;
      requirementCount: z.ZodNumber;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      id: z.ZodString;
      requirementCount: z.ZodNumber;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      id: z.ZodString;
      requirementCount: z.ZodNumber;
    }, z.ZodTypeAny, "passthrough">>, "many">;
    storeId: z.ZodString;
    evidence: z.ZodOptional<z.ZodNullable<z.ZodUnknown>>;
    error: z.ZodOptional<z.ZodObject<{
      kind: z.ZodString;
      message: z.ZodString;
      cliVersion: z.ZodOptional<z.ZodString>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      kind: z.ZodString;
      message: z.ZodString;
      cliVersion: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      kind: z.ZodString;
      message: z.ZodString;
      cliVersion: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">>>;
    cliVersion: z.ZodOptional<z.ZodString>;
  }, z.ZodTypeAny, "passthrough">, z.ZodTypeDef, z.objectInputType<{
    available: z.ZodBoolean;
    specs: z.ZodArray<z.ZodObject<{
      id: z.ZodString;
      requirementCount: z.ZodNumber;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      id: z.ZodString;
      requirementCount: z.ZodNumber;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      id: z.ZodString;
      requirementCount: z.ZodNumber;
    }, z.ZodTypeAny, "passthrough">>, "many">;
    storeId: z.ZodString;
    evidence: z.ZodOptional<z.ZodNullable<z.ZodUnknown>>;
    error: z.ZodOptional<z.ZodObject<{
      kind: z.ZodString;
      message: z.ZodString;
      cliVersion: z.ZodOptional<z.ZodString>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      kind: z.ZodString;
      message: z.ZodString;
      cliVersion: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      kind: z.ZodString;
      message: z.ZodString;
      cliVersion: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">>>;
    cliVersion: z.ZodOptional<z.ZodString>;
  }, z.ZodTypeAny, "passthrough">>;
  freshness: z.ZodLiteral<"stale-display-only">;
  snapshotGeneration: z.ZodNumber;
  error: z.ZodObject<{
    name: z.ZodString;
    message: z.ZodString;
    cliEvidence: z.ZodNullable<z.ZodObject<{
      success: z.ZodBoolean;
      stdout: z.ZodString;
      stderr: z.ZodString;
      exitCode: z.ZodNullable<z.ZodNumber>;
      payload: z.ZodNullable<z.ZodType<CliJsonValue, z.ZodTypeDef, CliJsonValue>>;
      diagnostics: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
      contractError: z.ZodOptional<z.ZodString>;
    }, "strip", z.ZodTypeAny, {
      success: boolean;
      stdout: string;
      stderr: string;
      exitCode: number | null;
      payload: CliJsonValue;
      diagnostics: z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">[];
      contractError?: string | undefined;
    }, {
      success: boolean;
      stdout: string;
      stderr: string;
      exitCode: number | null;
      payload: CliJsonValue;
      diagnostics: z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">[];
      contractError?: string | undefined;
    }>>;
  }, "strip", z.ZodTypeAny, {
    message: string;
    name: string;
    cliEvidence: {
      success: boolean;
      stdout: string;
      stderr: string;
      exitCode: number | null;
      payload: CliJsonValue;
      diagnostics: z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">[];
      contractError?: string | undefined;
    } | null;
  }, {
    message: string;
    name: string;
    cliEvidence: {
      success: boolean;
      stdout: string;
      stderr: string;
      exitCode: number | null;
      payload: CliJsonValue;
      diagnostics: z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">[];
      contractError?: string | undefined;
    } | null;
  }>;
  identity: z.ZodString;
  workGeneration: z.ZodNumber;
  invalidationCause: z.ZodEnum<["initial", "dependency", "explicit-refresh", "subscriber-resume"]>;
}, "strip", z.ZodTypeAny, {
  error: {
    message: string;
    name: string;
    cliEvidence: {
      success: boolean;
      stdout: string;
      stderr: string;
      exitCode: number | null;
      payload: CliJsonValue;
      diagnostics: z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">[];
      contractError?: string | undefined;
    } | null;
  };
  state: "refresh-error";
  data: {
    storeId: string;
    specs: z.objectOutputType<{
      id: z.ZodString;
      requirementCount: z.ZodNumber;
    }, z.ZodTypeAny, "passthrough">[];
    available: boolean;
    error?: z.objectOutputType<{
      kind: z.ZodString;
      message: z.ZodString;
      cliVersion: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough"> | undefined;
    evidence?: unknown;
    cliVersion?: string | undefined;
  } & {
    [k: string]: unknown;
  };
  freshness: "stale-display-only";
  snapshotGeneration: number;
  identity: string;
  workGeneration: number;
  invalidationCause: "dependency" | "initial" | "explicit-refresh" | "subscriber-resume";
}, {
  error: {
    message: string;
    name: string;
    cliEvidence: {
      success: boolean;
      stdout: string;
      stderr: string;
      exitCode: number | null;
      payload: CliJsonValue;
      diagnostics: z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">[];
      contractError?: string | undefined;
    } | null;
  };
  state: "refresh-error";
  data: {
    storeId: string;
    specs: z.objectInputType<{
      id: z.ZodString;
      requirementCount: z.ZodNumber;
    }, z.ZodTypeAny, "passthrough">[];
    available: boolean;
    error?: z.objectInputType<{
      kind: z.ZodString;
      message: z.ZodString;
      cliVersion: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough"> | undefined;
    evidence?: unknown;
    cliVersion?: string | undefined;
  } & {
    [k: string]: unknown;
  };
  freshness: "stale-display-only";
  snapshotGeneration: number;
  identity: string;
  workGeneration: number;
  invalidationCause: "dependency" | "initial" | "explicit-refresh" | "subscriber-resume";
}>]>;
/** Browser-safe Pull state for Store active-Changes-content CLI Projection Work (one composite identity). */
declare const HostedStoreContentChangesProjectionStateSchema: z.ZodDiscriminatedUnion<"state", [z.ZodObject<{
  state: z.ZodLiteral<"loading">;
  data: z.ZodNull;
  freshness: z.ZodNull;
  snapshotGeneration: z.ZodNull;
  error: z.ZodNull;
  identity: z.ZodString;
  workGeneration: z.ZodNumber;
  invalidationCause: z.ZodEnum<["initial", "dependency", "explicit-refresh", "subscriber-resume"]>;
}, "strip", z.ZodTypeAny, {
  error: null;
  state: "loading";
  data: null;
  freshness: null;
  snapshotGeneration: null;
  identity: string;
  workGeneration: number;
  invalidationCause: "dependency" | "initial" | "explicit-refresh" | "subscriber-resume";
}, {
  error: null;
  state: "loading";
  data: null;
  freshness: null;
  snapshotGeneration: null;
  identity: string;
  workGeneration: number;
  invalidationCause: "dependency" | "initial" | "explicit-refresh" | "subscriber-resume";
}>, z.ZodObject<{
  state: z.ZodLiteral<"ready">;
  data: z.ZodType<z.objectOutputType<{
    available: z.ZodBoolean;
    changes: z.ZodArray<z.ZodObject<{
      name: z.ZodString;
      completedTasks: z.ZodNumber;
      totalTasks: z.ZodNumber;
      lastModified: z.ZodString;
      status: z.ZodEnum<["no-tasks", "complete", "in-progress"]>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      name: z.ZodString;
      completedTasks: z.ZodNumber;
      totalTasks: z.ZodNumber;
      lastModified: z.ZodString;
      status: z.ZodEnum<["no-tasks", "complete", "in-progress"]>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      name: z.ZodString;
      completedTasks: z.ZodNumber;
      totalTasks: z.ZodNumber;
      lastModified: z.ZodString;
      status: z.ZodEnum<["no-tasks", "complete", "in-progress"]>;
    }, z.ZodTypeAny, "passthrough">>, "many">;
    storeId: z.ZodString;
    evidence: z.ZodOptional<z.ZodNullable<z.ZodUnknown>>;
    error: z.ZodOptional<z.ZodObject<{
      kind: z.ZodString;
      message: z.ZodString;
      cliVersion: z.ZodOptional<z.ZodString>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      kind: z.ZodString;
      message: z.ZodString;
      cliVersion: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      kind: z.ZodString;
      message: z.ZodString;
      cliVersion: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">>>;
    cliVersion: z.ZodOptional<z.ZodString>;
  }, z.ZodTypeAny, "passthrough">, z.ZodTypeDef, z.objectInputType<{
    available: z.ZodBoolean;
    changes: z.ZodArray<z.ZodObject<{
      name: z.ZodString;
      completedTasks: z.ZodNumber;
      totalTasks: z.ZodNumber;
      lastModified: z.ZodString;
      status: z.ZodEnum<["no-tasks", "complete", "in-progress"]>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      name: z.ZodString;
      completedTasks: z.ZodNumber;
      totalTasks: z.ZodNumber;
      lastModified: z.ZodString;
      status: z.ZodEnum<["no-tasks", "complete", "in-progress"]>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      name: z.ZodString;
      completedTasks: z.ZodNumber;
      totalTasks: z.ZodNumber;
      lastModified: z.ZodString;
      status: z.ZodEnum<["no-tasks", "complete", "in-progress"]>;
    }, z.ZodTypeAny, "passthrough">>, "many">;
    storeId: z.ZodString;
    evidence: z.ZodOptional<z.ZodNullable<z.ZodUnknown>>;
    error: z.ZodOptional<z.ZodObject<{
      kind: z.ZodString;
      message: z.ZodString;
      cliVersion: z.ZodOptional<z.ZodString>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      kind: z.ZodString;
      message: z.ZodString;
      cliVersion: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      kind: z.ZodString;
      message: z.ZodString;
      cliVersion: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">>>;
    cliVersion: z.ZodOptional<z.ZodString>;
  }, z.ZodTypeAny, "passthrough">>;
  freshness: z.ZodLiteral<"current">;
  snapshotGeneration: z.ZodNumber;
  error: z.ZodNull;
  identity: z.ZodString;
  workGeneration: z.ZodNumber;
  invalidationCause: z.ZodEnum<["initial", "dependency", "explicit-refresh", "subscriber-resume"]>;
}, "strip", z.ZodTypeAny, {
  error: null;
  state: "ready";
  data: {
    storeId: string;
    changes: z.objectOutputType<{
      name: z.ZodString;
      completedTasks: z.ZodNumber;
      totalTasks: z.ZodNumber;
      lastModified: z.ZodString;
      status: z.ZodEnum<["no-tasks", "complete", "in-progress"]>;
    }, z.ZodTypeAny, "passthrough">[];
    available: boolean;
    error?: z.objectOutputType<{
      kind: z.ZodString;
      message: z.ZodString;
      cliVersion: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough"> | undefined;
    evidence?: unknown;
    cliVersion?: string | undefined;
  } & {
    [k: string]: unknown;
  };
  freshness: "current";
  snapshotGeneration: number;
  identity: string;
  workGeneration: number;
  invalidationCause: "dependency" | "initial" | "explicit-refresh" | "subscriber-resume";
}, {
  error: null;
  state: "ready";
  data: {
    storeId: string;
    changes: z.objectInputType<{
      name: z.ZodString;
      completedTasks: z.ZodNumber;
      totalTasks: z.ZodNumber;
      lastModified: z.ZodString;
      status: z.ZodEnum<["no-tasks", "complete", "in-progress"]>;
    }, z.ZodTypeAny, "passthrough">[];
    available: boolean;
    error?: z.objectInputType<{
      kind: z.ZodString;
      message: z.ZodString;
      cliVersion: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough"> | undefined;
    evidence?: unknown;
    cliVersion?: string | undefined;
  } & {
    [k: string]: unknown;
  };
  freshness: "current";
  snapshotGeneration: number;
  identity: string;
  workGeneration: number;
  invalidationCause: "dependency" | "initial" | "explicit-refresh" | "subscriber-resume";
}>, z.ZodObject<{
  state: z.ZodLiteral<"revalidating">;
  data: z.ZodType<z.objectOutputType<{
    available: z.ZodBoolean;
    changes: z.ZodArray<z.ZodObject<{
      name: z.ZodString;
      completedTasks: z.ZodNumber;
      totalTasks: z.ZodNumber;
      lastModified: z.ZodString;
      status: z.ZodEnum<["no-tasks", "complete", "in-progress"]>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      name: z.ZodString;
      completedTasks: z.ZodNumber;
      totalTasks: z.ZodNumber;
      lastModified: z.ZodString;
      status: z.ZodEnum<["no-tasks", "complete", "in-progress"]>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      name: z.ZodString;
      completedTasks: z.ZodNumber;
      totalTasks: z.ZodNumber;
      lastModified: z.ZodString;
      status: z.ZodEnum<["no-tasks", "complete", "in-progress"]>;
    }, z.ZodTypeAny, "passthrough">>, "many">;
    storeId: z.ZodString;
    evidence: z.ZodOptional<z.ZodNullable<z.ZodUnknown>>;
    error: z.ZodOptional<z.ZodObject<{
      kind: z.ZodString;
      message: z.ZodString;
      cliVersion: z.ZodOptional<z.ZodString>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      kind: z.ZodString;
      message: z.ZodString;
      cliVersion: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      kind: z.ZodString;
      message: z.ZodString;
      cliVersion: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">>>;
    cliVersion: z.ZodOptional<z.ZodString>;
  }, z.ZodTypeAny, "passthrough">, z.ZodTypeDef, z.objectInputType<{
    available: z.ZodBoolean;
    changes: z.ZodArray<z.ZodObject<{
      name: z.ZodString;
      completedTasks: z.ZodNumber;
      totalTasks: z.ZodNumber;
      lastModified: z.ZodString;
      status: z.ZodEnum<["no-tasks", "complete", "in-progress"]>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      name: z.ZodString;
      completedTasks: z.ZodNumber;
      totalTasks: z.ZodNumber;
      lastModified: z.ZodString;
      status: z.ZodEnum<["no-tasks", "complete", "in-progress"]>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      name: z.ZodString;
      completedTasks: z.ZodNumber;
      totalTasks: z.ZodNumber;
      lastModified: z.ZodString;
      status: z.ZodEnum<["no-tasks", "complete", "in-progress"]>;
    }, z.ZodTypeAny, "passthrough">>, "many">;
    storeId: z.ZodString;
    evidence: z.ZodOptional<z.ZodNullable<z.ZodUnknown>>;
    error: z.ZodOptional<z.ZodObject<{
      kind: z.ZodString;
      message: z.ZodString;
      cliVersion: z.ZodOptional<z.ZodString>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      kind: z.ZodString;
      message: z.ZodString;
      cliVersion: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      kind: z.ZodString;
      message: z.ZodString;
      cliVersion: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">>>;
    cliVersion: z.ZodOptional<z.ZodString>;
  }, z.ZodTypeAny, "passthrough">>;
  freshness: z.ZodLiteral<"stale-display-only">;
  snapshotGeneration: z.ZodNumber;
  error: z.ZodNull;
  identity: z.ZodString;
  workGeneration: z.ZodNumber;
  invalidationCause: z.ZodEnum<["initial", "dependency", "explicit-refresh", "subscriber-resume"]>;
}, "strip", z.ZodTypeAny, {
  error: null;
  state: "revalidating";
  data: {
    storeId: string;
    changes: z.objectOutputType<{
      name: z.ZodString;
      completedTasks: z.ZodNumber;
      totalTasks: z.ZodNumber;
      lastModified: z.ZodString;
      status: z.ZodEnum<["no-tasks", "complete", "in-progress"]>;
    }, z.ZodTypeAny, "passthrough">[];
    available: boolean;
    error?: z.objectOutputType<{
      kind: z.ZodString;
      message: z.ZodString;
      cliVersion: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough"> | undefined;
    evidence?: unknown;
    cliVersion?: string | undefined;
  } & {
    [k: string]: unknown;
  };
  freshness: "stale-display-only";
  snapshotGeneration: number;
  identity: string;
  workGeneration: number;
  invalidationCause: "dependency" | "initial" | "explicit-refresh" | "subscriber-resume";
}, {
  error: null;
  state: "revalidating";
  data: {
    storeId: string;
    changes: z.objectInputType<{
      name: z.ZodString;
      completedTasks: z.ZodNumber;
      totalTasks: z.ZodNumber;
      lastModified: z.ZodString;
      status: z.ZodEnum<["no-tasks", "complete", "in-progress"]>;
    }, z.ZodTypeAny, "passthrough">[];
    available: boolean;
    error?: z.objectInputType<{
      kind: z.ZodString;
      message: z.ZodString;
      cliVersion: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough"> | undefined;
    evidence?: unknown;
    cliVersion?: string | undefined;
  } & {
    [k: string]: unknown;
  };
  freshness: "stale-display-only";
  snapshotGeneration: number;
  identity: string;
  workGeneration: number;
  invalidationCause: "dependency" | "initial" | "explicit-refresh" | "subscriber-resume";
}>, z.ZodObject<{
  state: z.ZodLiteral<"error">;
  data: z.ZodNull;
  freshness: z.ZodNull;
  snapshotGeneration: z.ZodNull;
  error: z.ZodObject<{
    name: z.ZodString;
    message: z.ZodString;
    cliEvidence: z.ZodNullable<z.ZodObject<{
      success: z.ZodBoolean;
      stdout: z.ZodString;
      stderr: z.ZodString;
      exitCode: z.ZodNullable<z.ZodNumber>;
      payload: z.ZodNullable<z.ZodType<CliJsonValue, z.ZodTypeDef, CliJsonValue>>;
      diagnostics: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
      contractError: z.ZodOptional<z.ZodString>;
    }, "strip", z.ZodTypeAny, {
      success: boolean;
      stdout: string;
      stderr: string;
      exitCode: number | null;
      payload: CliJsonValue;
      diagnostics: z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">[];
      contractError?: string | undefined;
    }, {
      success: boolean;
      stdout: string;
      stderr: string;
      exitCode: number | null;
      payload: CliJsonValue;
      diagnostics: z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">[];
      contractError?: string | undefined;
    }>>;
  }, "strip", z.ZodTypeAny, {
    message: string;
    name: string;
    cliEvidence: {
      success: boolean;
      stdout: string;
      stderr: string;
      exitCode: number | null;
      payload: CliJsonValue;
      diagnostics: z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">[];
      contractError?: string | undefined;
    } | null;
  }, {
    message: string;
    name: string;
    cliEvidence: {
      success: boolean;
      stdout: string;
      stderr: string;
      exitCode: number | null;
      payload: CliJsonValue;
      diagnostics: z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">[];
      contractError?: string | undefined;
    } | null;
  }>;
  identity: z.ZodString;
  workGeneration: z.ZodNumber;
  invalidationCause: z.ZodEnum<["initial", "dependency", "explicit-refresh", "subscriber-resume"]>;
}, "strip", z.ZodTypeAny, {
  error: {
    message: string;
    name: string;
    cliEvidence: {
      success: boolean;
      stdout: string;
      stderr: string;
      exitCode: number | null;
      payload: CliJsonValue;
      diagnostics: z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">[];
      contractError?: string | undefined;
    } | null;
  };
  state: "error";
  data: null;
  freshness: null;
  snapshotGeneration: null;
  identity: string;
  workGeneration: number;
  invalidationCause: "dependency" | "initial" | "explicit-refresh" | "subscriber-resume";
}, {
  error: {
    message: string;
    name: string;
    cliEvidence: {
      success: boolean;
      stdout: string;
      stderr: string;
      exitCode: number | null;
      payload: CliJsonValue;
      diagnostics: z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">[];
      contractError?: string | undefined;
    } | null;
  };
  state: "error";
  data: null;
  freshness: null;
  snapshotGeneration: null;
  identity: string;
  workGeneration: number;
  invalidationCause: "dependency" | "initial" | "explicit-refresh" | "subscriber-resume";
}>, z.ZodObject<{
  state: z.ZodLiteral<"refresh-error">;
  data: z.ZodType<z.objectOutputType<{
    available: z.ZodBoolean;
    changes: z.ZodArray<z.ZodObject<{
      name: z.ZodString;
      completedTasks: z.ZodNumber;
      totalTasks: z.ZodNumber;
      lastModified: z.ZodString;
      status: z.ZodEnum<["no-tasks", "complete", "in-progress"]>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      name: z.ZodString;
      completedTasks: z.ZodNumber;
      totalTasks: z.ZodNumber;
      lastModified: z.ZodString;
      status: z.ZodEnum<["no-tasks", "complete", "in-progress"]>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      name: z.ZodString;
      completedTasks: z.ZodNumber;
      totalTasks: z.ZodNumber;
      lastModified: z.ZodString;
      status: z.ZodEnum<["no-tasks", "complete", "in-progress"]>;
    }, z.ZodTypeAny, "passthrough">>, "many">;
    storeId: z.ZodString;
    evidence: z.ZodOptional<z.ZodNullable<z.ZodUnknown>>;
    error: z.ZodOptional<z.ZodObject<{
      kind: z.ZodString;
      message: z.ZodString;
      cliVersion: z.ZodOptional<z.ZodString>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      kind: z.ZodString;
      message: z.ZodString;
      cliVersion: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      kind: z.ZodString;
      message: z.ZodString;
      cliVersion: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">>>;
    cliVersion: z.ZodOptional<z.ZodString>;
  }, z.ZodTypeAny, "passthrough">, z.ZodTypeDef, z.objectInputType<{
    available: z.ZodBoolean;
    changes: z.ZodArray<z.ZodObject<{
      name: z.ZodString;
      completedTasks: z.ZodNumber;
      totalTasks: z.ZodNumber;
      lastModified: z.ZodString;
      status: z.ZodEnum<["no-tasks", "complete", "in-progress"]>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      name: z.ZodString;
      completedTasks: z.ZodNumber;
      totalTasks: z.ZodNumber;
      lastModified: z.ZodString;
      status: z.ZodEnum<["no-tasks", "complete", "in-progress"]>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      name: z.ZodString;
      completedTasks: z.ZodNumber;
      totalTasks: z.ZodNumber;
      lastModified: z.ZodString;
      status: z.ZodEnum<["no-tasks", "complete", "in-progress"]>;
    }, z.ZodTypeAny, "passthrough">>, "many">;
    storeId: z.ZodString;
    evidence: z.ZodOptional<z.ZodNullable<z.ZodUnknown>>;
    error: z.ZodOptional<z.ZodObject<{
      kind: z.ZodString;
      message: z.ZodString;
      cliVersion: z.ZodOptional<z.ZodString>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      kind: z.ZodString;
      message: z.ZodString;
      cliVersion: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      kind: z.ZodString;
      message: z.ZodString;
      cliVersion: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">>>;
    cliVersion: z.ZodOptional<z.ZodString>;
  }, z.ZodTypeAny, "passthrough">>;
  freshness: z.ZodLiteral<"stale-display-only">;
  snapshotGeneration: z.ZodNumber;
  error: z.ZodObject<{
    name: z.ZodString;
    message: z.ZodString;
    cliEvidence: z.ZodNullable<z.ZodObject<{
      success: z.ZodBoolean;
      stdout: z.ZodString;
      stderr: z.ZodString;
      exitCode: z.ZodNullable<z.ZodNumber>;
      payload: z.ZodNullable<z.ZodType<CliJsonValue, z.ZodTypeDef, CliJsonValue>>;
      diagnostics: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
      contractError: z.ZodOptional<z.ZodString>;
    }, "strip", z.ZodTypeAny, {
      success: boolean;
      stdout: string;
      stderr: string;
      exitCode: number | null;
      payload: CliJsonValue;
      diagnostics: z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">[];
      contractError?: string | undefined;
    }, {
      success: boolean;
      stdout: string;
      stderr: string;
      exitCode: number | null;
      payload: CliJsonValue;
      diagnostics: z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">[];
      contractError?: string | undefined;
    }>>;
  }, "strip", z.ZodTypeAny, {
    message: string;
    name: string;
    cliEvidence: {
      success: boolean;
      stdout: string;
      stderr: string;
      exitCode: number | null;
      payload: CliJsonValue;
      diagnostics: z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">[];
      contractError?: string | undefined;
    } | null;
  }, {
    message: string;
    name: string;
    cliEvidence: {
      success: boolean;
      stdout: string;
      stderr: string;
      exitCode: number | null;
      payload: CliJsonValue;
      diagnostics: z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">[];
      contractError?: string | undefined;
    } | null;
  }>;
  identity: z.ZodString;
  workGeneration: z.ZodNumber;
  invalidationCause: z.ZodEnum<["initial", "dependency", "explicit-refresh", "subscriber-resume"]>;
}, "strip", z.ZodTypeAny, {
  error: {
    message: string;
    name: string;
    cliEvidence: {
      success: boolean;
      stdout: string;
      stderr: string;
      exitCode: number | null;
      payload: CliJsonValue;
      diagnostics: z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">[];
      contractError?: string | undefined;
    } | null;
  };
  state: "refresh-error";
  data: {
    storeId: string;
    changes: z.objectOutputType<{
      name: z.ZodString;
      completedTasks: z.ZodNumber;
      totalTasks: z.ZodNumber;
      lastModified: z.ZodString;
      status: z.ZodEnum<["no-tasks", "complete", "in-progress"]>;
    }, z.ZodTypeAny, "passthrough">[];
    available: boolean;
    error?: z.objectOutputType<{
      kind: z.ZodString;
      message: z.ZodString;
      cliVersion: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough"> | undefined;
    evidence?: unknown;
    cliVersion?: string | undefined;
  } & {
    [k: string]: unknown;
  };
  freshness: "stale-display-only";
  snapshotGeneration: number;
  identity: string;
  workGeneration: number;
  invalidationCause: "dependency" | "initial" | "explicit-refresh" | "subscriber-resume";
}, {
  error: {
    message: string;
    name: string;
    cliEvidence: {
      success: boolean;
      stdout: string;
      stderr: string;
      exitCode: number | null;
      payload: CliJsonValue;
      diagnostics: z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">[];
      contractError?: string | undefined;
    } | null;
  };
  state: "refresh-error";
  data: {
    storeId: string;
    changes: z.objectInputType<{
      name: z.ZodString;
      completedTasks: z.ZodNumber;
      totalTasks: z.ZodNumber;
      lastModified: z.ZodString;
      status: z.ZodEnum<["no-tasks", "complete", "in-progress"]>;
    }, z.ZodTypeAny, "passthrough">[];
    available: boolean;
    error?: z.objectInputType<{
      kind: z.ZodString;
      message: z.ZodString;
      cliVersion: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough"> | undefined;
    evidence?: unknown;
    cliVersion?: string | undefined;
  } & {
    [k: string]: unknown;
  };
  freshness: "stale-display-only";
  snapshotGeneration: number;
  identity: string;
  workGeneration: number;
  invalidationCause: "dependency" | "initial" | "explicit-refresh" | "subscriber-resume";
}>]>;
/** Browser-safe lifecycle-only Push shared by hosted CLI projections. */
declare const HostedCliProjectionNoticeSchema: z.ZodObject<{
  identity: z.ZodString;
  workGeneration: z.ZodNumber;
  snapshotGeneration: z.ZodNullable<z.ZodNumber>;
  state: z.ZodEnum<["loading", "ready", "revalidating", "error", "refresh-error"]>;
  invalidationCause: z.ZodEnum<["initial", "dependency", "explicit-refresh", "subscriber-resume"]>;
}, "strip", z.ZodTypeAny, {
  state: "error" | "loading" | "ready" | "revalidating" | "refresh-error";
  snapshotGeneration: number | null;
  identity: string;
  workGeneration: number;
  invalidationCause: "dependency" | "initial" | "explicit-refresh" | "subscriber-resume";
}, {
  state: "error" | "loading" | "ready" | "revalidating" | "refresh-error";
  snapshotGeneration: number | null;
  identity: string;
  workGeneration: number;
  invalidationCause: "dependency" | "initial" | "explicit-refresh" | "subscriber-resume";
}>;
/** Browser-safe complete Root Context fact retained by the hosted App projection. */
declare const HostedRootContextSchema: z.ZodObject<{
  launchProject: z.ZodObject<{
    path: z.ZodString;
    physicalPath: z.ZodOptional<z.ZodString>;
  }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
    path: z.ZodString;
    physicalPath: z.ZodOptional<z.ZodString>;
  }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
    path: z.ZodString;
    physicalPath: z.ZodOptional<z.ZodString>;
  }, z.ZodTypeAny, "passthrough">>;
  planningRoot: z.ZodNullable<z.ZodObject<{
    path: z.ZodString;
    source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
    store_id: z.ZodOptional<z.ZodString>;
  } & {
    healthy: z.ZodBoolean;
    status: z.ZodArray<z.ZodObject<{
      severity: z.ZodEnum<["error", "warning", "info"]>;
      code: z.ZodString;
      message: z.ZodString;
      target: z.ZodOptional<z.ZodString>;
      fix: z.ZodOptional<z.ZodString>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      severity: z.ZodEnum<["error", "warning", "info"]>;
      code: z.ZodString;
      message: z.ZodString;
      target: z.ZodOptional<z.ZodString>;
      fix: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      severity: z.ZodEnum<["error", "warning", "info"]>;
      code: z.ZodString;
      message: z.ZodString;
      target: z.ZodOptional<z.ZodString>;
      fix: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">>, "many">;
  }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
    path: z.ZodString;
    source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
    store_id: z.ZodOptional<z.ZodString>;
  } & {
    healthy: z.ZodBoolean;
    status: z.ZodArray<z.ZodObject<{
      severity: z.ZodEnum<["error", "warning", "info"]>;
      code: z.ZodString;
      message: z.ZodString;
      target: z.ZodOptional<z.ZodString>;
      fix: z.ZodOptional<z.ZodString>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      severity: z.ZodEnum<["error", "warning", "info"]>;
      code: z.ZodString;
      message: z.ZodString;
      target: z.ZodOptional<z.ZodString>;
      fix: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      severity: z.ZodEnum<["error", "warning", "info"]>;
      code: z.ZodString;
      message: z.ZodString;
      target: z.ZodOptional<z.ZodString>;
      fix: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">>, "many">;
  }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
    path: z.ZodString;
    source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
    store_id: z.ZodOptional<z.ZodString>;
  } & {
    healthy: z.ZodBoolean;
    status: z.ZodArray<z.ZodObject<{
      severity: z.ZodEnum<["error", "warning", "info"]>;
      code: z.ZodString;
      message: z.ZodString;
      target: z.ZodOptional<z.ZodString>;
      fix: z.ZodOptional<z.ZodString>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      severity: z.ZodEnum<["error", "warning", "info"]>;
      code: z.ZodString;
      message: z.ZodString;
      target: z.ZodOptional<z.ZodString>;
      fix: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      severity: z.ZodEnum<["error", "warning", "info"]>;
      code: z.ZodString;
      message: z.ZodString;
      target: z.ZodOptional<z.ZodString>;
      fix: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">>, "many">;
  }, z.ZodTypeAny, "passthrough">>>;
  storeId: z.ZodNullable<z.ZodString>;
  generation: z.ZodOptional<z.ZodString>;
  cli: z.ZodObject<{
    available: z.ZodBoolean;
    version: z.ZodOptional<z.ZodString>;
    error: z.ZodOptional<z.ZodString>;
    effectiveCommand: z.ZodOptional<z.ZodString>;
    tried: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
  }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
    available: z.ZodBoolean;
    version: z.ZodOptional<z.ZodString>;
    error: z.ZodOptional<z.ZodString>;
    effectiveCommand: z.ZodOptional<z.ZodString>;
    tried: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
  }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
    available: z.ZodBoolean;
    version: z.ZodOptional<z.ZodString>;
    error: z.ZodOptional<z.ZodString>;
    effectiveCommand: z.ZodOptional<z.ZodString>;
    tried: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
  }, z.ZodTypeAny, "passthrough">>;
  references: z.ZodArray<z.ZodObject<{
    store_id: z.ZodString;
    root: z.ZodOptional<z.ZodString>;
    status: z.ZodArray<z.ZodObject<{
      severity: z.ZodEnum<["error", "warning", "info"]>;
      code: z.ZodString;
      message: z.ZodString;
      target: z.ZodOptional<z.ZodString>;
      fix: z.ZodOptional<z.ZodString>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      severity: z.ZodEnum<["error", "warning", "info"]>;
      code: z.ZodString;
      message: z.ZodString;
      target: z.ZodOptional<z.ZodString>;
      fix: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      severity: z.ZodEnum<["error", "warning", "info"]>;
      code: z.ZodString;
      message: z.ZodString;
      target: z.ZodOptional<z.ZodString>;
      fix: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">>, "many">;
  }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
    store_id: z.ZodString;
    root: z.ZodOptional<z.ZodString>;
    status: z.ZodArray<z.ZodObject<{
      severity: z.ZodEnum<["error", "warning", "info"]>;
      code: z.ZodString;
      message: z.ZodString;
      target: z.ZodOptional<z.ZodString>;
      fix: z.ZodOptional<z.ZodString>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      severity: z.ZodEnum<["error", "warning", "info"]>;
      code: z.ZodString;
      message: z.ZodString;
      target: z.ZodOptional<z.ZodString>;
      fix: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      severity: z.ZodEnum<["error", "warning", "info"]>;
      code: z.ZodString;
      message: z.ZodString;
      target: z.ZodOptional<z.ZodString>;
      fix: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">>, "many">;
  }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
    store_id: z.ZodString;
    root: z.ZodOptional<z.ZodString>;
    status: z.ZodArray<z.ZodObject<{
      severity: z.ZodEnum<["error", "warning", "info"]>;
      code: z.ZodString;
      message: z.ZodString;
      target: z.ZodOptional<z.ZodString>;
      fix: z.ZodOptional<z.ZodString>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      severity: z.ZodEnum<["error", "warning", "info"]>;
      code: z.ZodString;
      message: z.ZodString;
      target: z.ZodOptional<z.ZodString>;
      fix: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      severity: z.ZodEnum<["error", "warning", "info"]>;
      code: z.ZodString;
      message: z.ZodString;
      target: z.ZodOptional<z.ZodString>;
      fix: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">>, "many">;
  }, z.ZodTypeAny, "passthrough">>, "many">;
  contextMembers: z.ZodArray<z.ZodObject<{
    role: z.ZodLiteral<"referenced_store">;
    id: z.ZodString;
    path: z.ZodOptional<z.ZodString>;
    remote: z.ZodOptional<z.ZodString>;
    fetch: z.ZodOptional<z.ZodString>;
    status: z.ZodArray<z.ZodObject<{
      severity: z.ZodEnum<["error", "warning", "info"]>;
      code: z.ZodString;
      message: z.ZodString;
      target: z.ZodOptional<z.ZodString>;
      fix: z.ZodOptional<z.ZodString>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      severity: z.ZodEnum<["error", "warning", "info"]>;
      code: z.ZodString;
      message: z.ZodString;
      target: z.ZodOptional<z.ZodString>;
      fix: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      severity: z.ZodEnum<["error", "warning", "info"]>;
      code: z.ZodString;
      message: z.ZodString;
      target: z.ZodOptional<z.ZodString>;
      fix: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">>, "many">;
  }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
    role: z.ZodLiteral<"referenced_store">;
    id: z.ZodString;
    path: z.ZodOptional<z.ZodString>;
    remote: z.ZodOptional<z.ZodString>;
    fetch: z.ZodOptional<z.ZodString>;
    status: z.ZodArray<z.ZodObject<{
      severity: z.ZodEnum<["error", "warning", "info"]>;
      code: z.ZodString;
      message: z.ZodString;
      target: z.ZodOptional<z.ZodString>;
      fix: z.ZodOptional<z.ZodString>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      severity: z.ZodEnum<["error", "warning", "info"]>;
      code: z.ZodString;
      message: z.ZodString;
      target: z.ZodOptional<z.ZodString>;
      fix: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      severity: z.ZodEnum<["error", "warning", "info"]>;
      code: z.ZodString;
      message: z.ZodString;
      target: z.ZodOptional<z.ZodString>;
      fix: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">>, "many">;
  }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
    role: z.ZodLiteral<"referenced_store">;
    id: z.ZodString;
    path: z.ZodOptional<z.ZodString>;
    remote: z.ZodOptional<z.ZodString>;
    fetch: z.ZodOptional<z.ZodString>;
    status: z.ZodArray<z.ZodObject<{
      severity: z.ZodEnum<["error", "warning", "info"]>;
      code: z.ZodString;
      message: z.ZodString;
      target: z.ZodOptional<z.ZodString>;
      fix: z.ZodOptional<z.ZodString>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      severity: z.ZodEnum<["error", "warning", "info"]>;
      code: z.ZodString;
      message: z.ZodString;
      target: z.ZodOptional<z.ZodString>;
      fix: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      severity: z.ZodEnum<["error", "warning", "info"]>;
      code: z.ZodString;
      message: z.ZodString;
      target: z.ZodOptional<z.ZodString>;
      fix: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">>, "many">;
  }, z.ZodTypeAny, "passthrough">>, "many">;
  dataScope: z.ZodObject<{
    path: z.ZodString;
    source: z.ZodEnum<["xdg-data-home", "local-app-data", "user-home-default"]>;
    environmentVariable: z.ZodNullable<z.ZodEnum<["XDG_DATA_HOME", "LOCALAPPDATA"]>>;
  }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
    path: z.ZodString;
    source: z.ZodEnum<["xdg-data-home", "local-app-data", "user-home-default"]>;
    environmentVariable: z.ZodNullable<z.ZodEnum<["XDG_DATA_HOME", "LOCALAPPDATA"]>>;
  }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
    path: z.ZodString;
    source: z.ZodEnum<["xdg-data-home", "local-app-data", "user-home-default"]>;
    environmentVariable: z.ZodNullable<z.ZodEnum<["XDG_DATA_HOME", "LOCALAPPDATA"]>>;
  }, z.ZodTypeAny, "passthrough">>;
  diagnostics: z.ZodObject<{
    root: z.ZodArray<z.ZodObject<{
      severity: z.ZodEnum<["error", "warning", "info"]>;
      code: z.ZodString;
      message: z.ZodString;
      target: z.ZodOptional<z.ZodString>;
      fix: z.ZodOptional<z.ZodString>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      severity: z.ZodEnum<["error", "warning", "info"]>;
      code: z.ZodString;
      message: z.ZodString;
      target: z.ZodOptional<z.ZodString>;
      fix: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      severity: z.ZodEnum<["error", "warning", "info"]>;
      code: z.ZodString;
      message: z.ZodString;
      target: z.ZodOptional<z.ZodString>;
      fix: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">>, "many">;
    doctor: z.ZodArray<z.ZodObject<{
      severity: z.ZodEnum<["error", "warning", "info"]>;
      code: z.ZodString;
      message: z.ZodString;
      target: z.ZodOptional<z.ZodString>;
      fix: z.ZodOptional<z.ZodString>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      severity: z.ZodEnum<["error", "warning", "info"]>;
      code: z.ZodString;
      message: z.ZodString;
      target: z.ZodOptional<z.ZodString>;
      fix: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      severity: z.ZodEnum<["error", "warning", "info"]>;
      code: z.ZodString;
      message: z.ZodString;
      target: z.ZodOptional<z.ZodString>;
      fix: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">>, "many">;
    context: z.ZodArray<z.ZodObject<{
      severity: z.ZodEnum<["error", "warning", "info"]>;
      code: z.ZodString;
      message: z.ZodString;
      target: z.ZodOptional<z.ZodString>;
      fix: z.ZodOptional<z.ZodString>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      severity: z.ZodEnum<["error", "warning", "info"]>;
      code: z.ZodString;
      message: z.ZodString;
      target: z.ZodOptional<z.ZodString>;
      fix: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      severity: z.ZodEnum<["error", "warning", "info"]>;
      code: z.ZodString;
      message: z.ZodString;
      target: z.ZodOptional<z.ZodString>;
      fix: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">>, "many">;
  }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
    root: z.ZodArray<z.ZodObject<{
      severity: z.ZodEnum<["error", "warning", "info"]>;
      code: z.ZodString;
      message: z.ZodString;
      target: z.ZodOptional<z.ZodString>;
      fix: z.ZodOptional<z.ZodString>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      severity: z.ZodEnum<["error", "warning", "info"]>;
      code: z.ZodString;
      message: z.ZodString;
      target: z.ZodOptional<z.ZodString>;
      fix: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      severity: z.ZodEnum<["error", "warning", "info"]>;
      code: z.ZodString;
      message: z.ZodString;
      target: z.ZodOptional<z.ZodString>;
      fix: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">>, "many">;
    doctor: z.ZodArray<z.ZodObject<{
      severity: z.ZodEnum<["error", "warning", "info"]>;
      code: z.ZodString;
      message: z.ZodString;
      target: z.ZodOptional<z.ZodString>;
      fix: z.ZodOptional<z.ZodString>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      severity: z.ZodEnum<["error", "warning", "info"]>;
      code: z.ZodString;
      message: z.ZodString;
      target: z.ZodOptional<z.ZodString>;
      fix: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      severity: z.ZodEnum<["error", "warning", "info"]>;
      code: z.ZodString;
      message: z.ZodString;
      target: z.ZodOptional<z.ZodString>;
      fix: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">>, "many">;
    context: z.ZodArray<z.ZodObject<{
      severity: z.ZodEnum<["error", "warning", "info"]>;
      code: z.ZodString;
      message: z.ZodString;
      target: z.ZodOptional<z.ZodString>;
      fix: z.ZodOptional<z.ZodString>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      severity: z.ZodEnum<["error", "warning", "info"]>;
      code: z.ZodString;
      message: z.ZodString;
      target: z.ZodOptional<z.ZodString>;
      fix: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      severity: z.ZodEnum<["error", "warning", "info"]>;
      code: z.ZodString;
      message: z.ZodString;
      target: z.ZodOptional<z.ZodString>;
      fix: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">>, "many">;
  }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
    root: z.ZodArray<z.ZodObject<{
      severity: z.ZodEnum<["error", "warning", "info"]>;
      code: z.ZodString;
      message: z.ZodString;
      target: z.ZodOptional<z.ZodString>;
      fix: z.ZodOptional<z.ZodString>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      severity: z.ZodEnum<["error", "warning", "info"]>;
      code: z.ZodString;
      message: z.ZodString;
      target: z.ZodOptional<z.ZodString>;
      fix: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      severity: z.ZodEnum<["error", "warning", "info"]>;
      code: z.ZodString;
      message: z.ZodString;
      target: z.ZodOptional<z.ZodString>;
      fix: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">>, "many">;
    doctor: z.ZodArray<z.ZodObject<{
      severity: z.ZodEnum<["error", "warning", "info"]>;
      code: z.ZodString;
      message: z.ZodString;
      target: z.ZodOptional<z.ZodString>;
      fix: z.ZodOptional<z.ZodString>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      severity: z.ZodEnum<["error", "warning", "info"]>;
      code: z.ZodString;
      message: z.ZodString;
      target: z.ZodOptional<z.ZodString>;
      fix: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      severity: z.ZodEnum<["error", "warning", "info"]>;
      code: z.ZodString;
      message: z.ZodString;
      target: z.ZodOptional<z.ZodString>;
      fix: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">>, "many">;
    context: z.ZodArray<z.ZodObject<{
      severity: z.ZodEnum<["error", "warning", "info"]>;
      code: z.ZodString;
      message: z.ZodString;
      target: z.ZodOptional<z.ZodString>;
      fix: z.ZodOptional<z.ZodString>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      severity: z.ZodEnum<["error", "warning", "info"]>;
      code: z.ZodString;
      message: z.ZodString;
      target: z.ZodOptional<z.ZodString>;
      fix: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      severity: z.ZodEnum<["error", "warning", "info"]>;
      code: z.ZodString;
      message: z.ZodString;
      target: z.ZodOptional<z.ZodString>;
      fix: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">>, "many">;
  }, z.ZodTypeAny, "passthrough">>;
  evidence: z.ZodObject<{
    doctor: z.ZodNullable<z.ZodObject<{
      success: z.ZodBoolean;
      stdout: z.ZodString;
      stderr: z.ZodString;
      exitCode: z.ZodNullable<z.ZodNumber>;
      diagnostics: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
      contractError: z.ZodOptional<z.ZodString>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      success: z.ZodBoolean;
      stdout: z.ZodString;
      stderr: z.ZodString;
      exitCode: z.ZodNullable<z.ZodNumber>;
      diagnostics: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
      contractError: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      success: z.ZodBoolean;
      stdout: z.ZodString;
      stderr: z.ZodString;
      exitCode: z.ZodNullable<z.ZodNumber>;
      diagnostics: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
      contractError: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">>>;
    context: z.ZodNullable<z.ZodObject<{
      success: z.ZodBoolean;
      stdout: z.ZodString;
      stderr: z.ZodString;
      exitCode: z.ZodNullable<z.ZodNumber>;
      diagnostics: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
      contractError: z.ZodOptional<z.ZodString>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      success: z.ZodBoolean;
      stdout: z.ZodString;
      stderr: z.ZodString;
      exitCode: z.ZodNullable<z.ZodNumber>;
      diagnostics: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
      contractError: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      success: z.ZodBoolean;
      stdout: z.ZodString;
      stderr: z.ZodString;
      exitCode: z.ZodNullable<z.ZodNumber>;
      diagnostics: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
      contractError: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">>>;
  }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
    doctor: z.ZodNullable<z.ZodObject<{
      success: z.ZodBoolean;
      stdout: z.ZodString;
      stderr: z.ZodString;
      exitCode: z.ZodNullable<z.ZodNumber>;
      diagnostics: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
      contractError: z.ZodOptional<z.ZodString>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      success: z.ZodBoolean;
      stdout: z.ZodString;
      stderr: z.ZodString;
      exitCode: z.ZodNullable<z.ZodNumber>;
      diagnostics: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
      contractError: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      success: z.ZodBoolean;
      stdout: z.ZodString;
      stderr: z.ZodString;
      exitCode: z.ZodNullable<z.ZodNumber>;
      diagnostics: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
      contractError: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">>>;
    context: z.ZodNullable<z.ZodObject<{
      success: z.ZodBoolean;
      stdout: z.ZodString;
      stderr: z.ZodString;
      exitCode: z.ZodNullable<z.ZodNumber>;
      diagnostics: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
      contractError: z.ZodOptional<z.ZodString>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      success: z.ZodBoolean;
      stdout: z.ZodString;
      stderr: z.ZodString;
      exitCode: z.ZodNullable<z.ZodNumber>;
      diagnostics: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
      contractError: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      success: z.ZodBoolean;
      stdout: z.ZodString;
      stderr: z.ZodString;
      exitCode: z.ZodNullable<z.ZodNumber>;
      diagnostics: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
      contractError: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">>>;
  }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
    doctor: z.ZodNullable<z.ZodObject<{
      success: z.ZodBoolean;
      stdout: z.ZodString;
      stderr: z.ZodString;
      exitCode: z.ZodNullable<z.ZodNumber>;
      diagnostics: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
      contractError: z.ZodOptional<z.ZodString>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      success: z.ZodBoolean;
      stdout: z.ZodString;
      stderr: z.ZodString;
      exitCode: z.ZodNullable<z.ZodNumber>;
      diagnostics: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
      contractError: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      success: z.ZodBoolean;
      stdout: z.ZodString;
      stderr: z.ZodString;
      exitCode: z.ZodNullable<z.ZodNumber>;
      diagnostics: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
      contractError: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">>>;
    context: z.ZodNullable<z.ZodObject<{
      success: z.ZodBoolean;
      stdout: z.ZodString;
      stderr: z.ZodString;
      exitCode: z.ZodNullable<z.ZodNumber>;
      diagnostics: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
      contractError: z.ZodOptional<z.ZodString>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      success: z.ZodBoolean;
      stdout: z.ZodString;
      stderr: z.ZodString;
      exitCode: z.ZodNullable<z.ZodNumber>;
      diagnostics: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
      contractError: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      success: z.ZodBoolean;
      stdout: z.ZodString;
      stderr: z.ZodString;
      exitCode: z.ZodNullable<z.ZodNumber>;
      diagnostics: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
      contractError: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">>>;
  }, z.ZodTypeAny, "passthrough">>;
  observedAt: z.ZodNumber;
}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
  launchProject: z.ZodObject<{
    path: z.ZodString;
    physicalPath: z.ZodOptional<z.ZodString>;
  }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
    path: z.ZodString;
    physicalPath: z.ZodOptional<z.ZodString>;
  }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
    path: z.ZodString;
    physicalPath: z.ZodOptional<z.ZodString>;
  }, z.ZodTypeAny, "passthrough">>;
  planningRoot: z.ZodNullable<z.ZodObject<{
    path: z.ZodString;
    source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
    store_id: z.ZodOptional<z.ZodString>;
  } & {
    healthy: z.ZodBoolean;
    status: z.ZodArray<z.ZodObject<{
      severity: z.ZodEnum<["error", "warning", "info"]>;
      code: z.ZodString;
      message: z.ZodString;
      target: z.ZodOptional<z.ZodString>;
      fix: z.ZodOptional<z.ZodString>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      severity: z.ZodEnum<["error", "warning", "info"]>;
      code: z.ZodString;
      message: z.ZodString;
      target: z.ZodOptional<z.ZodString>;
      fix: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      severity: z.ZodEnum<["error", "warning", "info"]>;
      code: z.ZodString;
      message: z.ZodString;
      target: z.ZodOptional<z.ZodString>;
      fix: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">>, "many">;
  }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
    path: z.ZodString;
    source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
    store_id: z.ZodOptional<z.ZodString>;
  } & {
    healthy: z.ZodBoolean;
    status: z.ZodArray<z.ZodObject<{
      severity: z.ZodEnum<["error", "warning", "info"]>;
      code: z.ZodString;
      message: z.ZodString;
      target: z.ZodOptional<z.ZodString>;
      fix: z.ZodOptional<z.ZodString>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      severity: z.ZodEnum<["error", "warning", "info"]>;
      code: z.ZodString;
      message: z.ZodString;
      target: z.ZodOptional<z.ZodString>;
      fix: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      severity: z.ZodEnum<["error", "warning", "info"]>;
      code: z.ZodString;
      message: z.ZodString;
      target: z.ZodOptional<z.ZodString>;
      fix: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">>, "many">;
  }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
    path: z.ZodString;
    source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
    store_id: z.ZodOptional<z.ZodString>;
  } & {
    healthy: z.ZodBoolean;
    status: z.ZodArray<z.ZodObject<{
      severity: z.ZodEnum<["error", "warning", "info"]>;
      code: z.ZodString;
      message: z.ZodString;
      target: z.ZodOptional<z.ZodString>;
      fix: z.ZodOptional<z.ZodString>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      severity: z.ZodEnum<["error", "warning", "info"]>;
      code: z.ZodString;
      message: z.ZodString;
      target: z.ZodOptional<z.ZodString>;
      fix: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      severity: z.ZodEnum<["error", "warning", "info"]>;
      code: z.ZodString;
      message: z.ZodString;
      target: z.ZodOptional<z.ZodString>;
      fix: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">>, "many">;
  }, z.ZodTypeAny, "passthrough">>>;
  storeId: z.ZodNullable<z.ZodString>;
  generation: z.ZodOptional<z.ZodString>;
  cli: z.ZodObject<{
    available: z.ZodBoolean;
    version: z.ZodOptional<z.ZodString>;
    error: z.ZodOptional<z.ZodString>;
    effectiveCommand: z.ZodOptional<z.ZodString>;
    tried: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
  }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
    available: z.ZodBoolean;
    version: z.ZodOptional<z.ZodString>;
    error: z.ZodOptional<z.ZodString>;
    effectiveCommand: z.ZodOptional<z.ZodString>;
    tried: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
  }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
    available: z.ZodBoolean;
    version: z.ZodOptional<z.ZodString>;
    error: z.ZodOptional<z.ZodString>;
    effectiveCommand: z.ZodOptional<z.ZodString>;
    tried: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
  }, z.ZodTypeAny, "passthrough">>;
  references: z.ZodArray<z.ZodObject<{
    store_id: z.ZodString;
    root: z.ZodOptional<z.ZodString>;
    status: z.ZodArray<z.ZodObject<{
      severity: z.ZodEnum<["error", "warning", "info"]>;
      code: z.ZodString;
      message: z.ZodString;
      target: z.ZodOptional<z.ZodString>;
      fix: z.ZodOptional<z.ZodString>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      severity: z.ZodEnum<["error", "warning", "info"]>;
      code: z.ZodString;
      message: z.ZodString;
      target: z.ZodOptional<z.ZodString>;
      fix: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      severity: z.ZodEnum<["error", "warning", "info"]>;
      code: z.ZodString;
      message: z.ZodString;
      target: z.ZodOptional<z.ZodString>;
      fix: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">>, "many">;
  }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
    store_id: z.ZodString;
    root: z.ZodOptional<z.ZodString>;
    status: z.ZodArray<z.ZodObject<{
      severity: z.ZodEnum<["error", "warning", "info"]>;
      code: z.ZodString;
      message: z.ZodString;
      target: z.ZodOptional<z.ZodString>;
      fix: z.ZodOptional<z.ZodString>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      severity: z.ZodEnum<["error", "warning", "info"]>;
      code: z.ZodString;
      message: z.ZodString;
      target: z.ZodOptional<z.ZodString>;
      fix: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      severity: z.ZodEnum<["error", "warning", "info"]>;
      code: z.ZodString;
      message: z.ZodString;
      target: z.ZodOptional<z.ZodString>;
      fix: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">>, "many">;
  }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
    store_id: z.ZodString;
    root: z.ZodOptional<z.ZodString>;
    status: z.ZodArray<z.ZodObject<{
      severity: z.ZodEnum<["error", "warning", "info"]>;
      code: z.ZodString;
      message: z.ZodString;
      target: z.ZodOptional<z.ZodString>;
      fix: z.ZodOptional<z.ZodString>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      severity: z.ZodEnum<["error", "warning", "info"]>;
      code: z.ZodString;
      message: z.ZodString;
      target: z.ZodOptional<z.ZodString>;
      fix: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      severity: z.ZodEnum<["error", "warning", "info"]>;
      code: z.ZodString;
      message: z.ZodString;
      target: z.ZodOptional<z.ZodString>;
      fix: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">>, "many">;
  }, z.ZodTypeAny, "passthrough">>, "many">;
  contextMembers: z.ZodArray<z.ZodObject<{
    role: z.ZodLiteral<"referenced_store">;
    id: z.ZodString;
    path: z.ZodOptional<z.ZodString>;
    remote: z.ZodOptional<z.ZodString>;
    fetch: z.ZodOptional<z.ZodString>;
    status: z.ZodArray<z.ZodObject<{
      severity: z.ZodEnum<["error", "warning", "info"]>;
      code: z.ZodString;
      message: z.ZodString;
      target: z.ZodOptional<z.ZodString>;
      fix: z.ZodOptional<z.ZodString>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      severity: z.ZodEnum<["error", "warning", "info"]>;
      code: z.ZodString;
      message: z.ZodString;
      target: z.ZodOptional<z.ZodString>;
      fix: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      severity: z.ZodEnum<["error", "warning", "info"]>;
      code: z.ZodString;
      message: z.ZodString;
      target: z.ZodOptional<z.ZodString>;
      fix: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">>, "many">;
  }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
    role: z.ZodLiteral<"referenced_store">;
    id: z.ZodString;
    path: z.ZodOptional<z.ZodString>;
    remote: z.ZodOptional<z.ZodString>;
    fetch: z.ZodOptional<z.ZodString>;
    status: z.ZodArray<z.ZodObject<{
      severity: z.ZodEnum<["error", "warning", "info"]>;
      code: z.ZodString;
      message: z.ZodString;
      target: z.ZodOptional<z.ZodString>;
      fix: z.ZodOptional<z.ZodString>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      severity: z.ZodEnum<["error", "warning", "info"]>;
      code: z.ZodString;
      message: z.ZodString;
      target: z.ZodOptional<z.ZodString>;
      fix: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      severity: z.ZodEnum<["error", "warning", "info"]>;
      code: z.ZodString;
      message: z.ZodString;
      target: z.ZodOptional<z.ZodString>;
      fix: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">>, "many">;
  }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
    role: z.ZodLiteral<"referenced_store">;
    id: z.ZodString;
    path: z.ZodOptional<z.ZodString>;
    remote: z.ZodOptional<z.ZodString>;
    fetch: z.ZodOptional<z.ZodString>;
    status: z.ZodArray<z.ZodObject<{
      severity: z.ZodEnum<["error", "warning", "info"]>;
      code: z.ZodString;
      message: z.ZodString;
      target: z.ZodOptional<z.ZodString>;
      fix: z.ZodOptional<z.ZodString>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      severity: z.ZodEnum<["error", "warning", "info"]>;
      code: z.ZodString;
      message: z.ZodString;
      target: z.ZodOptional<z.ZodString>;
      fix: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      severity: z.ZodEnum<["error", "warning", "info"]>;
      code: z.ZodString;
      message: z.ZodString;
      target: z.ZodOptional<z.ZodString>;
      fix: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">>, "many">;
  }, z.ZodTypeAny, "passthrough">>, "many">;
  dataScope: z.ZodObject<{
    path: z.ZodString;
    source: z.ZodEnum<["xdg-data-home", "local-app-data", "user-home-default"]>;
    environmentVariable: z.ZodNullable<z.ZodEnum<["XDG_DATA_HOME", "LOCALAPPDATA"]>>;
  }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
    path: z.ZodString;
    source: z.ZodEnum<["xdg-data-home", "local-app-data", "user-home-default"]>;
    environmentVariable: z.ZodNullable<z.ZodEnum<["XDG_DATA_HOME", "LOCALAPPDATA"]>>;
  }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
    path: z.ZodString;
    source: z.ZodEnum<["xdg-data-home", "local-app-data", "user-home-default"]>;
    environmentVariable: z.ZodNullable<z.ZodEnum<["XDG_DATA_HOME", "LOCALAPPDATA"]>>;
  }, z.ZodTypeAny, "passthrough">>;
  diagnostics: z.ZodObject<{
    root: z.ZodArray<z.ZodObject<{
      severity: z.ZodEnum<["error", "warning", "info"]>;
      code: z.ZodString;
      message: z.ZodString;
      target: z.ZodOptional<z.ZodString>;
      fix: z.ZodOptional<z.ZodString>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      severity: z.ZodEnum<["error", "warning", "info"]>;
      code: z.ZodString;
      message: z.ZodString;
      target: z.ZodOptional<z.ZodString>;
      fix: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      severity: z.ZodEnum<["error", "warning", "info"]>;
      code: z.ZodString;
      message: z.ZodString;
      target: z.ZodOptional<z.ZodString>;
      fix: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">>, "many">;
    doctor: z.ZodArray<z.ZodObject<{
      severity: z.ZodEnum<["error", "warning", "info"]>;
      code: z.ZodString;
      message: z.ZodString;
      target: z.ZodOptional<z.ZodString>;
      fix: z.ZodOptional<z.ZodString>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      severity: z.ZodEnum<["error", "warning", "info"]>;
      code: z.ZodString;
      message: z.ZodString;
      target: z.ZodOptional<z.ZodString>;
      fix: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      severity: z.ZodEnum<["error", "warning", "info"]>;
      code: z.ZodString;
      message: z.ZodString;
      target: z.ZodOptional<z.ZodString>;
      fix: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">>, "many">;
    context: z.ZodArray<z.ZodObject<{
      severity: z.ZodEnum<["error", "warning", "info"]>;
      code: z.ZodString;
      message: z.ZodString;
      target: z.ZodOptional<z.ZodString>;
      fix: z.ZodOptional<z.ZodString>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      severity: z.ZodEnum<["error", "warning", "info"]>;
      code: z.ZodString;
      message: z.ZodString;
      target: z.ZodOptional<z.ZodString>;
      fix: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      severity: z.ZodEnum<["error", "warning", "info"]>;
      code: z.ZodString;
      message: z.ZodString;
      target: z.ZodOptional<z.ZodString>;
      fix: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">>, "many">;
  }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
    root: z.ZodArray<z.ZodObject<{
      severity: z.ZodEnum<["error", "warning", "info"]>;
      code: z.ZodString;
      message: z.ZodString;
      target: z.ZodOptional<z.ZodString>;
      fix: z.ZodOptional<z.ZodString>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      severity: z.ZodEnum<["error", "warning", "info"]>;
      code: z.ZodString;
      message: z.ZodString;
      target: z.ZodOptional<z.ZodString>;
      fix: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      severity: z.ZodEnum<["error", "warning", "info"]>;
      code: z.ZodString;
      message: z.ZodString;
      target: z.ZodOptional<z.ZodString>;
      fix: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">>, "many">;
    doctor: z.ZodArray<z.ZodObject<{
      severity: z.ZodEnum<["error", "warning", "info"]>;
      code: z.ZodString;
      message: z.ZodString;
      target: z.ZodOptional<z.ZodString>;
      fix: z.ZodOptional<z.ZodString>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      severity: z.ZodEnum<["error", "warning", "info"]>;
      code: z.ZodString;
      message: z.ZodString;
      target: z.ZodOptional<z.ZodString>;
      fix: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      severity: z.ZodEnum<["error", "warning", "info"]>;
      code: z.ZodString;
      message: z.ZodString;
      target: z.ZodOptional<z.ZodString>;
      fix: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">>, "many">;
    context: z.ZodArray<z.ZodObject<{
      severity: z.ZodEnum<["error", "warning", "info"]>;
      code: z.ZodString;
      message: z.ZodString;
      target: z.ZodOptional<z.ZodString>;
      fix: z.ZodOptional<z.ZodString>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      severity: z.ZodEnum<["error", "warning", "info"]>;
      code: z.ZodString;
      message: z.ZodString;
      target: z.ZodOptional<z.ZodString>;
      fix: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      severity: z.ZodEnum<["error", "warning", "info"]>;
      code: z.ZodString;
      message: z.ZodString;
      target: z.ZodOptional<z.ZodString>;
      fix: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">>, "many">;
  }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
    root: z.ZodArray<z.ZodObject<{
      severity: z.ZodEnum<["error", "warning", "info"]>;
      code: z.ZodString;
      message: z.ZodString;
      target: z.ZodOptional<z.ZodString>;
      fix: z.ZodOptional<z.ZodString>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      severity: z.ZodEnum<["error", "warning", "info"]>;
      code: z.ZodString;
      message: z.ZodString;
      target: z.ZodOptional<z.ZodString>;
      fix: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      severity: z.ZodEnum<["error", "warning", "info"]>;
      code: z.ZodString;
      message: z.ZodString;
      target: z.ZodOptional<z.ZodString>;
      fix: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">>, "many">;
    doctor: z.ZodArray<z.ZodObject<{
      severity: z.ZodEnum<["error", "warning", "info"]>;
      code: z.ZodString;
      message: z.ZodString;
      target: z.ZodOptional<z.ZodString>;
      fix: z.ZodOptional<z.ZodString>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      severity: z.ZodEnum<["error", "warning", "info"]>;
      code: z.ZodString;
      message: z.ZodString;
      target: z.ZodOptional<z.ZodString>;
      fix: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      severity: z.ZodEnum<["error", "warning", "info"]>;
      code: z.ZodString;
      message: z.ZodString;
      target: z.ZodOptional<z.ZodString>;
      fix: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">>, "many">;
    context: z.ZodArray<z.ZodObject<{
      severity: z.ZodEnum<["error", "warning", "info"]>;
      code: z.ZodString;
      message: z.ZodString;
      target: z.ZodOptional<z.ZodString>;
      fix: z.ZodOptional<z.ZodString>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      severity: z.ZodEnum<["error", "warning", "info"]>;
      code: z.ZodString;
      message: z.ZodString;
      target: z.ZodOptional<z.ZodString>;
      fix: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      severity: z.ZodEnum<["error", "warning", "info"]>;
      code: z.ZodString;
      message: z.ZodString;
      target: z.ZodOptional<z.ZodString>;
      fix: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">>, "many">;
  }, z.ZodTypeAny, "passthrough">>;
  evidence: z.ZodObject<{
    doctor: z.ZodNullable<z.ZodObject<{
      success: z.ZodBoolean;
      stdout: z.ZodString;
      stderr: z.ZodString;
      exitCode: z.ZodNullable<z.ZodNumber>;
      diagnostics: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
      contractError: z.ZodOptional<z.ZodString>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      success: z.ZodBoolean;
      stdout: z.ZodString;
      stderr: z.ZodString;
      exitCode: z.ZodNullable<z.ZodNumber>;
      diagnostics: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
      contractError: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      success: z.ZodBoolean;
      stdout: z.ZodString;
      stderr: z.ZodString;
      exitCode: z.ZodNullable<z.ZodNumber>;
      diagnostics: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
      contractError: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">>>;
    context: z.ZodNullable<z.ZodObject<{
      success: z.ZodBoolean;
      stdout: z.ZodString;
      stderr: z.ZodString;
      exitCode: z.ZodNullable<z.ZodNumber>;
      diagnostics: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
      contractError: z.ZodOptional<z.ZodString>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      success: z.ZodBoolean;
      stdout: z.ZodString;
      stderr: z.ZodString;
      exitCode: z.ZodNullable<z.ZodNumber>;
      diagnostics: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
      contractError: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      success: z.ZodBoolean;
      stdout: z.ZodString;
      stderr: z.ZodString;
      exitCode: z.ZodNullable<z.ZodNumber>;
      diagnostics: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
      contractError: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">>>;
  }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
    doctor: z.ZodNullable<z.ZodObject<{
      success: z.ZodBoolean;
      stdout: z.ZodString;
      stderr: z.ZodString;
      exitCode: z.ZodNullable<z.ZodNumber>;
      diagnostics: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
      contractError: z.ZodOptional<z.ZodString>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      success: z.ZodBoolean;
      stdout: z.ZodString;
      stderr: z.ZodString;
      exitCode: z.ZodNullable<z.ZodNumber>;
      diagnostics: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
      contractError: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      success: z.ZodBoolean;
      stdout: z.ZodString;
      stderr: z.ZodString;
      exitCode: z.ZodNullable<z.ZodNumber>;
      diagnostics: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
      contractError: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">>>;
    context: z.ZodNullable<z.ZodObject<{
      success: z.ZodBoolean;
      stdout: z.ZodString;
      stderr: z.ZodString;
      exitCode: z.ZodNullable<z.ZodNumber>;
      diagnostics: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
      contractError: z.ZodOptional<z.ZodString>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      success: z.ZodBoolean;
      stdout: z.ZodString;
      stderr: z.ZodString;
      exitCode: z.ZodNullable<z.ZodNumber>;
      diagnostics: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
      contractError: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      success: z.ZodBoolean;
      stdout: z.ZodString;
      stderr: z.ZodString;
      exitCode: z.ZodNullable<z.ZodNumber>;
      diagnostics: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
      contractError: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">>>;
  }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
    doctor: z.ZodNullable<z.ZodObject<{
      success: z.ZodBoolean;
      stdout: z.ZodString;
      stderr: z.ZodString;
      exitCode: z.ZodNullable<z.ZodNumber>;
      diagnostics: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
      contractError: z.ZodOptional<z.ZodString>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      success: z.ZodBoolean;
      stdout: z.ZodString;
      stderr: z.ZodString;
      exitCode: z.ZodNullable<z.ZodNumber>;
      diagnostics: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
      contractError: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      success: z.ZodBoolean;
      stdout: z.ZodString;
      stderr: z.ZodString;
      exitCode: z.ZodNullable<z.ZodNumber>;
      diagnostics: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
      contractError: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">>>;
    context: z.ZodNullable<z.ZodObject<{
      success: z.ZodBoolean;
      stdout: z.ZodString;
      stderr: z.ZodString;
      exitCode: z.ZodNullable<z.ZodNumber>;
      diagnostics: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
      contractError: z.ZodOptional<z.ZodString>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      success: z.ZodBoolean;
      stdout: z.ZodString;
      stderr: z.ZodString;
      exitCode: z.ZodNullable<z.ZodNumber>;
      diagnostics: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
      contractError: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      success: z.ZodBoolean;
      stdout: z.ZodString;
      stderr: z.ZodString;
      exitCode: z.ZodNullable<z.ZodNumber>;
      diagnostics: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
      contractError: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">>>;
  }, z.ZodTypeAny, "passthrough">>;
  observedAt: z.ZodNumber;
}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
  launchProject: z.ZodObject<{
    path: z.ZodString;
    physicalPath: z.ZodOptional<z.ZodString>;
  }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
    path: z.ZodString;
    physicalPath: z.ZodOptional<z.ZodString>;
  }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
    path: z.ZodString;
    physicalPath: z.ZodOptional<z.ZodString>;
  }, z.ZodTypeAny, "passthrough">>;
  planningRoot: z.ZodNullable<z.ZodObject<{
    path: z.ZodString;
    source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
    store_id: z.ZodOptional<z.ZodString>;
  } & {
    healthy: z.ZodBoolean;
    status: z.ZodArray<z.ZodObject<{
      severity: z.ZodEnum<["error", "warning", "info"]>;
      code: z.ZodString;
      message: z.ZodString;
      target: z.ZodOptional<z.ZodString>;
      fix: z.ZodOptional<z.ZodString>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      severity: z.ZodEnum<["error", "warning", "info"]>;
      code: z.ZodString;
      message: z.ZodString;
      target: z.ZodOptional<z.ZodString>;
      fix: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      severity: z.ZodEnum<["error", "warning", "info"]>;
      code: z.ZodString;
      message: z.ZodString;
      target: z.ZodOptional<z.ZodString>;
      fix: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">>, "many">;
  }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
    path: z.ZodString;
    source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
    store_id: z.ZodOptional<z.ZodString>;
  } & {
    healthy: z.ZodBoolean;
    status: z.ZodArray<z.ZodObject<{
      severity: z.ZodEnum<["error", "warning", "info"]>;
      code: z.ZodString;
      message: z.ZodString;
      target: z.ZodOptional<z.ZodString>;
      fix: z.ZodOptional<z.ZodString>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      severity: z.ZodEnum<["error", "warning", "info"]>;
      code: z.ZodString;
      message: z.ZodString;
      target: z.ZodOptional<z.ZodString>;
      fix: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      severity: z.ZodEnum<["error", "warning", "info"]>;
      code: z.ZodString;
      message: z.ZodString;
      target: z.ZodOptional<z.ZodString>;
      fix: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">>, "many">;
  }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
    path: z.ZodString;
    source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
    store_id: z.ZodOptional<z.ZodString>;
  } & {
    healthy: z.ZodBoolean;
    status: z.ZodArray<z.ZodObject<{
      severity: z.ZodEnum<["error", "warning", "info"]>;
      code: z.ZodString;
      message: z.ZodString;
      target: z.ZodOptional<z.ZodString>;
      fix: z.ZodOptional<z.ZodString>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      severity: z.ZodEnum<["error", "warning", "info"]>;
      code: z.ZodString;
      message: z.ZodString;
      target: z.ZodOptional<z.ZodString>;
      fix: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      severity: z.ZodEnum<["error", "warning", "info"]>;
      code: z.ZodString;
      message: z.ZodString;
      target: z.ZodOptional<z.ZodString>;
      fix: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">>, "many">;
  }, z.ZodTypeAny, "passthrough">>>;
  storeId: z.ZodNullable<z.ZodString>;
  generation: z.ZodOptional<z.ZodString>;
  cli: z.ZodObject<{
    available: z.ZodBoolean;
    version: z.ZodOptional<z.ZodString>;
    error: z.ZodOptional<z.ZodString>;
    effectiveCommand: z.ZodOptional<z.ZodString>;
    tried: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
  }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
    available: z.ZodBoolean;
    version: z.ZodOptional<z.ZodString>;
    error: z.ZodOptional<z.ZodString>;
    effectiveCommand: z.ZodOptional<z.ZodString>;
    tried: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
  }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
    available: z.ZodBoolean;
    version: z.ZodOptional<z.ZodString>;
    error: z.ZodOptional<z.ZodString>;
    effectiveCommand: z.ZodOptional<z.ZodString>;
    tried: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
  }, z.ZodTypeAny, "passthrough">>;
  references: z.ZodArray<z.ZodObject<{
    store_id: z.ZodString;
    root: z.ZodOptional<z.ZodString>;
    status: z.ZodArray<z.ZodObject<{
      severity: z.ZodEnum<["error", "warning", "info"]>;
      code: z.ZodString;
      message: z.ZodString;
      target: z.ZodOptional<z.ZodString>;
      fix: z.ZodOptional<z.ZodString>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      severity: z.ZodEnum<["error", "warning", "info"]>;
      code: z.ZodString;
      message: z.ZodString;
      target: z.ZodOptional<z.ZodString>;
      fix: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      severity: z.ZodEnum<["error", "warning", "info"]>;
      code: z.ZodString;
      message: z.ZodString;
      target: z.ZodOptional<z.ZodString>;
      fix: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">>, "many">;
  }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
    store_id: z.ZodString;
    root: z.ZodOptional<z.ZodString>;
    status: z.ZodArray<z.ZodObject<{
      severity: z.ZodEnum<["error", "warning", "info"]>;
      code: z.ZodString;
      message: z.ZodString;
      target: z.ZodOptional<z.ZodString>;
      fix: z.ZodOptional<z.ZodString>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      severity: z.ZodEnum<["error", "warning", "info"]>;
      code: z.ZodString;
      message: z.ZodString;
      target: z.ZodOptional<z.ZodString>;
      fix: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      severity: z.ZodEnum<["error", "warning", "info"]>;
      code: z.ZodString;
      message: z.ZodString;
      target: z.ZodOptional<z.ZodString>;
      fix: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">>, "many">;
  }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
    store_id: z.ZodString;
    root: z.ZodOptional<z.ZodString>;
    status: z.ZodArray<z.ZodObject<{
      severity: z.ZodEnum<["error", "warning", "info"]>;
      code: z.ZodString;
      message: z.ZodString;
      target: z.ZodOptional<z.ZodString>;
      fix: z.ZodOptional<z.ZodString>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      severity: z.ZodEnum<["error", "warning", "info"]>;
      code: z.ZodString;
      message: z.ZodString;
      target: z.ZodOptional<z.ZodString>;
      fix: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      severity: z.ZodEnum<["error", "warning", "info"]>;
      code: z.ZodString;
      message: z.ZodString;
      target: z.ZodOptional<z.ZodString>;
      fix: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">>, "many">;
  }, z.ZodTypeAny, "passthrough">>, "many">;
  contextMembers: z.ZodArray<z.ZodObject<{
    role: z.ZodLiteral<"referenced_store">;
    id: z.ZodString;
    path: z.ZodOptional<z.ZodString>;
    remote: z.ZodOptional<z.ZodString>;
    fetch: z.ZodOptional<z.ZodString>;
    status: z.ZodArray<z.ZodObject<{
      severity: z.ZodEnum<["error", "warning", "info"]>;
      code: z.ZodString;
      message: z.ZodString;
      target: z.ZodOptional<z.ZodString>;
      fix: z.ZodOptional<z.ZodString>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      severity: z.ZodEnum<["error", "warning", "info"]>;
      code: z.ZodString;
      message: z.ZodString;
      target: z.ZodOptional<z.ZodString>;
      fix: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      severity: z.ZodEnum<["error", "warning", "info"]>;
      code: z.ZodString;
      message: z.ZodString;
      target: z.ZodOptional<z.ZodString>;
      fix: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">>, "many">;
  }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
    role: z.ZodLiteral<"referenced_store">;
    id: z.ZodString;
    path: z.ZodOptional<z.ZodString>;
    remote: z.ZodOptional<z.ZodString>;
    fetch: z.ZodOptional<z.ZodString>;
    status: z.ZodArray<z.ZodObject<{
      severity: z.ZodEnum<["error", "warning", "info"]>;
      code: z.ZodString;
      message: z.ZodString;
      target: z.ZodOptional<z.ZodString>;
      fix: z.ZodOptional<z.ZodString>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      severity: z.ZodEnum<["error", "warning", "info"]>;
      code: z.ZodString;
      message: z.ZodString;
      target: z.ZodOptional<z.ZodString>;
      fix: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      severity: z.ZodEnum<["error", "warning", "info"]>;
      code: z.ZodString;
      message: z.ZodString;
      target: z.ZodOptional<z.ZodString>;
      fix: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">>, "many">;
  }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
    role: z.ZodLiteral<"referenced_store">;
    id: z.ZodString;
    path: z.ZodOptional<z.ZodString>;
    remote: z.ZodOptional<z.ZodString>;
    fetch: z.ZodOptional<z.ZodString>;
    status: z.ZodArray<z.ZodObject<{
      severity: z.ZodEnum<["error", "warning", "info"]>;
      code: z.ZodString;
      message: z.ZodString;
      target: z.ZodOptional<z.ZodString>;
      fix: z.ZodOptional<z.ZodString>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      severity: z.ZodEnum<["error", "warning", "info"]>;
      code: z.ZodString;
      message: z.ZodString;
      target: z.ZodOptional<z.ZodString>;
      fix: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      severity: z.ZodEnum<["error", "warning", "info"]>;
      code: z.ZodString;
      message: z.ZodString;
      target: z.ZodOptional<z.ZodString>;
      fix: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">>, "many">;
  }, z.ZodTypeAny, "passthrough">>, "many">;
  dataScope: z.ZodObject<{
    path: z.ZodString;
    source: z.ZodEnum<["xdg-data-home", "local-app-data", "user-home-default"]>;
    environmentVariable: z.ZodNullable<z.ZodEnum<["XDG_DATA_HOME", "LOCALAPPDATA"]>>;
  }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
    path: z.ZodString;
    source: z.ZodEnum<["xdg-data-home", "local-app-data", "user-home-default"]>;
    environmentVariable: z.ZodNullable<z.ZodEnum<["XDG_DATA_HOME", "LOCALAPPDATA"]>>;
  }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
    path: z.ZodString;
    source: z.ZodEnum<["xdg-data-home", "local-app-data", "user-home-default"]>;
    environmentVariable: z.ZodNullable<z.ZodEnum<["XDG_DATA_HOME", "LOCALAPPDATA"]>>;
  }, z.ZodTypeAny, "passthrough">>;
  diagnostics: z.ZodObject<{
    root: z.ZodArray<z.ZodObject<{
      severity: z.ZodEnum<["error", "warning", "info"]>;
      code: z.ZodString;
      message: z.ZodString;
      target: z.ZodOptional<z.ZodString>;
      fix: z.ZodOptional<z.ZodString>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      severity: z.ZodEnum<["error", "warning", "info"]>;
      code: z.ZodString;
      message: z.ZodString;
      target: z.ZodOptional<z.ZodString>;
      fix: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      severity: z.ZodEnum<["error", "warning", "info"]>;
      code: z.ZodString;
      message: z.ZodString;
      target: z.ZodOptional<z.ZodString>;
      fix: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">>, "many">;
    doctor: z.ZodArray<z.ZodObject<{
      severity: z.ZodEnum<["error", "warning", "info"]>;
      code: z.ZodString;
      message: z.ZodString;
      target: z.ZodOptional<z.ZodString>;
      fix: z.ZodOptional<z.ZodString>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      severity: z.ZodEnum<["error", "warning", "info"]>;
      code: z.ZodString;
      message: z.ZodString;
      target: z.ZodOptional<z.ZodString>;
      fix: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      severity: z.ZodEnum<["error", "warning", "info"]>;
      code: z.ZodString;
      message: z.ZodString;
      target: z.ZodOptional<z.ZodString>;
      fix: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">>, "many">;
    context: z.ZodArray<z.ZodObject<{
      severity: z.ZodEnum<["error", "warning", "info"]>;
      code: z.ZodString;
      message: z.ZodString;
      target: z.ZodOptional<z.ZodString>;
      fix: z.ZodOptional<z.ZodString>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      severity: z.ZodEnum<["error", "warning", "info"]>;
      code: z.ZodString;
      message: z.ZodString;
      target: z.ZodOptional<z.ZodString>;
      fix: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      severity: z.ZodEnum<["error", "warning", "info"]>;
      code: z.ZodString;
      message: z.ZodString;
      target: z.ZodOptional<z.ZodString>;
      fix: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">>, "many">;
  }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
    root: z.ZodArray<z.ZodObject<{
      severity: z.ZodEnum<["error", "warning", "info"]>;
      code: z.ZodString;
      message: z.ZodString;
      target: z.ZodOptional<z.ZodString>;
      fix: z.ZodOptional<z.ZodString>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      severity: z.ZodEnum<["error", "warning", "info"]>;
      code: z.ZodString;
      message: z.ZodString;
      target: z.ZodOptional<z.ZodString>;
      fix: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      severity: z.ZodEnum<["error", "warning", "info"]>;
      code: z.ZodString;
      message: z.ZodString;
      target: z.ZodOptional<z.ZodString>;
      fix: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">>, "many">;
    doctor: z.ZodArray<z.ZodObject<{
      severity: z.ZodEnum<["error", "warning", "info"]>;
      code: z.ZodString;
      message: z.ZodString;
      target: z.ZodOptional<z.ZodString>;
      fix: z.ZodOptional<z.ZodString>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      severity: z.ZodEnum<["error", "warning", "info"]>;
      code: z.ZodString;
      message: z.ZodString;
      target: z.ZodOptional<z.ZodString>;
      fix: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      severity: z.ZodEnum<["error", "warning", "info"]>;
      code: z.ZodString;
      message: z.ZodString;
      target: z.ZodOptional<z.ZodString>;
      fix: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">>, "many">;
    context: z.ZodArray<z.ZodObject<{
      severity: z.ZodEnum<["error", "warning", "info"]>;
      code: z.ZodString;
      message: z.ZodString;
      target: z.ZodOptional<z.ZodString>;
      fix: z.ZodOptional<z.ZodString>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      severity: z.ZodEnum<["error", "warning", "info"]>;
      code: z.ZodString;
      message: z.ZodString;
      target: z.ZodOptional<z.ZodString>;
      fix: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      severity: z.ZodEnum<["error", "warning", "info"]>;
      code: z.ZodString;
      message: z.ZodString;
      target: z.ZodOptional<z.ZodString>;
      fix: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">>, "many">;
  }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
    root: z.ZodArray<z.ZodObject<{
      severity: z.ZodEnum<["error", "warning", "info"]>;
      code: z.ZodString;
      message: z.ZodString;
      target: z.ZodOptional<z.ZodString>;
      fix: z.ZodOptional<z.ZodString>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      severity: z.ZodEnum<["error", "warning", "info"]>;
      code: z.ZodString;
      message: z.ZodString;
      target: z.ZodOptional<z.ZodString>;
      fix: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      severity: z.ZodEnum<["error", "warning", "info"]>;
      code: z.ZodString;
      message: z.ZodString;
      target: z.ZodOptional<z.ZodString>;
      fix: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">>, "many">;
    doctor: z.ZodArray<z.ZodObject<{
      severity: z.ZodEnum<["error", "warning", "info"]>;
      code: z.ZodString;
      message: z.ZodString;
      target: z.ZodOptional<z.ZodString>;
      fix: z.ZodOptional<z.ZodString>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      severity: z.ZodEnum<["error", "warning", "info"]>;
      code: z.ZodString;
      message: z.ZodString;
      target: z.ZodOptional<z.ZodString>;
      fix: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      severity: z.ZodEnum<["error", "warning", "info"]>;
      code: z.ZodString;
      message: z.ZodString;
      target: z.ZodOptional<z.ZodString>;
      fix: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">>, "many">;
    context: z.ZodArray<z.ZodObject<{
      severity: z.ZodEnum<["error", "warning", "info"]>;
      code: z.ZodString;
      message: z.ZodString;
      target: z.ZodOptional<z.ZodString>;
      fix: z.ZodOptional<z.ZodString>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      severity: z.ZodEnum<["error", "warning", "info"]>;
      code: z.ZodString;
      message: z.ZodString;
      target: z.ZodOptional<z.ZodString>;
      fix: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      severity: z.ZodEnum<["error", "warning", "info"]>;
      code: z.ZodString;
      message: z.ZodString;
      target: z.ZodOptional<z.ZodString>;
      fix: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">>, "many">;
  }, z.ZodTypeAny, "passthrough">>;
  evidence: z.ZodObject<{
    doctor: z.ZodNullable<z.ZodObject<{
      success: z.ZodBoolean;
      stdout: z.ZodString;
      stderr: z.ZodString;
      exitCode: z.ZodNullable<z.ZodNumber>;
      diagnostics: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
      contractError: z.ZodOptional<z.ZodString>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      success: z.ZodBoolean;
      stdout: z.ZodString;
      stderr: z.ZodString;
      exitCode: z.ZodNullable<z.ZodNumber>;
      diagnostics: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
      contractError: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      success: z.ZodBoolean;
      stdout: z.ZodString;
      stderr: z.ZodString;
      exitCode: z.ZodNullable<z.ZodNumber>;
      diagnostics: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
      contractError: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">>>;
    context: z.ZodNullable<z.ZodObject<{
      success: z.ZodBoolean;
      stdout: z.ZodString;
      stderr: z.ZodString;
      exitCode: z.ZodNullable<z.ZodNumber>;
      diagnostics: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
      contractError: z.ZodOptional<z.ZodString>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      success: z.ZodBoolean;
      stdout: z.ZodString;
      stderr: z.ZodString;
      exitCode: z.ZodNullable<z.ZodNumber>;
      diagnostics: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
      contractError: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      success: z.ZodBoolean;
      stdout: z.ZodString;
      stderr: z.ZodString;
      exitCode: z.ZodNullable<z.ZodNumber>;
      diagnostics: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
      contractError: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">>>;
  }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
    doctor: z.ZodNullable<z.ZodObject<{
      success: z.ZodBoolean;
      stdout: z.ZodString;
      stderr: z.ZodString;
      exitCode: z.ZodNullable<z.ZodNumber>;
      diagnostics: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
      contractError: z.ZodOptional<z.ZodString>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      success: z.ZodBoolean;
      stdout: z.ZodString;
      stderr: z.ZodString;
      exitCode: z.ZodNullable<z.ZodNumber>;
      diagnostics: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
      contractError: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      success: z.ZodBoolean;
      stdout: z.ZodString;
      stderr: z.ZodString;
      exitCode: z.ZodNullable<z.ZodNumber>;
      diagnostics: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
      contractError: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">>>;
    context: z.ZodNullable<z.ZodObject<{
      success: z.ZodBoolean;
      stdout: z.ZodString;
      stderr: z.ZodString;
      exitCode: z.ZodNullable<z.ZodNumber>;
      diagnostics: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
      contractError: z.ZodOptional<z.ZodString>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      success: z.ZodBoolean;
      stdout: z.ZodString;
      stderr: z.ZodString;
      exitCode: z.ZodNullable<z.ZodNumber>;
      diagnostics: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
      contractError: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      success: z.ZodBoolean;
      stdout: z.ZodString;
      stderr: z.ZodString;
      exitCode: z.ZodNullable<z.ZodNumber>;
      diagnostics: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
      contractError: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">>>;
  }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
    doctor: z.ZodNullable<z.ZodObject<{
      success: z.ZodBoolean;
      stdout: z.ZodString;
      stderr: z.ZodString;
      exitCode: z.ZodNullable<z.ZodNumber>;
      diagnostics: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
      contractError: z.ZodOptional<z.ZodString>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      success: z.ZodBoolean;
      stdout: z.ZodString;
      stderr: z.ZodString;
      exitCode: z.ZodNullable<z.ZodNumber>;
      diagnostics: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
      contractError: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      success: z.ZodBoolean;
      stdout: z.ZodString;
      stderr: z.ZodString;
      exitCode: z.ZodNullable<z.ZodNumber>;
      diagnostics: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
      contractError: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">>>;
    context: z.ZodNullable<z.ZodObject<{
      success: z.ZodBoolean;
      stdout: z.ZodString;
      stderr: z.ZodString;
      exitCode: z.ZodNullable<z.ZodNumber>;
      diagnostics: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
      contractError: z.ZodOptional<z.ZodString>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      success: z.ZodBoolean;
      stdout: z.ZodString;
      stderr: z.ZodString;
      exitCode: z.ZodNullable<z.ZodNumber>;
      diagnostics: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
      contractError: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      success: z.ZodBoolean;
      stdout: z.ZodString;
      stderr: z.ZodString;
      exitCode: z.ZodNullable<z.ZodNumber>;
      diagnostics: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
      contractError: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">>>;
  }, z.ZodTypeAny, "passthrough">>;
  observedAt: z.ZodNumber;
}, z.ZodTypeAny, "passthrough">>;
declare const HostedRootContextErrorCodeSchema: z.ZodEnum<["cli-unavailable", "doctor-command-failed", "doctor-contract-drift", "root-unresolved", "root-unhealthy", "context-command-failed", "context-contract-drift", "context-root-mismatch", "references-unresolved", "resolver-failed"]>;
/** Browser-safe settled CLI result cached by Root Context Projection Work. */
declare const HostedRootContextResolvedStateSchema: z.ZodDiscriminatedUnion<"state", [z.ZodObject<{
  state: z.ZodLiteral<"ready">;
  data: z.ZodObject<{
    launchProject: z.ZodObject<{
      path: z.ZodString;
      physicalPath: z.ZodOptional<z.ZodString>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      path: z.ZodString;
      physicalPath: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      path: z.ZodString;
      physicalPath: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">>;
    planningRoot: z.ZodNullable<z.ZodObject<{
      path: z.ZodString;
      source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
      store_id: z.ZodOptional<z.ZodString>;
    } & {
      healthy: z.ZodBoolean;
      status: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      path: z.ZodString;
      source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
      store_id: z.ZodOptional<z.ZodString>;
    } & {
      healthy: z.ZodBoolean;
      status: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      path: z.ZodString;
      source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
      store_id: z.ZodOptional<z.ZodString>;
    } & {
      healthy: z.ZodBoolean;
      status: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, z.ZodTypeAny, "passthrough">>>;
    storeId: z.ZodNullable<z.ZodString>;
    generation: z.ZodOptional<z.ZodString>;
    cli: z.ZodObject<{
      available: z.ZodBoolean;
      version: z.ZodOptional<z.ZodString>;
      error: z.ZodOptional<z.ZodString>;
      effectiveCommand: z.ZodOptional<z.ZodString>;
      tried: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      available: z.ZodBoolean;
      version: z.ZodOptional<z.ZodString>;
      error: z.ZodOptional<z.ZodString>;
      effectiveCommand: z.ZodOptional<z.ZodString>;
      tried: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      available: z.ZodBoolean;
      version: z.ZodOptional<z.ZodString>;
      error: z.ZodOptional<z.ZodString>;
      effectiveCommand: z.ZodOptional<z.ZodString>;
      tried: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
    }, z.ZodTypeAny, "passthrough">>;
    references: z.ZodArray<z.ZodObject<{
      store_id: z.ZodString;
      root: z.ZodOptional<z.ZodString>;
      status: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      store_id: z.ZodString;
      root: z.ZodOptional<z.ZodString>;
      status: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      store_id: z.ZodString;
      root: z.ZodOptional<z.ZodString>;
      status: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, z.ZodTypeAny, "passthrough">>, "many">;
    contextMembers: z.ZodArray<z.ZodObject<{
      role: z.ZodLiteral<"referenced_store">;
      id: z.ZodString;
      path: z.ZodOptional<z.ZodString>;
      remote: z.ZodOptional<z.ZodString>;
      fetch: z.ZodOptional<z.ZodString>;
      status: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      role: z.ZodLiteral<"referenced_store">;
      id: z.ZodString;
      path: z.ZodOptional<z.ZodString>;
      remote: z.ZodOptional<z.ZodString>;
      fetch: z.ZodOptional<z.ZodString>;
      status: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      role: z.ZodLiteral<"referenced_store">;
      id: z.ZodString;
      path: z.ZodOptional<z.ZodString>;
      remote: z.ZodOptional<z.ZodString>;
      fetch: z.ZodOptional<z.ZodString>;
      status: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, z.ZodTypeAny, "passthrough">>, "many">;
    dataScope: z.ZodObject<{
      path: z.ZodString;
      source: z.ZodEnum<["xdg-data-home", "local-app-data", "user-home-default"]>;
      environmentVariable: z.ZodNullable<z.ZodEnum<["XDG_DATA_HOME", "LOCALAPPDATA"]>>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      path: z.ZodString;
      source: z.ZodEnum<["xdg-data-home", "local-app-data", "user-home-default"]>;
      environmentVariable: z.ZodNullable<z.ZodEnum<["XDG_DATA_HOME", "LOCALAPPDATA"]>>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      path: z.ZodString;
      source: z.ZodEnum<["xdg-data-home", "local-app-data", "user-home-default"]>;
      environmentVariable: z.ZodNullable<z.ZodEnum<["XDG_DATA_HOME", "LOCALAPPDATA"]>>;
    }, z.ZodTypeAny, "passthrough">>;
    diagnostics: z.ZodObject<{
      root: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
      doctor: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
      context: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      root: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
      doctor: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
      context: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      root: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
      doctor: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
      context: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, z.ZodTypeAny, "passthrough">>;
    evidence: z.ZodObject<{
      doctor: z.ZodNullable<z.ZodObject<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>>;
      context: z.ZodNullable<z.ZodObject<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      doctor: z.ZodNullable<z.ZodObject<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>>;
      context: z.ZodNullable<z.ZodObject<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      doctor: z.ZodNullable<z.ZodObject<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>>;
      context: z.ZodNullable<z.ZodObject<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>>;
    }, z.ZodTypeAny, "passthrough">>;
    observedAt: z.ZodNumber;
  }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
    launchProject: z.ZodObject<{
      path: z.ZodString;
      physicalPath: z.ZodOptional<z.ZodString>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      path: z.ZodString;
      physicalPath: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      path: z.ZodString;
      physicalPath: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">>;
    planningRoot: z.ZodNullable<z.ZodObject<{
      path: z.ZodString;
      source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
      store_id: z.ZodOptional<z.ZodString>;
    } & {
      healthy: z.ZodBoolean;
      status: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      path: z.ZodString;
      source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
      store_id: z.ZodOptional<z.ZodString>;
    } & {
      healthy: z.ZodBoolean;
      status: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      path: z.ZodString;
      source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
      store_id: z.ZodOptional<z.ZodString>;
    } & {
      healthy: z.ZodBoolean;
      status: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, z.ZodTypeAny, "passthrough">>>;
    storeId: z.ZodNullable<z.ZodString>;
    generation: z.ZodOptional<z.ZodString>;
    cli: z.ZodObject<{
      available: z.ZodBoolean;
      version: z.ZodOptional<z.ZodString>;
      error: z.ZodOptional<z.ZodString>;
      effectiveCommand: z.ZodOptional<z.ZodString>;
      tried: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      available: z.ZodBoolean;
      version: z.ZodOptional<z.ZodString>;
      error: z.ZodOptional<z.ZodString>;
      effectiveCommand: z.ZodOptional<z.ZodString>;
      tried: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      available: z.ZodBoolean;
      version: z.ZodOptional<z.ZodString>;
      error: z.ZodOptional<z.ZodString>;
      effectiveCommand: z.ZodOptional<z.ZodString>;
      tried: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
    }, z.ZodTypeAny, "passthrough">>;
    references: z.ZodArray<z.ZodObject<{
      store_id: z.ZodString;
      root: z.ZodOptional<z.ZodString>;
      status: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      store_id: z.ZodString;
      root: z.ZodOptional<z.ZodString>;
      status: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      store_id: z.ZodString;
      root: z.ZodOptional<z.ZodString>;
      status: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, z.ZodTypeAny, "passthrough">>, "many">;
    contextMembers: z.ZodArray<z.ZodObject<{
      role: z.ZodLiteral<"referenced_store">;
      id: z.ZodString;
      path: z.ZodOptional<z.ZodString>;
      remote: z.ZodOptional<z.ZodString>;
      fetch: z.ZodOptional<z.ZodString>;
      status: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      role: z.ZodLiteral<"referenced_store">;
      id: z.ZodString;
      path: z.ZodOptional<z.ZodString>;
      remote: z.ZodOptional<z.ZodString>;
      fetch: z.ZodOptional<z.ZodString>;
      status: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      role: z.ZodLiteral<"referenced_store">;
      id: z.ZodString;
      path: z.ZodOptional<z.ZodString>;
      remote: z.ZodOptional<z.ZodString>;
      fetch: z.ZodOptional<z.ZodString>;
      status: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, z.ZodTypeAny, "passthrough">>, "many">;
    dataScope: z.ZodObject<{
      path: z.ZodString;
      source: z.ZodEnum<["xdg-data-home", "local-app-data", "user-home-default"]>;
      environmentVariable: z.ZodNullable<z.ZodEnum<["XDG_DATA_HOME", "LOCALAPPDATA"]>>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      path: z.ZodString;
      source: z.ZodEnum<["xdg-data-home", "local-app-data", "user-home-default"]>;
      environmentVariable: z.ZodNullable<z.ZodEnum<["XDG_DATA_HOME", "LOCALAPPDATA"]>>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      path: z.ZodString;
      source: z.ZodEnum<["xdg-data-home", "local-app-data", "user-home-default"]>;
      environmentVariable: z.ZodNullable<z.ZodEnum<["XDG_DATA_HOME", "LOCALAPPDATA"]>>;
    }, z.ZodTypeAny, "passthrough">>;
    diagnostics: z.ZodObject<{
      root: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
      doctor: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
      context: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      root: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
      doctor: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
      context: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      root: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
      doctor: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
      context: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, z.ZodTypeAny, "passthrough">>;
    evidence: z.ZodObject<{
      doctor: z.ZodNullable<z.ZodObject<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>>;
      context: z.ZodNullable<z.ZodObject<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      doctor: z.ZodNullable<z.ZodObject<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>>;
      context: z.ZodNullable<z.ZodObject<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      doctor: z.ZodNullable<z.ZodObject<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>>;
      context: z.ZodNullable<z.ZodObject<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>>;
    }, z.ZodTypeAny, "passthrough">>;
    observedAt: z.ZodNumber;
  }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
    launchProject: z.ZodObject<{
      path: z.ZodString;
      physicalPath: z.ZodOptional<z.ZodString>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      path: z.ZodString;
      physicalPath: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      path: z.ZodString;
      physicalPath: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">>;
    planningRoot: z.ZodNullable<z.ZodObject<{
      path: z.ZodString;
      source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
      store_id: z.ZodOptional<z.ZodString>;
    } & {
      healthy: z.ZodBoolean;
      status: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      path: z.ZodString;
      source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
      store_id: z.ZodOptional<z.ZodString>;
    } & {
      healthy: z.ZodBoolean;
      status: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      path: z.ZodString;
      source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
      store_id: z.ZodOptional<z.ZodString>;
    } & {
      healthy: z.ZodBoolean;
      status: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, z.ZodTypeAny, "passthrough">>>;
    storeId: z.ZodNullable<z.ZodString>;
    generation: z.ZodOptional<z.ZodString>;
    cli: z.ZodObject<{
      available: z.ZodBoolean;
      version: z.ZodOptional<z.ZodString>;
      error: z.ZodOptional<z.ZodString>;
      effectiveCommand: z.ZodOptional<z.ZodString>;
      tried: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      available: z.ZodBoolean;
      version: z.ZodOptional<z.ZodString>;
      error: z.ZodOptional<z.ZodString>;
      effectiveCommand: z.ZodOptional<z.ZodString>;
      tried: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      available: z.ZodBoolean;
      version: z.ZodOptional<z.ZodString>;
      error: z.ZodOptional<z.ZodString>;
      effectiveCommand: z.ZodOptional<z.ZodString>;
      tried: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
    }, z.ZodTypeAny, "passthrough">>;
    references: z.ZodArray<z.ZodObject<{
      store_id: z.ZodString;
      root: z.ZodOptional<z.ZodString>;
      status: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      store_id: z.ZodString;
      root: z.ZodOptional<z.ZodString>;
      status: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      store_id: z.ZodString;
      root: z.ZodOptional<z.ZodString>;
      status: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, z.ZodTypeAny, "passthrough">>, "many">;
    contextMembers: z.ZodArray<z.ZodObject<{
      role: z.ZodLiteral<"referenced_store">;
      id: z.ZodString;
      path: z.ZodOptional<z.ZodString>;
      remote: z.ZodOptional<z.ZodString>;
      fetch: z.ZodOptional<z.ZodString>;
      status: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      role: z.ZodLiteral<"referenced_store">;
      id: z.ZodString;
      path: z.ZodOptional<z.ZodString>;
      remote: z.ZodOptional<z.ZodString>;
      fetch: z.ZodOptional<z.ZodString>;
      status: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      role: z.ZodLiteral<"referenced_store">;
      id: z.ZodString;
      path: z.ZodOptional<z.ZodString>;
      remote: z.ZodOptional<z.ZodString>;
      fetch: z.ZodOptional<z.ZodString>;
      status: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, z.ZodTypeAny, "passthrough">>, "many">;
    dataScope: z.ZodObject<{
      path: z.ZodString;
      source: z.ZodEnum<["xdg-data-home", "local-app-data", "user-home-default"]>;
      environmentVariable: z.ZodNullable<z.ZodEnum<["XDG_DATA_HOME", "LOCALAPPDATA"]>>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      path: z.ZodString;
      source: z.ZodEnum<["xdg-data-home", "local-app-data", "user-home-default"]>;
      environmentVariable: z.ZodNullable<z.ZodEnum<["XDG_DATA_HOME", "LOCALAPPDATA"]>>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      path: z.ZodString;
      source: z.ZodEnum<["xdg-data-home", "local-app-data", "user-home-default"]>;
      environmentVariable: z.ZodNullable<z.ZodEnum<["XDG_DATA_HOME", "LOCALAPPDATA"]>>;
    }, z.ZodTypeAny, "passthrough">>;
    diagnostics: z.ZodObject<{
      root: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
      doctor: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
      context: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      root: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
      doctor: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
      context: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      root: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
      doctor: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
      context: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, z.ZodTypeAny, "passthrough">>;
    evidence: z.ZodObject<{
      doctor: z.ZodNullable<z.ZodObject<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>>;
      context: z.ZodNullable<z.ZodObject<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      doctor: z.ZodNullable<z.ZodObject<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>>;
      context: z.ZodNullable<z.ZodObject<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      doctor: z.ZodNullable<z.ZodObject<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>>;
      context: z.ZodNullable<z.ZodObject<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>>;
    }, z.ZodTypeAny, "passthrough">>;
    observedAt: z.ZodNumber;
  }, z.ZodTypeAny, "passthrough">>;
  attempt: z.ZodNull;
  error: z.ZodNull;
  observedAt: z.ZodNumber;
}, "strip", z.ZodTypeAny, {
  error: null;
  state: "ready";
  data: {
    storeId: string | null;
    diagnostics: {
      root: z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">[];
      context: z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">[];
      doctor: z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">[];
    } & {
      [k: string]: unknown;
    };
    evidence: {
      context: z.objectOutputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough"> | null;
      doctor: z.objectOutputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough"> | null;
    } & {
      [k: string]: unknown;
    };
    cli: {
      available: boolean;
      version?: string | undefined;
      error?: string | undefined;
      effectiveCommand?: string | undefined;
      tried?: string[] | undefined;
    } & {
      [k: string]: unknown;
    };
    references: z.objectOutputType<{
      store_id: z.ZodString;
      root: z.ZodOptional<z.ZodString>;
      status: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, z.ZodTypeAny, "passthrough">[];
    dataScope: {
      path: string;
      source: "xdg-data-home" | "local-app-data" | "user-home-default";
      environmentVariable: "XDG_DATA_HOME" | "LOCALAPPDATA" | null;
    } & {
      [k: string]: unknown;
    };
    observedAt: number;
    launchProject: {
      path: string;
      physicalPath?: string | undefined;
    } & {
      [k: string]: unknown;
    };
    planningRoot: z.objectOutputType<{
      path: z.ZodString;
      source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
      store_id: z.ZodOptional<z.ZodString>;
    } & {
      healthy: z.ZodBoolean;
      status: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, z.ZodTypeAny, "passthrough"> | null;
    contextMembers: z.objectOutputType<{
      role: z.ZodLiteral<"referenced_store">;
      id: z.ZodString;
      path: z.ZodOptional<z.ZodString>;
      remote: z.ZodOptional<z.ZodString>;
      fetch: z.ZodOptional<z.ZodString>;
      status: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, z.ZodTypeAny, "passthrough">[];
    generation?: string | undefined;
  } & {
    [k: string]: unknown;
  };
  observedAt: number;
  attempt: null;
}, {
  error: null;
  state: "ready";
  data: {
    storeId: string | null;
    diagnostics: {
      root: z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">[];
      context: z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">[];
      doctor: z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">[];
    } & {
      [k: string]: unknown;
    };
    evidence: {
      context: z.objectInputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough"> | null;
      doctor: z.objectInputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough"> | null;
    } & {
      [k: string]: unknown;
    };
    cli: {
      available: boolean;
      version?: string | undefined;
      error?: string | undefined;
      effectiveCommand?: string | undefined;
      tried?: string[] | undefined;
    } & {
      [k: string]: unknown;
    };
    references: z.objectInputType<{
      store_id: z.ZodString;
      root: z.ZodOptional<z.ZodString>;
      status: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, z.ZodTypeAny, "passthrough">[];
    dataScope: {
      path: string;
      source: "xdg-data-home" | "local-app-data" | "user-home-default";
      environmentVariable: "XDG_DATA_HOME" | "LOCALAPPDATA" | null;
    } & {
      [k: string]: unknown;
    };
    observedAt: number;
    launchProject: {
      path: string;
      physicalPath?: string | undefined;
    } & {
      [k: string]: unknown;
    };
    planningRoot: z.objectInputType<{
      path: z.ZodString;
      source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
      store_id: z.ZodOptional<z.ZodString>;
    } & {
      healthy: z.ZodBoolean;
      status: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, z.ZodTypeAny, "passthrough"> | null;
    contextMembers: z.objectInputType<{
      role: z.ZodLiteral<"referenced_store">;
      id: z.ZodString;
      path: z.ZodOptional<z.ZodString>;
      remote: z.ZodOptional<z.ZodString>;
      fetch: z.ZodOptional<z.ZodString>;
      status: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, z.ZodTypeAny, "passthrough">[];
    generation?: string | undefined;
  } & {
    [k: string]: unknown;
  };
  observedAt: number;
  attempt: null;
}>, z.ZodObject<{
  state: z.ZodLiteral<"error">;
  data: z.ZodNullable<z.ZodObject<{
    launchProject: z.ZodObject<{
      path: z.ZodString;
      physicalPath: z.ZodOptional<z.ZodString>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      path: z.ZodString;
      physicalPath: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      path: z.ZodString;
      physicalPath: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">>;
    planningRoot: z.ZodNullable<z.ZodObject<{
      path: z.ZodString;
      source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
      store_id: z.ZodOptional<z.ZodString>;
    } & {
      healthy: z.ZodBoolean;
      status: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      path: z.ZodString;
      source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
      store_id: z.ZodOptional<z.ZodString>;
    } & {
      healthy: z.ZodBoolean;
      status: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      path: z.ZodString;
      source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
      store_id: z.ZodOptional<z.ZodString>;
    } & {
      healthy: z.ZodBoolean;
      status: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, z.ZodTypeAny, "passthrough">>>;
    storeId: z.ZodNullable<z.ZodString>;
    generation: z.ZodOptional<z.ZodString>;
    cli: z.ZodObject<{
      available: z.ZodBoolean;
      version: z.ZodOptional<z.ZodString>;
      error: z.ZodOptional<z.ZodString>;
      effectiveCommand: z.ZodOptional<z.ZodString>;
      tried: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      available: z.ZodBoolean;
      version: z.ZodOptional<z.ZodString>;
      error: z.ZodOptional<z.ZodString>;
      effectiveCommand: z.ZodOptional<z.ZodString>;
      tried: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      available: z.ZodBoolean;
      version: z.ZodOptional<z.ZodString>;
      error: z.ZodOptional<z.ZodString>;
      effectiveCommand: z.ZodOptional<z.ZodString>;
      tried: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
    }, z.ZodTypeAny, "passthrough">>;
    references: z.ZodArray<z.ZodObject<{
      store_id: z.ZodString;
      root: z.ZodOptional<z.ZodString>;
      status: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      store_id: z.ZodString;
      root: z.ZodOptional<z.ZodString>;
      status: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      store_id: z.ZodString;
      root: z.ZodOptional<z.ZodString>;
      status: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, z.ZodTypeAny, "passthrough">>, "many">;
    contextMembers: z.ZodArray<z.ZodObject<{
      role: z.ZodLiteral<"referenced_store">;
      id: z.ZodString;
      path: z.ZodOptional<z.ZodString>;
      remote: z.ZodOptional<z.ZodString>;
      fetch: z.ZodOptional<z.ZodString>;
      status: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      role: z.ZodLiteral<"referenced_store">;
      id: z.ZodString;
      path: z.ZodOptional<z.ZodString>;
      remote: z.ZodOptional<z.ZodString>;
      fetch: z.ZodOptional<z.ZodString>;
      status: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      role: z.ZodLiteral<"referenced_store">;
      id: z.ZodString;
      path: z.ZodOptional<z.ZodString>;
      remote: z.ZodOptional<z.ZodString>;
      fetch: z.ZodOptional<z.ZodString>;
      status: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, z.ZodTypeAny, "passthrough">>, "many">;
    dataScope: z.ZodObject<{
      path: z.ZodString;
      source: z.ZodEnum<["xdg-data-home", "local-app-data", "user-home-default"]>;
      environmentVariable: z.ZodNullable<z.ZodEnum<["XDG_DATA_HOME", "LOCALAPPDATA"]>>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      path: z.ZodString;
      source: z.ZodEnum<["xdg-data-home", "local-app-data", "user-home-default"]>;
      environmentVariable: z.ZodNullable<z.ZodEnum<["XDG_DATA_HOME", "LOCALAPPDATA"]>>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      path: z.ZodString;
      source: z.ZodEnum<["xdg-data-home", "local-app-data", "user-home-default"]>;
      environmentVariable: z.ZodNullable<z.ZodEnum<["XDG_DATA_HOME", "LOCALAPPDATA"]>>;
    }, z.ZodTypeAny, "passthrough">>;
    diagnostics: z.ZodObject<{
      root: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
      doctor: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
      context: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      root: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
      doctor: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
      context: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      root: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
      doctor: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
      context: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, z.ZodTypeAny, "passthrough">>;
    evidence: z.ZodObject<{
      doctor: z.ZodNullable<z.ZodObject<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>>;
      context: z.ZodNullable<z.ZodObject<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      doctor: z.ZodNullable<z.ZodObject<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>>;
      context: z.ZodNullable<z.ZodObject<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      doctor: z.ZodNullable<z.ZodObject<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>>;
      context: z.ZodNullable<z.ZodObject<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>>;
    }, z.ZodTypeAny, "passthrough">>;
    observedAt: z.ZodNumber;
  }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
    launchProject: z.ZodObject<{
      path: z.ZodString;
      physicalPath: z.ZodOptional<z.ZodString>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      path: z.ZodString;
      physicalPath: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      path: z.ZodString;
      physicalPath: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">>;
    planningRoot: z.ZodNullable<z.ZodObject<{
      path: z.ZodString;
      source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
      store_id: z.ZodOptional<z.ZodString>;
    } & {
      healthy: z.ZodBoolean;
      status: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      path: z.ZodString;
      source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
      store_id: z.ZodOptional<z.ZodString>;
    } & {
      healthy: z.ZodBoolean;
      status: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      path: z.ZodString;
      source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
      store_id: z.ZodOptional<z.ZodString>;
    } & {
      healthy: z.ZodBoolean;
      status: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, z.ZodTypeAny, "passthrough">>>;
    storeId: z.ZodNullable<z.ZodString>;
    generation: z.ZodOptional<z.ZodString>;
    cli: z.ZodObject<{
      available: z.ZodBoolean;
      version: z.ZodOptional<z.ZodString>;
      error: z.ZodOptional<z.ZodString>;
      effectiveCommand: z.ZodOptional<z.ZodString>;
      tried: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      available: z.ZodBoolean;
      version: z.ZodOptional<z.ZodString>;
      error: z.ZodOptional<z.ZodString>;
      effectiveCommand: z.ZodOptional<z.ZodString>;
      tried: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      available: z.ZodBoolean;
      version: z.ZodOptional<z.ZodString>;
      error: z.ZodOptional<z.ZodString>;
      effectiveCommand: z.ZodOptional<z.ZodString>;
      tried: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
    }, z.ZodTypeAny, "passthrough">>;
    references: z.ZodArray<z.ZodObject<{
      store_id: z.ZodString;
      root: z.ZodOptional<z.ZodString>;
      status: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      store_id: z.ZodString;
      root: z.ZodOptional<z.ZodString>;
      status: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      store_id: z.ZodString;
      root: z.ZodOptional<z.ZodString>;
      status: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, z.ZodTypeAny, "passthrough">>, "many">;
    contextMembers: z.ZodArray<z.ZodObject<{
      role: z.ZodLiteral<"referenced_store">;
      id: z.ZodString;
      path: z.ZodOptional<z.ZodString>;
      remote: z.ZodOptional<z.ZodString>;
      fetch: z.ZodOptional<z.ZodString>;
      status: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      role: z.ZodLiteral<"referenced_store">;
      id: z.ZodString;
      path: z.ZodOptional<z.ZodString>;
      remote: z.ZodOptional<z.ZodString>;
      fetch: z.ZodOptional<z.ZodString>;
      status: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      role: z.ZodLiteral<"referenced_store">;
      id: z.ZodString;
      path: z.ZodOptional<z.ZodString>;
      remote: z.ZodOptional<z.ZodString>;
      fetch: z.ZodOptional<z.ZodString>;
      status: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, z.ZodTypeAny, "passthrough">>, "many">;
    dataScope: z.ZodObject<{
      path: z.ZodString;
      source: z.ZodEnum<["xdg-data-home", "local-app-data", "user-home-default"]>;
      environmentVariable: z.ZodNullable<z.ZodEnum<["XDG_DATA_HOME", "LOCALAPPDATA"]>>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      path: z.ZodString;
      source: z.ZodEnum<["xdg-data-home", "local-app-data", "user-home-default"]>;
      environmentVariable: z.ZodNullable<z.ZodEnum<["XDG_DATA_HOME", "LOCALAPPDATA"]>>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      path: z.ZodString;
      source: z.ZodEnum<["xdg-data-home", "local-app-data", "user-home-default"]>;
      environmentVariable: z.ZodNullable<z.ZodEnum<["XDG_DATA_HOME", "LOCALAPPDATA"]>>;
    }, z.ZodTypeAny, "passthrough">>;
    diagnostics: z.ZodObject<{
      root: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
      doctor: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
      context: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      root: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
      doctor: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
      context: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      root: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
      doctor: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
      context: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, z.ZodTypeAny, "passthrough">>;
    evidence: z.ZodObject<{
      doctor: z.ZodNullable<z.ZodObject<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>>;
      context: z.ZodNullable<z.ZodObject<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      doctor: z.ZodNullable<z.ZodObject<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>>;
      context: z.ZodNullable<z.ZodObject<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      doctor: z.ZodNullable<z.ZodObject<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>>;
      context: z.ZodNullable<z.ZodObject<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>>;
    }, z.ZodTypeAny, "passthrough">>;
    observedAt: z.ZodNumber;
  }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
    launchProject: z.ZodObject<{
      path: z.ZodString;
      physicalPath: z.ZodOptional<z.ZodString>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      path: z.ZodString;
      physicalPath: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      path: z.ZodString;
      physicalPath: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">>;
    planningRoot: z.ZodNullable<z.ZodObject<{
      path: z.ZodString;
      source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
      store_id: z.ZodOptional<z.ZodString>;
    } & {
      healthy: z.ZodBoolean;
      status: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      path: z.ZodString;
      source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
      store_id: z.ZodOptional<z.ZodString>;
    } & {
      healthy: z.ZodBoolean;
      status: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      path: z.ZodString;
      source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
      store_id: z.ZodOptional<z.ZodString>;
    } & {
      healthy: z.ZodBoolean;
      status: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, z.ZodTypeAny, "passthrough">>>;
    storeId: z.ZodNullable<z.ZodString>;
    generation: z.ZodOptional<z.ZodString>;
    cli: z.ZodObject<{
      available: z.ZodBoolean;
      version: z.ZodOptional<z.ZodString>;
      error: z.ZodOptional<z.ZodString>;
      effectiveCommand: z.ZodOptional<z.ZodString>;
      tried: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      available: z.ZodBoolean;
      version: z.ZodOptional<z.ZodString>;
      error: z.ZodOptional<z.ZodString>;
      effectiveCommand: z.ZodOptional<z.ZodString>;
      tried: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      available: z.ZodBoolean;
      version: z.ZodOptional<z.ZodString>;
      error: z.ZodOptional<z.ZodString>;
      effectiveCommand: z.ZodOptional<z.ZodString>;
      tried: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
    }, z.ZodTypeAny, "passthrough">>;
    references: z.ZodArray<z.ZodObject<{
      store_id: z.ZodString;
      root: z.ZodOptional<z.ZodString>;
      status: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      store_id: z.ZodString;
      root: z.ZodOptional<z.ZodString>;
      status: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      store_id: z.ZodString;
      root: z.ZodOptional<z.ZodString>;
      status: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, z.ZodTypeAny, "passthrough">>, "many">;
    contextMembers: z.ZodArray<z.ZodObject<{
      role: z.ZodLiteral<"referenced_store">;
      id: z.ZodString;
      path: z.ZodOptional<z.ZodString>;
      remote: z.ZodOptional<z.ZodString>;
      fetch: z.ZodOptional<z.ZodString>;
      status: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      role: z.ZodLiteral<"referenced_store">;
      id: z.ZodString;
      path: z.ZodOptional<z.ZodString>;
      remote: z.ZodOptional<z.ZodString>;
      fetch: z.ZodOptional<z.ZodString>;
      status: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      role: z.ZodLiteral<"referenced_store">;
      id: z.ZodString;
      path: z.ZodOptional<z.ZodString>;
      remote: z.ZodOptional<z.ZodString>;
      fetch: z.ZodOptional<z.ZodString>;
      status: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, z.ZodTypeAny, "passthrough">>, "many">;
    dataScope: z.ZodObject<{
      path: z.ZodString;
      source: z.ZodEnum<["xdg-data-home", "local-app-data", "user-home-default"]>;
      environmentVariable: z.ZodNullable<z.ZodEnum<["XDG_DATA_HOME", "LOCALAPPDATA"]>>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      path: z.ZodString;
      source: z.ZodEnum<["xdg-data-home", "local-app-data", "user-home-default"]>;
      environmentVariable: z.ZodNullable<z.ZodEnum<["XDG_DATA_HOME", "LOCALAPPDATA"]>>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      path: z.ZodString;
      source: z.ZodEnum<["xdg-data-home", "local-app-data", "user-home-default"]>;
      environmentVariable: z.ZodNullable<z.ZodEnum<["XDG_DATA_HOME", "LOCALAPPDATA"]>>;
    }, z.ZodTypeAny, "passthrough">>;
    diagnostics: z.ZodObject<{
      root: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
      doctor: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
      context: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      root: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
      doctor: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
      context: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      root: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
      doctor: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
      context: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, z.ZodTypeAny, "passthrough">>;
    evidence: z.ZodObject<{
      doctor: z.ZodNullable<z.ZodObject<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>>;
      context: z.ZodNullable<z.ZodObject<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      doctor: z.ZodNullable<z.ZodObject<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>>;
      context: z.ZodNullable<z.ZodObject<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      doctor: z.ZodNullable<z.ZodObject<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>>;
      context: z.ZodNullable<z.ZodObject<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>>;
    }, z.ZodTypeAny, "passthrough">>;
    observedAt: z.ZodNumber;
  }, z.ZodTypeAny, "passthrough">>>;
  attempt: z.ZodObject<{
    launchProject: z.ZodObject<{
      path: z.ZodString;
      physicalPath: z.ZodOptional<z.ZodString>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      path: z.ZodString;
      physicalPath: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      path: z.ZodString;
      physicalPath: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">>;
    planningRoot: z.ZodNullable<z.ZodObject<{
      path: z.ZodString;
      source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
      store_id: z.ZodOptional<z.ZodString>;
    } & {
      healthy: z.ZodBoolean;
      status: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      path: z.ZodString;
      source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
      store_id: z.ZodOptional<z.ZodString>;
    } & {
      healthy: z.ZodBoolean;
      status: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      path: z.ZodString;
      source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
      store_id: z.ZodOptional<z.ZodString>;
    } & {
      healthy: z.ZodBoolean;
      status: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, z.ZodTypeAny, "passthrough">>>;
    storeId: z.ZodNullable<z.ZodString>;
    generation: z.ZodOptional<z.ZodString>;
    cli: z.ZodObject<{
      available: z.ZodBoolean;
      version: z.ZodOptional<z.ZodString>;
      error: z.ZodOptional<z.ZodString>;
      effectiveCommand: z.ZodOptional<z.ZodString>;
      tried: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      available: z.ZodBoolean;
      version: z.ZodOptional<z.ZodString>;
      error: z.ZodOptional<z.ZodString>;
      effectiveCommand: z.ZodOptional<z.ZodString>;
      tried: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      available: z.ZodBoolean;
      version: z.ZodOptional<z.ZodString>;
      error: z.ZodOptional<z.ZodString>;
      effectiveCommand: z.ZodOptional<z.ZodString>;
      tried: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
    }, z.ZodTypeAny, "passthrough">>;
    references: z.ZodArray<z.ZodObject<{
      store_id: z.ZodString;
      root: z.ZodOptional<z.ZodString>;
      status: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      store_id: z.ZodString;
      root: z.ZodOptional<z.ZodString>;
      status: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      store_id: z.ZodString;
      root: z.ZodOptional<z.ZodString>;
      status: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, z.ZodTypeAny, "passthrough">>, "many">;
    contextMembers: z.ZodArray<z.ZodObject<{
      role: z.ZodLiteral<"referenced_store">;
      id: z.ZodString;
      path: z.ZodOptional<z.ZodString>;
      remote: z.ZodOptional<z.ZodString>;
      fetch: z.ZodOptional<z.ZodString>;
      status: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      role: z.ZodLiteral<"referenced_store">;
      id: z.ZodString;
      path: z.ZodOptional<z.ZodString>;
      remote: z.ZodOptional<z.ZodString>;
      fetch: z.ZodOptional<z.ZodString>;
      status: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      role: z.ZodLiteral<"referenced_store">;
      id: z.ZodString;
      path: z.ZodOptional<z.ZodString>;
      remote: z.ZodOptional<z.ZodString>;
      fetch: z.ZodOptional<z.ZodString>;
      status: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, z.ZodTypeAny, "passthrough">>, "many">;
    dataScope: z.ZodObject<{
      path: z.ZodString;
      source: z.ZodEnum<["xdg-data-home", "local-app-data", "user-home-default"]>;
      environmentVariable: z.ZodNullable<z.ZodEnum<["XDG_DATA_HOME", "LOCALAPPDATA"]>>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      path: z.ZodString;
      source: z.ZodEnum<["xdg-data-home", "local-app-data", "user-home-default"]>;
      environmentVariable: z.ZodNullable<z.ZodEnum<["XDG_DATA_HOME", "LOCALAPPDATA"]>>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      path: z.ZodString;
      source: z.ZodEnum<["xdg-data-home", "local-app-data", "user-home-default"]>;
      environmentVariable: z.ZodNullable<z.ZodEnum<["XDG_DATA_HOME", "LOCALAPPDATA"]>>;
    }, z.ZodTypeAny, "passthrough">>;
    diagnostics: z.ZodObject<{
      root: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
      doctor: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
      context: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      root: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
      doctor: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
      context: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      root: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
      doctor: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
      context: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, z.ZodTypeAny, "passthrough">>;
    evidence: z.ZodObject<{
      doctor: z.ZodNullable<z.ZodObject<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>>;
      context: z.ZodNullable<z.ZodObject<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      doctor: z.ZodNullable<z.ZodObject<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>>;
      context: z.ZodNullable<z.ZodObject<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      doctor: z.ZodNullable<z.ZodObject<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>>;
      context: z.ZodNullable<z.ZodObject<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>>;
    }, z.ZodTypeAny, "passthrough">>;
    observedAt: z.ZodNumber;
  }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
    launchProject: z.ZodObject<{
      path: z.ZodString;
      physicalPath: z.ZodOptional<z.ZodString>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      path: z.ZodString;
      physicalPath: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      path: z.ZodString;
      physicalPath: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">>;
    planningRoot: z.ZodNullable<z.ZodObject<{
      path: z.ZodString;
      source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
      store_id: z.ZodOptional<z.ZodString>;
    } & {
      healthy: z.ZodBoolean;
      status: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      path: z.ZodString;
      source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
      store_id: z.ZodOptional<z.ZodString>;
    } & {
      healthy: z.ZodBoolean;
      status: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      path: z.ZodString;
      source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
      store_id: z.ZodOptional<z.ZodString>;
    } & {
      healthy: z.ZodBoolean;
      status: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, z.ZodTypeAny, "passthrough">>>;
    storeId: z.ZodNullable<z.ZodString>;
    generation: z.ZodOptional<z.ZodString>;
    cli: z.ZodObject<{
      available: z.ZodBoolean;
      version: z.ZodOptional<z.ZodString>;
      error: z.ZodOptional<z.ZodString>;
      effectiveCommand: z.ZodOptional<z.ZodString>;
      tried: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      available: z.ZodBoolean;
      version: z.ZodOptional<z.ZodString>;
      error: z.ZodOptional<z.ZodString>;
      effectiveCommand: z.ZodOptional<z.ZodString>;
      tried: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      available: z.ZodBoolean;
      version: z.ZodOptional<z.ZodString>;
      error: z.ZodOptional<z.ZodString>;
      effectiveCommand: z.ZodOptional<z.ZodString>;
      tried: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
    }, z.ZodTypeAny, "passthrough">>;
    references: z.ZodArray<z.ZodObject<{
      store_id: z.ZodString;
      root: z.ZodOptional<z.ZodString>;
      status: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      store_id: z.ZodString;
      root: z.ZodOptional<z.ZodString>;
      status: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      store_id: z.ZodString;
      root: z.ZodOptional<z.ZodString>;
      status: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, z.ZodTypeAny, "passthrough">>, "many">;
    contextMembers: z.ZodArray<z.ZodObject<{
      role: z.ZodLiteral<"referenced_store">;
      id: z.ZodString;
      path: z.ZodOptional<z.ZodString>;
      remote: z.ZodOptional<z.ZodString>;
      fetch: z.ZodOptional<z.ZodString>;
      status: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      role: z.ZodLiteral<"referenced_store">;
      id: z.ZodString;
      path: z.ZodOptional<z.ZodString>;
      remote: z.ZodOptional<z.ZodString>;
      fetch: z.ZodOptional<z.ZodString>;
      status: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      role: z.ZodLiteral<"referenced_store">;
      id: z.ZodString;
      path: z.ZodOptional<z.ZodString>;
      remote: z.ZodOptional<z.ZodString>;
      fetch: z.ZodOptional<z.ZodString>;
      status: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, z.ZodTypeAny, "passthrough">>, "many">;
    dataScope: z.ZodObject<{
      path: z.ZodString;
      source: z.ZodEnum<["xdg-data-home", "local-app-data", "user-home-default"]>;
      environmentVariable: z.ZodNullable<z.ZodEnum<["XDG_DATA_HOME", "LOCALAPPDATA"]>>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      path: z.ZodString;
      source: z.ZodEnum<["xdg-data-home", "local-app-data", "user-home-default"]>;
      environmentVariable: z.ZodNullable<z.ZodEnum<["XDG_DATA_HOME", "LOCALAPPDATA"]>>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      path: z.ZodString;
      source: z.ZodEnum<["xdg-data-home", "local-app-data", "user-home-default"]>;
      environmentVariable: z.ZodNullable<z.ZodEnum<["XDG_DATA_HOME", "LOCALAPPDATA"]>>;
    }, z.ZodTypeAny, "passthrough">>;
    diagnostics: z.ZodObject<{
      root: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
      doctor: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
      context: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      root: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
      doctor: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
      context: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      root: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
      doctor: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
      context: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, z.ZodTypeAny, "passthrough">>;
    evidence: z.ZodObject<{
      doctor: z.ZodNullable<z.ZodObject<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>>;
      context: z.ZodNullable<z.ZodObject<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      doctor: z.ZodNullable<z.ZodObject<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>>;
      context: z.ZodNullable<z.ZodObject<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      doctor: z.ZodNullable<z.ZodObject<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>>;
      context: z.ZodNullable<z.ZodObject<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>>;
    }, z.ZodTypeAny, "passthrough">>;
    observedAt: z.ZodNumber;
  }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
    launchProject: z.ZodObject<{
      path: z.ZodString;
      physicalPath: z.ZodOptional<z.ZodString>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      path: z.ZodString;
      physicalPath: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      path: z.ZodString;
      physicalPath: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">>;
    planningRoot: z.ZodNullable<z.ZodObject<{
      path: z.ZodString;
      source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
      store_id: z.ZodOptional<z.ZodString>;
    } & {
      healthy: z.ZodBoolean;
      status: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      path: z.ZodString;
      source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
      store_id: z.ZodOptional<z.ZodString>;
    } & {
      healthy: z.ZodBoolean;
      status: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      path: z.ZodString;
      source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
      store_id: z.ZodOptional<z.ZodString>;
    } & {
      healthy: z.ZodBoolean;
      status: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, z.ZodTypeAny, "passthrough">>>;
    storeId: z.ZodNullable<z.ZodString>;
    generation: z.ZodOptional<z.ZodString>;
    cli: z.ZodObject<{
      available: z.ZodBoolean;
      version: z.ZodOptional<z.ZodString>;
      error: z.ZodOptional<z.ZodString>;
      effectiveCommand: z.ZodOptional<z.ZodString>;
      tried: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      available: z.ZodBoolean;
      version: z.ZodOptional<z.ZodString>;
      error: z.ZodOptional<z.ZodString>;
      effectiveCommand: z.ZodOptional<z.ZodString>;
      tried: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      available: z.ZodBoolean;
      version: z.ZodOptional<z.ZodString>;
      error: z.ZodOptional<z.ZodString>;
      effectiveCommand: z.ZodOptional<z.ZodString>;
      tried: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
    }, z.ZodTypeAny, "passthrough">>;
    references: z.ZodArray<z.ZodObject<{
      store_id: z.ZodString;
      root: z.ZodOptional<z.ZodString>;
      status: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      store_id: z.ZodString;
      root: z.ZodOptional<z.ZodString>;
      status: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      store_id: z.ZodString;
      root: z.ZodOptional<z.ZodString>;
      status: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, z.ZodTypeAny, "passthrough">>, "many">;
    contextMembers: z.ZodArray<z.ZodObject<{
      role: z.ZodLiteral<"referenced_store">;
      id: z.ZodString;
      path: z.ZodOptional<z.ZodString>;
      remote: z.ZodOptional<z.ZodString>;
      fetch: z.ZodOptional<z.ZodString>;
      status: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      role: z.ZodLiteral<"referenced_store">;
      id: z.ZodString;
      path: z.ZodOptional<z.ZodString>;
      remote: z.ZodOptional<z.ZodString>;
      fetch: z.ZodOptional<z.ZodString>;
      status: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      role: z.ZodLiteral<"referenced_store">;
      id: z.ZodString;
      path: z.ZodOptional<z.ZodString>;
      remote: z.ZodOptional<z.ZodString>;
      fetch: z.ZodOptional<z.ZodString>;
      status: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, z.ZodTypeAny, "passthrough">>, "many">;
    dataScope: z.ZodObject<{
      path: z.ZodString;
      source: z.ZodEnum<["xdg-data-home", "local-app-data", "user-home-default"]>;
      environmentVariable: z.ZodNullable<z.ZodEnum<["XDG_DATA_HOME", "LOCALAPPDATA"]>>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      path: z.ZodString;
      source: z.ZodEnum<["xdg-data-home", "local-app-data", "user-home-default"]>;
      environmentVariable: z.ZodNullable<z.ZodEnum<["XDG_DATA_HOME", "LOCALAPPDATA"]>>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      path: z.ZodString;
      source: z.ZodEnum<["xdg-data-home", "local-app-data", "user-home-default"]>;
      environmentVariable: z.ZodNullable<z.ZodEnum<["XDG_DATA_HOME", "LOCALAPPDATA"]>>;
    }, z.ZodTypeAny, "passthrough">>;
    diagnostics: z.ZodObject<{
      root: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
      doctor: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
      context: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      root: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
      doctor: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
      context: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      root: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
      doctor: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
      context: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, z.ZodTypeAny, "passthrough">>;
    evidence: z.ZodObject<{
      doctor: z.ZodNullable<z.ZodObject<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>>;
      context: z.ZodNullable<z.ZodObject<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      doctor: z.ZodNullable<z.ZodObject<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>>;
      context: z.ZodNullable<z.ZodObject<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      doctor: z.ZodNullable<z.ZodObject<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>>;
      context: z.ZodNullable<z.ZodObject<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>>;
    }, z.ZodTypeAny, "passthrough">>;
    observedAt: z.ZodNumber;
  }, z.ZodTypeAny, "passthrough">>;
  error: z.ZodObject<{
    code: z.ZodEnum<["cli-unavailable", "doctor-command-failed", "doctor-contract-drift", "root-unresolved", "root-unhealthy", "context-command-failed", "context-contract-drift", "context-root-mismatch", "references-unresolved", "resolver-failed"]>;
    message: z.ZodString;
  }, "strip", z.ZodTypeAny, {
    code: "cli-unavailable" | "doctor-command-failed" | "doctor-contract-drift" | "root-unresolved" | "root-unhealthy" | "context-command-failed" | "context-contract-drift" | "context-root-mismatch" | "references-unresolved" | "resolver-failed";
    message: string;
  }, {
    code: "cli-unavailable" | "doctor-command-failed" | "doctor-contract-drift" | "root-unresolved" | "root-unhealthy" | "context-command-failed" | "context-contract-drift" | "context-root-mismatch" | "references-unresolved" | "resolver-failed";
    message: string;
  }>;
  observedAt: z.ZodNumber;
}, "strip", z.ZodTypeAny, {
  error: {
    code: "cli-unavailable" | "doctor-command-failed" | "doctor-contract-drift" | "root-unresolved" | "root-unhealthy" | "context-command-failed" | "context-contract-drift" | "context-root-mismatch" | "references-unresolved" | "resolver-failed";
    message: string;
  };
  state: "error";
  data: z.objectOutputType<{
    launchProject: z.ZodObject<{
      path: z.ZodString;
      physicalPath: z.ZodOptional<z.ZodString>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      path: z.ZodString;
      physicalPath: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      path: z.ZodString;
      physicalPath: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">>;
    planningRoot: z.ZodNullable<z.ZodObject<{
      path: z.ZodString;
      source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
      store_id: z.ZodOptional<z.ZodString>;
    } & {
      healthy: z.ZodBoolean;
      status: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      path: z.ZodString;
      source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
      store_id: z.ZodOptional<z.ZodString>;
    } & {
      healthy: z.ZodBoolean;
      status: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      path: z.ZodString;
      source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
      store_id: z.ZodOptional<z.ZodString>;
    } & {
      healthy: z.ZodBoolean;
      status: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, z.ZodTypeAny, "passthrough">>>;
    storeId: z.ZodNullable<z.ZodString>;
    generation: z.ZodOptional<z.ZodString>;
    cli: z.ZodObject<{
      available: z.ZodBoolean;
      version: z.ZodOptional<z.ZodString>;
      error: z.ZodOptional<z.ZodString>;
      effectiveCommand: z.ZodOptional<z.ZodString>;
      tried: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      available: z.ZodBoolean;
      version: z.ZodOptional<z.ZodString>;
      error: z.ZodOptional<z.ZodString>;
      effectiveCommand: z.ZodOptional<z.ZodString>;
      tried: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      available: z.ZodBoolean;
      version: z.ZodOptional<z.ZodString>;
      error: z.ZodOptional<z.ZodString>;
      effectiveCommand: z.ZodOptional<z.ZodString>;
      tried: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
    }, z.ZodTypeAny, "passthrough">>;
    references: z.ZodArray<z.ZodObject<{
      store_id: z.ZodString;
      root: z.ZodOptional<z.ZodString>;
      status: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      store_id: z.ZodString;
      root: z.ZodOptional<z.ZodString>;
      status: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      store_id: z.ZodString;
      root: z.ZodOptional<z.ZodString>;
      status: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, z.ZodTypeAny, "passthrough">>, "many">;
    contextMembers: z.ZodArray<z.ZodObject<{
      role: z.ZodLiteral<"referenced_store">;
      id: z.ZodString;
      path: z.ZodOptional<z.ZodString>;
      remote: z.ZodOptional<z.ZodString>;
      fetch: z.ZodOptional<z.ZodString>;
      status: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      role: z.ZodLiteral<"referenced_store">;
      id: z.ZodString;
      path: z.ZodOptional<z.ZodString>;
      remote: z.ZodOptional<z.ZodString>;
      fetch: z.ZodOptional<z.ZodString>;
      status: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      role: z.ZodLiteral<"referenced_store">;
      id: z.ZodString;
      path: z.ZodOptional<z.ZodString>;
      remote: z.ZodOptional<z.ZodString>;
      fetch: z.ZodOptional<z.ZodString>;
      status: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, z.ZodTypeAny, "passthrough">>, "many">;
    dataScope: z.ZodObject<{
      path: z.ZodString;
      source: z.ZodEnum<["xdg-data-home", "local-app-data", "user-home-default"]>;
      environmentVariable: z.ZodNullable<z.ZodEnum<["XDG_DATA_HOME", "LOCALAPPDATA"]>>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      path: z.ZodString;
      source: z.ZodEnum<["xdg-data-home", "local-app-data", "user-home-default"]>;
      environmentVariable: z.ZodNullable<z.ZodEnum<["XDG_DATA_HOME", "LOCALAPPDATA"]>>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      path: z.ZodString;
      source: z.ZodEnum<["xdg-data-home", "local-app-data", "user-home-default"]>;
      environmentVariable: z.ZodNullable<z.ZodEnum<["XDG_DATA_HOME", "LOCALAPPDATA"]>>;
    }, z.ZodTypeAny, "passthrough">>;
    diagnostics: z.ZodObject<{
      root: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
      doctor: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
      context: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      root: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
      doctor: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
      context: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      root: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
      doctor: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
      context: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, z.ZodTypeAny, "passthrough">>;
    evidence: z.ZodObject<{
      doctor: z.ZodNullable<z.ZodObject<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>>;
      context: z.ZodNullable<z.ZodObject<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      doctor: z.ZodNullable<z.ZodObject<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>>;
      context: z.ZodNullable<z.ZodObject<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      doctor: z.ZodNullable<z.ZodObject<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>>;
      context: z.ZodNullable<z.ZodObject<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>>;
    }, z.ZodTypeAny, "passthrough">>;
    observedAt: z.ZodNumber;
  }, z.ZodTypeAny, "passthrough"> | null;
  observedAt: number;
  attempt: {
    storeId: string | null;
    diagnostics: {
      root: z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">[];
      context: z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">[];
      doctor: z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">[];
    } & {
      [k: string]: unknown;
    };
    evidence: {
      context: z.objectOutputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough"> | null;
      doctor: z.objectOutputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough"> | null;
    } & {
      [k: string]: unknown;
    };
    cli: {
      available: boolean;
      version?: string | undefined;
      error?: string | undefined;
      effectiveCommand?: string | undefined;
      tried?: string[] | undefined;
    } & {
      [k: string]: unknown;
    };
    references: z.objectOutputType<{
      store_id: z.ZodString;
      root: z.ZodOptional<z.ZodString>;
      status: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, z.ZodTypeAny, "passthrough">[];
    dataScope: {
      path: string;
      source: "xdg-data-home" | "local-app-data" | "user-home-default";
      environmentVariable: "XDG_DATA_HOME" | "LOCALAPPDATA" | null;
    } & {
      [k: string]: unknown;
    };
    observedAt: number;
    launchProject: {
      path: string;
      physicalPath?: string | undefined;
    } & {
      [k: string]: unknown;
    };
    planningRoot: z.objectOutputType<{
      path: z.ZodString;
      source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
      store_id: z.ZodOptional<z.ZodString>;
    } & {
      healthy: z.ZodBoolean;
      status: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, z.ZodTypeAny, "passthrough"> | null;
    contextMembers: z.objectOutputType<{
      role: z.ZodLiteral<"referenced_store">;
      id: z.ZodString;
      path: z.ZodOptional<z.ZodString>;
      remote: z.ZodOptional<z.ZodString>;
      fetch: z.ZodOptional<z.ZodString>;
      status: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, z.ZodTypeAny, "passthrough">[];
    generation?: string | undefined;
  } & {
    [k: string]: unknown;
  };
}, {
  error: {
    code: "cli-unavailable" | "doctor-command-failed" | "doctor-contract-drift" | "root-unresolved" | "root-unhealthy" | "context-command-failed" | "context-contract-drift" | "context-root-mismatch" | "references-unresolved" | "resolver-failed";
    message: string;
  };
  state: "error";
  data: z.objectInputType<{
    launchProject: z.ZodObject<{
      path: z.ZodString;
      physicalPath: z.ZodOptional<z.ZodString>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      path: z.ZodString;
      physicalPath: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      path: z.ZodString;
      physicalPath: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">>;
    planningRoot: z.ZodNullable<z.ZodObject<{
      path: z.ZodString;
      source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
      store_id: z.ZodOptional<z.ZodString>;
    } & {
      healthy: z.ZodBoolean;
      status: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      path: z.ZodString;
      source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
      store_id: z.ZodOptional<z.ZodString>;
    } & {
      healthy: z.ZodBoolean;
      status: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      path: z.ZodString;
      source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
      store_id: z.ZodOptional<z.ZodString>;
    } & {
      healthy: z.ZodBoolean;
      status: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, z.ZodTypeAny, "passthrough">>>;
    storeId: z.ZodNullable<z.ZodString>;
    generation: z.ZodOptional<z.ZodString>;
    cli: z.ZodObject<{
      available: z.ZodBoolean;
      version: z.ZodOptional<z.ZodString>;
      error: z.ZodOptional<z.ZodString>;
      effectiveCommand: z.ZodOptional<z.ZodString>;
      tried: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      available: z.ZodBoolean;
      version: z.ZodOptional<z.ZodString>;
      error: z.ZodOptional<z.ZodString>;
      effectiveCommand: z.ZodOptional<z.ZodString>;
      tried: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      available: z.ZodBoolean;
      version: z.ZodOptional<z.ZodString>;
      error: z.ZodOptional<z.ZodString>;
      effectiveCommand: z.ZodOptional<z.ZodString>;
      tried: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
    }, z.ZodTypeAny, "passthrough">>;
    references: z.ZodArray<z.ZodObject<{
      store_id: z.ZodString;
      root: z.ZodOptional<z.ZodString>;
      status: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      store_id: z.ZodString;
      root: z.ZodOptional<z.ZodString>;
      status: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      store_id: z.ZodString;
      root: z.ZodOptional<z.ZodString>;
      status: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, z.ZodTypeAny, "passthrough">>, "many">;
    contextMembers: z.ZodArray<z.ZodObject<{
      role: z.ZodLiteral<"referenced_store">;
      id: z.ZodString;
      path: z.ZodOptional<z.ZodString>;
      remote: z.ZodOptional<z.ZodString>;
      fetch: z.ZodOptional<z.ZodString>;
      status: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      role: z.ZodLiteral<"referenced_store">;
      id: z.ZodString;
      path: z.ZodOptional<z.ZodString>;
      remote: z.ZodOptional<z.ZodString>;
      fetch: z.ZodOptional<z.ZodString>;
      status: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      role: z.ZodLiteral<"referenced_store">;
      id: z.ZodString;
      path: z.ZodOptional<z.ZodString>;
      remote: z.ZodOptional<z.ZodString>;
      fetch: z.ZodOptional<z.ZodString>;
      status: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, z.ZodTypeAny, "passthrough">>, "many">;
    dataScope: z.ZodObject<{
      path: z.ZodString;
      source: z.ZodEnum<["xdg-data-home", "local-app-data", "user-home-default"]>;
      environmentVariable: z.ZodNullable<z.ZodEnum<["XDG_DATA_HOME", "LOCALAPPDATA"]>>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      path: z.ZodString;
      source: z.ZodEnum<["xdg-data-home", "local-app-data", "user-home-default"]>;
      environmentVariable: z.ZodNullable<z.ZodEnum<["XDG_DATA_HOME", "LOCALAPPDATA"]>>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      path: z.ZodString;
      source: z.ZodEnum<["xdg-data-home", "local-app-data", "user-home-default"]>;
      environmentVariable: z.ZodNullable<z.ZodEnum<["XDG_DATA_HOME", "LOCALAPPDATA"]>>;
    }, z.ZodTypeAny, "passthrough">>;
    diagnostics: z.ZodObject<{
      root: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
      doctor: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
      context: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      root: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
      doctor: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
      context: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      root: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
      doctor: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
      context: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, z.ZodTypeAny, "passthrough">>;
    evidence: z.ZodObject<{
      doctor: z.ZodNullable<z.ZodObject<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>>;
      context: z.ZodNullable<z.ZodObject<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      doctor: z.ZodNullable<z.ZodObject<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>>;
      context: z.ZodNullable<z.ZodObject<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      doctor: z.ZodNullable<z.ZodObject<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>>;
      context: z.ZodNullable<z.ZodObject<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>>;
    }, z.ZodTypeAny, "passthrough">>;
    observedAt: z.ZodNumber;
  }, z.ZodTypeAny, "passthrough"> | null;
  observedAt: number;
  attempt: {
    storeId: string | null;
    diagnostics: {
      root: z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">[];
      context: z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">[];
      doctor: z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">[];
    } & {
      [k: string]: unknown;
    };
    evidence: {
      context: z.objectInputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough"> | null;
      doctor: z.objectInputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough"> | null;
    } & {
      [k: string]: unknown;
    };
    cli: {
      available: boolean;
      version?: string | undefined;
      error?: string | undefined;
      effectiveCommand?: string | undefined;
      tried?: string[] | undefined;
    } & {
      [k: string]: unknown;
    };
    references: z.objectInputType<{
      store_id: z.ZodString;
      root: z.ZodOptional<z.ZodString>;
      status: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, z.ZodTypeAny, "passthrough">[];
    dataScope: {
      path: string;
      source: "xdg-data-home" | "local-app-data" | "user-home-default";
      environmentVariable: "XDG_DATA_HOME" | "LOCALAPPDATA" | null;
    } & {
      [k: string]: unknown;
    };
    observedAt: number;
    launchProject: {
      path: string;
      physicalPath?: string | undefined;
    } & {
      [k: string]: unknown;
    };
    planningRoot: z.objectInputType<{
      path: z.ZodString;
      source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
      store_id: z.ZodOptional<z.ZodString>;
    } & {
      healthy: z.ZodBoolean;
      status: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, z.ZodTypeAny, "passthrough"> | null;
    contextMembers: z.objectInputType<{
      role: z.ZodLiteral<"referenced_store">;
      id: z.ZodString;
      path: z.ZodOptional<z.ZodString>;
      remote: z.ZodOptional<z.ZodString>;
      fetch: z.ZodOptional<z.ZodString>;
      status: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, z.ZodTypeAny, "passthrough">[];
    generation?: string | undefined;
  } & {
    [k: string]: unknown;
  };
}>]>;
/** Browser-safe Pull lifecycle for cached Root Context CLI Projection Work. */
declare const HostedRootContextProjectionStateSchema: z.ZodDiscriminatedUnion<"state", [z.ZodObject<{
  state: z.ZodLiteral<"loading">;
  data: z.ZodNull;
  freshness: z.ZodNull;
  snapshotGeneration: z.ZodNull;
  error: z.ZodNull;
  identity: z.ZodString;
  workGeneration: z.ZodNumber;
  invalidationCause: z.ZodEnum<["initial", "dependency", "explicit-refresh", "subscriber-resume"]>;
}, "strip", z.ZodTypeAny, {
  error: null;
  state: "loading";
  data: null;
  freshness: null;
  snapshotGeneration: null;
  identity: string;
  workGeneration: number;
  invalidationCause: "dependency" | "initial" | "explicit-refresh" | "subscriber-resume";
}, {
  error: null;
  state: "loading";
  data: null;
  freshness: null;
  snapshotGeneration: null;
  identity: string;
  workGeneration: number;
  invalidationCause: "dependency" | "initial" | "explicit-refresh" | "subscriber-resume";
}>, z.ZodObject<{
  state: z.ZodLiteral<"ready">;
  data: z.ZodType<{
    error: null;
    state: "ready";
    data: {
      storeId: string | null;
      diagnostics: {
        root: z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">[];
        context: z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">[];
        doctor: z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">[];
      } & {
        [k: string]: unknown;
      };
      evidence: {
        context: z.objectOutputType<{
          success: z.ZodBoolean;
          stdout: z.ZodString;
          stderr: z.ZodString;
          exitCode: z.ZodNullable<z.ZodNumber>;
          diagnostics: z.ZodArray<z.ZodObject<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">>, "many">;
          contractError: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough"> | null;
        doctor: z.objectOutputType<{
          success: z.ZodBoolean;
          stdout: z.ZodString;
          stderr: z.ZodString;
          exitCode: z.ZodNullable<z.ZodNumber>;
          diagnostics: z.ZodArray<z.ZodObject<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">>, "many">;
          contractError: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough"> | null;
      } & {
        [k: string]: unknown;
      };
      cli: {
        available: boolean;
        version?: string | undefined;
        error?: string | undefined;
        effectiveCommand?: string | undefined;
        tried?: string[] | undefined;
      } & {
        [k: string]: unknown;
      };
      references: z.objectOutputType<{
        store_id: z.ZodString;
        root: z.ZodOptional<z.ZodString>;
        status: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
      }, z.ZodTypeAny, "passthrough">[];
      dataScope: {
        path: string;
        source: "xdg-data-home" | "local-app-data" | "user-home-default";
        environmentVariable: "XDG_DATA_HOME" | "LOCALAPPDATA" | null;
      } & {
        [k: string]: unknown;
      };
      observedAt: number;
      launchProject: {
        path: string;
        physicalPath?: string | undefined;
      } & {
        [k: string]: unknown;
      };
      planningRoot: z.objectOutputType<{
        path: z.ZodString;
        source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
        store_id: z.ZodOptional<z.ZodString>;
      } & {
        healthy: z.ZodBoolean;
        status: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
      }, z.ZodTypeAny, "passthrough"> | null;
      contextMembers: z.objectOutputType<{
        role: z.ZodLiteral<"referenced_store">;
        id: z.ZodString;
        path: z.ZodOptional<z.ZodString>;
        remote: z.ZodOptional<z.ZodString>;
        fetch: z.ZodOptional<z.ZodString>;
        status: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
      }, z.ZodTypeAny, "passthrough">[];
      generation?: string | undefined;
    } & {
      [k: string]: unknown;
    };
    observedAt: number;
    attempt: null;
  } | {
    error: {
      code: "cli-unavailable" | "doctor-command-failed" | "doctor-contract-drift" | "root-unresolved" | "root-unhealthy" | "context-command-failed" | "context-contract-drift" | "context-root-mismatch" | "references-unresolved" | "resolver-failed";
      message: string;
    };
    state: "error";
    data: z.objectOutputType<{
      launchProject: z.ZodObject<{
        path: z.ZodString;
        physicalPath: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        path: z.ZodString;
        physicalPath: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        path: z.ZodString;
        physicalPath: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>;
      planningRoot: z.ZodNullable<z.ZodObject<{
        path: z.ZodString;
        source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
        store_id: z.ZodOptional<z.ZodString>;
      } & {
        healthy: z.ZodBoolean;
        status: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        path: z.ZodString;
        source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
        store_id: z.ZodOptional<z.ZodString>;
      } & {
        healthy: z.ZodBoolean;
        status: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        path: z.ZodString;
        source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
        store_id: z.ZodOptional<z.ZodString>;
      } & {
        healthy: z.ZodBoolean;
        status: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
      }, z.ZodTypeAny, "passthrough">>>;
      storeId: z.ZodNullable<z.ZodString>;
      generation: z.ZodOptional<z.ZodString>;
      cli: z.ZodObject<{
        available: z.ZodBoolean;
        version: z.ZodOptional<z.ZodString>;
        error: z.ZodOptional<z.ZodString>;
        effectiveCommand: z.ZodOptional<z.ZodString>;
        tried: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        available: z.ZodBoolean;
        version: z.ZodOptional<z.ZodString>;
        error: z.ZodOptional<z.ZodString>;
        effectiveCommand: z.ZodOptional<z.ZodString>;
        tried: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        available: z.ZodBoolean;
        version: z.ZodOptional<z.ZodString>;
        error: z.ZodOptional<z.ZodString>;
        effectiveCommand: z.ZodOptional<z.ZodString>;
        tried: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
      }, z.ZodTypeAny, "passthrough">>;
      references: z.ZodArray<z.ZodObject<{
        store_id: z.ZodString;
        root: z.ZodOptional<z.ZodString>;
        status: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        store_id: z.ZodString;
        root: z.ZodOptional<z.ZodString>;
        status: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        store_id: z.ZodString;
        root: z.ZodOptional<z.ZodString>;
        status: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
      }, z.ZodTypeAny, "passthrough">>, "many">;
      contextMembers: z.ZodArray<z.ZodObject<{
        role: z.ZodLiteral<"referenced_store">;
        id: z.ZodString;
        path: z.ZodOptional<z.ZodString>;
        remote: z.ZodOptional<z.ZodString>;
        fetch: z.ZodOptional<z.ZodString>;
        status: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        role: z.ZodLiteral<"referenced_store">;
        id: z.ZodString;
        path: z.ZodOptional<z.ZodString>;
        remote: z.ZodOptional<z.ZodString>;
        fetch: z.ZodOptional<z.ZodString>;
        status: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        role: z.ZodLiteral<"referenced_store">;
        id: z.ZodString;
        path: z.ZodOptional<z.ZodString>;
        remote: z.ZodOptional<z.ZodString>;
        fetch: z.ZodOptional<z.ZodString>;
        status: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
      }, z.ZodTypeAny, "passthrough">>, "many">;
      dataScope: z.ZodObject<{
        path: z.ZodString;
        source: z.ZodEnum<["xdg-data-home", "local-app-data", "user-home-default"]>;
        environmentVariable: z.ZodNullable<z.ZodEnum<["XDG_DATA_HOME", "LOCALAPPDATA"]>>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        path: z.ZodString;
        source: z.ZodEnum<["xdg-data-home", "local-app-data", "user-home-default"]>;
        environmentVariable: z.ZodNullable<z.ZodEnum<["XDG_DATA_HOME", "LOCALAPPDATA"]>>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        path: z.ZodString;
        source: z.ZodEnum<["xdg-data-home", "local-app-data", "user-home-default"]>;
        environmentVariable: z.ZodNullable<z.ZodEnum<["XDG_DATA_HOME", "LOCALAPPDATA"]>>;
      }, z.ZodTypeAny, "passthrough">>;
      diagnostics: z.ZodObject<{
        root: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        doctor: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        context: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        root: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        doctor: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        context: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        root: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        doctor: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        context: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
      }, z.ZodTypeAny, "passthrough">>;
      evidence: z.ZodObject<{
        doctor: z.ZodNullable<z.ZodObject<{
          success: z.ZodBoolean;
          stdout: z.ZodString;
          stderr: z.ZodString;
          exitCode: z.ZodNullable<z.ZodNumber>;
          diagnostics: z.ZodArray<z.ZodObject<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">>, "many">;
          contractError: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          success: z.ZodBoolean;
          stdout: z.ZodString;
          stderr: z.ZodString;
          exitCode: z.ZodNullable<z.ZodNumber>;
          diagnostics: z.ZodArray<z.ZodObject<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">>, "many">;
          contractError: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          success: z.ZodBoolean;
          stdout: z.ZodString;
          stderr: z.ZodString;
          exitCode: z.ZodNullable<z.ZodNumber>;
          diagnostics: z.ZodArray<z.ZodObject<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">>, "many">;
          contractError: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>>;
        context: z.ZodNullable<z.ZodObject<{
          success: z.ZodBoolean;
          stdout: z.ZodString;
          stderr: z.ZodString;
          exitCode: z.ZodNullable<z.ZodNumber>;
          diagnostics: z.ZodArray<z.ZodObject<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">>, "many">;
          contractError: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          success: z.ZodBoolean;
          stdout: z.ZodString;
          stderr: z.ZodString;
          exitCode: z.ZodNullable<z.ZodNumber>;
          diagnostics: z.ZodArray<z.ZodObject<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">>, "many">;
          contractError: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          success: z.ZodBoolean;
          stdout: z.ZodString;
          stderr: z.ZodString;
          exitCode: z.ZodNullable<z.ZodNumber>;
          diagnostics: z.ZodArray<z.ZodObject<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">>, "many">;
          contractError: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        doctor: z.ZodNullable<z.ZodObject<{
          success: z.ZodBoolean;
          stdout: z.ZodString;
          stderr: z.ZodString;
          exitCode: z.ZodNullable<z.ZodNumber>;
          diagnostics: z.ZodArray<z.ZodObject<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">>, "many">;
          contractError: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          success: z.ZodBoolean;
          stdout: z.ZodString;
          stderr: z.ZodString;
          exitCode: z.ZodNullable<z.ZodNumber>;
          diagnostics: z.ZodArray<z.ZodObject<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">>, "many">;
          contractError: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          success: z.ZodBoolean;
          stdout: z.ZodString;
          stderr: z.ZodString;
          exitCode: z.ZodNullable<z.ZodNumber>;
          diagnostics: z.ZodArray<z.ZodObject<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">>, "many">;
          contractError: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>>;
        context: z.ZodNullable<z.ZodObject<{
          success: z.ZodBoolean;
          stdout: z.ZodString;
          stderr: z.ZodString;
          exitCode: z.ZodNullable<z.ZodNumber>;
          diagnostics: z.ZodArray<z.ZodObject<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">>, "many">;
          contractError: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          success: z.ZodBoolean;
          stdout: z.ZodString;
          stderr: z.ZodString;
          exitCode: z.ZodNullable<z.ZodNumber>;
          diagnostics: z.ZodArray<z.ZodObject<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">>, "many">;
          contractError: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          success: z.ZodBoolean;
          stdout: z.ZodString;
          stderr: z.ZodString;
          exitCode: z.ZodNullable<z.ZodNumber>;
          diagnostics: z.ZodArray<z.ZodObject<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">>, "many">;
          contractError: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        doctor: z.ZodNullable<z.ZodObject<{
          success: z.ZodBoolean;
          stdout: z.ZodString;
          stderr: z.ZodString;
          exitCode: z.ZodNullable<z.ZodNumber>;
          diagnostics: z.ZodArray<z.ZodObject<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">>, "many">;
          contractError: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          success: z.ZodBoolean;
          stdout: z.ZodString;
          stderr: z.ZodString;
          exitCode: z.ZodNullable<z.ZodNumber>;
          diagnostics: z.ZodArray<z.ZodObject<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">>, "many">;
          contractError: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          success: z.ZodBoolean;
          stdout: z.ZodString;
          stderr: z.ZodString;
          exitCode: z.ZodNullable<z.ZodNumber>;
          diagnostics: z.ZodArray<z.ZodObject<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">>, "many">;
          contractError: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>>;
        context: z.ZodNullable<z.ZodObject<{
          success: z.ZodBoolean;
          stdout: z.ZodString;
          stderr: z.ZodString;
          exitCode: z.ZodNullable<z.ZodNumber>;
          diagnostics: z.ZodArray<z.ZodObject<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">>, "many">;
          contractError: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          success: z.ZodBoolean;
          stdout: z.ZodString;
          stderr: z.ZodString;
          exitCode: z.ZodNullable<z.ZodNumber>;
          diagnostics: z.ZodArray<z.ZodObject<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">>, "many">;
          contractError: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          success: z.ZodBoolean;
          stdout: z.ZodString;
          stderr: z.ZodString;
          exitCode: z.ZodNullable<z.ZodNumber>;
          diagnostics: z.ZodArray<z.ZodObject<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">>, "many">;
          contractError: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>>;
      }, z.ZodTypeAny, "passthrough">>;
      observedAt: z.ZodNumber;
    }, z.ZodTypeAny, "passthrough"> | null;
    observedAt: number;
    attempt: {
      storeId: string | null;
      diagnostics: {
        root: z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">[];
        context: z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">[];
        doctor: z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">[];
      } & {
        [k: string]: unknown;
      };
      evidence: {
        context: z.objectOutputType<{
          success: z.ZodBoolean;
          stdout: z.ZodString;
          stderr: z.ZodString;
          exitCode: z.ZodNullable<z.ZodNumber>;
          diagnostics: z.ZodArray<z.ZodObject<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">>, "many">;
          contractError: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough"> | null;
        doctor: z.objectOutputType<{
          success: z.ZodBoolean;
          stdout: z.ZodString;
          stderr: z.ZodString;
          exitCode: z.ZodNullable<z.ZodNumber>;
          diagnostics: z.ZodArray<z.ZodObject<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">>, "many">;
          contractError: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough"> | null;
      } & {
        [k: string]: unknown;
      };
      cli: {
        available: boolean;
        version?: string | undefined;
        error?: string | undefined;
        effectiveCommand?: string | undefined;
        tried?: string[] | undefined;
      } & {
        [k: string]: unknown;
      };
      references: z.objectOutputType<{
        store_id: z.ZodString;
        root: z.ZodOptional<z.ZodString>;
        status: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
      }, z.ZodTypeAny, "passthrough">[];
      dataScope: {
        path: string;
        source: "xdg-data-home" | "local-app-data" | "user-home-default";
        environmentVariable: "XDG_DATA_HOME" | "LOCALAPPDATA" | null;
      } & {
        [k: string]: unknown;
      };
      observedAt: number;
      launchProject: {
        path: string;
        physicalPath?: string | undefined;
      } & {
        [k: string]: unknown;
      };
      planningRoot: z.objectOutputType<{
        path: z.ZodString;
        source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
        store_id: z.ZodOptional<z.ZodString>;
      } & {
        healthy: z.ZodBoolean;
        status: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
      }, z.ZodTypeAny, "passthrough"> | null;
      contextMembers: z.objectOutputType<{
        role: z.ZodLiteral<"referenced_store">;
        id: z.ZodString;
        path: z.ZodOptional<z.ZodString>;
        remote: z.ZodOptional<z.ZodString>;
        fetch: z.ZodOptional<z.ZodString>;
        status: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
      }, z.ZodTypeAny, "passthrough">[];
      generation?: string | undefined;
    } & {
      [k: string]: unknown;
    };
  }, z.ZodTypeDef, {
    error: null;
    state: "ready";
    data: {
      storeId: string | null;
      diagnostics: {
        root: z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">[];
        context: z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">[];
        doctor: z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">[];
      } & {
        [k: string]: unknown;
      };
      evidence: {
        context: z.objectInputType<{
          success: z.ZodBoolean;
          stdout: z.ZodString;
          stderr: z.ZodString;
          exitCode: z.ZodNullable<z.ZodNumber>;
          diagnostics: z.ZodArray<z.ZodObject<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">>, "many">;
          contractError: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough"> | null;
        doctor: z.objectInputType<{
          success: z.ZodBoolean;
          stdout: z.ZodString;
          stderr: z.ZodString;
          exitCode: z.ZodNullable<z.ZodNumber>;
          diagnostics: z.ZodArray<z.ZodObject<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">>, "many">;
          contractError: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough"> | null;
      } & {
        [k: string]: unknown;
      };
      cli: {
        available: boolean;
        version?: string | undefined;
        error?: string | undefined;
        effectiveCommand?: string | undefined;
        tried?: string[] | undefined;
      } & {
        [k: string]: unknown;
      };
      references: z.objectInputType<{
        store_id: z.ZodString;
        root: z.ZodOptional<z.ZodString>;
        status: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
      }, z.ZodTypeAny, "passthrough">[];
      dataScope: {
        path: string;
        source: "xdg-data-home" | "local-app-data" | "user-home-default";
        environmentVariable: "XDG_DATA_HOME" | "LOCALAPPDATA" | null;
      } & {
        [k: string]: unknown;
      };
      observedAt: number;
      launchProject: {
        path: string;
        physicalPath?: string | undefined;
      } & {
        [k: string]: unknown;
      };
      planningRoot: z.objectInputType<{
        path: z.ZodString;
        source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
        store_id: z.ZodOptional<z.ZodString>;
      } & {
        healthy: z.ZodBoolean;
        status: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
      }, z.ZodTypeAny, "passthrough"> | null;
      contextMembers: z.objectInputType<{
        role: z.ZodLiteral<"referenced_store">;
        id: z.ZodString;
        path: z.ZodOptional<z.ZodString>;
        remote: z.ZodOptional<z.ZodString>;
        fetch: z.ZodOptional<z.ZodString>;
        status: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
      }, z.ZodTypeAny, "passthrough">[];
      generation?: string | undefined;
    } & {
      [k: string]: unknown;
    };
    observedAt: number;
    attempt: null;
  } | {
    error: {
      code: "cli-unavailable" | "doctor-command-failed" | "doctor-contract-drift" | "root-unresolved" | "root-unhealthy" | "context-command-failed" | "context-contract-drift" | "context-root-mismatch" | "references-unresolved" | "resolver-failed";
      message: string;
    };
    state: "error";
    data: z.objectInputType<{
      launchProject: z.ZodObject<{
        path: z.ZodString;
        physicalPath: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        path: z.ZodString;
        physicalPath: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        path: z.ZodString;
        physicalPath: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>;
      planningRoot: z.ZodNullable<z.ZodObject<{
        path: z.ZodString;
        source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
        store_id: z.ZodOptional<z.ZodString>;
      } & {
        healthy: z.ZodBoolean;
        status: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        path: z.ZodString;
        source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
        store_id: z.ZodOptional<z.ZodString>;
      } & {
        healthy: z.ZodBoolean;
        status: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        path: z.ZodString;
        source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
        store_id: z.ZodOptional<z.ZodString>;
      } & {
        healthy: z.ZodBoolean;
        status: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
      }, z.ZodTypeAny, "passthrough">>>;
      storeId: z.ZodNullable<z.ZodString>;
      generation: z.ZodOptional<z.ZodString>;
      cli: z.ZodObject<{
        available: z.ZodBoolean;
        version: z.ZodOptional<z.ZodString>;
        error: z.ZodOptional<z.ZodString>;
        effectiveCommand: z.ZodOptional<z.ZodString>;
        tried: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        available: z.ZodBoolean;
        version: z.ZodOptional<z.ZodString>;
        error: z.ZodOptional<z.ZodString>;
        effectiveCommand: z.ZodOptional<z.ZodString>;
        tried: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        available: z.ZodBoolean;
        version: z.ZodOptional<z.ZodString>;
        error: z.ZodOptional<z.ZodString>;
        effectiveCommand: z.ZodOptional<z.ZodString>;
        tried: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
      }, z.ZodTypeAny, "passthrough">>;
      references: z.ZodArray<z.ZodObject<{
        store_id: z.ZodString;
        root: z.ZodOptional<z.ZodString>;
        status: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        store_id: z.ZodString;
        root: z.ZodOptional<z.ZodString>;
        status: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        store_id: z.ZodString;
        root: z.ZodOptional<z.ZodString>;
        status: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
      }, z.ZodTypeAny, "passthrough">>, "many">;
      contextMembers: z.ZodArray<z.ZodObject<{
        role: z.ZodLiteral<"referenced_store">;
        id: z.ZodString;
        path: z.ZodOptional<z.ZodString>;
        remote: z.ZodOptional<z.ZodString>;
        fetch: z.ZodOptional<z.ZodString>;
        status: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        role: z.ZodLiteral<"referenced_store">;
        id: z.ZodString;
        path: z.ZodOptional<z.ZodString>;
        remote: z.ZodOptional<z.ZodString>;
        fetch: z.ZodOptional<z.ZodString>;
        status: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        role: z.ZodLiteral<"referenced_store">;
        id: z.ZodString;
        path: z.ZodOptional<z.ZodString>;
        remote: z.ZodOptional<z.ZodString>;
        fetch: z.ZodOptional<z.ZodString>;
        status: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
      }, z.ZodTypeAny, "passthrough">>, "many">;
      dataScope: z.ZodObject<{
        path: z.ZodString;
        source: z.ZodEnum<["xdg-data-home", "local-app-data", "user-home-default"]>;
        environmentVariable: z.ZodNullable<z.ZodEnum<["XDG_DATA_HOME", "LOCALAPPDATA"]>>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        path: z.ZodString;
        source: z.ZodEnum<["xdg-data-home", "local-app-data", "user-home-default"]>;
        environmentVariable: z.ZodNullable<z.ZodEnum<["XDG_DATA_HOME", "LOCALAPPDATA"]>>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        path: z.ZodString;
        source: z.ZodEnum<["xdg-data-home", "local-app-data", "user-home-default"]>;
        environmentVariable: z.ZodNullable<z.ZodEnum<["XDG_DATA_HOME", "LOCALAPPDATA"]>>;
      }, z.ZodTypeAny, "passthrough">>;
      diagnostics: z.ZodObject<{
        root: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        doctor: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        context: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        root: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        doctor: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        context: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        root: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        doctor: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        context: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
      }, z.ZodTypeAny, "passthrough">>;
      evidence: z.ZodObject<{
        doctor: z.ZodNullable<z.ZodObject<{
          success: z.ZodBoolean;
          stdout: z.ZodString;
          stderr: z.ZodString;
          exitCode: z.ZodNullable<z.ZodNumber>;
          diagnostics: z.ZodArray<z.ZodObject<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">>, "many">;
          contractError: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          success: z.ZodBoolean;
          stdout: z.ZodString;
          stderr: z.ZodString;
          exitCode: z.ZodNullable<z.ZodNumber>;
          diagnostics: z.ZodArray<z.ZodObject<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">>, "many">;
          contractError: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          success: z.ZodBoolean;
          stdout: z.ZodString;
          stderr: z.ZodString;
          exitCode: z.ZodNullable<z.ZodNumber>;
          diagnostics: z.ZodArray<z.ZodObject<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">>, "many">;
          contractError: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>>;
        context: z.ZodNullable<z.ZodObject<{
          success: z.ZodBoolean;
          stdout: z.ZodString;
          stderr: z.ZodString;
          exitCode: z.ZodNullable<z.ZodNumber>;
          diagnostics: z.ZodArray<z.ZodObject<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">>, "many">;
          contractError: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          success: z.ZodBoolean;
          stdout: z.ZodString;
          stderr: z.ZodString;
          exitCode: z.ZodNullable<z.ZodNumber>;
          diagnostics: z.ZodArray<z.ZodObject<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">>, "many">;
          contractError: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          success: z.ZodBoolean;
          stdout: z.ZodString;
          stderr: z.ZodString;
          exitCode: z.ZodNullable<z.ZodNumber>;
          diagnostics: z.ZodArray<z.ZodObject<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">>, "many">;
          contractError: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        doctor: z.ZodNullable<z.ZodObject<{
          success: z.ZodBoolean;
          stdout: z.ZodString;
          stderr: z.ZodString;
          exitCode: z.ZodNullable<z.ZodNumber>;
          diagnostics: z.ZodArray<z.ZodObject<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">>, "many">;
          contractError: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          success: z.ZodBoolean;
          stdout: z.ZodString;
          stderr: z.ZodString;
          exitCode: z.ZodNullable<z.ZodNumber>;
          diagnostics: z.ZodArray<z.ZodObject<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">>, "many">;
          contractError: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          success: z.ZodBoolean;
          stdout: z.ZodString;
          stderr: z.ZodString;
          exitCode: z.ZodNullable<z.ZodNumber>;
          diagnostics: z.ZodArray<z.ZodObject<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">>, "many">;
          contractError: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>>;
        context: z.ZodNullable<z.ZodObject<{
          success: z.ZodBoolean;
          stdout: z.ZodString;
          stderr: z.ZodString;
          exitCode: z.ZodNullable<z.ZodNumber>;
          diagnostics: z.ZodArray<z.ZodObject<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">>, "many">;
          contractError: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          success: z.ZodBoolean;
          stdout: z.ZodString;
          stderr: z.ZodString;
          exitCode: z.ZodNullable<z.ZodNumber>;
          diagnostics: z.ZodArray<z.ZodObject<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">>, "many">;
          contractError: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          success: z.ZodBoolean;
          stdout: z.ZodString;
          stderr: z.ZodString;
          exitCode: z.ZodNullable<z.ZodNumber>;
          diagnostics: z.ZodArray<z.ZodObject<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">>, "many">;
          contractError: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        doctor: z.ZodNullable<z.ZodObject<{
          success: z.ZodBoolean;
          stdout: z.ZodString;
          stderr: z.ZodString;
          exitCode: z.ZodNullable<z.ZodNumber>;
          diagnostics: z.ZodArray<z.ZodObject<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">>, "many">;
          contractError: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          success: z.ZodBoolean;
          stdout: z.ZodString;
          stderr: z.ZodString;
          exitCode: z.ZodNullable<z.ZodNumber>;
          diagnostics: z.ZodArray<z.ZodObject<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">>, "many">;
          contractError: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          success: z.ZodBoolean;
          stdout: z.ZodString;
          stderr: z.ZodString;
          exitCode: z.ZodNullable<z.ZodNumber>;
          diagnostics: z.ZodArray<z.ZodObject<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">>, "many">;
          contractError: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>>;
        context: z.ZodNullable<z.ZodObject<{
          success: z.ZodBoolean;
          stdout: z.ZodString;
          stderr: z.ZodString;
          exitCode: z.ZodNullable<z.ZodNumber>;
          diagnostics: z.ZodArray<z.ZodObject<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">>, "many">;
          contractError: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          success: z.ZodBoolean;
          stdout: z.ZodString;
          stderr: z.ZodString;
          exitCode: z.ZodNullable<z.ZodNumber>;
          diagnostics: z.ZodArray<z.ZodObject<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">>, "many">;
          contractError: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          success: z.ZodBoolean;
          stdout: z.ZodString;
          stderr: z.ZodString;
          exitCode: z.ZodNullable<z.ZodNumber>;
          diagnostics: z.ZodArray<z.ZodObject<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">>, "many">;
          contractError: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>>;
      }, z.ZodTypeAny, "passthrough">>;
      observedAt: z.ZodNumber;
    }, z.ZodTypeAny, "passthrough"> | null;
    observedAt: number;
    attempt: {
      storeId: string | null;
      diagnostics: {
        root: z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">[];
        context: z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">[];
        doctor: z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">[];
      } & {
        [k: string]: unknown;
      };
      evidence: {
        context: z.objectInputType<{
          success: z.ZodBoolean;
          stdout: z.ZodString;
          stderr: z.ZodString;
          exitCode: z.ZodNullable<z.ZodNumber>;
          diagnostics: z.ZodArray<z.ZodObject<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">>, "many">;
          contractError: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough"> | null;
        doctor: z.objectInputType<{
          success: z.ZodBoolean;
          stdout: z.ZodString;
          stderr: z.ZodString;
          exitCode: z.ZodNullable<z.ZodNumber>;
          diagnostics: z.ZodArray<z.ZodObject<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">>, "many">;
          contractError: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough"> | null;
      } & {
        [k: string]: unknown;
      };
      cli: {
        available: boolean;
        version?: string | undefined;
        error?: string | undefined;
        effectiveCommand?: string | undefined;
        tried?: string[] | undefined;
      } & {
        [k: string]: unknown;
      };
      references: z.objectInputType<{
        store_id: z.ZodString;
        root: z.ZodOptional<z.ZodString>;
        status: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
      }, z.ZodTypeAny, "passthrough">[];
      dataScope: {
        path: string;
        source: "xdg-data-home" | "local-app-data" | "user-home-default";
        environmentVariable: "XDG_DATA_HOME" | "LOCALAPPDATA" | null;
      } & {
        [k: string]: unknown;
      };
      observedAt: number;
      launchProject: {
        path: string;
        physicalPath?: string | undefined;
      } & {
        [k: string]: unknown;
      };
      planningRoot: z.objectInputType<{
        path: z.ZodString;
        source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
        store_id: z.ZodOptional<z.ZodString>;
      } & {
        healthy: z.ZodBoolean;
        status: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
      }, z.ZodTypeAny, "passthrough"> | null;
      contextMembers: z.objectInputType<{
        role: z.ZodLiteral<"referenced_store">;
        id: z.ZodString;
        path: z.ZodOptional<z.ZodString>;
        remote: z.ZodOptional<z.ZodString>;
        fetch: z.ZodOptional<z.ZodString>;
        status: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
      }, z.ZodTypeAny, "passthrough">[];
      generation?: string | undefined;
    } & {
      [k: string]: unknown;
    };
  }>;
  freshness: z.ZodLiteral<"current">;
  snapshotGeneration: z.ZodNumber;
  error: z.ZodNull;
  identity: z.ZodString;
  workGeneration: z.ZodNumber;
  invalidationCause: z.ZodEnum<["initial", "dependency", "explicit-refresh", "subscriber-resume"]>;
}, "strip", z.ZodTypeAny, {
  error: null;
  state: "ready";
  data: {
    error: null;
    state: "ready";
    data: {
      storeId: string | null;
      diagnostics: {
        root: z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">[];
        context: z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">[];
        doctor: z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">[];
      } & {
        [k: string]: unknown;
      };
      evidence: {
        context: z.objectOutputType<{
          success: z.ZodBoolean;
          stdout: z.ZodString;
          stderr: z.ZodString;
          exitCode: z.ZodNullable<z.ZodNumber>;
          diagnostics: z.ZodArray<z.ZodObject<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">>, "many">;
          contractError: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough"> | null;
        doctor: z.objectOutputType<{
          success: z.ZodBoolean;
          stdout: z.ZodString;
          stderr: z.ZodString;
          exitCode: z.ZodNullable<z.ZodNumber>;
          diagnostics: z.ZodArray<z.ZodObject<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">>, "many">;
          contractError: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough"> | null;
      } & {
        [k: string]: unknown;
      };
      cli: {
        available: boolean;
        version?: string | undefined;
        error?: string | undefined;
        effectiveCommand?: string | undefined;
        tried?: string[] | undefined;
      } & {
        [k: string]: unknown;
      };
      references: z.objectOutputType<{
        store_id: z.ZodString;
        root: z.ZodOptional<z.ZodString>;
        status: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
      }, z.ZodTypeAny, "passthrough">[];
      dataScope: {
        path: string;
        source: "xdg-data-home" | "local-app-data" | "user-home-default";
        environmentVariable: "XDG_DATA_HOME" | "LOCALAPPDATA" | null;
      } & {
        [k: string]: unknown;
      };
      observedAt: number;
      launchProject: {
        path: string;
        physicalPath?: string | undefined;
      } & {
        [k: string]: unknown;
      };
      planningRoot: z.objectOutputType<{
        path: z.ZodString;
        source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
        store_id: z.ZodOptional<z.ZodString>;
      } & {
        healthy: z.ZodBoolean;
        status: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
      }, z.ZodTypeAny, "passthrough"> | null;
      contextMembers: z.objectOutputType<{
        role: z.ZodLiteral<"referenced_store">;
        id: z.ZodString;
        path: z.ZodOptional<z.ZodString>;
        remote: z.ZodOptional<z.ZodString>;
        fetch: z.ZodOptional<z.ZodString>;
        status: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
      }, z.ZodTypeAny, "passthrough">[];
      generation?: string | undefined;
    } & {
      [k: string]: unknown;
    };
    observedAt: number;
    attempt: null;
  } | {
    error: {
      code: "cli-unavailable" | "doctor-command-failed" | "doctor-contract-drift" | "root-unresolved" | "root-unhealthy" | "context-command-failed" | "context-contract-drift" | "context-root-mismatch" | "references-unresolved" | "resolver-failed";
      message: string;
    };
    state: "error";
    data: z.objectOutputType<{
      launchProject: z.ZodObject<{
        path: z.ZodString;
        physicalPath: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        path: z.ZodString;
        physicalPath: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        path: z.ZodString;
        physicalPath: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>;
      planningRoot: z.ZodNullable<z.ZodObject<{
        path: z.ZodString;
        source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
        store_id: z.ZodOptional<z.ZodString>;
      } & {
        healthy: z.ZodBoolean;
        status: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        path: z.ZodString;
        source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
        store_id: z.ZodOptional<z.ZodString>;
      } & {
        healthy: z.ZodBoolean;
        status: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        path: z.ZodString;
        source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
        store_id: z.ZodOptional<z.ZodString>;
      } & {
        healthy: z.ZodBoolean;
        status: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
      }, z.ZodTypeAny, "passthrough">>>;
      storeId: z.ZodNullable<z.ZodString>;
      generation: z.ZodOptional<z.ZodString>;
      cli: z.ZodObject<{
        available: z.ZodBoolean;
        version: z.ZodOptional<z.ZodString>;
        error: z.ZodOptional<z.ZodString>;
        effectiveCommand: z.ZodOptional<z.ZodString>;
        tried: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        available: z.ZodBoolean;
        version: z.ZodOptional<z.ZodString>;
        error: z.ZodOptional<z.ZodString>;
        effectiveCommand: z.ZodOptional<z.ZodString>;
        tried: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        available: z.ZodBoolean;
        version: z.ZodOptional<z.ZodString>;
        error: z.ZodOptional<z.ZodString>;
        effectiveCommand: z.ZodOptional<z.ZodString>;
        tried: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
      }, z.ZodTypeAny, "passthrough">>;
      references: z.ZodArray<z.ZodObject<{
        store_id: z.ZodString;
        root: z.ZodOptional<z.ZodString>;
        status: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        store_id: z.ZodString;
        root: z.ZodOptional<z.ZodString>;
        status: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        store_id: z.ZodString;
        root: z.ZodOptional<z.ZodString>;
        status: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
      }, z.ZodTypeAny, "passthrough">>, "many">;
      contextMembers: z.ZodArray<z.ZodObject<{
        role: z.ZodLiteral<"referenced_store">;
        id: z.ZodString;
        path: z.ZodOptional<z.ZodString>;
        remote: z.ZodOptional<z.ZodString>;
        fetch: z.ZodOptional<z.ZodString>;
        status: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        role: z.ZodLiteral<"referenced_store">;
        id: z.ZodString;
        path: z.ZodOptional<z.ZodString>;
        remote: z.ZodOptional<z.ZodString>;
        fetch: z.ZodOptional<z.ZodString>;
        status: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        role: z.ZodLiteral<"referenced_store">;
        id: z.ZodString;
        path: z.ZodOptional<z.ZodString>;
        remote: z.ZodOptional<z.ZodString>;
        fetch: z.ZodOptional<z.ZodString>;
        status: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
      }, z.ZodTypeAny, "passthrough">>, "many">;
      dataScope: z.ZodObject<{
        path: z.ZodString;
        source: z.ZodEnum<["xdg-data-home", "local-app-data", "user-home-default"]>;
        environmentVariable: z.ZodNullable<z.ZodEnum<["XDG_DATA_HOME", "LOCALAPPDATA"]>>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        path: z.ZodString;
        source: z.ZodEnum<["xdg-data-home", "local-app-data", "user-home-default"]>;
        environmentVariable: z.ZodNullable<z.ZodEnum<["XDG_DATA_HOME", "LOCALAPPDATA"]>>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        path: z.ZodString;
        source: z.ZodEnum<["xdg-data-home", "local-app-data", "user-home-default"]>;
        environmentVariable: z.ZodNullable<z.ZodEnum<["XDG_DATA_HOME", "LOCALAPPDATA"]>>;
      }, z.ZodTypeAny, "passthrough">>;
      diagnostics: z.ZodObject<{
        root: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        doctor: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        context: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        root: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        doctor: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        context: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        root: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        doctor: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        context: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
      }, z.ZodTypeAny, "passthrough">>;
      evidence: z.ZodObject<{
        doctor: z.ZodNullable<z.ZodObject<{
          success: z.ZodBoolean;
          stdout: z.ZodString;
          stderr: z.ZodString;
          exitCode: z.ZodNullable<z.ZodNumber>;
          diagnostics: z.ZodArray<z.ZodObject<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">>, "many">;
          contractError: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          success: z.ZodBoolean;
          stdout: z.ZodString;
          stderr: z.ZodString;
          exitCode: z.ZodNullable<z.ZodNumber>;
          diagnostics: z.ZodArray<z.ZodObject<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">>, "many">;
          contractError: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          success: z.ZodBoolean;
          stdout: z.ZodString;
          stderr: z.ZodString;
          exitCode: z.ZodNullable<z.ZodNumber>;
          diagnostics: z.ZodArray<z.ZodObject<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">>, "many">;
          contractError: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>>;
        context: z.ZodNullable<z.ZodObject<{
          success: z.ZodBoolean;
          stdout: z.ZodString;
          stderr: z.ZodString;
          exitCode: z.ZodNullable<z.ZodNumber>;
          diagnostics: z.ZodArray<z.ZodObject<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">>, "many">;
          contractError: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          success: z.ZodBoolean;
          stdout: z.ZodString;
          stderr: z.ZodString;
          exitCode: z.ZodNullable<z.ZodNumber>;
          diagnostics: z.ZodArray<z.ZodObject<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">>, "many">;
          contractError: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          success: z.ZodBoolean;
          stdout: z.ZodString;
          stderr: z.ZodString;
          exitCode: z.ZodNullable<z.ZodNumber>;
          diagnostics: z.ZodArray<z.ZodObject<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">>, "many">;
          contractError: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        doctor: z.ZodNullable<z.ZodObject<{
          success: z.ZodBoolean;
          stdout: z.ZodString;
          stderr: z.ZodString;
          exitCode: z.ZodNullable<z.ZodNumber>;
          diagnostics: z.ZodArray<z.ZodObject<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">>, "many">;
          contractError: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          success: z.ZodBoolean;
          stdout: z.ZodString;
          stderr: z.ZodString;
          exitCode: z.ZodNullable<z.ZodNumber>;
          diagnostics: z.ZodArray<z.ZodObject<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">>, "many">;
          contractError: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          success: z.ZodBoolean;
          stdout: z.ZodString;
          stderr: z.ZodString;
          exitCode: z.ZodNullable<z.ZodNumber>;
          diagnostics: z.ZodArray<z.ZodObject<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">>, "many">;
          contractError: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>>;
        context: z.ZodNullable<z.ZodObject<{
          success: z.ZodBoolean;
          stdout: z.ZodString;
          stderr: z.ZodString;
          exitCode: z.ZodNullable<z.ZodNumber>;
          diagnostics: z.ZodArray<z.ZodObject<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">>, "many">;
          contractError: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          success: z.ZodBoolean;
          stdout: z.ZodString;
          stderr: z.ZodString;
          exitCode: z.ZodNullable<z.ZodNumber>;
          diagnostics: z.ZodArray<z.ZodObject<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">>, "many">;
          contractError: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          success: z.ZodBoolean;
          stdout: z.ZodString;
          stderr: z.ZodString;
          exitCode: z.ZodNullable<z.ZodNumber>;
          diagnostics: z.ZodArray<z.ZodObject<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">>, "many">;
          contractError: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        doctor: z.ZodNullable<z.ZodObject<{
          success: z.ZodBoolean;
          stdout: z.ZodString;
          stderr: z.ZodString;
          exitCode: z.ZodNullable<z.ZodNumber>;
          diagnostics: z.ZodArray<z.ZodObject<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">>, "many">;
          contractError: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          success: z.ZodBoolean;
          stdout: z.ZodString;
          stderr: z.ZodString;
          exitCode: z.ZodNullable<z.ZodNumber>;
          diagnostics: z.ZodArray<z.ZodObject<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">>, "many">;
          contractError: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          success: z.ZodBoolean;
          stdout: z.ZodString;
          stderr: z.ZodString;
          exitCode: z.ZodNullable<z.ZodNumber>;
          diagnostics: z.ZodArray<z.ZodObject<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">>, "many">;
          contractError: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>>;
        context: z.ZodNullable<z.ZodObject<{
          success: z.ZodBoolean;
          stdout: z.ZodString;
          stderr: z.ZodString;
          exitCode: z.ZodNullable<z.ZodNumber>;
          diagnostics: z.ZodArray<z.ZodObject<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">>, "many">;
          contractError: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          success: z.ZodBoolean;
          stdout: z.ZodString;
          stderr: z.ZodString;
          exitCode: z.ZodNullable<z.ZodNumber>;
          diagnostics: z.ZodArray<z.ZodObject<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">>, "many">;
          contractError: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          success: z.ZodBoolean;
          stdout: z.ZodString;
          stderr: z.ZodString;
          exitCode: z.ZodNullable<z.ZodNumber>;
          diagnostics: z.ZodArray<z.ZodObject<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">>, "many">;
          contractError: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>>;
      }, z.ZodTypeAny, "passthrough">>;
      observedAt: z.ZodNumber;
    }, z.ZodTypeAny, "passthrough"> | null;
    observedAt: number;
    attempt: {
      storeId: string | null;
      diagnostics: {
        root: z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">[];
        context: z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">[];
        doctor: z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">[];
      } & {
        [k: string]: unknown;
      };
      evidence: {
        context: z.objectOutputType<{
          success: z.ZodBoolean;
          stdout: z.ZodString;
          stderr: z.ZodString;
          exitCode: z.ZodNullable<z.ZodNumber>;
          diagnostics: z.ZodArray<z.ZodObject<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">>, "many">;
          contractError: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough"> | null;
        doctor: z.objectOutputType<{
          success: z.ZodBoolean;
          stdout: z.ZodString;
          stderr: z.ZodString;
          exitCode: z.ZodNullable<z.ZodNumber>;
          diagnostics: z.ZodArray<z.ZodObject<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">>, "many">;
          contractError: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough"> | null;
      } & {
        [k: string]: unknown;
      };
      cli: {
        available: boolean;
        version?: string | undefined;
        error?: string | undefined;
        effectiveCommand?: string | undefined;
        tried?: string[] | undefined;
      } & {
        [k: string]: unknown;
      };
      references: z.objectOutputType<{
        store_id: z.ZodString;
        root: z.ZodOptional<z.ZodString>;
        status: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
      }, z.ZodTypeAny, "passthrough">[];
      dataScope: {
        path: string;
        source: "xdg-data-home" | "local-app-data" | "user-home-default";
        environmentVariable: "XDG_DATA_HOME" | "LOCALAPPDATA" | null;
      } & {
        [k: string]: unknown;
      };
      observedAt: number;
      launchProject: {
        path: string;
        physicalPath?: string | undefined;
      } & {
        [k: string]: unknown;
      };
      planningRoot: z.objectOutputType<{
        path: z.ZodString;
        source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
        store_id: z.ZodOptional<z.ZodString>;
      } & {
        healthy: z.ZodBoolean;
        status: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
      }, z.ZodTypeAny, "passthrough"> | null;
      contextMembers: z.objectOutputType<{
        role: z.ZodLiteral<"referenced_store">;
        id: z.ZodString;
        path: z.ZodOptional<z.ZodString>;
        remote: z.ZodOptional<z.ZodString>;
        fetch: z.ZodOptional<z.ZodString>;
        status: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
      }, z.ZodTypeAny, "passthrough">[];
      generation?: string | undefined;
    } & {
      [k: string]: unknown;
    };
  };
  freshness: "current";
  snapshotGeneration: number;
  identity: string;
  workGeneration: number;
  invalidationCause: "dependency" | "initial" | "explicit-refresh" | "subscriber-resume";
}, {
  error: null;
  state: "ready";
  data: {
    error: null;
    state: "ready";
    data: {
      storeId: string | null;
      diagnostics: {
        root: z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">[];
        context: z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">[];
        doctor: z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">[];
      } & {
        [k: string]: unknown;
      };
      evidence: {
        context: z.objectInputType<{
          success: z.ZodBoolean;
          stdout: z.ZodString;
          stderr: z.ZodString;
          exitCode: z.ZodNullable<z.ZodNumber>;
          diagnostics: z.ZodArray<z.ZodObject<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">>, "many">;
          contractError: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough"> | null;
        doctor: z.objectInputType<{
          success: z.ZodBoolean;
          stdout: z.ZodString;
          stderr: z.ZodString;
          exitCode: z.ZodNullable<z.ZodNumber>;
          diagnostics: z.ZodArray<z.ZodObject<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">>, "many">;
          contractError: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough"> | null;
      } & {
        [k: string]: unknown;
      };
      cli: {
        available: boolean;
        version?: string | undefined;
        error?: string | undefined;
        effectiveCommand?: string | undefined;
        tried?: string[] | undefined;
      } & {
        [k: string]: unknown;
      };
      references: z.objectInputType<{
        store_id: z.ZodString;
        root: z.ZodOptional<z.ZodString>;
        status: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
      }, z.ZodTypeAny, "passthrough">[];
      dataScope: {
        path: string;
        source: "xdg-data-home" | "local-app-data" | "user-home-default";
        environmentVariable: "XDG_DATA_HOME" | "LOCALAPPDATA" | null;
      } & {
        [k: string]: unknown;
      };
      observedAt: number;
      launchProject: {
        path: string;
        physicalPath?: string | undefined;
      } & {
        [k: string]: unknown;
      };
      planningRoot: z.objectInputType<{
        path: z.ZodString;
        source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
        store_id: z.ZodOptional<z.ZodString>;
      } & {
        healthy: z.ZodBoolean;
        status: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
      }, z.ZodTypeAny, "passthrough"> | null;
      contextMembers: z.objectInputType<{
        role: z.ZodLiteral<"referenced_store">;
        id: z.ZodString;
        path: z.ZodOptional<z.ZodString>;
        remote: z.ZodOptional<z.ZodString>;
        fetch: z.ZodOptional<z.ZodString>;
        status: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
      }, z.ZodTypeAny, "passthrough">[];
      generation?: string | undefined;
    } & {
      [k: string]: unknown;
    };
    observedAt: number;
    attempt: null;
  } | {
    error: {
      code: "cli-unavailable" | "doctor-command-failed" | "doctor-contract-drift" | "root-unresolved" | "root-unhealthy" | "context-command-failed" | "context-contract-drift" | "context-root-mismatch" | "references-unresolved" | "resolver-failed";
      message: string;
    };
    state: "error";
    data: z.objectInputType<{
      launchProject: z.ZodObject<{
        path: z.ZodString;
        physicalPath: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        path: z.ZodString;
        physicalPath: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        path: z.ZodString;
        physicalPath: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>;
      planningRoot: z.ZodNullable<z.ZodObject<{
        path: z.ZodString;
        source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
        store_id: z.ZodOptional<z.ZodString>;
      } & {
        healthy: z.ZodBoolean;
        status: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        path: z.ZodString;
        source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
        store_id: z.ZodOptional<z.ZodString>;
      } & {
        healthy: z.ZodBoolean;
        status: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        path: z.ZodString;
        source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
        store_id: z.ZodOptional<z.ZodString>;
      } & {
        healthy: z.ZodBoolean;
        status: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
      }, z.ZodTypeAny, "passthrough">>>;
      storeId: z.ZodNullable<z.ZodString>;
      generation: z.ZodOptional<z.ZodString>;
      cli: z.ZodObject<{
        available: z.ZodBoolean;
        version: z.ZodOptional<z.ZodString>;
        error: z.ZodOptional<z.ZodString>;
        effectiveCommand: z.ZodOptional<z.ZodString>;
        tried: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        available: z.ZodBoolean;
        version: z.ZodOptional<z.ZodString>;
        error: z.ZodOptional<z.ZodString>;
        effectiveCommand: z.ZodOptional<z.ZodString>;
        tried: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        available: z.ZodBoolean;
        version: z.ZodOptional<z.ZodString>;
        error: z.ZodOptional<z.ZodString>;
        effectiveCommand: z.ZodOptional<z.ZodString>;
        tried: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
      }, z.ZodTypeAny, "passthrough">>;
      references: z.ZodArray<z.ZodObject<{
        store_id: z.ZodString;
        root: z.ZodOptional<z.ZodString>;
        status: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        store_id: z.ZodString;
        root: z.ZodOptional<z.ZodString>;
        status: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        store_id: z.ZodString;
        root: z.ZodOptional<z.ZodString>;
        status: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
      }, z.ZodTypeAny, "passthrough">>, "many">;
      contextMembers: z.ZodArray<z.ZodObject<{
        role: z.ZodLiteral<"referenced_store">;
        id: z.ZodString;
        path: z.ZodOptional<z.ZodString>;
        remote: z.ZodOptional<z.ZodString>;
        fetch: z.ZodOptional<z.ZodString>;
        status: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        role: z.ZodLiteral<"referenced_store">;
        id: z.ZodString;
        path: z.ZodOptional<z.ZodString>;
        remote: z.ZodOptional<z.ZodString>;
        fetch: z.ZodOptional<z.ZodString>;
        status: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        role: z.ZodLiteral<"referenced_store">;
        id: z.ZodString;
        path: z.ZodOptional<z.ZodString>;
        remote: z.ZodOptional<z.ZodString>;
        fetch: z.ZodOptional<z.ZodString>;
        status: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
      }, z.ZodTypeAny, "passthrough">>, "many">;
      dataScope: z.ZodObject<{
        path: z.ZodString;
        source: z.ZodEnum<["xdg-data-home", "local-app-data", "user-home-default"]>;
        environmentVariable: z.ZodNullable<z.ZodEnum<["XDG_DATA_HOME", "LOCALAPPDATA"]>>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        path: z.ZodString;
        source: z.ZodEnum<["xdg-data-home", "local-app-data", "user-home-default"]>;
        environmentVariable: z.ZodNullable<z.ZodEnum<["XDG_DATA_HOME", "LOCALAPPDATA"]>>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        path: z.ZodString;
        source: z.ZodEnum<["xdg-data-home", "local-app-data", "user-home-default"]>;
        environmentVariable: z.ZodNullable<z.ZodEnum<["XDG_DATA_HOME", "LOCALAPPDATA"]>>;
      }, z.ZodTypeAny, "passthrough">>;
      diagnostics: z.ZodObject<{
        root: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        doctor: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        context: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        root: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        doctor: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        context: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        root: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        doctor: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        context: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
      }, z.ZodTypeAny, "passthrough">>;
      evidence: z.ZodObject<{
        doctor: z.ZodNullable<z.ZodObject<{
          success: z.ZodBoolean;
          stdout: z.ZodString;
          stderr: z.ZodString;
          exitCode: z.ZodNullable<z.ZodNumber>;
          diagnostics: z.ZodArray<z.ZodObject<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">>, "many">;
          contractError: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          success: z.ZodBoolean;
          stdout: z.ZodString;
          stderr: z.ZodString;
          exitCode: z.ZodNullable<z.ZodNumber>;
          diagnostics: z.ZodArray<z.ZodObject<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">>, "many">;
          contractError: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          success: z.ZodBoolean;
          stdout: z.ZodString;
          stderr: z.ZodString;
          exitCode: z.ZodNullable<z.ZodNumber>;
          diagnostics: z.ZodArray<z.ZodObject<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">>, "many">;
          contractError: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>>;
        context: z.ZodNullable<z.ZodObject<{
          success: z.ZodBoolean;
          stdout: z.ZodString;
          stderr: z.ZodString;
          exitCode: z.ZodNullable<z.ZodNumber>;
          diagnostics: z.ZodArray<z.ZodObject<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">>, "many">;
          contractError: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          success: z.ZodBoolean;
          stdout: z.ZodString;
          stderr: z.ZodString;
          exitCode: z.ZodNullable<z.ZodNumber>;
          diagnostics: z.ZodArray<z.ZodObject<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">>, "many">;
          contractError: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          success: z.ZodBoolean;
          stdout: z.ZodString;
          stderr: z.ZodString;
          exitCode: z.ZodNullable<z.ZodNumber>;
          diagnostics: z.ZodArray<z.ZodObject<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">>, "many">;
          contractError: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        doctor: z.ZodNullable<z.ZodObject<{
          success: z.ZodBoolean;
          stdout: z.ZodString;
          stderr: z.ZodString;
          exitCode: z.ZodNullable<z.ZodNumber>;
          diagnostics: z.ZodArray<z.ZodObject<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">>, "many">;
          contractError: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          success: z.ZodBoolean;
          stdout: z.ZodString;
          stderr: z.ZodString;
          exitCode: z.ZodNullable<z.ZodNumber>;
          diagnostics: z.ZodArray<z.ZodObject<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">>, "many">;
          contractError: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          success: z.ZodBoolean;
          stdout: z.ZodString;
          stderr: z.ZodString;
          exitCode: z.ZodNullable<z.ZodNumber>;
          diagnostics: z.ZodArray<z.ZodObject<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">>, "many">;
          contractError: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>>;
        context: z.ZodNullable<z.ZodObject<{
          success: z.ZodBoolean;
          stdout: z.ZodString;
          stderr: z.ZodString;
          exitCode: z.ZodNullable<z.ZodNumber>;
          diagnostics: z.ZodArray<z.ZodObject<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">>, "many">;
          contractError: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          success: z.ZodBoolean;
          stdout: z.ZodString;
          stderr: z.ZodString;
          exitCode: z.ZodNullable<z.ZodNumber>;
          diagnostics: z.ZodArray<z.ZodObject<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">>, "many">;
          contractError: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          success: z.ZodBoolean;
          stdout: z.ZodString;
          stderr: z.ZodString;
          exitCode: z.ZodNullable<z.ZodNumber>;
          diagnostics: z.ZodArray<z.ZodObject<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">>, "many">;
          contractError: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        doctor: z.ZodNullable<z.ZodObject<{
          success: z.ZodBoolean;
          stdout: z.ZodString;
          stderr: z.ZodString;
          exitCode: z.ZodNullable<z.ZodNumber>;
          diagnostics: z.ZodArray<z.ZodObject<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">>, "many">;
          contractError: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          success: z.ZodBoolean;
          stdout: z.ZodString;
          stderr: z.ZodString;
          exitCode: z.ZodNullable<z.ZodNumber>;
          diagnostics: z.ZodArray<z.ZodObject<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">>, "many">;
          contractError: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          success: z.ZodBoolean;
          stdout: z.ZodString;
          stderr: z.ZodString;
          exitCode: z.ZodNullable<z.ZodNumber>;
          diagnostics: z.ZodArray<z.ZodObject<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">>, "many">;
          contractError: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>>;
        context: z.ZodNullable<z.ZodObject<{
          success: z.ZodBoolean;
          stdout: z.ZodString;
          stderr: z.ZodString;
          exitCode: z.ZodNullable<z.ZodNumber>;
          diagnostics: z.ZodArray<z.ZodObject<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">>, "many">;
          contractError: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          success: z.ZodBoolean;
          stdout: z.ZodString;
          stderr: z.ZodString;
          exitCode: z.ZodNullable<z.ZodNumber>;
          diagnostics: z.ZodArray<z.ZodObject<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">>, "many">;
          contractError: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          success: z.ZodBoolean;
          stdout: z.ZodString;
          stderr: z.ZodString;
          exitCode: z.ZodNullable<z.ZodNumber>;
          diagnostics: z.ZodArray<z.ZodObject<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">>, "many">;
          contractError: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>>;
      }, z.ZodTypeAny, "passthrough">>;
      observedAt: z.ZodNumber;
    }, z.ZodTypeAny, "passthrough"> | null;
    observedAt: number;
    attempt: {
      storeId: string | null;
      diagnostics: {
        root: z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">[];
        context: z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">[];
        doctor: z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">[];
      } & {
        [k: string]: unknown;
      };
      evidence: {
        context: z.objectInputType<{
          success: z.ZodBoolean;
          stdout: z.ZodString;
          stderr: z.ZodString;
          exitCode: z.ZodNullable<z.ZodNumber>;
          diagnostics: z.ZodArray<z.ZodObject<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">>, "many">;
          contractError: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough"> | null;
        doctor: z.objectInputType<{
          success: z.ZodBoolean;
          stdout: z.ZodString;
          stderr: z.ZodString;
          exitCode: z.ZodNullable<z.ZodNumber>;
          diagnostics: z.ZodArray<z.ZodObject<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">>, "many">;
          contractError: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough"> | null;
      } & {
        [k: string]: unknown;
      };
      cli: {
        available: boolean;
        version?: string | undefined;
        error?: string | undefined;
        effectiveCommand?: string | undefined;
        tried?: string[] | undefined;
      } & {
        [k: string]: unknown;
      };
      references: z.objectInputType<{
        store_id: z.ZodString;
        root: z.ZodOptional<z.ZodString>;
        status: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
      }, z.ZodTypeAny, "passthrough">[];
      dataScope: {
        path: string;
        source: "xdg-data-home" | "local-app-data" | "user-home-default";
        environmentVariable: "XDG_DATA_HOME" | "LOCALAPPDATA" | null;
      } & {
        [k: string]: unknown;
      };
      observedAt: number;
      launchProject: {
        path: string;
        physicalPath?: string | undefined;
      } & {
        [k: string]: unknown;
      };
      planningRoot: z.objectInputType<{
        path: z.ZodString;
        source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
        store_id: z.ZodOptional<z.ZodString>;
      } & {
        healthy: z.ZodBoolean;
        status: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
      }, z.ZodTypeAny, "passthrough"> | null;
      contextMembers: z.objectInputType<{
        role: z.ZodLiteral<"referenced_store">;
        id: z.ZodString;
        path: z.ZodOptional<z.ZodString>;
        remote: z.ZodOptional<z.ZodString>;
        fetch: z.ZodOptional<z.ZodString>;
        status: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
      }, z.ZodTypeAny, "passthrough">[];
      generation?: string | undefined;
    } & {
      [k: string]: unknown;
    };
  };
  freshness: "current";
  snapshotGeneration: number;
  identity: string;
  workGeneration: number;
  invalidationCause: "dependency" | "initial" | "explicit-refresh" | "subscriber-resume";
}>, z.ZodObject<{
  state: z.ZodLiteral<"revalidating">;
  data: z.ZodType<{
    error: null;
    state: "ready";
    data: {
      storeId: string | null;
      diagnostics: {
        root: z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">[];
        context: z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">[];
        doctor: z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">[];
      } & {
        [k: string]: unknown;
      };
      evidence: {
        context: z.objectOutputType<{
          success: z.ZodBoolean;
          stdout: z.ZodString;
          stderr: z.ZodString;
          exitCode: z.ZodNullable<z.ZodNumber>;
          diagnostics: z.ZodArray<z.ZodObject<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">>, "many">;
          contractError: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough"> | null;
        doctor: z.objectOutputType<{
          success: z.ZodBoolean;
          stdout: z.ZodString;
          stderr: z.ZodString;
          exitCode: z.ZodNullable<z.ZodNumber>;
          diagnostics: z.ZodArray<z.ZodObject<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">>, "many">;
          contractError: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough"> | null;
      } & {
        [k: string]: unknown;
      };
      cli: {
        available: boolean;
        version?: string | undefined;
        error?: string | undefined;
        effectiveCommand?: string | undefined;
        tried?: string[] | undefined;
      } & {
        [k: string]: unknown;
      };
      references: z.objectOutputType<{
        store_id: z.ZodString;
        root: z.ZodOptional<z.ZodString>;
        status: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
      }, z.ZodTypeAny, "passthrough">[];
      dataScope: {
        path: string;
        source: "xdg-data-home" | "local-app-data" | "user-home-default";
        environmentVariable: "XDG_DATA_HOME" | "LOCALAPPDATA" | null;
      } & {
        [k: string]: unknown;
      };
      observedAt: number;
      launchProject: {
        path: string;
        physicalPath?: string | undefined;
      } & {
        [k: string]: unknown;
      };
      planningRoot: z.objectOutputType<{
        path: z.ZodString;
        source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
        store_id: z.ZodOptional<z.ZodString>;
      } & {
        healthy: z.ZodBoolean;
        status: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
      }, z.ZodTypeAny, "passthrough"> | null;
      contextMembers: z.objectOutputType<{
        role: z.ZodLiteral<"referenced_store">;
        id: z.ZodString;
        path: z.ZodOptional<z.ZodString>;
        remote: z.ZodOptional<z.ZodString>;
        fetch: z.ZodOptional<z.ZodString>;
        status: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
      }, z.ZodTypeAny, "passthrough">[];
      generation?: string | undefined;
    } & {
      [k: string]: unknown;
    };
    observedAt: number;
    attempt: null;
  } | {
    error: {
      code: "cli-unavailable" | "doctor-command-failed" | "doctor-contract-drift" | "root-unresolved" | "root-unhealthy" | "context-command-failed" | "context-contract-drift" | "context-root-mismatch" | "references-unresolved" | "resolver-failed";
      message: string;
    };
    state: "error";
    data: z.objectOutputType<{
      launchProject: z.ZodObject<{
        path: z.ZodString;
        physicalPath: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        path: z.ZodString;
        physicalPath: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        path: z.ZodString;
        physicalPath: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>;
      planningRoot: z.ZodNullable<z.ZodObject<{
        path: z.ZodString;
        source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
        store_id: z.ZodOptional<z.ZodString>;
      } & {
        healthy: z.ZodBoolean;
        status: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        path: z.ZodString;
        source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
        store_id: z.ZodOptional<z.ZodString>;
      } & {
        healthy: z.ZodBoolean;
        status: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        path: z.ZodString;
        source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
        store_id: z.ZodOptional<z.ZodString>;
      } & {
        healthy: z.ZodBoolean;
        status: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
      }, z.ZodTypeAny, "passthrough">>>;
      storeId: z.ZodNullable<z.ZodString>;
      generation: z.ZodOptional<z.ZodString>;
      cli: z.ZodObject<{
        available: z.ZodBoolean;
        version: z.ZodOptional<z.ZodString>;
        error: z.ZodOptional<z.ZodString>;
        effectiveCommand: z.ZodOptional<z.ZodString>;
        tried: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        available: z.ZodBoolean;
        version: z.ZodOptional<z.ZodString>;
        error: z.ZodOptional<z.ZodString>;
        effectiveCommand: z.ZodOptional<z.ZodString>;
        tried: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        available: z.ZodBoolean;
        version: z.ZodOptional<z.ZodString>;
        error: z.ZodOptional<z.ZodString>;
        effectiveCommand: z.ZodOptional<z.ZodString>;
        tried: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
      }, z.ZodTypeAny, "passthrough">>;
      references: z.ZodArray<z.ZodObject<{
        store_id: z.ZodString;
        root: z.ZodOptional<z.ZodString>;
        status: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        store_id: z.ZodString;
        root: z.ZodOptional<z.ZodString>;
        status: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        store_id: z.ZodString;
        root: z.ZodOptional<z.ZodString>;
        status: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
      }, z.ZodTypeAny, "passthrough">>, "many">;
      contextMembers: z.ZodArray<z.ZodObject<{
        role: z.ZodLiteral<"referenced_store">;
        id: z.ZodString;
        path: z.ZodOptional<z.ZodString>;
        remote: z.ZodOptional<z.ZodString>;
        fetch: z.ZodOptional<z.ZodString>;
        status: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        role: z.ZodLiteral<"referenced_store">;
        id: z.ZodString;
        path: z.ZodOptional<z.ZodString>;
        remote: z.ZodOptional<z.ZodString>;
        fetch: z.ZodOptional<z.ZodString>;
        status: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        role: z.ZodLiteral<"referenced_store">;
        id: z.ZodString;
        path: z.ZodOptional<z.ZodString>;
        remote: z.ZodOptional<z.ZodString>;
        fetch: z.ZodOptional<z.ZodString>;
        status: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
      }, z.ZodTypeAny, "passthrough">>, "many">;
      dataScope: z.ZodObject<{
        path: z.ZodString;
        source: z.ZodEnum<["xdg-data-home", "local-app-data", "user-home-default"]>;
        environmentVariable: z.ZodNullable<z.ZodEnum<["XDG_DATA_HOME", "LOCALAPPDATA"]>>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        path: z.ZodString;
        source: z.ZodEnum<["xdg-data-home", "local-app-data", "user-home-default"]>;
        environmentVariable: z.ZodNullable<z.ZodEnum<["XDG_DATA_HOME", "LOCALAPPDATA"]>>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        path: z.ZodString;
        source: z.ZodEnum<["xdg-data-home", "local-app-data", "user-home-default"]>;
        environmentVariable: z.ZodNullable<z.ZodEnum<["XDG_DATA_HOME", "LOCALAPPDATA"]>>;
      }, z.ZodTypeAny, "passthrough">>;
      diagnostics: z.ZodObject<{
        root: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        doctor: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        context: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        root: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        doctor: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        context: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        root: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        doctor: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        context: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
      }, z.ZodTypeAny, "passthrough">>;
      evidence: z.ZodObject<{
        doctor: z.ZodNullable<z.ZodObject<{
          success: z.ZodBoolean;
          stdout: z.ZodString;
          stderr: z.ZodString;
          exitCode: z.ZodNullable<z.ZodNumber>;
          diagnostics: z.ZodArray<z.ZodObject<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">>, "many">;
          contractError: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          success: z.ZodBoolean;
          stdout: z.ZodString;
          stderr: z.ZodString;
          exitCode: z.ZodNullable<z.ZodNumber>;
          diagnostics: z.ZodArray<z.ZodObject<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">>, "many">;
          contractError: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          success: z.ZodBoolean;
          stdout: z.ZodString;
          stderr: z.ZodString;
          exitCode: z.ZodNullable<z.ZodNumber>;
          diagnostics: z.ZodArray<z.ZodObject<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">>, "many">;
          contractError: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>>;
        context: z.ZodNullable<z.ZodObject<{
          success: z.ZodBoolean;
          stdout: z.ZodString;
          stderr: z.ZodString;
          exitCode: z.ZodNullable<z.ZodNumber>;
          diagnostics: z.ZodArray<z.ZodObject<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">>, "many">;
          contractError: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          success: z.ZodBoolean;
          stdout: z.ZodString;
          stderr: z.ZodString;
          exitCode: z.ZodNullable<z.ZodNumber>;
          diagnostics: z.ZodArray<z.ZodObject<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">>, "many">;
          contractError: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          success: z.ZodBoolean;
          stdout: z.ZodString;
          stderr: z.ZodString;
          exitCode: z.ZodNullable<z.ZodNumber>;
          diagnostics: z.ZodArray<z.ZodObject<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">>, "many">;
          contractError: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        doctor: z.ZodNullable<z.ZodObject<{
          success: z.ZodBoolean;
          stdout: z.ZodString;
          stderr: z.ZodString;
          exitCode: z.ZodNullable<z.ZodNumber>;
          diagnostics: z.ZodArray<z.ZodObject<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">>, "many">;
          contractError: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          success: z.ZodBoolean;
          stdout: z.ZodString;
          stderr: z.ZodString;
          exitCode: z.ZodNullable<z.ZodNumber>;
          diagnostics: z.ZodArray<z.ZodObject<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">>, "many">;
          contractError: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          success: z.ZodBoolean;
          stdout: z.ZodString;
          stderr: z.ZodString;
          exitCode: z.ZodNullable<z.ZodNumber>;
          diagnostics: z.ZodArray<z.ZodObject<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">>, "many">;
          contractError: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>>;
        context: z.ZodNullable<z.ZodObject<{
          success: z.ZodBoolean;
          stdout: z.ZodString;
          stderr: z.ZodString;
          exitCode: z.ZodNullable<z.ZodNumber>;
          diagnostics: z.ZodArray<z.ZodObject<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">>, "many">;
          contractError: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          success: z.ZodBoolean;
          stdout: z.ZodString;
          stderr: z.ZodString;
          exitCode: z.ZodNullable<z.ZodNumber>;
          diagnostics: z.ZodArray<z.ZodObject<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">>, "many">;
          contractError: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          success: z.ZodBoolean;
          stdout: z.ZodString;
          stderr: z.ZodString;
          exitCode: z.ZodNullable<z.ZodNumber>;
          diagnostics: z.ZodArray<z.ZodObject<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">>, "many">;
          contractError: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        doctor: z.ZodNullable<z.ZodObject<{
          success: z.ZodBoolean;
          stdout: z.ZodString;
          stderr: z.ZodString;
          exitCode: z.ZodNullable<z.ZodNumber>;
          diagnostics: z.ZodArray<z.ZodObject<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">>, "many">;
          contractError: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          success: z.ZodBoolean;
          stdout: z.ZodString;
          stderr: z.ZodString;
          exitCode: z.ZodNullable<z.ZodNumber>;
          diagnostics: z.ZodArray<z.ZodObject<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">>, "many">;
          contractError: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          success: z.ZodBoolean;
          stdout: z.ZodString;
          stderr: z.ZodString;
          exitCode: z.ZodNullable<z.ZodNumber>;
          diagnostics: z.ZodArray<z.ZodObject<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">>, "many">;
          contractError: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>>;
        context: z.ZodNullable<z.ZodObject<{
          success: z.ZodBoolean;
          stdout: z.ZodString;
          stderr: z.ZodString;
          exitCode: z.ZodNullable<z.ZodNumber>;
          diagnostics: z.ZodArray<z.ZodObject<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">>, "many">;
          contractError: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          success: z.ZodBoolean;
          stdout: z.ZodString;
          stderr: z.ZodString;
          exitCode: z.ZodNullable<z.ZodNumber>;
          diagnostics: z.ZodArray<z.ZodObject<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">>, "many">;
          contractError: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          success: z.ZodBoolean;
          stdout: z.ZodString;
          stderr: z.ZodString;
          exitCode: z.ZodNullable<z.ZodNumber>;
          diagnostics: z.ZodArray<z.ZodObject<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">>, "many">;
          contractError: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>>;
      }, z.ZodTypeAny, "passthrough">>;
      observedAt: z.ZodNumber;
    }, z.ZodTypeAny, "passthrough"> | null;
    observedAt: number;
    attempt: {
      storeId: string | null;
      diagnostics: {
        root: z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">[];
        context: z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">[];
        doctor: z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">[];
      } & {
        [k: string]: unknown;
      };
      evidence: {
        context: z.objectOutputType<{
          success: z.ZodBoolean;
          stdout: z.ZodString;
          stderr: z.ZodString;
          exitCode: z.ZodNullable<z.ZodNumber>;
          diagnostics: z.ZodArray<z.ZodObject<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">>, "many">;
          contractError: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough"> | null;
        doctor: z.objectOutputType<{
          success: z.ZodBoolean;
          stdout: z.ZodString;
          stderr: z.ZodString;
          exitCode: z.ZodNullable<z.ZodNumber>;
          diagnostics: z.ZodArray<z.ZodObject<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">>, "many">;
          contractError: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough"> | null;
      } & {
        [k: string]: unknown;
      };
      cli: {
        available: boolean;
        version?: string | undefined;
        error?: string | undefined;
        effectiveCommand?: string | undefined;
        tried?: string[] | undefined;
      } & {
        [k: string]: unknown;
      };
      references: z.objectOutputType<{
        store_id: z.ZodString;
        root: z.ZodOptional<z.ZodString>;
        status: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
      }, z.ZodTypeAny, "passthrough">[];
      dataScope: {
        path: string;
        source: "xdg-data-home" | "local-app-data" | "user-home-default";
        environmentVariable: "XDG_DATA_HOME" | "LOCALAPPDATA" | null;
      } & {
        [k: string]: unknown;
      };
      observedAt: number;
      launchProject: {
        path: string;
        physicalPath?: string | undefined;
      } & {
        [k: string]: unknown;
      };
      planningRoot: z.objectOutputType<{
        path: z.ZodString;
        source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
        store_id: z.ZodOptional<z.ZodString>;
      } & {
        healthy: z.ZodBoolean;
        status: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
      }, z.ZodTypeAny, "passthrough"> | null;
      contextMembers: z.objectOutputType<{
        role: z.ZodLiteral<"referenced_store">;
        id: z.ZodString;
        path: z.ZodOptional<z.ZodString>;
        remote: z.ZodOptional<z.ZodString>;
        fetch: z.ZodOptional<z.ZodString>;
        status: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
      }, z.ZodTypeAny, "passthrough">[];
      generation?: string | undefined;
    } & {
      [k: string]: unknown;
    };
  }, z.ZodTypeDef, {
    error: null;
    state: "ready";
    data: {
      storeId: string | null;
      diagnostics: {
        root: z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">[];
        context: z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">[];
        doctor: z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">[];
      } & {
        [k: string]: unknown;
      };
      evidence: {
        context: z.objectInputType<{
          success: z.ZodBoolean;
          stdout: z.ZodString;
          stderr: z.ZodString;
          exitCode: z.ZodNullable<z.ZodNumber>;
          diagnostics: z.ZodArray<z.ZodObject<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">>, "many">;
          contractError: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough"> | null;
        doctor: z.objectInputType<{
          success: z.ZodBoolean;
          stdout: z.ZodString;
          stderr: z.ZodString;
          exitCode: z.ZodNullable<z.ZodNumber>;
          diagnostics: z.ZodArray<z.ZodObject<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">>, "many">;
          contractError: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough"> | null;
      } & {
        [k: string]: unknown;
      };
      cli: {
        available: boolean;
        version?: string | undefined;
        error?: string | undefined;
        effectiveCommand?: string | undefined;
        tried?: string[] | undefined;
      } & {
        [k: string]: unknown;
      };
      references: z.objectInputType<{
        store_id: z.ZodString;
        root: z.ZodOptional<z.ZodString>;
        status: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
      }, z.ZodTypeAny, "passthrough">[];
      dataScope: {
        path: string;
        source: "xdg-data-home" | "local-app-data" | "user-home-default";
        environmentVariable: "XDG_DATA_HOME" | "LOCALAPPDATA" | null;
      } & {
        [k: string]: unknown;
      };
      observedAt: number;
      launchProject: {
        path: string;
        physicalPath?: string | undefined;
      } & {
        [k: string]: unknown;
      };
      planningRoot: z.objectInputType<{
        path: z.ZodString;
        source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
        store_id: z.ZodOptional<z.ZodString>;
      } & {
        healthy: z.ZodBoolean;
        status: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
      }, z.ZodTypeAny, "passthrough"> | null;
      contextMembers: z.objectInputType<{
        role: z.ZodLiteral<"referenced_store">;
        id: z.ZodString;
        path: z.ZodOptional<z.ZodString>;
        remote: z.ZodOptional<z.ZodString>;
        fetch: z.ZodOptional<z.ZodString>;
        status: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
      }, z.ZodTypeAny, "passthrough">[];
      generation?: string | undefined;
    } & {
      [k: string]: unknown;
    };
    observedAt: number;
    attempt: null;
  } | {
    error: {
      code: "cli-unavailable" | "doctor-command-failed" | "doctor-contract-drift" | "root-unresolved" | "root-unhealthy" | "context-command-failed" | "context-contract-drift" | "context-root-mismatch" | "references-unresolved" | "resolver-failed";
      message: string;
    };
    state: "error";
    data: z.objectInputType<{
      launchProject: z.ZodObject<{
        path: z.ZodString;
        physicalPath: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        path: z.ZodString;
        physicalPath: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        path: z.ZodString;
        physicalPath: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>;
      planningRoot: z.ZodNullable<z.ZodObject<{
        path: z.ZodString;
        source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
        store_id: z.ZodOptional<z.ZodString>;
      } & {
        healthy: z.ZodBoolean;
        status: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        path: z.ZodString;
        source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
        store_id: z.ZodOptional<z.ZodString>;
      } & {
        healthy: z.ZodBoolean;
        status: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        path: z.ZodString;
        source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
        store_id: z.ZodOptional<z.ZodString>;
      } & {
        healthy: z.ZodBoolean;
        status: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
      }, z.ZodTypeAny, "passthrough">>>;
      storeId: z.ZodNullable<z.ZodString>;
      generation: z.ZodOptional<z.ZodString>;
      cli: z.ZodObject<{
        available: z.ZodBoolean;
        version: z.ZodOptional<z.ZodString>;
        error: z.ZodOptional<z.ZodString>;
        effectiveCommand: z.ZodOptional<z.ZodString>;
        tried: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        available: z.ZodBoolean;
        version: z.ZodOptional<z.ZodString>;
        error: z.ZodOptional<z.ZodString>;
        effectiveCommand: z.ZodOptional<z.ZodString>;
        tried: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        available: z.ZodBoolean;
        version: z.ZodOptional<z.ZodString>;
        error: z.ZodOptional<z.ZodString>;
        effectiveCommand: z.ZodOptional<z.ZodString>;
        tried: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
      }, z.ZodTypeAny, "passthrough">>;
      references: z.ZodArray<z.ZodObject<{
        store_id: z.ZodString;
        root: z.ZodOptional<z.ZodString>;
        status: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        store_id: z.ZodString;
        root: z.ZodOptional<z.ZodString>;
        status: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        store_id: z.ZodString;
        root: z.ZodOptional<z.ZodString>;
        status: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
      }, z.ZodTypeAny, "passthrough">>, "many">;
      contextMembers: z.ZodArray<z.ZodObject<{
        role: z.ZodLiteral<"referenced_store">;
        id: z.ZodString;
        path: z.ZodOptional<z.ZodString>;
        remote: z.ZodOptional<z.ZodString>;
        fetch: z.ZodOptional<z.ZodString>;
        status: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        role: z.ZodLiteral<"referenced_store">;
        id: z.ZodString;
        path: z.ZodOptional<z.ZodString>;
        remote: z.ZodOptional<z.ZodString>;
        fetch: z.ZodOptional<z.ZodString>;
        status: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        role: z.ZodLiteral<"referenced_store">;
        id: z.ZodString;
        path: z.ZodOptional<z.ZodString>;
        remote: z.ZodOptional<z.ZodString>;
        fetch: z.ZodOptional<z.ZodString>;
        status: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
      }, z.ZodTypeAny, "passthrough">>, "many">;
      dataScope: z.ZodObject<{
        path: z.ZodString;
        source: z.ZodEnum<["xdg-data-home", "local-app-data", "user-home-default"]>;
        environmentVariable: z.ZodNullable<z.ZodEnum<["XDG_DATA_HOME", "LOCALAPPDATA"]>>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        path: z.ZodString;
        source: z.ZodEnum<["xdg-data-home", "local-app-data", "user-home-default"]>;
        environmentVariable: z.ZodNullable<z.ZodEnum<["XDG_DATA_HOME", "LOCALAPPDATA"]>>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        path: z.ZodString;
        source: z.ZodEnum<["xdg-data-home", "local-app-data", "user-home-default"]>;
        environmentVariable: z.ZodNullable<z.ZodEnum<["XDG_DATA_HOME", "LOCALAPPDATA"]>>;
      }, z.ZodTypeAny, "passthrough">>;
      diagnostics: z.ZodObject<{
        root: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        doctor: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        context: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        root: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        doctor: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        context: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        root: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        doctor: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        context: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
      }, z.ZodTypeAny, "passthrough">>;
      evidence: z.ZodObject<{
        doctor: z.ZodNullable<z.ZodObject<{
          success: z.ZodBoolean;
          stdout: z.ZodString;
          stderr: z.ZodString;
          exitCode: z.ZodNullable<z.ZodNumber>;
          diagnostics: z.ZodArray<z.ZodObject<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">>, "many">;
          contractError: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          success: z.ZodBoolean;
          stdout: z.ZodString;
          stderr: z.ZodString;
          exitCode: z.ZodNullable<z.ZodNumber>;
          diagnostics: z.ZodArray<z.ZodObject<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">>, "many">;
          contractError: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          success: z.ZodBoolean;
          stdout: z.ZodString;
          stderr: z.ZodString;
          exitCode: z.ZodNullable<z.ZodNumber>;
          diagnostics: z.ZodArray<z.ZodObject<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">>, "many">;
          contractError: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>>;
        context: z.ZodNullable<z.ZodObject<{
          success: z.ZodBoolean;
          stdout: z.ZodString;
          stderr: z.ZodString;
          exitCode: z.ZodNullable<z.ZodNumber>;
          diagnostics: z.ZodArray<z.ZodObject<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">>, "many">;
          contractError: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          success: z.ZodBoolean;
          stdout: z.ZodString;
          stderr: z.ZodString;
          exitCode: z.ZodNullable<z.ZodNumber>;
          diagnostics: z.ZodArray<z.ZodObject<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">>, "many">;
          contractError: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          success: z.ZodBoolean;
          stdout: z.ZodString;
          stderr: z.ZodString;
          exitCode: z.ZodNullable<z.ZodNumber>;
          diagnostics: z.ZodArray<z.ZodObject<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">>, "many">;
          contractError: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        doctor: z.ZodNullable<z.ZodObject<{
          success: z.ZodBoolean;
          stdout: z.ZodString;
          stderr: z.ZodString;
          exitCode: z.ZodNullable<z.ZodNumber>;
          diagnostics: z.ZodArray<z.ZodObject<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">>, "many">;
          contractError: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          success: z.ZodBoolean;
          stdout: z.ZodString;
          stderr: z.ZodString;
          exitCode: z.ZodNullable<z.ZodNumber>;
          diagnostics: z.ZodArray<z.ZodObject<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">>, "many">;
          contractError: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          success: z.ZodBoolean;
          stdout: z.ZodString;
          stderr: z.ZodString;
          exitCode: z.ZodNullable<z.ZodNumber>;
          diagnostics: z.ZodArray<z.ZodObject<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">>, "many">;
          contractError: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>>;
        context: z.ZodNullable<z.ZodObject<{
          success: z.ZodBoolean;
          stdout: z.ZodString;
          stderr: z.ZodString;
          exitCode: z.ZodNullable<z.ZodNumber>;
          diagnostics: z.ZodArray<z.ZodObject<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">>, "many">;
          contractError: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          success: z.ZodBoolean;
          stdout: z.ZodString;
          stderr: z.ZodString;
          exitCode: z.ZodNullable<z.ZodNumber>;
          diagnostics: z.ZodArray<z.ZodObject<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">>, "many">;
          contractError: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          success: z.ZodBoolean;
          stdout: z.ZodString;
          stderr: z.ZodString;
          exitCode: z.ZodNullable<z.ZodNumber>;
          diagnostics: z.ZodArray<z.ZodObject<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">>, "many">;
          contractError: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        doctor: z.ZodNullable<z.ZodObject<{
          success: z.ZodBoolean;
          stdout: z.ZodString;
          stderr: z.ZodString;
          exitCode: z.ZodNullable<z.ZodNumber>;
          diagnostics: z.ZodArray<z.ZodObject<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">>, "many">;
          contractError: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          success: z.ZodBoolean;
          stdout: z.ZodString;
          stderr: z.ZodString;
          exitCode: z.ZodNullable<z.ZodNumber>;
          diagnostics: z.ZodArray<z.ZodObject<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">>, "many">;
          contractError: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          success: z.ZodBoolean;
          stdout: z.ZodString;
          stderr: z.ZodString;
          exitCode: z.ZodNullable<z.ZodNumber>;
          diagnostics: z.ZodArray<z.ZodObject<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">>, "many">;
          contractError: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>>;
        context: z.ZodNullable<z.ZodObject<{
          success: z.ZodBoolean;
          stdout: z.ZodString;
          stderr: z.ZodString;
          exitCode: z.ZodNullable<z.ZodNumber>;
          diagnostics: z.ZodArray<z.ZodObject<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">>, "many">;
          contractError: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          success: z.ZodBoolean;
          stdout: z.ZodString;
          stderr: z.ZodString;
          exitCode: z.ZodNullable<z.ZodNumber>;
          diagnostics: z.ZodArray<z.ZodObject<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">>, "many">;
          contractError: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          success: z.ZodBoolean;
          stdout: z.ZodString;
          stderr: z.ZodString;
          exitCode: z.ZodNullable<z.ZodNumber>;
          diagnostics: z.ZodArray<z.ZodObject<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">>, "many">;
          contractError: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>>;
      }, z.ZodTypeAny, "passthrough">>;
      observedAt: z.ZodNumber;
    }, z.ZodTypeAny, "passthrough"> | null;
    observedAt: number;
    attempt: {
      storeId: string | null;
      diagnostics: {
        root: z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">[];
        context: z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">[];
        doctor: z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">[];
      } & {
        [k: string]: unknown;
      };
      evidence: {
        context: z.objectInputType<{
          success: z.ZodBoolean;
          stdout: z.ZodString;
          stderr: z.ZodString;
          exitCode: z.ZodNullable<z.ZodNumber>;
          diagnostics: z.ZodArray<z.ZodObject<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">>, "many">;
          contractError: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough"> | null;
        doctor: z.objectInputType<{
          success: z.ZodBoolean;
          stdout: z.ZodString;
          stderr: z.ZodString;
          exitCode: z.ZodNullable<z.ZodNumber>;
          diagnostics: z.ZodArray<z.ZodObject<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">>, "many">;
          contractError: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough"> | null;
      } & {
        [k: string]: unknown;
      };
      cli: {
        available: boolean;
        version?: string | undefined;
        error?: string | undefined;
        effectiveCommand?: string | undefined;
        tried?: string[] | undefined;
      } & {
        [k: string]: unknown;
      };
      references: z.objectInputType<{
        store_id: z.ZodString;
        root: z.ZodOptional<z.ZodString>;
        status: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
      }, z.ZodTypeAny, "passthrough">[];
      dataScope: {
        path: string;
        source: "xdg-data-home" | "local-app-data" | "user-home-default";
        environmentVariable: "XDG_DATA_HOME" | "LOCALAPPDATA" | null;
      } & {
        [k: string]: unknown;
      };
      observedAt: number;
      launchProject: {
        path: string;
        physicalPath?: string | undefined;
      } & {
        [k: string]: unknown;
      };
      planningRoot: z.objectInputType<{
        path: z.ZodString;
        source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
        store_id: z.ZodOptional<z.ZodString>;
      } & {
        healthy: z.ZodBoolean;
        status: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
      }, z.ZodTypeAny, "passthrough"> | null;
      contextMembers: z.objectInputType<{
        role: z.ZodLiteral<"referenced_store">;
        id: z.ZodString;
        path: z.ZodOptional<z.ZodString>;
        remote: z.ZodOptional<z.ZodString>;
        fetch: z.ZodOptional<z.ZodString>;
        status: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
      }, z.ZodTypeAny, "passthrough">[];
      generation?: string | undefined;
    } & {
      [k: string]: unknown;
    };
  }>;
  freshness: z.ZodLiteral<"stale-display-only">;
  snapshotGeneration: z.ZodNumber;
  error: z.ZodNull;
  identity: z.ZodString;
  workGeneration: z.ZodNumber;
  invalidationCause: z.ZodEnum<["initial", "dependency", "explicit-refresh", "subscriber-resume"]>;
}, "strip", z.ZodTypeAny, {
  error: null;
  state: "revalidating";
  data: {
    error: null;
    state: "ready";
    data: {
      storeId: string | null;
      diagnostics: {
        root: z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">[];
        context: z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">[];
        doctor: z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">[];
      } & {
        [k: string]: unknown;
      };
      evidence: {
        context: z.objectOutputType<{
          success: z.ZodBoolean;
          stdout: z.ZodString;
          stderr: z.ZodString;
          exitCode: z.ZodNullable<z.ZodNumber>;
          diagnostics: z.ZodArray<z.ZodObject<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">>, "many">;
          contractError: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough"> | null;
        doctor: z.objectOutputType<{
          success: z.ZodBoolean;
          stdout: z.ZodString;
          stderr: z.ZodString;
          exitCode: z.ZodNullable<z.ZodNumber>;
          diagnostics: z.ZodArray<z.ZodObject<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">>, "many">;
          contractError: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough"> | null;
      } & {
        [k: string]: unknown;
      };
      cli: {
        available: boolean;
        version?: string | undefined;
        error?: string | undefined;
        effectiveCommand?: string | undefined;
        tried?: string[] | undefined;
      } & {
        [k: string]: unknown;
      };
      references: z.objectOutputType<{
        store_id: z.ZodString;
        root: z.ZodOptional<z.ZodString>;
        status: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
      }, z.ZodTypeAny, "passthrough">[];
      dataScope: {
        path: string;
        source: "xdg-data-home" | "local-app-data" | "user-home-default";
        environmentVariable: "XDG_DATA_HOME" | "LOCALAPPDATA" | null;
      } & {
        [k: string]: unknown;
      };
      observedAt: number;
      launchProject: {
        path: string;
        physicalPath?: string | undefined;
      } & {
        [k: string]: unknown;
      };
      planningRoot: z.objectOutputType<{
        path: z.ZodString;
        source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
        store_id: z.ZodOptional<z.ZodString>;
      } & {
        healthy: z.ZodBoolean;
        status: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
      }, z.ZodTypeAny, "passthrough"> | null;
      contextMembers: z.objectOutputType<{
        role: z.ZodLiteral<"referenced_store">;
        id: z.ZodString;
        path: z.ZodOptional<z.ZodString>;
        remote: z.ZodOptional<z.ZodString>;
        fetch: z.ZodOptional<z.ZodString>;
        status: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
      }, z.ZodTypeAny, "passthrough">[];
      generation?: string | undefined;
    } & {
      [k: string]: unknown;
    };
    observedAt: number;
    attempt: null;
  } | {
    error: {
      code: "cli-unavailable" | "doctor-command-failed" | "doctor-contract-drift" | "root-unresolved" | "root-unhealthy" | "context-command-failed" | "context-contract-drift" | "context-root-mismatch" | "references-unresolved" | "resolver-failed";
      message: string;
    };
    state: "error";
    data: z.objectOutputType<{
      launchProject: z.ZodObject<{
        path: z.ZodString;
        physicalPath: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        path: z.ZodString;
        physicalPath: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        path: z.ZodString;
        physicalPath: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>;
      planningRoot: z.ZodNullable<z.ZodObject<{
        path: z.ZodString;
        source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
        store_id: z.ZodOptional<z.ZodString>;
      } & {
        healthy: z.ZodBoolean;
        status: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        path: z.ZodString;
        source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
        store_id: z.ZodOptional<z.ZodString>;
      } & {
        healthy: z.ZodBoolean;
        status: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        path: z.ZodString;
        source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
        store_id: z.ZodOptional<z.ZodString>;
      } & {
        healthy: z.ZodBoolean;
        status: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
      }, z.ZodTypeAny, "passthrough">>>;
      storeId: z.ZodNullable<z.ZodString>;
      generation: z.ZodOptional<z.ZodString>;
      cli: z.ZodObject<{
        available: z.ZodBoolean;
        version: z.ZodOptional<z.ZodString>;
        error: z.ZodOptional<z.ZodString>;
        effectiveCommand: z.ZodOptional<z.ZodString>;
        tried: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        available: z.ZodBoolean;
        version: z.ZodOptional<z.ZodString>;
        error: z.ZodOptional<z.ZodString>;
        effectiveCommand: z.ZodOptional<z.ZodString>;
        tried: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        available: z.ZodBoolean;
        version: z.ZodOptional<z.ZodString>;
        error: z.ZodOptional<z.ZodString>;
        effectiveCommand: z.ZodOptional<z.ZodString>;
        tried: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
      }, z.ZodTypeAny, "passthrough">>;
      references: z.ZodArray<z.ZodObject<{
        store_id: z.ZodString;
        root: z.ZodOptional<z.ZodString>;
        status: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        store_id: z.ZodString;
        root: z.ZodOptional<z.ZodString>;
        status: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        store_id: z.ZodString;
        root: z.ZodOptional<z.ZodString>;
        status: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
      }, z.ZodTypeAny, "passthrough">>, "many">;
      contextMembers: z.ZodArray<z.ZodObject<{
        role: z.ZodLiteral<"referenced_store">;
        id: z.ZodString;
        path: z.ZodOptional<z.ZodString>;
        remote: z.ZodOptional<z.ZodString>;
        fetch: z.ZodOptional<z.ZodString>;
        status: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        role: z.ZodLiteral<"referenced_store">;
        id: z.ZodString;
        path: z.ZodOptional<z.ZodString>;
        remote: z.ZodOptional<z.ZodString>;
        fetch: z.ZodOptional<z.ZodString>;
        status: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        role: z.ZodLiteral<"referenced_store">;
        id: z.ZodString;
        path: z.ZodOptional<z.ZodString>;
        remote: z.ZodOptional<z.ZodString>;
        fetch: z.ZodOptional<z.ZodString>;
        status: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
      }, z.ZodTypeAny, "passthrough">>, "many">;
      dataScope: z.ZodObject<{
        path: z.ZodString;
        source: z.ZodEnum<["xdg-data-home", "local-app-data", "user-home-default"]>;
        environmentVariable: z.ZodNullable<z.ZodEnum<["XDG_DATA_HOME", "LOCALAPPDATA"]>>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        path: z.ZodString;
        source: z.ZodEnum<["xdg-data-home", "local-app-data", "user-home-default"]>;
        environmentVariable: z.ZodNullable<z.ZodEnum<["XDG_DATA_HOME", "LOCALAPPDATA"]>>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        path: z.ZodString;
        source: z.ZodEnum<["xdg-data-home", "local-app-data", "user-home-default"]>;
        environmentVariable: z.ZodNullable<z.ZodEnum<["XDG_DATA_HOME", "LOCALAPPDATA"]>>;
      }, z.ZodTypeAny, "passthrough">>;
      diagnostics: z.ZodObject<{
        root: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        doctor: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        context: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        root: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        doctor: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        context: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        root: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        doctor: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        context: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
      }, z.ZodTypeAny, "passthrough">>;
      evidence: z.ZodObject<{
        doctor: z.ZodNullable<z.ZodObject<{
          success: z.ZodBoolean;
          stdout: z.ZodString;
          stderr: z.ZodString;
          exitCode: z.ZodNullable<z.ZodNumber>;
          diagnostics: z.ZodArray<z.ZodObject<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">>, "many">;
          contractError: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          success: z.ZodBoolean;
          stdout: z.ZodString;
          stderr: z.ZodString;
          exitCode: z.ZodNullable<z.ZodNumber>;
          diagnostics: z.ZodArray<z.ZodObject<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">>, "many">;
          contractError: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          success: z.ZodBoolean;
          stdout: z.ZodString;
          stderr: z.ZodString;
          exitCode: z.ZodNullable<z.ZodNumber>;
          diagnostics: z.ZodArray<z.ZodObject<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">>, "many">;
          contractError: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>>;
        context: z.ZodNullable<z.ZodObject<{
          success: z.ZodBoolean;
          stdout: z.ZodString;
          stderr: z.ZodString;
          exitCode: z.ZodNullable<z.ZodNumber>;
          diagnostics: z.ZodArray<z.ZodObject<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">>, "many">;
          contractError: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          success: z.ZodBoolean;
          stdout: z.ZodString;
          stderr: z.ZodString;
          exitCode: z.ZodNullable<z.ZodNumber>;
          diagnostics: z.ZodArray<z.ZodObject<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">>, "many">;
          contractError: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          success: z.ZodBoolean;
          stdout: z.ZodString;
          stderr: z.ZodString;
          exitCode: z.ZodNullable<z.ZodNumber>;
          diagnostics: z.ZodArray<z.ZodObject<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">>, "many">;
          contractError: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        doctor: z.ZodNullable<z.ZodObject<{
          success: z.ZodBoolean;
          stdout: z.ZodString;
          stderr: z.ZodString;
          exitCode: z.ZodNullable<z.ZodNumber>;
          diagnostics: z.ZodArray<z.ZodObject<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">>, "many">;
          contractError: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          success: z.ZodBoolean;
          stdout: z.ZodString;
          stderr: z.ZodString;
          exitCode: z.ZodNullable<z.ZodNumber>;
          diagnostics: z.ZodArray<z.ZodObject<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">>, "many">;
          contractError: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          success: z.ZodBoolean;
          stdout: z.ZodString;
          stderr: z.ZodString;
          exitCode: z.ZodNullable<z.ZodNumber>;
          diagnostics: z.ZodArray<z.ZodObject<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">>, "many">;
          contractError: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>>;
        context: z.ZodNullable<z.ZodObject<{
          success: z.ZodBoolean;
          stdout: z.ZodString;
          stderr: z.ZodString;
          exitCode: z.ZodNullable<z.ZodNumber>;
          diagnostics: z.ZodArray<z.ZodObject<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">>, "many">;
          contractError: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          success: z.ZodBoolean;
          stdout: z.ZodString;
          stderr: z.ZodString;
          exitCode: z.ZodNullable<z.ZodNumber>;
          diagnostics: z.ZodArray<z.ZodObject<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">>, "many">;
          contractError: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          success: z.ZodBoolean;
          stdout: z.ZodString;
          stderr: z.ZodString;
          exitCode: z.ZodNullable<z.ZodNumber>;
          diagnostics: z.ZodArray<z.ZodObject<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">>, "many">;
          contractError: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        doctor: z.ZodNullable<z.ZodObject<{
          success: z.ZodBoolean;
          stdout: z.ZodString;
          stderr: z.ZodString;
          exitCode: z.ZodNullable<z.ZodNumber>;
          diagnostics: z.ZodArray<z.ZodObject<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">>, "many">;
          contractError: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          success: z.ZodBoolean;
          stdout: z.ZodString;
          stderr: z.ZodString;
          exitCode: z.ZodNullable<z.ZodNumber>;
          diagnostics: z.ZodArray<z.ZodObject<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">>, "many">;
          contractError: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          success: z.ZodBoolean;
          stdout: z.ZodString;
          stderr: z.ZodString;
          exitCode: z.ZodNullable<z.ZodNumber>;
          diagnostics: z.ZodArray<z.ZodObject<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">>, "many">;
          contractError: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>>;
        context: z.ZodNullable<z.ZodObject<{
          success: z.ZodBoolean;
          stdout: z.ZodString;
          stderr: z.ZodString;
          exitCode: z.ZodNullable<z.ZodNumber>;
          diagnostics: z.ZodArray<z.ZodObject<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">>, "many">;
          contractError: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          success: z.ZodBoolean;
          stdout: z.ZodString;
          stderr: z.ZodString;
          exitCode: z.ZodNullable<z.ZodNumber>;
          diagnostics: z.ZodArray<z.ZodObject<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">>, "many">;
          contractError: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          success: z.ZodBoolean;
          stdout: z.ZodString;
          stderr: z.ZodString;
          exitCode: z.ZodNullable<z.ZodNumber>;
          diagnostics: z.ZodArray<z.ZodObject<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">>, "many">;
          contractError: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>>;
      }, z.ZodTypeAny, "passthrough">>;
      observedAt: z.ZodNumber;
    }, z.ZodTypeAny, "passthrough"> | null;
    observedAt: number;
    attempt: {
      storeId: string | null;
      diagnostics: {
        root: z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">[];
        context: z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">[];
        doctor: z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">[];
      } & {
        [k: string]: unknown;
      };
      evidence: {
        context: z.objectOutputType<{
          success: z.ZodBoolean;
          stdout: z.ZodString;
          stderr: z.ZodString;
          exitCode: z.ZodNullable<z.ZodNumber>;
          diagnostics: z.ZodArray<z.ZodObject<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">>, "many">;
          contractError: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough"> | null;
        doctor: z.objectOutputType<{
          success: z.ZodBoolean;
          stdout: z.ZodString;
          stderr: z.ZodString;
          exitCode: z.ZodNullable<z.ZodNumber>;
          diagnostics: z.ZodArray<z.ZodObject<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">>, "many">;
          contractError: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough"> | null;
      } & {
        [k: string]: unknown;
      };
      cli: {
        available: boolean;
        version?: string | undefined;
        error?: string | undefined;
        effectiveCommand?: string | undefined;
        tried?: string[] | undefined;
      } & {
        [k: string]: unknown;
      };
      references: z.objectOutputType<{
        store_id: z.ZodString;
        root: z.ZodOptional<z.ZodString>;
        status: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
      }, z.ZodTypeAny, "passthrough">[];
      dataScope: {
        path: string;
        source: "xdg-data-home" | "local-app-data" | "user-home-default";
        environmentVariable: "XDG_DATA_HOME" | "LOCALAPPDATA" | null;
      } & {
        [k: string]: unknown;
      };
      observedAt: number;
      launchProject: {
        path: string;
        physicalPath?: string | undefined;
      } & {
        [k: string]: unknown;
      };
      planningRoot: z.objectOutputType<{
        path: z.ZodString;
        source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
        store_id: z.ZodOptional<z.ZodString>;
      } & {
        healthy: z.ZodBoolean;
        status: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
      }, z.ZodTypeAny, "passthrough"> | null;
      contextMembers: z.objectOutputType<{
        role: z.ZodLiteral<"referenced_store">;
        id: z.ZodString;
        path: z.ZodOptional<z.ZodString>;
        remote: z.ZodOptional<z.ZodString>;
        fetch: z.ZodOptional<z.ZodString>;
        status: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
      }, z.ZodTypeAny, "passthrough">[];
      generation?: string | undefined;
    } & {
      [k: string]: unknown;
    };
  };
  freshness: "stale-display-only";
  snapshotGeneration: number;
  identity: string;
  workGeneration: number;
  invalidationCause: "dependency" | "initial" | "explicit-refresh" | "subscriber-resume";
}, {
  error: null;
  state: "revalidating";
  data: {
    error: null;
    state: "ready";
    data: {
      storeId: string | null;
      diagnostics: {
        root: z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">[];
        context: z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">[];
        doctor: z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">[];
      } & {
        [k: string]: unknown;
      };
      evidence: {
        context: z.objectInputType<{
          success: z.ZodBoolean;
          stdout: z.ZodString;
          stderr: z.ZodString;
          exitCode: z.ZodNullable<z.ZodNumber>;
          diagnostics: z.ZodArray<z.ZodObject<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">>, "many">;
          contractError: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough"> | null;
        doctor: z.objectInputType<{
          success: z.ZodBoolean;
          stdout: z.ZodString;
          stderr: z.ZodString;
          exitCode: z.ZodNullable<z.ZodNumber>;
          diagnostics: z.ZodArray<z.ZodObject<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">>, "many">;
          contractError: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough"> | null;
      } & {
        [k: string]: unknown;
      };
      cli: {
        available: boolean;
        version?: string | undefined;
        error?: string | undefined;
        effectiveCommand?: string | undefined;
        tried?: string[] | undefined;
      } & {
        [k: string]: unknown;
      };
      references: z.objectInputType<{
        store_id: z.ZodString;
        root: z.ZodOptional<z.ZodString>;
        status: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
      }, z.ZodTypeAny, "passthrough">[];
      dataScope: {
        path: string;
        source: "xdg-data-home" | "local-app-data" | "user-home-default";
        environmentVariable: "XDG_DATA_HOME" | "LOCALAPPDATA" | null;
      } & {
        [k: string]: unknown;
      };
      observedAt: number;
      launchProject: {
        path: string;
        physicalPath?: string | undefined;
      } & {
        [k: string]: unknown;
      };
      planningRoot: z.objectInputType<{
        path: z.ZodString;
        source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
        store_id: z.ZodOptional<z.ZodString>;
      } & {
        healthy: z.ZodBoolean;
        status: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
      }, z.ZodTypeAny, "passthrough"> | null;
      contextMembers: z.objectInputType<{
        role: z.ZodLiteral<"referenced_store">;
        id: z.ZodString;
        path: z.ZodOptional<z.ZodString>;
        remote: z.ZodOptional<z.ZodString>;
        fetch: z.ZodOptional<z.ZodString>;
        status: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
      }, z.ZodTypeAny, "passthrough">[];
      generation?: string | undefined;
    } & {
      [k: string]: unknown;
    };
    observedAt: number;
    attempt: null;
  } | {
    error: {
      code: "cli-unavailable" | "doctor-command-failed" | "doctor-contract-drift" | "root-unresolved" | "root-unhealthy" | "context-command-failed" | "context-contract-drift" | "context-root-mismatch" | "references-unresolved" | "resolver-failed";
      message: string;
    };
    state: "error";
    data: z.objectInputType<{
      launchProject: z.ZodObject<{
        path: z.ZodString;
        physicalPath: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        path: z.ZodString;
        physicalPath: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        path: z.ZodString;
        physicalPath: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>;
      planningRoot: z.ZodNullable<z.ZodObject<{
        path: z.ZodString;
        source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
        store_id: z.ZodOptional<z.ZodString>;
      } & {
        healthy: z.ZodBoolean;
        status: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        path: z.ZodString;
        source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
        store_id: z.ZodOptional<z.ZodString>;
      } & {
        healthy: z.ZodBoolean;
        status: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        path: z.ZodString;
        source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
        store_id: z.ZodOptional<z.ZodString>;
      } & {
        healthy: z.ZodBoolean;
        status: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
      }, z.ZodTypeAny, "passthrough">>>;
      storeId: z.ZodNullable<z.ZodString>;
      generation: z.ZodOptional<z.ZodString>;
      cli: z.ZodObject<{
        available: z.ZodBoolean;
        version: z.ZodOptional<z.ZodString>;
        error: z.ZodOptional<z.ZodString>;
        effectiveCommand: z.ZodOptional<z.ZodString>;
        tried: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        available: z.ZodBoolean;
        version: z.ZodOptional<z.ZodString>;
        error: z.ZodOptional<z.ZodString>;
        effectiveCommand: z.ZodOptional<z.ZodString>;
        tried: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        available: z.ZodBoolean;
        version: z.ZodOptional<z.ZodString>;
        error: z.ZodOptional<z.ZodString>;
        effectiveCommand: z.ZodOptional<z.ZodString>;
        tried: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
      }, z.ZodTypeAny, "passthrough">>;
      references: z.ZodArray<z.ZodObject<{
        store_id: z.ZodString;
        root: z.ZodOptional<z.ZodString>;
        status: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        store_id: z.ZodString;
        root: z.ZodOptional<z.ZodString>;
        status: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        store_id: z.ZodString;
        root: z.ZodOptional<z.ZodString>;
        status: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
      }, z.ZodTypeAny, "passthrough">>, "many">;
      contextMembers: z.ZodArray<z.ZodObject<{
        role: z.ZodLiteral<"referenced_store">;
        id: z.ZodString;
        path: z.ZodOptional<z.ZodString>;
        remote: z.ZodOptional<z.ZodString>;
        fetch: z.ZodOptional<z.ZodString>;
        status: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        role: z.ZodLiteral<"referenced_store">;
        id: z.ZodString;
        path: z.ZodOptional<z.ZodString>;
        remote: z.ZodOptional<z.ZodString>;
        fetch: z.ZodOptional<z.ZodString>;
        status: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        role: z.ZodLiteral<"referenced_store">;
        id: z.ZodString;
        path: z.ZodOptional<z.ZodString>;
        remote: z.ZodOptional<z.ZodString>;
        fetch: z.ZodOptional<z.ZodString>;
        status: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
      }, z.ZodTypeAny, "passthrough">>, "many">;
      dataScope: z.ZodObject<{
        path: z.ZodString;
        source: z.ZodEnum<["xdg-data-home", "local-app-data", "user-home-default"]>;
        environmentVariable: z.ZodNullable<z.ZodEnum<["XDG_DATA_HOME", "LOCALAPPDATA"]>>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        path: z.ZodString;
        source: z.ZodEnum<["xdg-data-home", "local-app-data", "user-home-default"]>;
        environmentVariable: z.ZodNullable<z.ZodEnum<["XDG_DATA_HOME", "LOCALAPPDATA"]>>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        path: z.ZodString;
        source: z.ZodEnum<["xdg-data-home", "local-app-data", "user-home-default"]>;
        environmentVariable: z.ZodNullable<z.ZodEnum<["XDG_DATA_HOME", "LOCALAPPDATA"]>>;
      }, z.ZodTypeAny, "passthrough">>;
      diagnostics: z.ZodObject<{
        root: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        doctor: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        context: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        root: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        doctor: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        context: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        root: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        doctor: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        context: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
      }, z.ZodTypeAny, "passthrough">>;
      evidence: z.ZodObject<{
        doctor: z.ZodNullable<z.ZodObject<{
          success: z.ZodBoolean;
          stdout: z.ZodString;
          stderr: z.ZodString;
          exitCode: z.ZodNullable<z.ZodNumber>;
          diagnostics: z.ZodArray<z.ZodObject<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">>, "many">;
          contractError: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          success: z.ZodBoolean;
          stdout: z.ZodString;
          stderr: z.ZodString;
          exitCode: z.ZodNullable<z.ZodNumber>;
          diagnostics: z.ZodArray<z.ZodObject<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">>, "many">;
          contractError: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          success: z.ZodBoolean;
          stdout: z.ZodString;
          stderr: z.ZodString;
          exitCode: z.ZodNullable<z.ZodNumber>;
          diagnostics: z.ZodArray<z.ZodObject<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">>, "many">;
          contractError: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>>;
        context: z.ZodNullable<z.ZodObject<{
          success: z.ZodBoolean;
          stdout: z.ZodString;
          stderr: z.ZodString;
          exitCode: z.ZodNullable<z.ZodNumber>;
          diagnostics: z.ZodArray<z.ZodObject<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">>, "many">;
          contractError: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          success: z.ZodBoolean;
          stdout: z.ZodString;
          stderr: z.ZodString;
          exitCode: z.ZodNullable<z.ZodNumber>;
          diagnostics: z.ZodArray<z.ZodObject<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">>, "many">;
          contractError: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          success: z.ZodBoolean;
          stdout: z.ZodString;
          stderr: z.ZodString;
          exitCode: z.ZodNullable<z.ZodNumber>;
          diagnostics: z.ZodArray<z.ZodObject<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">>, "many">;
          contractError: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        doctor: z.ZodNullable<z.ZodObject<{
          success: z.ZodBoolean;
          stdout: z.ZodString;
          stderr: z.ZodString;
          exitCode: z.ZodNullable<z.ZodNumber>;
          diagnostics: z.ZodArray<z.ZodObject<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">>, "many">;
          contractError: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          success: z.ZodBoolean;
          stdout: z.ZodString;
          stderr: z.ZodString;
          exitCode: z.ZodNullable<z.ZodNumber>;
          diagnostics: z.ZodArray<z.ZodObject<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">>, "many">;
          contractError: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          success: z.ZodBoolean;
          stdout: z.ZodString;
          stderr: z.ZodString;
          exitCode: z.ZodNullable<z.ZodNumber>;
          diagnostics: z.ZodArray<z.ZodObject<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">>, "many">;
          contractError: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>>;
        context: z.ZodNullable<z.ZodObject<{
          success: z.ZodBoolean;
          stdout: z.ZodString;
          stderr: z.ZodString;
          exitCode: z.ZodNullable<z.ZodNumber>;
          diagnostics: z.ZodArray<z.ZodObject<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">>, "many">;
          contractError: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          success: z.ZodBoolean;
          stdout: z.ZodString;
          stderr: z.ZodString;
          exitCode: z.ZodNullable<z.ZodNumber>;
          diagnostics: z.ZodArray<z.ZodObject<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">>, "many">;
          contractError: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          success: z.ZodBoolean;
          stdout: z.ZodString;
          stderr: z.ZodString;
          exitCode: z.ZodNullable<z.ZodNumber>;
          diagnostics: z.ZodArray<z.ZodObject<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">>, "many">;
          contractError: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        doctor: z.ZodNullable<z.ZodObject<{
          success: z.ZodBoolean;
          stdout: z.ZodString;
          stderr: z.ZodString;
          exitCode: z.ZodNullable<z.ZodNumber>;
          diagnostics: z.ZodArray<z.ZodObject<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">>, "many">;
          contractError: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          success: z.ZodBoolean;
          stdout: z.ZodString;
          stderr: z.ZodString;
          exitCode: z.ZodNullable<z.ZodNumber>;
          diagnostics: z.ZodArray<z.ZodObject<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">>, "many">;
          contractError: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          success: z.ZodBoolean;
          stdout: z.ZodString;
          stderr: z.ZodString;
          exitCode: z.ZodNullable<z.ZodNumber>;
          diagnostics: z.ZodArray<z.ZodObject<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">>, "many">;
          contractError: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>>;
        context: z.ZodNullable<z.ZodObject<{
          success: z.ZodBoolean;
          stdout: z.ZodString;
          stderr: z.ZodString;
          exitCode: z.ZodNullable<z.ZodNumber>;
          diagnostics: z.ZodArray<z.ZodObject<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">>, "many">;
          contractError: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          success: z.ZodBoolean;
          stdout: z.ZodString;
          stderr: z.ZodString;
          exitCode: z.ZodNullable<z.ZodNumber>;
          diagnostics: z.ZodArray<z.ZodObject<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">>, "many">;
          contractError: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          success: z.ZodBoolean;
          stdout: z.ZodString;
          stderr: z.ZodString;
          exitCode: z.ZodNullable<z.ZodNumber>;
          diagnostics: z.ZodArray<z.ZodObject<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">>, "many">;
          contractError: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>>;
      }, z.ZodTypeAny, "passthrough">>;
      observedAt: z.ZodNumber;
    }, z.ZodTypeAny, "passthrough"> | null;
    observedAt: number;
    attempt: {
      storeId: string | null;
      diagnostics: {
        root: z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">[];
        context: z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">[];
        doctor: z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">[];
      } & {
        [k: string]: unknown;
      };
      evidence: {
        context: z.objectInputType<{
          success: z.ZodBoolean;
          stdout: z.ZodString;
          stderr: z.ZodString;
          exitCode: z.ZodNullable<z.ZodNumber>;
          diagnostics: z.ZodArray<z.ZodObject<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">>, "many">;
          contractError: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough"> | null;
        doctor: z.objectInputType<{
          success: z.ZodBoolean;
          stdout: z.ZodString;
          stderr: z.ZodString;
          exitCode: z.ZodNullable<z.ZodNumber>;
          diagnostics: z.ZodArray<z.ZodObject<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">>, "many">;
          contractError: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough"> | null;
      } & {
        [k: string]: unknown;
      };
      cli: {
        available: boolean;
        version?: string | undefined;
        error?: string | undefined;
        effectiveCommand?: string | undefined;
        tried?: string[] | undefined;
      } & {
        [k: string]: unknown;
      };
      references: z.objectInputType<{
        store_id: z.ZodString;
        root: z.ZodOptional<z.ZodString>;
        status: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
      }, z.ZodTypeAny, "passthrough">[];
      dataScope: {
        path: string;
        source: "xdg-data-home" | "local-app-data" | "user-home-default";
        environmentVariable: "XDG_DATA_HOME" | "LOCALAPPDATA" | null;
      } & {
        [k: string]: unknown;
      };
      observedAt: number;
      launchProject: {
        path: string;
        physicalPath?: string | undefined;
      } & {
        [k: string]: unknown;
      };
      planningRoot: z.objectInputType<{
        path: z.ZodString;
        source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
        store_id: z.ZodOptional<z.ZodString>;
      } & {
        healthy: z.ZodBoolean;
        status: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
      }, z.ZodTypeAny, "passthrough"> | null;
      contextMembers: z.objectInputType<{
        role: z.ZodLiteral<"referenced_store">;
        id: z.ZodString;
        path: z.ZodOptional<z.ZodString>;
        remote: z.ZodOptional<z.ZodString>;
        fetch: z.ZodOptional<z.ZodString>;
        status: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
      }, z.ZodTypeAny, "passthrough">[];
      generation?: string | undefined;
    } & {
      [k: string]: unknown;
    };
  };
  freshness: "stale-display-only";
  snapshotGeneration: number;
  identity: string;
  workGeneration: number;
  invalidationCause: "dependency" | "initial" | "explicit-refresh" | "subscriber-resume";
}>, z.ZodObject<{
  state: z.ZodLiteral<"error">;
  data: z.ZodNull;
  freshness: z.ZodNull;
  snapshotGeneration: z.ZodNull;
  error: z.ZodObject<{
    name: z.ZodString;
    message: z.ZodString;
    cliEvidence: z.ZodNullable<z.ZodObject<{
      success: z.ZodBoolean;
      stdout: z.ZodString;
      stderr: z.ZodString;
      exitCode: z.ZodNullable<z.ZodNumber>;
      payload: z.ZodNullable<z.ZodType<CliJsonValue, z.ZodTypeDef, CliJsonValue>>;
      diagnostics: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
      contractError: z.ZodOptional<z.ZodString>;
    }, "strip", z.ZodTypeAny, {
      success: boolean;
      stdout: string;
      stderr: string;
      exitCode: number | null;
      payload: CliJsonValue;
      diagnostics: z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">[];
      contractError?: string | undefined;
    }, {
      success: boolean;
      stdout: string;
      stderr: string;
      exitCode: number | null;
      payload: CliJsonValue;
      diagnostics: z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">[];
      contractError?: string | undefined;
    }>>;
  }, "strip", z.ZodTypeAny, {
    message: string;
    name: string;
    cliEvidence: {
      success: boolean;
      stdout: string;
      stderr: string;
      exitCode: number | null;
      payload: CliJsonValue;
      diagnostics: z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">[];
      contractError?: string | undefined;
    } | null;
  }, {
    message: string;
    name: string;
    cliEvidence: {
      success: boolean;
      stdout: string;
      stderr: string;
      exitCode: number | null;
      payload: CliJsonValue;
      diagnostics: z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">[];
      contractError?: string | undefined;
    } | null;
  }>;
  identity: z.ZodString;
  workGeneration: z.ZodNumber;
  invalidationCause: z.ZodEnum<["initial", "dependency", "explicit-refresh", "subscriber-resume"]>;
}, "strip", z.ZodTypeAny, {
  error: {
    message: string;
    name: string;
    cliEvidence: {
      success: boolean;
      stdout: string;
      stderr: string;
      exitCode: number | null;
      payload: CliJsonValue;
      diagnostics: z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">[];
      contractError?: string | undefined;
    } | null;
  };
  state: "error";
  data: null;
  freshness: null;
  snapshotGeneration: null;
  identity: string;
  workGeneration: number;
  invalidationCause: "dependency" | "initial" | "explicit-refresh" | "subscriber-resume";
}, {
  error: {
    message: string;
    name: string;
    cliEvidence: {
      success: boolean;
      stdout: string;
      stderr: string;
      exitCode: number | null;
      payload: CliJsonValue;
      diagnostics: z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">[];
      contractError?: string | undefined;
    } | null;
  };
  state: "error";
  data: null;
  freshness: null;
  snapshotGeneration: null;
  identity: string;
  workGeneration: number;
  invalidationCause: "dependency" | "initial" | "explicit-refresh" | "subscriber-resume";
}>, z.ZodObject<{
  state: z.ZodLiteral<"refresh-error">;
  data: z.ZodType<{
    error: null;
    state: "ready";
    data: {
      storeId: string | null;
      diagnostics: {
        root: z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">[];
        context: z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">[];
        doctor: z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">[];
      } & {
        [k: string]: unknown;
      };
      evidence: {
        context: z.objectOutputType<{
          success: z.ZodBoolean;
          stdout: z.ZodString;
          stderr: z.ZodString;
          exitCode: z.ZodNullable<z.ZodNumber>;
          diagnostics: z.ZodArray<z.ZodObject<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">>, "many">;
          contractError: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough"> | null;
        doctor: z.objectOutputType<{
          success: z.ZodBoolean;
          stdout: z.ZodString;
          stderr: z.ZodString;
          exitCode: z.ZodNullable<z.ZodNumber>;
          diagnostics: z.ZodArray<z.ZodObject<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">>, "many">;
          contractError: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough"> | null;
      } & {
        [k: string]: unknown;
      };
      cli: {
        available: boolean;
        version?: string | undefined;
        error?: string | undefined;
        effectiveCommand?: string | undefined;
        tried?: string[] | undefined;
      } & {
        [k: string]: unknown;
      };
      references: z.objectOutputType<{
        store_id: z.ZodString;
        root: z.ZodOptional<z.ZodString>;
        status: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
      }, z.ZodTypeAny, "passthrough">[];
      dataScope: {
        path: string;
        source: "xdg-data-home" | "local-app-data" | "user-home-default";
        environmentVariable: "XDG_DATA_HOME" | "LOCALAPPDATA" | null;
      } & {
        [k: string]: unknown;
      };
      observedAt: number;
      launchProject: {
        path: string;
        physicalPath?: string | undefined;
      } & {
        [k: string]: unknown;
      };
      planningRoot: z.objectOutputType<{
        path: z.ZodString;
        source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
        store_id: z.ZodOptional<z.ZodString>;
      } & {
        healthy: z.ZodBoolean;
        status: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
      }, z.ZodTypeAny, "passthrough"> | null;
      contextMembers: z.objectOutputType<{
        role: z.ZodLiteral<"referenced_store">;
        id: z.ZodString;
        path: z.ZodOptional<z.ZodString>;
        remote: z.ZodOptional<z.ZodString>;
        fetch: z.ZodOptional<z.ZodString>;
        status: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
      }, z.ZodTypeAny, "passthrough">[];
      generation?: string | undefined;
    } & {
      [k: string]: unknown;
    };
    observedAt: number;
    attempt: null;
  } | {
    error: {
      code: "cli-unavailable" | "doctor-command-failed" | "doctor-contract-drift" | "root-unresolved" | "root-unhealthy" | "context-command-failed" | "context-contract-drift" | "context-root-mismatch" | "references-unresolved" | "resolver-failed";
      message: string;
    };
    state: "error";
    data: z.objectOutputType<{
      launchProject: z.ZodObject<{
        path: z.ZodString;
        physicalPath: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        path: z.ZodString;
        physicalPath: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        path: z.ZodString;
        physicalPath: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>;
      planningRoot: z.ZodNullable<z.ZodObject<{
        path: z.ZodString;
        source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
        store_id: z.ZodOptional<z.ZodString>;
      } & {
        healthy: z.ZodBoolean;
        status: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        path: z.ZodString;
        source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
        store_id: z.ZodOptional<z.ZodString>;
      } & {
        healthy: z.ZodBoolean;
        status: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        path: z.ZodString;
        source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
        store_id: z.ZodOptional<z.ZodString>;
      } & {
        healthy: z.ZodBoolean;
        status: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
      }, z.ZodTypeAny, "passthrough">>>;
      storeId: z.ZodNullable<z.ZodString>;
      generation: z.ZodOptional<z.ZodString>;
      cli: z.ZodObject<{
        available: z.ZodBoolean;
        version: z.ZodOptional<z.ZodString>;
        error: z.ZodOptional<z.ZodString>;
        effectiveCommand: z.ZodOptional<z.ZodString>;
        tried: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        available: z.ZodBoolean;
        version: z.ZodOptional<z.ZodString>;
        error: z.ZodOptional<z.ZodString>;
        effectiveCommand: z.ZodOptional<z.ZodString>;
        tried: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        available: z.ZodBoolean;
        version: z.ZodOptional<z.ZodString>;
        error: z.ZodOptional<z.ZodString>;
        effectiveCommand: z.ZodOptional<z.ZodString>;
        tried: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
      }, z.ZodTypeAny, "passthrough">>;
      references: z.ZodArray<z.ZodObject<{
        store_id: z.ZodString;
        root: z.ZodOptional<z.ZodString>;
        status: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        store_id: z.ZodString;
        root: z.ZodOptional<z.ZodString>;
        status: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        store_id: z.ZodString;
        root: z.ZodOptional<z.ZodString>;
        status: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
      }, z.ZodTypeAny, "passthrough">>, "many">;
      contextMembers: z.ZodArray<z.ZodObject<{
        role: z.ZodLiteral<"referenced_store">;
        id: z.ZodString;
        path: z.ZodOptional<z.ZodString>;
        remote: z.ZodOptional<z.ZodString>;
        fetch: z.ZodOptional<z.ZodString>;
        status: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        role: z.ZodLiteral<"referenced_store">;
        id: z.ZodString;
        path: z.ZodOptional<z.ZodString>;
        remote: z.ZodOptional<z.ZodString>;
        fetch: z.ZodOptional<z.ZodString>;
        status: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        role: z.ZodLiteral<"referenced_store">;
        id: z.ZodString;
        path: z.ZodOptional<z.ZodString>;
        remote: z.ZodOptional<z.ZodString>;
        fetch: z.ZodOptional<z.ZodString>;
        status: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
      }, z.ZodTypeAny, "passthrough">>, "many">;
      dataScope: z.ZodObject<{
        path: z.ZodString;
        source: z.ZodEnum<["xdg-data-home", "local-app-data", "user-home-default"]>;
        environmentVariable: z.ZodNullable<z.ZodEnum<["XDG_DATA_HOME", "LOCALAPPDATA"]>>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        path: z.ZodString;
        source: z.ZodEnum<["xdg-data-home", "local-app-data", "user-home-default"]>;
        environmentVariable: z.ZodNullable<z.ZodEnum<["XDG_DATA_HOME", "LOCALAPPDATA"]>>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        path: z.ZodString;
        source: z.ZodEnum<["xdg-data-home", "local-app-data", "user-home-default"]>;
        environmentVariable: z.ZodNullable<z.ZodEnum<["XDG_DATA_HOME", "LOCALAPPDATA"]>>;
      }, z.ZodTypeAny, "passthrough">>;
      diagnostics: z.ZodObject<{
        root: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        doctor: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        context: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        root: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        doctor: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        context: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        root: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        doctor: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        context: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
      }, z.ZodTypeAny, "passthrough">>;
      evidence: z.ZodObject<{
        doctor: z.ZodNullable<z.ZodObject<{
          success: z.ZodBoolean;
          stdout: z.ZodString;
          stderr: z.ZodString;
          exitCode: z.ZodNullable<z.ZodNumber>;
          diagnostics: z.ZodArray<z.ZodObject<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">>, "many">;
          contractError: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          success: z.ZodBoolean;
          stdout: z.ZodString;
          stderr: z.ZodString;
          exitCode: z.ZodNullable<z.ZodNumber>;
          diagnostics: z.ZodArray<z.ZodObject<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">>, "many">;
          contractError: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          success: z.ZodBoolean;
          stdout: z.ZodString;
          stderr: z.ZodString;
          exitCode: z.ZodNullable<z.ZodNumber>;
          diagnostics: z.ZodArray<z.ZodObject<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">>, "many">;
          contractError: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>>;
        context: z.ZodNullable<z.ZodObject<{
          success: z.ZodBoolean;
          stdout: z.ZodString;
          stderr: z.ZodString;
          exitCode: z.ZodNullable<z.ZodNumber>;
          diagnostics: z.ZodArray<z.ZodObject<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">>, "many">;
          contractError: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          success: z.ZodBoolean;
          stdout: z.ZodString;
          stderr: z.ZodString;
          exitCode: z.ZodNullable<z.ZodNumber>;
          diagnostics: z.ZodArray<z.ZodObject<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">>, "many">;
          contractError: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          success: z.ZodBoolean;
          stdout: z.ZodString;
          stderr: z.ZodString;
          exitCode: z.ZodNullable<z.ZodNumber>;
          diagnostics: z.ZodArray<z.ZodObject<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">>, "many">;
          contractError: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        doctor: z.ZodNullable<z.ZodObject<{
          success: z.ZodBoolean;
          stdout: z.ZodString;
          stderr: z.ZodString;
          exitCode: z.ZodNullable<z.ZodNumber>;
          diagnostics: z.ZodArray<z.ZodObject<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">>, "many">;
          contractError: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          success: z.ZodBoolean;
          stdout: z.ZodString;
          stderr: z.ZodString;
          exitCode: z.ZodNullable<z.ZodNumber>;
          diagnostics: z.ZodArray<z.ZodObject<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">>, "many">;
          contractError: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          success: z.ZodBoolean;
          stdout: z.ZodString;
          stderr: z.ZodString;
          exitCode: z.ZodNullable<z.ZodNumber>;
          diagnostics: z.ZodArray<z.ZodObject<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">>, "many">;
          contractError: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>>;
        context: z.ZodNullable<z.ZodObject<{
          success: z.ZodBoolean;
          stdout: z.ZodString;
          stderr: z.ZodString;
          exitCode: z.ZodNullable<z.ZodNumber>;
          diagnostics: z.ZodArray<z.ZodObject<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">>, "many">;
          contractError: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          success: z.ZodBoolean;
          stdout: z.ZodString;
          stderr: z.ZodString;
          exitCode: z.ZodNullable<z.ZodNumber>;
          diagnostics: z.ZodArray<z.ZodObject<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">>, "many">;
          contractError: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          success: z.ZodBoolean;
          stdout: z.ZodString;
          stderr: z.ZodString;
          exitCode: z.ZodNullable<z.ZodNumber>;
          diagnostics: z.ZodArray<z.ZodObject<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">>, "many">;
          contractError: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        doctor: z.ZodNullable<z.ZodObject<{
          success: z.ZodBoolean;
          stdout: z.ZodString;
          stderr: z.ZodString;
          exitCode: z.ZodNullable<z.ZodNumber>;
          diagnostics: z.ZodArray<z.ZodObject<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">>, "many">;
          contractError: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          success: z.ZodBoolean;
          stdout: z.ZodString;
          stderr: z.ZodString;
          exitCode: z.ZodNullable<z.ZodNumber>;
          diagnostics: z.ZodArray<z.ZodObject<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">>, "many">;
          contractError: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          success: z.ZodBoolean;
          stdout: z.ZodString;
          stderr: z.ZodString;
          exitCode: z.ZodNullable<z.ZodNumber>;
          diagnostics: z.ZodArray<z.ZodObject<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">>, "many">;
          contractError: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>>;
        context: z.ZodNullable<z.ZodObject<{
          success: z.ZodBoolean;
          stdout: z.ZodString;
          stderr: z.ZodString;
          exitCode: z.ZodNullable<z.ZodNumber>;
          diagnostics: z.ZodArray<z.ZodObject<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">>, "many">;
          contractError: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          success: z.ZodBoolean;
          stdout: z.ZodString;
          stderr: z.ZodString;
          exitCode: z.ZodNullable<z.ZodNumber>;
          diagnostics: z.ZodArray<z.ZodObject<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">>, "many">;
          contractError: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          success: z.ZodBoolean;
          stdout: z.ZodString;
          stderr: z.ZodString;
          exitCode: z.ZodNullable<z.ZodNumber>;
          diagnostics: z.ZodArray<z.ZodObject<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">>, "many">;
          contractError: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>>;
      }, z.ZodTypeAny, "passthrough">>;
      observedAt: z.ZodNumber;
    }, z.ZodTypeAny, "passthrough"> | null;
    observedAt: number;
    attempt: {
      storeId: string | null;
      diagnostics: {
        root: z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">[];
        context: z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">[];
        doctor: z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">[];
      } & {
        [k: string]: unknown;
      };
      evidence: {
        context: z.objectOutputType<{
          success: z.ZodBoolean;
          stdout: z.ZodString;
          stderr: z.ZodString;
          exitCode: z.ZodNullable<z.ZodNumber>;
          diagnostics: z.ZodArray<z.ZodObject<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">>, "many">;
          contractError: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough"> | null;
        doctor: z.objectOutputType<{
          success: z.ZodBoolean;
          stdout: z.ZodString;
          stderr: z.ZodString;
          exitCode: z.ZodNullable<z.ZodNumber>;
          diagnostics: z.ZodArray<z.ZodObject<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">>, "many">;
          contractError: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough"> | null;
      } & {
        [k: string]: unknown;
      };
      cli: {
        available: boolean;
        version?: string | undefined;
        error?: string | undefined;
        effectiveCommand?: string | undefined;
        tried?: string[] | undefined;
      } & {
        [k: string]: unknown;
      };
      references: z.objectOutputType<{
        store_id: z.ZodString;
        root: z.ZodOptional<z.ZodString>;
        status: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
      }, z.ZodTypeAny, "passthrough">[];
      dataScope: {
        path: string;
        source: "xdg-data-home" | "local-app-data" | "user-home-default";
        environmentVariable: "XDG_DATA_HOME" | "LOCALAPPDATA" | null;
      } & {
        [k: string]: unknown;
      };
      observedAt: number;
      launchProject: {
        path: string;
        physicalPath?: string | undefined;
      } & {
        [k: string]: unknown;
      };
      planningRoot: z.objectOutputType<{
        path: z.ZodString;
        source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
        store_id: z.ZodOptional<z.ZodString>;
      } & {
        healthy: z.ZodBoolean;
        status: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
      }, z.ZodTypeAny, "passthrough"> | null;
      contextMembers: z.objectOutputType<{
        role: z.ZodLiteral<"referenced_store">;
        id: z.ZodString;
        path: z.ZodOptional<z.ZodString>;
        remote: z.ZodOptional<z.ZodString>;
        fetch: z.ZodOptional<z.ZodString>;
        status: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
      }, z.ZodTypeAny, "passthrough">[];
      generation?: string | undefined;
    } & {
      [k: string]: unknown;
    };
  }, z.ZodTypeDef, {
    error: null;
    state: "ready";
    data: {
      storeId: string | null;
      diagnostics: {
        root: z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">[];
        context: z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">[];
        doctor: z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">[];
      } & {
        [k: string]: unknown;
      };
      evidence: {
        context: z.objectInputType<{
          success: z.ZodBoolean;
          stdout: z.ZodString;
          stderr: z.ZodString;
          exitCode: z.ZodNullable<z.ZodNumber>;
          diagnostics: z.ZodArray<z.ZodObject<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">>, "many">;
          contractError: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough"> | null;
        doctor: z.objectInputType<{
          success: z.ZodBoolean;
          stdout: z.ZodString;
          stderr: z.ZodString;
          exitCode: z.ZodNullable<z.ZodNumber>;
          diagnostics: z.ZodArray<z.ZodObject<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">>, "many">;
          contractError: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough"> | null;
      } & {
        [k: string]: unknown;
      };
      cli: {
        available: boolean;
        version?: string | undefined;
        error?: string | undefined;
        effectiveCommand?: string | undefined;
        tried?: string[] | undefined;
      } & {
        [k: string]: unknown;
      };
      references: z.objectInputType<{
        store_id: z.ZodString;
        root: z.ZodOptional<z.ZodString>;
        status: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
      }, z.ZodTypeAny, "passthrough">[];
      dataScope: {
        path: string;
        source: "xdg-data-home" | "local-app-data" | "user-home-default";
        environmentVariable: "XDG_DATA_HOME" | "LOCALAPPDATA" | null;
      } & {
        [k: string]: unknown;
      };
      observedAt: number;
      launchProject: {
        path: string;
        physicalPath?: string | undefined;
      } & {
        [k: string]: unknown;
      };
      planningRoot: z.objectInputType<{
        path: z.ZodString;
        source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
        store_id: z.ZodOptional<z.ZodString>;
      } & {
        healthy: z.ZodBoolean;
        status: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
      }, z.ZodTypeAny, "passthrough"> | null;
      contextMembers: z.objectInputType<{
        role: z.ZodLiteral<"referenced_store">;
        id: z.ZodString;
        path: z.ZodOptional<z.ZodString>;
        remote: z.ZodOptional<z.ZodString>;
        fetch: z.ZodOptional<z.ZodString>;
        status: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
      }, z.ZodTypeAny, "passthrough">[];
      generation?: string | undefined;
    } & {
      [k: string]: unknown;
    };
    observedAt: number;
    attempt: null;
  } | {
    error: {
      code: "cli-unavailable" | "doctor-command-failed" | "doctor-contract-drift" | "root-unresolved" | "root-unhealthy" | "context-command-failed" | "context-contract-drift" | "context-root-mismatch" | "references-unresolved" | "resolver-failed";
      message: string;
    };
    state: "error";
    data: z.objectInputType<{
      launchProject: z.ZodObject<{
        path: z.ZodString;
        physicalPath: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        path: z.ZodString;
        physicalPath: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        path: z.ZodString;
        physicalPath: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>;
      planningRoot: z.ZodNullable<z.ZodObject<{
        path: z.ZodString;
        source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
        store_id: z.ZodOptional<z.ZodString>;
      } & {
        healthy: z.ZodBoolean;
        status: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        path: z.ZodString;
        source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
        store_id: z.ZodOptional<z.ZodString>;
      } & {
        healthy: z.ZodBoolean;
        status: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        path: z.ZodString;
        source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
        store_id: z.ZodOptional<z.ZodString>;
      } & {
        healthy: z.ZodBoolean;
        status: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
      }, z.ZodTypeAny, "passthrough">>>;
      storeId: z.ZodNullable<z.ZodString>;
      generation: z.ZodOptional<z.ZodString>;
      cli: z.ZodObject<{
        available: z.ZodBoolean;
        version: z.ZodOptional<z.ZodString>;
        error: z.ZodOptional<z.ZodString>;
        effectiveCommand: z.ZodOptional<z.ZodString>;
        tried: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        available: z.ZodBoolean;
        version: z.ZodOptional<z.ZodString>;
        error: z.ZodOptional<z.ZodString>;
        effectiveCommand: z.ZodOptional<z.ZodString>;
        tried: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        available: z.ZodBoolean;
        version: z.ZodOptional<z.ZodString>;
        error: z.ZodOptional<z.ZodString>;
        effectiveCommand: z.ZodOptional<z.ZodString>;
        tried: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
      }, z.ZodTypeAny, "passthrough">>;
      references: z.ZodArray<z.ZodObject<{
        store_id: z.ZodString;
        root: z.ZodOptional<z.ZodString>;
        status: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        store_id: z.ZodString;
        root: z.ZodOptional<z.ZodString>;
        status: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        store_id: z.ZodString;
        root: z.ZodOptional<z.ZodString>;
        status: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
      }, z.ZodTypeAny, "passthrough">>, "many">;
      contextMembers: z.ZodArray<z.ZodObject<{
        role: z.ZodLiteral<"referenced_store">;
        id: z.ZodString;
        path: z.ZodOptional<z.ZodString>;
        remote: z.ZodOptional<z.ZodString>;
        fetch: z.ZodOptional<z.ZodString>;
        status: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        role: z.ZodLiteral<"referenced_store">;
        id: z.ZodString;
        path: z.ZodOptional<z.ZodString>;
        remote: z.ZodOptional<z.ZodString>;
        fetch: z.ZodOptional<z.ZodString>;
        status: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        role: z.ZodLiteral<"referenced_store">;
        id: z.ZodString;
        path: z.ZodOptional<z.ZodString>;
        remote: z.ZodOptional<z.ZodString>;
        fetch: z.ZodOptional<z.ZodString>;
        status: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
      }, z.ZodTypeAny, "passthrough">>, "many">;
      dataScope: z.ZodObject<{
        path: z.ZodString;
        source: z.ZodEnum<["xdg-data-home", "local-app-data", "user-home-default"]>;
        environmentVariable: z.ZodNullable<z.ZodEnum<["XDG_DATA_HOME", "LOCALAPPDATA"]>>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        path: z.ZodString;
        source: z.ZodEnum<["xdg-data-home", "local-app-data", "user-home-default"]>;
        environmentVariable: z.ZodNullable<z.ZodEnum<["XDG_DATA_HOME", "LOCALAPPDATA"]>>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        path: z.ZodString;
        source: z.ZodEnum<["xdg-data-home", "local-app-data", "user-home-default"]>;
        environmentVariable: z.ZodNullable<z.ZodEnum<["XDG_DATA_HOME", "LOCALAPPDATA"]>>;
      }, z.ZodTypeAny, "passthrough">>;
      diagnostics: z.ZodObject<{
        root: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        doctor: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        context: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        root: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        doctor: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        context: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        root: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        doctor: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        context: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
      }, z.ZodTypeAny, "passthrough">>;
      evidence: z.ZodObject<{
        doctor: z.ZodNullable<z.ZodObject<{
          success: z.ZodBoolean;
          stdout: z.ZodString;
          stderr: z.ZodString;
          exitCode: z.ZodNullable<z.ZodNumber>;
          diagnostics: z.ZodArray<z.ZodObject<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">>, "many">;
          contractError: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          success: z.ZodBoolean;
          stdout: z.ZodString;
          stderr: z.ZodString;
          exitCode: z.ZodNullable<z.ZodNumber>;
          diagnostics: z.ZodArray<z.ZodObject<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">>, "many">;
          contractError: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          success: z.ZodBoolean;
          stdout: z.ZodString;
          stderr: z.ZodString;
          exitCode: z.ZodNullable<z.ZodNumber>;
          diagnostics: z.ZodArray<z.ZodObject<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">>, "many">;
          contractError: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>>;
        context: z.ZodNullable<z.ZodObject<{
          success: z.ZodBoolean;
          stdout: z.ZodString;
          stderr: z.ZodString;
          exitCode: z.ZodNullable<z.ZodNumber>;
          diagnostics: z.ZodArray<z.ZodObject<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">>, "many">;
          contractError: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          success: z.ZodBoolean;
          stdout: z.ZodString;
          stderr: z.ZodString;
          exitCode: z.ZodNullable<z.ZodNumber>;
          diagnostics: z.ZodArray<z.ZodObject<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">>, "many">;
          contractError: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          success: z.ZodBoolean;
          stdout: z.ZodString;
          stderr: z.ZodString;
          exitCode: z.ZodNullable<z.ZodNumber>;
          diagnostics: z.ZodArray<z.ZodObject<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">>, "many">;
          contractError: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        doctor: z.ZodNullable<z.ZodObject<{
          success: z.ZodBoolean;
          stdout: z.ZodString;
          stderr: z.ZodString;
          exitCode: z.ZodNullable<z.ZodNumber>;
          diagnostics: z.ZodArray<z.ZodObject<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">>, "many">;
          contractError: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          success: z.ZodBoolean;
          stdout: z.ZodString;
          stderr: z.ZodString;
          exitCode: z.ZodNullable<z.ZodNumber>;
          diagnostics: z.ZodArray<z.ZodObject<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">>, "many">;
          contractError: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          success: z.ZodBoolean;
          stdout: z.ZodString;
          stderr: z.ZodString;
          exitCode: z.ZodNullable<z.ZodNumber>;
          diagnostics: z.ZodArray<z.ZodObject<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">>, "many">;
          contractError: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>>;
        context: z.ZodNullable<z.ZodObject<{
          success: z.ZodBoolean;
          stdout: z.ZodString;
          stderr: z.ZodString;
          exitCode: z.ZodNullable<z.ZodNumber>;
          diagnostics: z.ZodArray<z.ZodObject<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">>, "many">;
          contractError: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          success: z.ZodBoolean;
          stdout: z.ZodString;
          stderr: z.ZodString;
          exitCode: z.ZodNullable<z.ZodNumber>;
          diagnostics: z.ZodArray<z.ZodObject<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">>, "many">;
          contractError: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          success: z.ZodBoolean;
          stdout: z.ZodString;
          stderr: z.ZodString;
          exitCode: z.ZodNullable<z.ZodNumber>;
          diagnostics: z.ZodArray<z.ZodObject<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">>, "many">;
          contractError: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        doctor: z.ZodNullable<z.ZodObject<{
          success: z.ZodBoolean;
          stdout: z.ZodString;
          stderr: z.ZodString;
          exitCode: z.ZodNullable<z.ZodNumber>;
          diagnostics: z.ZodArray<z.ZodObject<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">>, "many">;
          contractError: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          success: z.ZodBoolean;
          stdout: z.ZodString;
          stderr: z.ZodString;
          exitCode: z.ZodNullable<z.ZodNumber>;
          diagnostics: z.ZodArray<z.ZodObject<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">>, "many">;
          contractError: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          success: z.ZodBoolean;
          stdout: z.ZodString;
          stderr: z.ZodString;
          exitCode: z.ZodNullable<z.ZodNumber>;
          diagnostics: z.ZodArray<z.ZodObject<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">>, "many">;
          contractError: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>>;
        context: z.ZodNullable<z.ZodObject<{
          success: z.ZodBoolean;
          stdout: z.ZodString;
          stderr: z.ZodString;
          exitCode: z.ZodNullable<z.ZodNumber>;
          diagnostics: z.ZodArray<z.ZodObject<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">>, "many">;
          contractError: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          success: z.ZodBoolean;
          stdout: z.ZodString;
          stderr: z.ZodString;
          exitCode: z.ZodNullable<z.ZodNumber>;
          diagnostics: z.ZodArray<z.ZodObject<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">>, "many">;
          contractError: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          success: z.ZodBoolean;
          stdout: z.ZodString;
          stderr: z.ZodString;
          exitCode: z.ZodNullable<z.ZodNumber>;
          diagnostics: z.ZodArray<z.ZodObject<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">>, "many">;
          contractError: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>>;
      }, z.ZodTypeAny, "passthrough">>;
      observedAt: z.ZodNumber;
    }, z.ZodTypeAny, "passthrough"> | null;
    observedAt: number;
    attempt: {
      storeId: string | null;
      diagnostics: {
        root: z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">[];
        context: z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">[];
        doctor: z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">[];
      } & {
        [k: string]: unknown;
      };
      evidence: {
        context: z.objectInputType<{
          success: z.ZodBoolean;
          stdout: z.ZodString;
          stderr: z.ZodString;
          exitCode: z.ZodNullable<z.ZodNumber>;
          diagnostics: z.ZodArray<z.ZodObject<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">>, "many">;
          contractError: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough"> | null;
        doctor: z.objectInputType<{
          success: z.ZodBoolean;
          stdout: z.ZodString;
          stderr: z.ZodString;
          exitCode: z.ZodNullable<z.ZodNumber>;
          diagnostics: z.ZodArray<z.ZodObject<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">>, "many">;
          contractError: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough"> | null;
      } & {
        [k: string]: unknown;
      };
      cli: {
        available: boolean;
        version?: string | undefined;
        error?: string | undefined;
        effectiveCommand?: string | undefined;
        tried?: string[] | undefined;
      } & {
        [k: string]: unknown;
      };
      references: z.objectInputType<{
        store_id: z.ZodString;
        root: z.ZodOptional<z.ZodString>;
        status: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
      }, z.ZodTypeAny, "passthrough">[];
      dataScope: {
        path: string;
        source: "xdg-data-home" | "local-app-data" | "user-home-default";
        environmentVariable: "XDG_DATA_HOME" | "LOCALAPPDATA" | null;
      } & {
        [k: string]: unknown;
      };
      observedAt: number;
      launchProject: {
        path: string;
        physicalPath?: string | undefined;
      } & {
        [k: string]: unknown;
      };
      planningRoot: z.objectInputType<{
        path: z.ZodString;
        source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
        store_id: z.ZodOptional<z.ZodString>;
      } & {
        healthy: z.ZodBoolean;
        status: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
      }, z.ZodTypeAny, "passthrough"> | null;
      contextMembers: z.objectInputType<{
        role: z.ZodLiteral<"referenced_store">;
        id: z.ZodString;
        path: z.ZodOptional<z.ZodString>;
        remote: z.ZodOptional<z.ZodString>;
        fetch: z.ZodOptional<z.ZodString>;
        status: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
      }, z.ZodTypeAny, "passthrough">[];
      generation?: string | undefined;
    } & {
      [k: string]: unknown;
    };
  }>;
  freshness: z.ZodLiteral<"stale-display-only">;
  snapshotGeneration: z.ZodNumber;
  error: z.ZodObject<{
    name: z.ZodString;
    message: z.ZodString;
    cliEvidence: z.ZodNullable<z.ZodObject<{
      success: z.ZodBoolean;
      stdout: z.ZodString;
      stderr: z.ZodString;
      exitCode: z.ZodNullable<z.ZodNumber>;
      payload: z.ZodNullable<z.ZodType<CliJsonValue, z.ZodTypeDef, CliJsonValue>>;
      diagnostics: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
      contractError: z.ZodOptional<z.ZodString>;
    }, "strip", z.ZodTypeAny, {
      success: boolean;
      stdout: string;
      stderr: string;
      exitCode: number | null;
      payload: CliJsonValue;
      diagnostics: z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">[];
      contractError?: string | undefined;
    }, {
      success: boolean;
      stdout: string;
      stderr: string;
      exitCode: number | null;
      payload: CliJsonValue;
      diagnostics: z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">[];
      contractError?: string | undefined;
    }>>;
  }, "strip", z.ZodTypeAny, {
    message: string;
    name: string;
    cliEvidence: {
      success: boolean;
      stdout: string;
      stderr: string;
      exitCode: number | null;
      payload: CliJsonValue;
      diagnostics: z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">[];
      contractError?: string | undefined;
    } | null;
  }, {
    message: string;
    name: string;
    cliEvidence: {
      success: boolean;
      stdout: string;
      stderr: string;
      exitCode: number | null;
      payload: CliJsonValue;
      diagnostics: z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">[];
      contractError?: string | undefined;
    } | null;
  }>;
  identity: z.ZodString;
  workGeneration: z.ZodNumber;
  invalidationCause: z.ZodEnum<["initial", "dependency", "explicit-refresh", "subscriber-resume"]>;
}, "strip", z.ZodTypeAny, {
  error: {
    message: string;
    name: string;
    cliEvidence: {
      success: boolean;
      stdout: string;
      stderr: string;
      exitCode: number | null;
      payload: CliJsonValue;
      diagnostics: z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">[];
      contractError?: string | undefined;
    } | null;
  };
  state: "refresh-error";
  data: {
    error: null;
    state: "ready";
    data: {
      storeId: string | null;
      diagnostics: {
        root: z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">[];
        context: z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">[];
        doctor: z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">[];
      } & {
        [k: string]: unknown;
      };
      evidence: {
        context: z.objectOutputType<{
          success: z.ZodBoolean;
          stdout: z.ZodString;
          stderr: z.ZodString;
          exitCode: z.ZodNullable<z.ZodNumber>;
          diagnostics: z.ZodArray<z.ZodObject<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">>, "many">;
          contractError: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough"> | null;
        doctor: z.objectOutputType<{
          success: z.ZodBoolean;
          stdout: z.ZodString;
          stderr: z.ZodString;
          exitCode: z.ZodNullable<z.ZodNumber>;
          diagnostics: z.ZodArray<z.ZodObject<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">>, "many">;
          contractError: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough"> | null;
      } & {
        [k: string]: unknown;
      };
      cli: {
        available: boolean;
        version?: string | undefined;
        error?: string | undefined;
        effectiveCommand?: string | undefined;
        tried?: string[] | undefined;
      } & {
        [k: string]: unknown;
      };
      references: z.objectOutputType<{
        store_id: z.ZodString;
        root: z.ZodOptional<z.ZodString>;
        status: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
      }, z.ZodTypeAny, "passthrough">[];
      dataScope: {
        path: string;
        source: "xdg-data-home" | "local-app-data" | "user-home-default";
        environmentVariable: "XDG_DATA_HOME" | "LOCALAPPDATA" | null;
      } & {
        [k: string]: unknown;
      };
      observedAt: number;
      launchProject: {
        path: string;
        physicalPath?: string | undefined;
      } & {
        [k: string]: unknown;
      };
      planningRoot: z.objectOutputType<{
        path: z.ZodString;
        source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
        store_id: z.ZodOptional<z.ZodString>;
      } & {
        healthy: z.ZodBoolean;
        status: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
      }, z.ZodTypeAny, "passthrough"> | null;
      contextMembers: z.objectOutputType<{
        role: z.ZodLiteral<"referenced_store">;
        id: z.ZodString;
        path: z.ZodOptional<z.ZodString>;
        remote: z.ZodOptional<z.ZodString>;
        fetch: z.ZodOptional<z.ZodString>;
        status: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
      }, z.ZodTypeAny, "passthrough">[];
      generation?: string | undefined;
    } & {
      [k: string]: unknown;
    };
    observedAt: number;
    attempt: null;
  } | {
    error: {
      code: "cli-unavailable" | "doctor-command-failed" | "doctor-contract-drift" | "root-unresolved" | "root-unhealthy" | "context-command-failed" | "context-contract-drift" | "context-root-mismatch" | "references-unresolved" | "resolver-failed";
      message: string;
    };
    state: "error";
    data: z.objectOutputType<{
      launchProject: z.ZodObject<{
        path: z.ZodString;
        physicalPath: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        path: z.ZodString;
        physicalPath: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        path: z.ZodString;
        physicalPath: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>;
      planningRoot: z.ZodNullable<z.ZodObject<{
        path: z.ZodString;
        source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
        store_id: z.ZodOptional<z.ZodString>;
      } & {
        healthy: z.ZodBoolean;
        status: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        path: z.ZodString;
        source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
        store_id: z.ZodOptional<z.ZodString>;
      } & {
        healthy: z.ZodBoolean;
        status: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        path: z.ZodString;
        source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
        store_id: z.ZodOptional<z.ZodString>;
      } & {
        healthy: z.ZodBoolean;
        status: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
      }, z.ZodTypeAny, "passthrough">>>;
      storeId: z.ZodNullable<z.ZodString>;
      generation: z.ZodOptional<z.ZodString>;
      cli: z.ZodObject<{
        available: z.ZodBoolean;
        version: z.ZodOptional<z.ZodString>;
        error: z.ZodOptional<z.ZodString>;
        effectiveCommand: z.ZodOptional<z.ZodString>;
        tried: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        available: z.ZodBoolean;
        version: z.ZodOptional<z.ZodString>;
        error: z.ZodOptional<z.ZodString>;
        effectiveCommand: z.ZodOptional<z.ZodString>;
        tried: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        available: z.ZodBoolean;
        version: z.ZodOptional<z.ZodString>;
        error: z.ZodOptional<z.ZodString>;
        effectiveCommand: z.ZodOptional<z.ZodString>;
        tried: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
      }, z.ZodTypeAny, "passthrough">>;
      references: z.ZodArray<z.ZodObject<{
        store_id: z.ZodString;
        root: z.ZodOptional<z.ZodString>;
        status: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        store_id: z.ZodString;
        root: z.ZodOptional<z.ZodString>;
        status: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        store_id: z.ZodString;
        root: z.ZodOptional<z.ZodString>;
        status: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
      }, z.ZodTypeAny, "passthrough">>, "many">;
      contextMembers: z.ZodArray<z.ZodObject<{
        role: z.ZodLiteral<"referenced_store">;
        id: z.ZodString;
        path: z.ZodOptional<z.ZodString>;
        remote: z.ZodOptional<z.ZodString>;
        fetch: z.ZodOptional<z.ZodString>;
        status: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        role: z.ZodLiteral<"referenced_store">;
        id: z.ZodString;
        path: z.ZodOptional<z.ZodString>;
        remote: z.ZodOptional<z.ZodString>;
        fetch: z.ZodOptional<z.ZodString>;
        status: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        role: z.ZodLiteral<"referenced_store">;
        id: z.ZodString;
        path: z.ZodOptional<z.ZodString>;
        remote: z.ZodOptional<z.ZodString>;
        fetch: z.ZodOptional<z.ZodString>;
        status: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
      }, z.ZodTypeAny, "passthrough">>, "many">;
      dataScope: z.ZodObject<{
        path: z.ZodString;
        source: z.ZodEnum<["xdg-data-home", "local-app-data", "user-home-default"]>;
        environmentVariable: z.ZodNullable<z.ZodEnum<["XDG_DATA_HOME", "LOCALAPPDATA"]>>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        path: z.ZodString;
        source: z.ZodEnum<["xdg-data-home", "local-app-data", "user-home-default"]>;
        environmentVariable: z.ZodNullable<z.ZodEnum<["XDG_DATA_HOME", "LOCALAPPDATA"]>>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        path: z.ZodString;
        source: z.ZodEnum<["xdg-data-home", "local-app-data", "user-home-default"]>;
        environmentVariable: z.ZodNullable<z.ZodEnum<["XDG_DATA_HOME", "LOCALAPPDATA"]>>;
      }, z.ZodTypeAny, "passthrough">>;
      diagnostics: z.ZodObject<{
        root: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        doctor: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        context: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        root: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        doctor: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        context: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        root: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        doctor: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        context: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
      }, z.ZodTypeAny, "passthrough">>;
      evidence: z.ZodObject<{
        doctor: z.ZodNullable<z.ZodObject<{
          success: z.ZodBoolean;
          stdout: z.ZodString;
          stderr: z.ZodString;
          exitCode: z.ZodNullable<z.ZodNumber>;
          diagnostics: z.ZodArray<z.ZodObject<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">>, "many">;
          contractError: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          success: z.ZodBoolean;
          stdout: z.ZodString;
          stderr: z.ZodString;
          exitCode: z.ZodNullable<z.ZodNumber>;
          diagnostics: z.ZodArray<z.ZodObject<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">>, "many">;
          contractError: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          success: z.ZodBoolean;
          stdout: z.ZodString;
          stderr: z.ZodString;
          exitCode: z.ZodNullable<z.ZodNumber>;
          diagnostics: z.ZodArray<z.ZodObject<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">>, "many">;
          contractError: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>>;
        context: z.ZodNullable<z.ZodObject<{
          success: z.ZodBoolean;
          stdout: z.ZodString;
          stderr: z.ZodString;
          exitCode: z.ZodNullable<z.ZodNumber>;
          diagnostics: z.ZodArray<z.ZodObject<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">>, "many">;
          contractError: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          success: z.ZodBoolean;
          stdout: z.ZodString;
          stderr: z.ZodString;
          exitCode: z.ZodNullable<z.ZodNumber>;
          diagnostics: z.ZodArray<z.ZodObject<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">>, "many">;
          contractError: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          success: z.ZodBoolean;
          stdout: z.ZodString;
          stderr: z.ZodString;
          exitCode: z.ZodNullable<z.ZodNumber>;
          diagnostics: z.ZodArray<z.ZodObject<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">>, "many">;
          contractError: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        doctor: z.ZodNullable<z.ZodObject<{
          success: z.ZodBoolean;
          stdout: z.ZodString;
          stderr: z.ZodString;
          exitCode: z.ZodNullable<z.ZodNumber>;
          diagnostics: z.ZodArray<z.ZodObject<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">>, "many">;
          contractError: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          success: z.ZodBoolean;
          stdout: z.ZodString;
          stderr: z.ZodString;
          exitCode: z.ZodNullable<z.ZodNumber>;
          diagnostics: z.ZodArray<z.ZodObject<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">>, "many">;
          contractError: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          success: z.ZodBoolean;
          stdout: z.ZodString;
          stderr: z.ZodString;
          exitCode: z.ZodNullable<z.ZodNumber>;
          diagnostics: z.ZodArray<z.ZodObject<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">>, "many">;
          contractError: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>>;
        context: z.ZodNullable<z.ZodObject<{
          success: z.ZodBoolean;
          stdout: z.ZodString;
          stderr: z.ZodString;
          exitCode: z.ZodNullable<z.ZodNumber>;
          diagnostics: z.ZodArray<z.ZodObject<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">>, "many">;
          contractError: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          success: z.ZodBoolean;
          stdout: z.ZodString;
          stderr: z.ZodString;
          exitCode: z.ZodNullable<z.ZodNumber>;
          diagnostics: z.ZodArray<z.ZodObject<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">>, "many">;
          contractError: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          success: z.ZodBoolean;
          stdout: z.ZodString;
          stderr: z.ZodString;
          exitCode: z.ZodNullable<z.ZodNumber>;
          diagnostics: z.ZodArray<z.ZodObject<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">>, "many">;
          contractError: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        doctor: z.ZodNullable<z.ZodObject<{
          success: z.ZodBoolean;
          stdout: z.ZodString;
          stderr: z.ZodString;
          exitCode: z.ZodNullable<z.ZodNumber>;
          diagnostics: z.ZodArray<z.ZodObject<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">>, "many">;
          contractError: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          success: z.ZodBoolean;
          stdout: z.ZodString;
          stderr: z.ZodString;
          exitCode: z.ZodNullable<z.ZodNumber>;
          diagnostics: z.ZodArray<z.ZodObject<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">>, "many">;
          contractError: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          success: z.ZodBoolean;
          stdout: z.ZodString;
          stderr: z.ZodString;
          exitCode: z.ZodNullable<z.ZodNumber>;
          diagnostics: z.ZodArray<z.ZodObject<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">>, "many">;
          contractError: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>>;
        context: z.ZodNullable<z.ZodObject<{
          success: z.ZodBoolean;
          stdout: z.ZodString;
          stderr: z.ZodString;
          exitCode: z.ZodNullable<z.ZodNumber>;
          diagnostics: z.ZodArray<z.ZodObject<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">>, "many">;
          contractError: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          success: z.ZodBoolean;
          stdout: z.ZodString;
          stderr: z.ZodString;
          exitCode: z.ZodNullable<z.ZodNumber>;
          diagnostics: z.ZodArray<z.ZodObject<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">>, "many">;
          contractError: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          success: z.ZodBoolean;
          stdout: z.ZodString;
          stderr: z.ZodString;
          exitCode: z.ZodNullable<z.ZodNumber>;
          diagnostics: z.ZodArray<z.ZodObject<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">>, "many">;
          contractError: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>>;
      }, z.ZodTypeAny, "passthrough">>;
      observedAt: z.ZodNumber;
    }, z.ZodTypeAny, "passthrough"> | null;
    observedAt: number;
    attempt: {
      storeId: string | null;
      diagnostics: {
        root: z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">[];
        context: z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">[];
        doctor: z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">[];
      } & {
        [k: string]: unknown;
      };
      evidence: {
        context: z.objectOutputType<{
          success: z.ZodBoolean;
          stdout: z.ZodString;
          stderr: z.ZodString;
          exitCode: z.ZodNullable<z.ZodNumber>;
          diagnostics: z.ZodArray<z.ZodObject<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">>, "many">;
          contractError: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough"> | null;
        doctor: z.objectOutputType<{
          success: z.ZodBoolean;
          stdout: z.ZodString;
          stderr: z.ZodString;
          exitCode: z.ZodNullable<z.ZodNumber>;
          diagnostics: z.ZodArray<z.ZodObject<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">>, "many">;
          contractError: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough"> | null;
      } & {
        [k: string]: unknown;
      };
      cli: {
        available: boolean;
        version?: string | undefined;
        error?: string | undefined;
        effectiveCommand?: string | undefined;
        tried?: string[] | undefined;
      } & {
        [k: string]: unknown;
      };
      references: z.objectOutputType<{
        store_id: z.ZodString;
        root: z.ZodOptional<z.ZodString>;
        status: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
      }, z.ZodTypeAny, "passthrough">[];
      dataScope: {
        path: string;
        source: "xdg-data-home" | "local-app-data" | "user-home-default";
        environmentVariable: "XDG_DATA_HOME" | "LOCALAPPDATA" | null;
      } & {
        [k: string]: unknown;
      };
      observedAt: number;
      launchProject: {
        path: string;
        physicalPath?: string | undefined;
      } & {
        [k: string]: unknown;
      };
      planningRoot: z.objectOutputType<{
        path: z.ZodString;
        source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
        store_id: z.ZodOptional<z.ZodString>;
      } & {
        healthy: z.ZodBoolean;
        status: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
      }, z.ZodTypeAny, "passthrough"> | null;
      contextMembers: z.objectOutputType<{
        role: z.ZodLiteral<"referenced_store">;
        id: z.ZodString;
        path: z.ZodOptional<z.ZodString>;
        remote: z.ZodOptional<z.ZodString>;
        fetch: z.ZodOptional<z.ZodString>;
        status: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
      }, z.ZodTypeAny, "passthrough">[];
      generation?: string | undefined;
    } & {
      [k: string]: unknown;
    };
  };
  freshness: "stale-display-only";
  snapshotGeneration: number;
  identity: string;
  workGeneration: number;
  invalidationCause: "dependency" | "initial" | "explicit-refresh" | "subscriber-resume";
}, {
  error: {
    message: string;
    name: string;
    cliEvidence: {
      success: boolean;
      stdout: string;
      stderr: string;
      exitCode: number | null;
      payload: CliJsonValue;
      diagnostics: z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">[];
      contractError?: string | undefined;
    } | null;
  };
  state: "refresh-error";
  data: {
    error: null;
    state: "ready";
    data: {
      storeId: string | null;
      diagnostics: {
        root: z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">[];
        context: z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">[];
        doctor: z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">[];
      } & {
        [k: string]: unknown;
      };
      evidence: {
        context: z.objectInputType<{
          success: z.ZodBoolean;
          stdout: z.ZodString;
          stderr: z.ZodString;
          exitCode: z.ZodNullable<z.ZodNumber>;
          diagnostics: z.ZodArray<z.ZodObject<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">>, "many">;
          contractError: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough"> | null;
        doctor: z.objectInputType<{
          success: z.ZodBoolean;
          stdout: z.ZodString;
          stderr: z.ZodString;
          exitCode: z.ZodNullable<z.ZodNumber>;
          diagnostics: z.ZodArray<z.ZodObject<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">>, "many">;
          contractError: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough"> | null;
      } & {
        [k: string]: unknown;
      };
      cli: {
        available: boolean;
        version?: string | undefined;
        error?: string | undefined;
        effectiveCommand?: string | undefined;
        tried?: string[] | undefined;
      } & {
        [k: string]: unknown;
      };
      references: z.objectInputType<{
        store_id: z.ZodString;
        root: z.ZodOptional<z.ZodString>;
        status: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
      }, z.ZodTypeAny, "passthrough">[];
      dataScope: {
        path: string;
        source: "xdg-data-home" | "local-app-data" | "user-home-default";
        environmentVariable: "XDG_DATA_HOME" | "LOCALAPPDATA" | null;
      } & {
        [k: string]: unknown;
      };
      observedAt: number;
      launchProject: {
        path: string;
        physicalPath?: string | undefined;
      } & {
        [k: string]: unknown;
      };
      planningRoot: z.objectInputType<{
        path: z.ZodString;
        source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
        store_id: z.ZodOptional<z.ZodString>;
      } & {
        healthy: z.ZodBoolean;
        status: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
      }, z.ZodTypeAny, "passthrough"> | null;
      contextMembers: z.objectInputType<{
        role: z.ZodLiteral<"referenced_store">;
        id: z.ZodString;
        path: z.ZodOptional<z.ZodString>;
        remote: z.ZodOptional<z.ZodString>;
        fetch: z.ZodOptional<z.ZodString>;
        status: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
      }, z.ZodTypeAny, "passthrough">[];
      generation?: string | undefined;
    } & {
      [k: string]: unknown;
    };
    observedAt: number;
    attempt: null;
  } | {
    error: {
      code: "cli-unavailable" | "doctor-command-failed" | "doctor-contract-drift" | "root-unresolved" | "root-unhealthy" | "context-command-failed" | "context-contract-drift" | "context-root-mismatch" | "references-unresolved" | "resolver-failed";
      message: string;
    };
    state: "error";
    data: z.objectInputType<{
      launchProject: z.ZodObject<{
        path: z.ZodString;
        physicalPath: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        path: z.ZodString;
        physicalPath: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        path: z.ZodString;
        physicalPath: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>;
      planningRoot: z.ZodNullable<z.ZodObject<{
        path: z.ZodString;
        source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
        store_id: z.ZodOptional<z.ZodString>;
      } & {
        healthy: z.ZodBoolean;
        status: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        path: z.ZodString;
        source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
        store_id: z.ZodOptional<z.ZodString>;
      } & {
        healthy: z.ZodBoolean;
        status: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        path: z.ZodString;
        source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
        store_id: z.ZodOptional<z.ZodString>;
      } & {
        healthy: z.ZodBoolean;
        status: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
      }, z.ZodTypeAny, "passthrough">>>;
      storeId: z.ZodNullable<z.ZodString>;
      generation: z.ZodOptional<z.ZodString>;
      cli: z.ZodObject<{
        available: z.ZodBoolean;
        version: z.ZodOptional<z.ZodString>;
        error: z.ZodOptional<z.ZodString>;
        effectiveCommand: z.ZodOptional<z.ZodString>;
        tried: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        available: z.ZodBoolean;
        version: z.ZodOptional<z.ZodString>;
        error: z.ZodOptional<z.ZodString>;
        effectiveCommand: z.ZodOptional<z.ZodString>;
        tried: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        available: z.ZodBoolean;
        version: z.ZodOptional<z.ZodString>;
        error: z.ZodOptional<z.ZodString>;
        effectiveCommand: z.ZodOptional<z.ZodString>;
        tried: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
      }, z.ZodTypeAny, "passthrough">>;
      references: z.ZodArray<z.ZodObject<{
        store_id: z.ZodString;
        root: z.ZodOptional<z.ZodString>;
        status: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        store_id: z.ZodString;
        root: z.ZodOptional<z.ZodString>;
        status: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        store_id: z.ZodString;
        root: z.ZodOptional<z.ZodString>;
        status: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
      }, z.ZodTypeAny, "passthrough">>, "many">;
      contextMembers: z.ZodArray<z.ZodObject<{
        role: z.ZodLiteral<"referenced_store">;
        id: z.ZodString;
        path: z.ZodOptional<z.ZodString>;
        remote: z.ZodOptional<z.ZodString>;
        fetch: z.ZodOptional<z.ZodString>;
        status: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        role: z.ZodLiteral<"referenced_store">;
        id: z.ZodString;
        path: z.ZodOptional<z.ZodString>;
        remote: z.ZodOptional<z.ZodString>;
        fetch: z.ZodOptional<z.ZodString>;
        status: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        role: z.ZodLiteral<"referenced_store">;
        id: z.ZodString;
        path: z.ZodOptional<z.ZodString>;
        remote: z.ZodOptional<z.ZodString>;
        fetch: z.ZodOptional<z.ZodString>;
        status: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
      }, z.ZodTypeAny, "passthrough">>, "many">;
      dataScope: z.ZodObject<{
        path: z.ZodString;
        source: z.ZodEnum<["xdg-data-home", "local-app-data", "user-home-default"]>;
        environmentVariable: z.ZodNullable<z.ZodEnum<["XDG_DATA_HOME", "LOCALAPPDATA"]>>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        path: z.ZodString;
        source: z.ZodEnum<["xdg-data-home", "local-app-data", "user-home-default"]>;
        environmentVariable: z.ZodNullable<z.ZodEnum<["XDG_DATA_HOME", "LOCALAPPDATA"]>>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        path: z.ZodString;
        source: z.ZodEnum<["xdg-data-home", "local-app-data", "user-home-default"]>;
        environmentVariable: z.ZodNullable<z.ZodEnum<["XDG_DATA_HOME", "LOCALAPPDATA"]>>;
      }, z.ZodTypeAny, "passthrough">>;
      diagnostics: z.ZodObject<{
        root: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        doctor: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        context: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        root: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        doctor: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        context: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        root: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        doctor: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        context: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
      }, z.ZodTypeAny, "passthrough">>;
      evidence: z.ZodObject<{
        doctor: z.ZodNullable<z.ZodObject<{
          success: z.ZodBoolean;
          stdout: z.ZodString;
          stderr: z.ZodString;
          exitCode: z.ZodNullable<z.ZodNumber>;
          diagnostics: z.ZodArray<z.ZodObject<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">>, "many">;
          contractError: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          success: z.ZodBoolean;
          stdout: z.ZodString;
          stderr: z.ZodString;
          exitCode: z.ZodNullable<z.ZodNumber>;
          diagnostics: z.ZodArray<z.ZodObject<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">>, "many">;
          contractError: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          success: z.ZodBoolean;
          stdout: z.ZodString;
          stderr: z.ZodString;
          exitCode: z.ZodNullable<z.ZodNumber>;
          diagnostics: z.ZodArray<z.ZodObject<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">>, "many">;
          contractError: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>>;
        context: z.ZodNullable<z.ZodObject<{
          success: z.ZodBoolean;
          stdout: z.ZodString;
          stderr: z.ZodString;
          exitCode: z.ZodNullable<z.ZodNumber>;
          diagnostics: z.ZodArray<z.ZodObject<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">>, "many">;
          contractError: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          success: z.ZodBoolean;
          stdout: z.ZodString;
          stderr: z.ZodString;
          exitCode: z.ZodNullable<z.ZodNumber>;
          diagnostics: z.ZodArray<z.ZodObject<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">>, "many">;
          contractError: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          success: z.ZodBoolean;
          stdout: z.ZodString;
          stderr: z.ZodString;
          exitCode: z.ZodNullable<z.ZodNumber>;
          diagnostics: z.ZodArray<z.ZodObject<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">>, "many">;
          contractError: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        doctor: z.ZodNullable<z.ZodObject<{
          success: z.ZodBoolean;
          stdout: z.ZodString;
          stderr: z.ZodString;
          exitCode: z.ZodNullable<z.ZodNumber>;
          diagnostics: z.ZodArray<z.ZodObject<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">>, "many">;
          contractError: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          success: z.ZodBoolean;
          stdout: z.ZodString;
          stderr: z.ZodString;
          exitCode: z.ZodNullable<z.ZodNumber>;
          diagnostics: z.ZodArray<z.ZodObject<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">>, "many">;
          contractError: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          success: z.ZodBoolean;
          stdout: z.ZodString;
          stderr: z.ZodString;
          exitCode: z.ZodNullable<z.ZodNumber>;
          diagnostics: z.ZodArray<z.ZodObject<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">>, "many">;
          contractError: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>>;
        context: z.ZodNullable<z.ZodObject<{
          success: z.ZodBoolean;
          stdout: z.ZodString;
          stderr: z.ZodString;
          exitCode: z.ZodNullable<z.ZodNumber>;
          diagnostics: z.ZodArray<z.ZodObject<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">>, "many">;
          contractError: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          success: z.ZodBoolean;
          stdout: z.ZodString;
          stderr: z.ZodString;
          exitCode: z.ZodNullable<z.ZodNumber>;
          diagnostics: z.ZodArray<z.ZodObject<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">>, "many">;
          contractError: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          success: z.ZodBoolean;
          stdout: z.ZodString;
          stderr: z.ZodString;
          exitCode: z.ZodNullable<z.ZodNumber>;
          diagnostics: z.ZodArray<z.ZodObject<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">>, "many">;
          contractError: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        doctor: z.ZodNullable<z.ZodObject<{
          success: z.ZodBoolean;
          stdout: z.ZodString;
          stderr: z.ZodString;
          exitCode: z.ZodNullable<z.ZodNumber>;
          diagnostics: z.ZodArray<z.ZodObject<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">>, "many">;
          contractError: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          success: z.ZodBoolean;
          stdout: z.ZodString;
          stderr: z.ZodString;
          exitCode: z.ZodNullable<z.ZodNumber>;
          diagnostics: z.ZodArray<z.ZodObject<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">>, "many">;
          contractError: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          success: z.ZodBoolean;
          stdout: z.ZodString;
          stderr: z.ZodString;
          exitCode: z.ZodNullable<z.ZodNumber>;
          diagnostics: z.ZodArray<z.ZodObject<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">>, "many">;
          contractError: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>>;
        context: z.ZodNullable<z.ZodObject<{
          success: z.ZodBoolean;
          stdout: z.ZodString;
          stderr: z.ZodString;
          exitCode: z.ZodNullable<z.ZodNumber>;
          diagnostics: z.ZodArray<z.ZodObject<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">>, "many">;
          contractError: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          success: z.ZodBoolean;
          stdout: z.ZodString;
          stderr: z.ZodString;
          exitCode: z.ZodNullable<z.ZodNumber>;
          diagnostics: z.ZodArray<z.ZodObject<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">>, "many">;
          contractError: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          success: z.ZodBoolean;
          stdout: z.ZodString;
          stderr: z.ZodString;
          exitCode: z.ZodNullable<z.ZodNumber>;
          diagnostics: z.ZodArray<z.ZodObject<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">>, "many">;
          contractError: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>>;
      }, z.ZodTypeAny, "passthrough">>;
      observedAt: z.ZodNumber;
    }, z.ZodTypeAny, "passthrough"> | null;
    observedAt: number;
    attempt: {
      storeId: string | null;
      diagnostics: {
        root: z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">[];
        context: z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">[];
        doctor: z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">[];
      } & {
        [k: string]: unknown;
      };
      evidence: {
        context: z.objectInputType<{
          success: z.ZodBoolean;
          stdout: z.ZodString;
          stderr: z.ZodString;
          exitCode: z.ZodNullable<z.ZodNumber>;
          diagnostics: z.ZodArray<z.ZodObject<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">>, "many">;
          contractError: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough"> | null;
        doctor: z.objectInputType<{
          success: z.ZodBoolean;
          stdout: z.ZodString;
          stderr: z.ZodString;
          exitCode: z.ZodNullable<z.ZodNumber>;
          diagnostics: z.ZodArray<z.ZodObject<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            severity: z.ZodEnum<["error", "warning", "info"]>;
            code: z.ZodString;
            message: z.ZodString;
            target: z.ZodOptional<z.ZodString>;
            fix: z.ZodOptional<z.ZodString>;
          }, z.ZodTypeAny, "passthrough">>, "many">;
          contractError: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough"> | null;
      } & {
        [k: string]: unknown;
      };
      cli: {
        available: boolean;
        version?: string | undefined;
        error?: string | undefined;
        effectiveCommand?: string | undefined;
        tried?: string[] | undefined;
      } & {
        [k: string]: unknown;
      };
      references: z.objectInputType<{
        store_id: z.ZodString;
        root: z.ZodOptional<z.ZodString>;
        status: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
      }, z.ZodTypeAny, "passthrough">[];
      dataScope: {
        path: string;
        source: "xdg-data-home" | "local-app-data" | "user-home-default";
        environmentVariable: "XDG_DATA_HOME" | "LOCALAPPDATA" | null;
      } & {
        [k: string]: unknown;
      };
      observedAt: number;
      launchProject: {
        path: string;
        physicalPath?: string | undefined;
      } & {
        [k: string]: unknown;
      };
      planningRoot: z.objectInputType<{
        path: z.ZodString;
        source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
        store_id: z.ZodOptional<z.ZodString>;
      } & {
        healthy: z.ZodBoolean;
        status: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
      }, z.ZodTypeAny, "passthrough"> | null;
      contextMembers: z.objectInputType<{
        role: z.ZodLiteral<"referenced_store">;
        id: z.ZodString;
        path: z.ZodOptional<z.ZodString>;
        remote: z.ZodOptional<z.ZodString>;
        fetch: z.ZodOptional<z.ZodString>;
        status: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
      }, z.ZodTypeAny, "passthrough">[];
      generation?: string | undefined;
    } & {
      [k: string]: unknown;
    };
  };
  freshness: "stale-display-only";
  snapshotGeneration: number;
  identity: string;
  workGeneration: number;
  invalidationCause: "dependency" | "initial" | "explicit-refresh" | "subscriber-resume";
}>]>;
/** Browser-safe legacy Root Context lifecycle retained for project-workspace adapters. */
declare const HostedRootContextStateSchema: z.ZodDiscriminatedUnion<"state", [z.ZodObject<{
  state: z.ZodLiteral<"loading">;
  data: z.ZodNull;
  attempt: z.ZodNull;
  error: z.ZodNull;
  observedAt: z.ZodNumber;
}, "strip", z.ZodTypeAny, {
  error: null;
  state: "loading";
  data: null;
  observedAt: number;
  attempt: null;
}, {
  error: null;
  state: "loading";
  data: null;
  observedAt: number;
  attempt: null;
}>, z.ZodObject<{
  state: z.ZodLiteral<"ready">;
  data: z.ZodObject<{
    launchProject: z.ZodObject<{
      path: z.ZodString;
      physicalPath: z.ZodOptional<z.ZodString>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      path: z.ZodString;
      physicalPath: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      path: z.ZodString;
      physicalPath: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">>;
    planningRoot: z.ZodNullable<z.ZodObject<{
      path: z.ZodString;
      source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
      store_id: z.ZodOptional<z.ZodString>;
    } & {
      healthy: z.ZodBoolean;
      status: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      path: z.ZodString;
      source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
      store_id: z.ZodOptional<z.ZodString>;
    } & {
      healthy: z.ZodBoolean;
      status: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      path: z.ZodString;
      source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
      store_id: z.ZodOptional<z.ZodString>;
    } & {
      healthy: z.ZodBoolean;
      status: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, z.ZodTypeAny, "passthrough">>>;
    storeId: z.ZodNullable<z.ZodString>;
    generation: z.ZodOptional<z.ZodString>;
    cli: z.ZodObject<{
      available: z.ZodBoolean;
      version: z.ZodOptional<z.ZodString>;
      error: z.ZodOptional<z.ZodString>;
      effectiveCommand: z.ZodOptional<z.ZodString>;
      tried: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      available: z.ZodBoolean;
      version: z.ZodOptional<z.ZodString>;
      error: z.ZodOptional<z.ZodString>;
      effectiveCommand: z.ZodOptional<z.ZodString>;
      tried: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      available: z.ZodBoolean;
      version: z.ZodOptional<z.ZodString>;
      error: z.ZodOptional<z.ZodString>;
      effectiveCommand: z.ZodOptional<z.ZodString>;
      tried: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
    }, z.ZodTypeAny, "passthrough">>;
    references: z.ZodArray<z.ZodObject<{
      store_id: z.ZodString;
      root: z.ZodOptional<z.ZodString>;
      status: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      store_id: z.ZodString;
      root: z.ZodOptional<z.ZodString>;
      status: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      store_id: z.ZodString;
      root: z.ZodOptional<z.ZodString>;
      status: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, z.ZodTypeAny, "passthrough">>, "many">;
    contextMembers: z.ZodArray<z.ZodObject<{
      role: z.ZodLiteral<"referenced_store">;
      id: z.ZodString;
      path: z.ZodOptional<z.ZodString>;
      remote: z.ZodOptional<z.ZodString>;
      fetch: z.ZodOptional<z.ZodString>;
      status: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      role: z.ZodLiteral<"referenced_store">;
      id: z.ZodString;
      path: z.ZodOptional<z.ZodString>;
      remote: z.ZodOptional<z.ZodString>;
      fetch: z.ZodOptional<z.ZodString>;
      status: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      role: z.ZodLiteral<"referenced_store">;
      id: z.ZodString;
      path: z.ZodOptional<z.ZodString>;
      remote: z.ZodOptional<z.ZodString>;
      fetch: z.ZodOptional<z.ZodString>;
      status: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, z.ZodTypeAny, "passthrough">>, "many">;
    dataScope: z.ZodObject<{
      path: z.ZodString;
      source: z.ZodEnum<["xdg-data-home", "local-app-data", "user-home-default"]>;
      environmentVariable: z.ZodNullable<z.ZodEnum<["XDG_DATA_HOME", "LOCALAPPDATA"]>>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      path: z.ZodString;
      source: z.ZodEnum<["xdg-data-home", "local-app-data", "user-home-default"]>;
      environmentVariable: z.ZodNullable<z.ZodEnum<["XDG_DATA_HOME", "LOCALAPPDATA"]>>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      path: z.ZodString;
      source: z.ZodEnum<["xdg-data-home", "local-app-data", "user-home-default"]>;
      environmentVariable: z.ZodNullable<z.ZodEnum<["XDG_DATA_HOME", "LOCALAPPDATA"]>>;
    }, z.ZodTypeAny, "passthrough">>;
    diagnostics: z.ZodObject<{
      root: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
      doctor: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
      context: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      root: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
      doctor: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
      context: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      root: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
      doctor: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
      context: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, z.ZodTypeAny, "passthrough">>;
    evidence: z.ZodObject<{
      doctor: z.ZodNullable<z.ZodObject<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>>;
      context: z.ZodNullable<z.ZodObject<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      doctor: z.ZodNullable<z.ZodObject<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>>;
      context: z.ZodNullable<z.ZodObject<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      doctor: z.ZodNullable<z.ZodObject<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>>;
      context: z.ZodNullable<z.ZodObject<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>>;
    }, z.ZodTypeAny, "passthrough">>;
    observedAt: z.ZodNumber;
  }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
    launchProject: z.ZodObject<{
      path: z.ZodString;
      physicalPath: z.ZodOptional<z.ZodString>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      path: z.ZodString;
      physicalPath: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      path: z.ZodString;
      physicalPath: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">>;
    planningRoot: z.ZodNullable<z.ZodObject<{
      path: z.ZodString;
      source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
      store_id: z.ZodOptional<z.ZodString>;
    } & {
      healthy: z.ZodBoolean;
      status: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      path: z.ZodString;
      source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
      store_id: z.ZodOptional<z.ZodString>;
    } & {
      healthy: z.ZodBoolean;
      status: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      path: z.ZodString;
      source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
      store_id: z.ZodOptional<z.ZodString>;
    } & {
      healthy: z.ZodBoolean;
      status: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, z.ZodTypeAny, "passthrough">>>;
    storeId: z.ZodNullable<z.ZodString>;
    generation: z.ZodOptional<z.ZodString>;
    cli: z.ZodObject<{
      available: z.ZodBoolean;
      version: z.ZodOptional<z.ZodString>;
      error: z.ZodOptional<z.ZodString>;
      effectiveCommand: z.ZodOptional<z.ZodString>;
      tried: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      available: z.ZodBoolean;
      version: z.ZodOptional<z.ZodString>;
      error: z.ZodOptional<z.ZodString>;
      effectiveCommand: z.ZodOptional<z.ZodString>;
      tried: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      available: z.ZodBoolean;
      version: z.ZodOptional<z.ZodString>;
      error: z.ZodOptional<z.ZodString>;
      effectiveCommand: z.ZodOptional<z.ZodString>;
      tried: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
    }, z.ZodTypeAny, "passthrough">>;
    references: z.ZodArray<z.ZodObject<{
      store_id: z.ZodString;
      root: z.ZodOptional<z.ZodString>;
      status: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      store_id: z.ZodString;
      root: z.ZodOptional<z.ZodString>;
      status: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      store_id: z.ZodString;
      root: z.ZodOptional<z.ZodString>;
      status: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, z.ZodTypeAny, "passthrough">>, "many">;
    contextMembers: z.ZodArray<z.ZodObject<{
      role: z.ZodLiteral<"referenced_store">;
      id: z.ZodString;
      path: z.ZodOptional<z.ZodString>;
      remote: z.ZodOptional<z.ZodString>;
      fetch: z.ZodOptional<z.ZodString>;
      status: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      role: z.ZodLiteral<"referenced_store">;
      id: z.ZodString;
      path: z.ZodOptional<z.ZodString>;
      remote: z.ZodOptional<z.ZodString>;
      fetch: z.ZodOptional<z.ZodString>;
      status: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      role: z.ZodLiteral<"referenced_store">;
      id: z.ZodString;
      path: z.ZodOptional<z.ZodString>;
      remote: z.ZodOptional<z.ZodString>;
      fetch: z.ZodOptional<z.ZodString>;
      status: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, z.ZodTypeAny, "passthrough">>, "many">;
    dataScope: z.ZodObject<{
      path: z.ZodString;
      source: z.ZodEnum<["xdg-data-home", "local-app-data", "user-home-default"]>;
      environmentVariable: z.ZodNullable<z.ZodEnum<["XDG_DATA_HOME", "LOCALAPPDATA"]>>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      path: z.ZodString;
      source: z.ZodEnum<["xdg-data-home", "local-app-data", "user-home-default"]>;
      environmentVariable: z.ZodNullable<z.ZodEnum<["XDG_DATA_HOME", "LOCALAPPDATA"]>>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      path: z.ZodString;
      source: z.ZodEnum<["xdg-data-home", "local-app-data", "user-home-default"]>;
      environmentVariable: z.ZodNullable<z.ZodEnum<["XDG_DATA_HOME", "LOCALAPPDATA"]>>;
    }, z.ZodTypeAny, "passthrough">>;
    diagnostics: z.ZodObject<{
      root: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
      doctor: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
      context: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      root: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
      doctor: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
      context: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      root: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
      doctor: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
      context: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, z.ZodTypeAny, "passthrough">>;
    evidence: z.ZodObject<{
      doctor: z.ZodNullable<z.ZodObject<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>>;
      context: z.ZodNullable<z.ZodObject<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      doctor: z.ZodNullable<z.ZodObject<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>>;
      context: z.ZodNullable<z.ZodObject<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      doctor: z.ZodNullable<z.ZodObject<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>>;
      context: z.ZodNullable<z.ZodObject<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>>;
    }, z.ZodTypeAny, "passthrough">>;
    observedAt: z.ZodNumber;
  }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
    launchProject: z.ZodObject<{
      path: z.ZodString;
      physicalPath: z.ZodOptional<z.ZodString>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      path: z.ZodString;
      physicalPath: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      path: z.ZodString;
      physicalPath: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">>;
    planningRoot: z.ZodNullable<z.ZodObject<{
      path: z.ZodString;
      source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
      store_id: z.ZodOptional<z.ZodString>;
    } & {
      healthy: z.ZodBoolean;
      status: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      path: z.ZodString;
      source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
      store_id: z.ZodOptional<z.ZodString>;
    } & {
      healthy: z.ZodBoolean;
      status: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      path: z.ZodString;
      source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
      store_id: z.ZodOptional<z.ZodString>;
    } & {
      healthy: z.ZodBoolean;
      status: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, z.ZodTypeAny, "passthrough">>>;
    storeId: z.ZodNullable<z.ZodString>;
    generation: z.ZodOptional<z.ZodString>;
    cli: z.ZodObject<{
      available: z.ZodBoolean;
      version: z.ZodOptional<z.ZodString>;
      error: z.ZodOptional<z.ZodString>;
      effectiveCommand: z.ZodOptional<z.ZodString>;
      tried: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      available: z.ZodBoolean;
      version: z.ZodOptional<z.ZodString>;
      error: z.ZodOptional<z.ZodString>;
      effectiveCommand: z.ZodOptional<z.ZodString>;
      tried: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      available: z.ZodBoolean;
      version: z.ZodOptional<z.ZodString>;
      error: z.ZodOptional<z.ZodString>;
      effectiveCommand: z.ZodOptional<z.ZodString>;
      tried: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
    }, z.ZodTypeAny, "passthrough">>;
    references: z.ZodArray<z.ZodObject<{
      store_id: z.ZodString;
      root: z.ZodOptional<z.ZodString>;
      status: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      store_id: z.ZodString;
      root: z.ZodOptional<z.ZodString>;
      status: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      store_id: z.ZodString;
      root: z.ZodOptional<z.ZodString>;
      status: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, z.ZodTypeAny, "passthrough">>, "many">;
    contextMembers: z.ZodArray<z.ZodObject<{
      role: z.ZodLiteral<"referenced_store">;
      id: z.ZodString;
      path: z.ZodOptional<z.ZodString>;
      remote: z.ZodOptional<z.ZodString>;
      fetch: z.ZodOptional<z.ZodString>;
      status: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      role: z.ZodLiteral<"referenced_store">;
      id: z.ZodString;
      path: z.ZodOptional<z.ZodString>;
      remote: z.ZodOptional<z.ZodString>;
      fetch: z.ZodOptional<z.ZodString>;
      status: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      role: z.ZodLiteral<"referenced_store">;
      id: z.ZodString;
      path: z.ZodOptional<z.ZodString>;
      remote: z.ZodOptional<z.ZodString>;
      fetch: z.ZodOptional<z.ZodString>;
      status: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, z.ZodTypeAny, "passthrough">>, "many">;
    dataScope: z.ZodObject<{
      path: z.ZodString;
      source: z.ZodEnum<["xdg-data-home", "local-app-data", "user-home-default"]>;
      environmentVariable: z.ZodNullable<z.ZodEnum<["XDG_DATA_HOME", "LOCALAPPDATA"]>>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      path: z.ZodString;
      source: z.ZodEnum<["xdg-data-home", "local-app-data", "user-home-default"]>;
      environmentVariable: z.ZodNullable<z.ZodEnum<["XDG_DATA_HOME", "LOCALAPPDATA"]>>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      path: z.ZodString;
      source: z.ZodEnum<["xdg-data-home", "local-app-data", "user-home-default"]>;
      environmentVariable: z.ZodNullable<z.ZodEnum<["XDG_DATA_HOME", "LOCALAPPDATA"]>>;
    }, z.ZodTypeAny, "passthrough">>;
    diagnostics: z.ZodObject<{
      root: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
      doctor: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
      context: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      root: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
      doctor: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
      context: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      root: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
      doctor: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
      context: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, z.ZodTypeAny, "passthrough">>;
    evidence: z.ZodObject<{
      doctor: z.ZodNullable<z.ZodObject<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>>;
      context: z.ZodNullable<z.ZodObject<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      doctor: z.ZodNullable<z.ZodObject<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>>;
      context: z.ZodNullable<z.ZodObject<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      doctor: z.ZodNullable<z.ZodObject<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>>;
      context: z.ZodNullable<z.ZodObject<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>>;
    }, z.ZodTypeAny, "passthrough">>;
    observedAt: z.ZodNumber;
  }, z.ZodTypeAny, "passthrough">>;
  attempt: z.ZodNull;
  error: z.ZodNull;
  observedAt: z.ZodNumber;
}, "strip", z.ZodTypeAny, {
  error: null;
  state: "ready";
  data: {
    storeId: string | null;
    diagnostics: {
      root: z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">[];
      context: z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">[];
      doctor: z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">[];
    } & {
      [k: string]: unknown;
    };
    evidence: {
      context: z.objectOutputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough"> | null;
      doctor: z.objectOutputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough"> | null;
    } & {
      [k: string]: unknown;
    };
    cli: {
      available: boolean;
      version?: string | undefined;
      error?: string | undefined;
      effectiveCommand?: string | undefined;
      tried?: string[] | undefined;
    } & {
      [k: string]: unknown;
    };
    references: z.objectOutputType<{
      store_id: z.ZodString;
      root: z.ZodOptional<z.ZodString>;
      status: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, z.ZodTypeAny, "passthrough">[];
    dataScope: {
      path: string;
      source: "xdg-data-home" | "local-app-data" | "user-home-default";
      environmentVariable: "XDG_DATA_HOME" | "LOCALAPPDATA" | null;
    } & {
      [k: string]: unknown;
    };
    observedAt: number;
    launchProject: {
      path: string;
      physicalPath?: string | undefined;
    } & {
      [k: string]: unknown;
    };
    planningRoot: z.objectOutputType<{
      path: z.ZodString;
      source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
      store_id: z.ZodOptional<z.ZodString>;
    } & {
      healthy: z.ZodBoolean;
      status: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, z.ZodTypeAny, "passthrough"> | null;
    contextMembers: z.objectOutputType<{
      role: z.ZodLiteral<"referenced_store">;
      id: z.ZodString;
      path: z.ZodOptional<z.ZodString>;
      remote: z.ZodOptional<z.ZodString>;
      fetch: z.ZodOptional<z.ZodString>;
      status: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, z.ZodTypeAny, "passthrough">[];
    generation?: string | undefined;
  } & {
    [k: string]: unknown;
  };
  observedAt: number;
  attempt: null;
}, {
  error: null;
  state: "ready";
  data: {
    storeId: string | null;
    diagnostics: {
      root: z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">[];
      context: z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">[];
      doctor: z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">[];
    } & {
      [k: string]: unknown;
    };
    evidence: {
      context: z.objectInputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough"> | null;
      doctor: z.objectInputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough"> | null;
    } & {
      [k: string]: unknown;
    };
    cli: {
      available: boolean;
      version?: string | undefined;
      error?: string | undefined;
      effectiveCommand?: string | undefined;
      tried?: string[] | undefined;
    } & {
      [k: string]: unknown;
    };
    references: z.objectInputType<{
      store_id: z.ZodString;
      root: z.ZodOptional<z.ZodString>;
      status: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, z.ZodTypeAny, "passthrough">[];
    dataScope: {
      path: string;
      source: "xdg-data-home" | "local-app-data" | "user-home-default";
      environmentVariable: "XDG_DATA_HOME" | "LOCALAPPDATA" | null;
    } & {
      [k: string]: unknown;
    };
    observedAt: number;
    launchProject: {
      path: string;
      physicalPath?: string | undefined;
    } & {
      [k: string]: unknown;
    };
    planningRoot: z.objectInputType<{
      path: z.ZodString;
      source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
      store_id: z.ZodOptional<z.ZodString>;
    } & {
      healthy: z.ZodBoolean;
      status: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, z.ZodTypeAny, "passthrough"> | null;
    contextMembers: z.objectInputType<{
      role: z.ZodLiteral<"referenced_store">;
      id: z.ZodString;
      path: z.ZodOptional<z.ZodString>;
      remote: z.ZodOptional<z.ZodString>;
      fetch: z.ZodOptional<z.ZodString>;
      status: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, z.ZodTypeAny, "passthrough">[];
    generation?: string | undefined;
  } & {
    [k: string]: unknown;
  };
  observedAt: number;
  attempt: null;
}>, z.ZodObject<{
  state: z.ZodLiteral<"refreshing">;
  data: z.ZodObject<{
    launchProject: z.ZodObject<{
      path: z.ZodString;
      physicalPath: z.ZodOptional<z.ZodString>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      path: z.ZodString;
      physicalPath: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      path: z.ZodString;
      physicalPath: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">>;
    planningRoot: z.ZodNullable<z.ZodObject<{
      path: z.ZodString;
      source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
      store_id: z.ZodOptional<z.ZodString>;
    } & {
      healthy: z.ZodBoolean;
      status: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      path: z.ZodString;
      source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
      store_id: z.ZodOptional<z.ZodString>;
    } & {
      healthy: z.ZodBoolean;
      status: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      path: z.ZodString;
      source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
      store_id: z.ZodOptional<z.ZodString>;
    } & {
      healthy: z.ZodBoolean;
      status: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, z.ZodTypeAny, "passthrough">>>;
    storeId: z.ZodNullable<z.ZodString>;
    generation: z.ZodOptional<z.ZodString>;
    cli: z.ZodObject<{
      available: z.ZodBoolean;
      version: z.ZodOptional<z.ZodString>;
      error: z.ZodOptional<z.ZodString>;
      effectiveCommand: z.ZodOptional<z.ZodString>;
      tried: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      available: z.ZodBoolean;
      version: z.ZodOptional<z.ZodString>;
      error: z.ZodOptional<z.ZodString>;
      effectiveCommand: z.ZodOptional<z.ZodString>;
      tried: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      available: z.ZodBoolean;
      version: z.ZodOptional<z.ZodString>;
      error: z.ZodOptional<z.ZodString>;
      effectiveCommand: z.ZodOptional<z.ZodString>;
      tried: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
    }, z.ZodTypeAny, "passthrough">>;
    references: z.ZodArray<z.ZodObject<{
      store_id: z.ZodString;
      root: z.ZodOptional<z.ZodString>;
      status: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      store_id: z.ZodString;
      root: z.ZodOptional<z.ZodString>;
      status: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      store_id: z.ZodString;
      root: z.ZodOptional<z.ZodString>;
      status: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, z.ZodTypeAny, "passthrough">>, "many">;
    contextMembers: z.ZodArray<z.ZodObject<{
      role: z.ZodLiteral<"referenced_store">;
      id: z.ZodString;
      path: z.ZodOptional<z.ZodString>;
      remote: z.ZodOptional<z.ZodString>;
      fetch: z.ZodOptional<z.ZodString>;
      status: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      role: z.ZodLiteral<"referenced_store">;
      id: z.ZodString;
      path: z.ZodOptional<z.ZodString>;
      remote: z.ZodOptional<z.ZodString>;
      fetch: z.ZodOptional<z.ZodString>;
      status: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      role: z.ZodLiteral<"referenced_store">;
      id: z.ZodString;
      path: z.ZodOptional<z.ZodString>;
      remote: z.ZodOptional<z.ZodString>;
      fetch: z.ZodOptional<z.ZodString>;
      status: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, z.ZodTypeAny, "passthrough">>, "many">;
    dataScope: z.ZodObject<{
      path: z.ZodString;
      source: z.ZodEnum<["xdg-data-home", "local-app-data", "user-home-default"]>;
      environmentVariable: z.ZodNullable<z.ZodEnum<["XDG_DATA_HOME", "LOCALAPPDATA"]>>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      path: z.ZodString;
      source: z.ZodEnum<["xdg-data-home", "local-app-data", "user-home-default"]>;
      environmentVariable: z.ZodNullable<z.ZodEnum<["XDG_DATA_HOME", "LOCALAPPDATA"]>>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      path: z.ZodString;
      source: z.ZodEnum<["xdg-data-home", "local-app-data", "user-home-default"]>;
      environmentVariable: z.ZodNullable<z.ZodEnum<["XDG_DATA_HOME", "LOCALAPPDATA"]>>;
    }, z.ZodTypeAny, "passthrough">>;
    diagnostics: z.ZodObject<{
      root: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
      doctor: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
      context: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      root: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
      doctor: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
      context: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      root: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
      doctor: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
      context: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, z.ZodTypeAny, "passthrough">>;
    evidence: z.ZodObject<{
      doctor: z.ZodNullable<z.ZodObject<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>>;
      context: z.ZodNullable<z.ZodObject<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      doctor: z.ZodNullable<z.ZodObject<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>>;
      context: z.ZodNullable<z.ZodObject<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      doctor: z.ZodNullable<z.ZodObject<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>>;
      context: z.ZodNullable<z.ZodObject<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>>;
    }, z.ZodTypeAny, "passthrough">>;
    observedAt: z.ZodNumber;
  }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
    launchProject: z.ZodObject<{
      path: z.ZodString;
      physicalPath: z.ZodOptional<z.ZodString>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      path: z.ZodString;
      physicalPath: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      path: z.ZodString;
      physicalPath: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">>;
    planningRoot: z.ZodNullable<z.ZodObject<{
      path: z.ZodString;
      source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
      store_id: z.ZodOptional<z.ZodString>;
    } & {
      healthy: z.ZodBoolean;
      status: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      path: z.ZodString;
      source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
      store_id: z.ZodOptional<z.ZodString>;
    } & {
      healthy: z.ZodBoolean;
      status: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      path: z.ZodString;
      source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
      store_id: z.ZodOptional<z.ZodString>;
    } & {
      healthy: z.ZodBoolean;
      status: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, z.ZodTypeAny, "passthrough">>>;
    storeId: z.ZodNullable<z.ZodString>;
    generation: z.ZodOptional<z.ZodString>;
    cli: z.ZodObject<{
      available: z.ZodBoolean;
      version: z.ZodOptional<z.ZodString>;
      error: z.ZodOptional<z.ZodString>;
      effectiveCommand: z.ZodOptional<z.ZodString>;
      tried: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      available: z.ZodBoolean;
      version: z.ZodOptional<z.ZodString>;
      error: z.ZodOptional<z.ZodString>;
      effectiveCommand: z.ZodOptional<z.ZodString>;
      tried: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      available: z.ZodBoolean;
      version: z.ZodOptional<z.ZodString>;
      error: z.ZodOptional<z.ZodString>;
      effectiveCommand: z.ZodOptional<z.ZodString>;
      tried: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
    }, z.ZodTypeAny, "passthrough">>;
    references: z.ZodArray<z.ZodObject<{
      store_id: z.ZodString;
      root: z.ZodOptional<z.ZodString>;
      status: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      store_id: z.ZodString;
      root: z.ZodOptional<z.ZodString>;
      status: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      store_id: z.ZodString;
      root: z.ZodOptional<z.ZodString>;
      status: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, z.ZodTypeAny, "passthrough">>, "many">;
    contextMembers: z.ZodArray<z.ZodObject<{
      role: z.ZodLiteral<"referenced_store">;
      id: z.ZodString;
      path: z.ZodOptional<z.ZodString>;
      remote: z.ZodOptional<z.ZodString>;
      fetch: z.ZodOptional<z.ZodString>;
      status: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      role: z.ZodLiteral<"referenced_store">;
      id: z.ZodString;
      path: z.ZodOptional<z.ZodString>;
      remote: z.ZodOptional<z.ZodString>;
      fetch: z.ZodOptional<z.ZodString>;
      status: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      role: z.ZodLiteral<"referenced_store">;
      id: z.ZodString;
      path: z.ZodOptional<z.ZodString>;
      remote: z.ZodOptional<z.ZodString>;
      fetch: z.ZodOptional<z.ZodString>;
      status: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, z.ZodTypeAny, "passthrough">>, "many">;
    dataScope: z.ZodObject<{
      path: z.ZodString;
      source: z.ZodEnum<["xdg-data-home", "local-app-data", "user-home-default"]>;
      environmentVariable: z.ZodNullable<z.ZodEnum<["XDG_DATA_HOME", "LOCALAPPDATA"]>>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      path: z.ZodString;
      source: z.ZodEnum<["xdg-data-home", "local-app-data", "user-home-default"]>;
      environmentVariable: z.ZodNullable<z.ZodEnum<["XDG_DATA_HOME", "LOCALAPPDATA"]>>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      path: z.ZodString;
      source: z.ZodEnum<["xdg-data-home", "local-app-data", "user-home-default"]>;
      environmentVariable: z.ZodNullable<z.ZodEnum<["XDG_DATA_HOME", "LOCALAPPDATA"]>>;
    }, z.ZodTypeAny, "passthrough">>;
    diagnostics: z.ZodObject<{
      root: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
      doctor: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
      context: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      root: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
      doctor: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
      context: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      root: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
      doctor: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
      context: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, z.ZodTypeAny, "passthrough">>;
    evidence: z.ZodObject<{
      doctor: z.ZodNullable<z.ZodObject<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>>;
      context: z.ZodNullable<z.ZodObject<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      doctor: z.ZodNullable<z.ZodObject<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>>;
      context: z.ZodNullable<z.ZodObject<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      doctor: z.ZodNullable<z.ZodObject<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>>;
      context: z.ZodNullable<z.ZodObject<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>>;
    }, z.ZodTypeAny, "passthrough">>;
    observedAt: z.ZodNumber;
  }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
    launchProject: z.ZodObject<{
      path: z.ZodString;
      physicalPath: z.ZodOptional<z.ZodString>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      path: z.ZodString;
      physicalPath: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      path: z.ZodString;
      physicalPath: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">>;
    planningRoot: z.ZodNullable<z.ZodObject<{
      path: z.ZodString;
      source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
      store_id: z.ZodOptional<z.ZodString>;
    } & {
      healthy: z.ZodBoolean;
      status: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      path: z.ZodString;
      source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
      store_id: z.ZodOptional<z.ZodString>;
    } & {
      healthy: z.ZodBoolean;
      status: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      path: z.ZodString;
      source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
      store_id: z.ZodOptional<z.ZodString>;
    } & {
      healthy: z.ZodBoolean;
      status: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, z.ZodTypeAny, "passthrough">>>;
    storeId: z.ZodNullable<z.ZodString>;
    generation: z.ZodOptional<z.ZodString>;
    cli: z.ZodObject<{
      available: z.ZodBoolean;
      version: z.ZodOptional<z.ZodString>;
      error: z.ZodOptional<z.ZodString>;
      effectiveCommand: z.ZodOptional<z.ZodString>;
      tried: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      available: z.ZodBoolean;
      version: z.ZodOptional<z.ZodString>;
      error: z.ZodOptional<z.ZodString>;
      effectiveCommand: z.ZodOptional<z.ZodString>;
      tried: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      available: z.ZodBoolean;
      version: z.ZodOptional<z.ZodString>;
      error: z.ZodOptional<z.ZodString>;
      effectiveCommand: z.ZodOptional<z.ZodString>;
      tried: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
    }, z.ZodTypeAny, "passthrough">>;
    references: z.ZodArray<z.ZodObject<{
      store_id: z.ZodString;
      root: z.ZodOptional<z.ZodString>;
      status: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      store_id: z.ZodString;
      root: z.ZodOptional<z.ZodString>;
      status: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      store_id: z.ZodString;
      root: z.ZodOptional<z.ZodString>;
      status: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, z.ZodTypeAny, "passthrough">>, "many">;
    contextMembers: z.ZodArray<z.ZodObject<{
      role: z.ZodLiteral<"referenced_store">;
      id: z.ZodString;
      path: z.ZodOptional<z.ZodString>;
      remote: z.ZodOptional<z.ZodString>;
      fetch: z.ZodOptional<z.ZodString>;
      status: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      role: z.ZodLiteral<"referenced_store">;
      id: z.ZodString;
      path: z.ZodOptional<z.ZodString>;
      remote: z.ZodOptional<z.ZodString>;
      fetch: z.ZodOptional<z.ZodString>;
      status: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      role: z.ZodLiteral<"referenced_store">;
      id: z.ZodString;
      path: z.ZodOptional<z.ZodString>;
      remote: z.ZodOptional<z.ZodString>;
      fetch: z.ZodOptional<z.ZodString>;
      status: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, z.ZodTypeAny, "passthrough">>, "many">;
    dataScope: z.ZodObject<{
      path: z.ZodString;
      source: z.ZodEnum<["xdg-data-home", "local-app-data", "user-home-default"]>;
      environmentVariable: z.ZodNullable<z.ZodEnum<["XDG_DATA_HOME", "LOCALAPPDATA"]>>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      path: z.ZodString;
      source: z.ZodEnum<["xdg-data-home", "local-app-data", "user-home-default"]>;
      environmentVariable: z.ZodNullable<z.ZodEnum<["XDG_DATA_HOME", "LOCALAPPDATA"]>>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      path: z.ZodString;
      source: z.ZodEnum<["xdg-data-home", "local-app-data", "user-home-default"]>;
      environmentVariable: z.ZodNullable<z.ZodEnum<["XDG_DATA_HOME", "LOCALAPPDATA"]>>;
    }, z.ZodTypeAny, "passthrough">>;
    diagnostics: z.ZodObject<{
      root: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
      doctor: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
      context: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      root: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
      doctor: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
      context: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      root: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
      doctor: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
      context: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, z.ZodTypeAny, "passthrough">>;
    evidence: z.ZodObject<{
      doctor: z.ZodNullable<z.ZodObject<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>>;
      context: z.ZodNullable<z.ZodObject<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      doctor: z.ZodNullable<z.ZodObject<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>>;
      context: z.ZodNullable<z.ZodObject<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      doctor: z.ZodNullable<z.ZodObject<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>>;
      context: z.ZodNullable<z.ZodObject<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>>;
    }, z.ZodTypeAny, "passthrough">>;
    observedAt: z.ZodNumber;
  }, z.ZodTypeAny, "passthrough">>;
  attempt: z.ZodNull;
  error: z.ZodNull;
  observedAt: z.ZodNumber;
}, "strip", z.ZodTypeAny, {
  error: null;
  state: "refreshing";
  data: {
    storeId: string | null;
    diagnostics: {
      root: z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">[];
      context: z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">[];
      doctor: z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">[];
    } & {
      [k: string]: unknown;
    };
    evidence: {
      context: z.objectOutputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough"> | null;
      doctor: z.objectOutputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough"> | null;
    } & {
      [k: string]: unknown;
    };
    cli: {
      available: boolean;
      version?: string | undefined;
      error?: string | undefined;
      effectiveCommand?: string | undefined;
      tried?: string[] | undefined;
    } & {
      [k: string]: unknown;
    };
    references: z.objectOutputType<{
      store_id: z.ZodString;
      root: z.ZodOptional<z.ZodString>;
      status: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, z.ZodTypeAny, "passthrough">[];
    dataScope: {
      path: string;
      source: "xdg-data-home" | "local-app-data" | "user-home-default";
      environmentVariable: "XDG_DATA_HOME" | "LOCALAPPDATA" | null;
    } & {
      [k: string]: unknown;
    };
    observedAt: number;
    launchProject: {
      path: string;
      physicalPath?: string | undefined;
    } & {
      [k: string]: unknown;
    };
    planningRoot: z.objectOutputType<{
      path: z.ZodString;
      source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
      store_id: z.ZodOptional<z.ZodString>;
    } & {
      healthy: z.ZodBoolean;
      status: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, z.ZodTypeAny, "passthrough"> | null;
    contextMembers: z.objectOutputType<{
      role: z.ZodLiteral<"referenced_store">;
      id: z.ZodString;
      path: z.ZodOptional<z.ZodString>;
      remote: z.ZodOptional<z.ZodString>;
      fetch: z.ZodOptional<z.ZodString>;
      status: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, z.ZodTypeAny, "passthrough">[];
    generation?: string | undefined;
  } & {
    [k: string]: unknown;
  };
  observedAt: number;
  attempt: null;
}, {
  error: null;
  state: "refreshing";
  data: {
    storeId: string | null;
    diagnostics: {
      root: z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">[];
      context: z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">[];
      doctor: z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">[];
    } & {
      [k: string]: unknown;
    };
    evidence: {
      context: z.objectInputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough"> | null;
      doctor: z.objectInputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough"> | null;
    } & {
      [k: string]: unknown;
    };
    cli: {
      available: boolean;
      version?: string | undefined;
      error?: string | undefined;
      effectiveCommand?: string | undefined;
      tried?: string[] | undefined;
    } & {
      [k: string]: unknown;
    };
    references: z.objectInputType<{
      store_id: z.ZodString;
      root: z.ZodOptional<z.ZodString>;
      status: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, z.ZodTypeAny, "passthrough">[];
    dataScope: {
      path: string;
      source: "xdg-data-home" | "local-app-data" | "user-home-default";
      environmentVariable: "XDG_DATA_HOME" | "LOCALAPPDATA" | null;
    } & {
      [k: string]: unknown;
    };
    observedAt: number;
    launchProject: {
      path: string;
      physicalPath?: string | undefined;
    } & {
      [k: string]: unknown;
    };
    planningRoot: z.objectInputType<{
      path: z.ZodString;
      source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
      store_id: z.ZodOptional<z.ZodString>;
    } & {
      healthy: z.ZodBoolean;
      status: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, z.ZodTypeAny, "passthrough"> | null;
    contextMembers: z.objectInputType<{
      role: z.ZodLiteral<"referenced_store">;
      id: z.ZodString;
      path: z.ZodOptional<z.ZodString>;
      remote: z.ZodOptional<z.ZodString>;
      fetch: z.ZodOptional<z.ZodString>;
      status: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, z.ZodTypeAny, "passthrough">[];
    generation?: string | undefined;
  } & {
    [k: string]: unknown;
  };
  observedAt: number;
  attempt: null;
}>, z.ZodObject<{
  state: z.ZodLiteral<"error">;
  data: z.ZodNullable<z.ZodObject<{
    launchProject: z.ZodObject<{
      path: z.ZodString;
      physicalPath: z.ZodOptional<z.ZodString>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      path: z.ZodString;
      physicalPath: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      path: z.ZodString;
      physicalPath: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">>;
    planningRoot: z.ZodNullable<z.ZodObject<{
      path: z.ZodString;
      source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
      store_id: z.ZodOptional<z.ZodString>;
    } & {
      healthy: z.ZodBoolean;
      status: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      path: z.ZodString;
      source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
      store_id: z.ZodOptional<z.ZodString>;
    } & {
      healthy: z.ZodBoolean;
      status: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      path: z.ZodString;
      source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
      store_id: z.ZodOptional<z.ZodString>;
    } & {
      healthy: z.ZodBoolean;
      status: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, z.ZodTypeAny, "passthrough">>>;
    storeId: z.ZodNullable<z.ZodString>;
    generation: z.ZodOptional<z.ZodString>;
    cli: z.ZodObject<{
      available: z.ZodBoolean;
      version: z.ZodOptional<z.ZodString>;
      error: z.ZodOptional<z.ZodString>;
      effectiveCommand: z.ZodOptional<z.ZodString>;
      tried: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      available: z.ZodBoolean;
      version: z.ZodOptional<z.ZodString>;
      error: z.ZodOptional<z.ZodString>;
      effectiveCommand: z.ZodOptional<z.ZodString>;
      tried: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      available: z.ZodBoolean;
      version: z.ZodOptional<z.ZodString>;
      error: z.ZodOptional<z.ZodString>;
      effectiveCommand: z.ZodOptional<z.ZodString>;
      tried: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
    }, z.ZodTypeAny, "passthrough">>;
    references: z.ZodArray<z.ZodObject<{
      store_id: z.ZodString;
      root: z.ZodOptional<z.ZodString>;
      status: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      store_id: z.ZodString;
      root: z.ZodOptional<z.ZodString>;
      status: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      store_id: z.ZodString;
      root: z.ZodOptional<z.ZodString>;
      status: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, z.ZodTypeAny, "passthrough">>, "many">;
    contextMembers: z.ZodArray<z.ZodObject<{
      role: z.ZodLiteral<"referenced_store">;
      id: z.ZodString;
      path: z.ZodOptional<z.ZodString>;
      remote: z.ZodOptional<z.ZodString>;
      fetch: z.ZodOptional<z.ZodString>;
      status: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      role: z.ZodLiteral<"referenced_store">;
      id: z.ZodString;
      path: z.ZodOptional<z.ZodString>;
      remote: z.ZodOptional<z.ZodString>;
      fetch: z.ZodOptional<z.ZodString>;
      status: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      role: z.ZodLiteral<"referenced_store">;
      id: z.ZodString;
      path: z.ZodOptional<z.ZodString>;
      remote: z.ZodOptional<z.ZodString>;
      fetch: z.ZodOptional<z.ZodString>;
      status: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, z.ZodTypeAny, "passthrough">>, "many">;
    dataScope: z.ZodObject<{
      path: z.ZodString;
      source: z.ZodEnum<["xdg-data-home", "local-app-data", "user-home-default"]>;
      environmentVariable: z.ZodNullable<z.ZodEnum<["XDG_DATA_HOME", "LOCALAPPDATA"]>>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      path: z.ZodString;
      source: z.ZodEnum<["xdg-data-home", "local-app-data", "user-home-default"]>;
      environmentVariable: z.ZodNullable<z.ZodEnum<["XDG_DATA_HOME", "LOCALAPPDATA"]>>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      path: z.ZodString;
      source: z.ZodEnum<["xdg-data-home", "local-app-data", "user-home-default"]>;
      environmentVariable: z.ZodNullable<z.ZodEnum<["XDG_DATA_HOME", "LOCALAPPDATA"]>>;
    }, z.ZodTypeAny, "passthrough">>;
    diagnostics: z.ZodObject<{
      root: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
      doctor: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
      context: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      root: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
      doctor: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
      context: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      root: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
      doctor: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
      context: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, z.ZodTypeAny, "passthrough">>;
    evidence: z.ZodObject<{
      doctor: z.ZodNullable<z.ZodObject<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>>;
      context: z.ZodNullable<z.ZodObject<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      doctor: z.ZodNullable<z.ZodObject<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>>;
      context: z.ZodNullable<z.ZodObject<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      doctor: z.ZodNullable<z.ZodObject<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>>;
      context: z.ZodNullable<z.ZodObject<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>>;
    }, z.ZodTypeAny, "passthrough">>;
    observedAt: z.ZodNumber;
  }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
    launchProject: z.ZodObject<{
      path: z.ZodString;
      physicalPath: z.ZodOptional<z.ZodString>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      path: z.ZodString;
      physicalPath: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      path: z.ZodString;
      physicalPath: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">>;
    planningRoot: z.ZodNullable<z.ZodObject<{
      path: z.ZodString;
      source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
      store_id: z.ZodOptional<z.ZodString>;
    } & {
      healthy: z.ZodBoolean;
      status: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      path: z.ZodString;
      source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
      store_id: z.ZodOptional<z.ZodString>;
    } & {
      healthy: z.ZodBoolean;
      status: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      path: z.ZodString;
      source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
      store_id: z.ZodOptional<z.ZodString>;
    } & {
      healthy: z.ZodBoolean;
      status: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, z.ZodTypeAny, "passthrough">>>;
    storeId: z.ZodNullable<z.ZodString>;
    generation: z.ZodOptional<z.ZodString>;
    cli: z.ZodObject<{
      available: z.ZodBoolean;
      version: z.ZodOptional<z.ZodString>;
      error: z.ZodOptional<z.ZodString>;
      effectiveCommand: z.ZodOptional<z.ZodString>;
      tried: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      available: z.ZodBoolean;
      version: z.ZodOptional<z.ZodString>;
      error: z.ZodOptional<z.ZodString>;
      effectiveCommand: z.ZodOptional<z.ZodString>;
      tried: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      available: z.ZodBoolean;
      version: z.ZodOptional<z.ZodString>;
      error: z.ZodOptional<z.ZodString>;
      effectiveCommand: z.ZodOptional<z.ZodString>;
      tried: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
    }, z.ZodTypeAny, "passthrough">>;
    references: z.ZodArray<z.ZodObject<{
      store_id: z.ZodString;
      root: z.ZodOptional<z.ZodString>;
      status: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      store_id: z.ZodString;
      root: z.ZodOptional<z.ZodString>;
      status: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      store_id: z.ZodString;
      root: z.ZodOptional<z.ZodString>;
      status: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, z.ZodTypeAny, "passthrough">>, "many">;
    contextMembers: z.ZodArray<z.ZodObject<{
      role: z.ZodLiteral<"referenced_store">;
      id: z.ZodString;
      path: z.ZodOptional<z.ZodString>;
      remote: z.ZodOptional<z.ZodString>;
      fetch: z.ZodOptional<z.ZodString>;
      status: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      role: z.ZodLiteral<"referenced_store">;
      id: z.ZodString;
      path: z.ZodOptional<z.ZodString>;
      remote: z.ZodOptional<z.ZodString>;
      fetch: z.ZodOptional<z.ZodString>;
      status: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      role: z.ZodLiteral<"referenced_store">;
      id: z.ZodString;
      path: z.ZodOptional<z.ZodString>;
      remote: z.ZodOptional<z.ZodString>;
      fetch: z.ZodOptional<z.ZodString>;
      status: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, z.ZodTypeAny, "passthrough">>, "many">;
    dataScope: z.ZodObject<{
      path: z.ZodString;
      source: z.ZodEnum<["xdg-data-home", "local-app-data", "user-home-default"]>;
      environmentVariable: z.ZodNullable<z.ZodEnum<["XDG_DATA_HOME", "LOCALAPPDATA"]>>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      path: z.ZodString;
      source: z.ZodEnum<["xdg-data-home", "local-app-data", "user-home-default"]>;
      environmentVariable: z.ZodNullable<z.ZodEnum<["XDG_DATA_HOME", "LOCALAPPDATA"]>>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      path: z.ZodString;
      source: z.ZodEnum<["xdg-data-home", "local-app-data", "user-home-default"]>;
      environmentVariable: z.ZodNullable<z.ZodEnum<["XDG_DATA_HOME", "LOCALAPPDATA"]>>;
    }, z.ZodTypeAny, "passthrough">>;
    diagnostics: z.ZodObject<{
      root: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
      doctor: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
      context: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      root: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
      doctor: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
      context: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      root: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
      doctor: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
      context: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, z.ZodTypeAny, "passthrough">>;
    evidence: z.ZodObject<{
      doctor: z.ZodNullable<z.ZodObject<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>>;
      context: z.ZodNullable<z.ZodObject<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      doctor: z.ZodNullable<z.ZodObject<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>>;
      context: z.ZodNullable<z.ZodObject<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      doctor: z.ZodNullable<z.ZodObject<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>>;
      context: z.ZodNullable<z.ZodObject<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>>;
    }, z.ZodTypeAny, "passthrough">>;
    observedAt: z.ZodNumber;
  }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
    launchProject: z.ZodObject<{
      path: z.ZodString;
      physicalPath: z.ZodOptional<z.ZodString>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      path: z.ZodString;
      physicalPath: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      path: z.ZodString;
      physicalPath: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">>;
    planningRoot: z.ZodNullable<z.ZodObject<{
      path: z.ZodString;
      source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
      store_id: z.ZodOptional<z.ZodString>;
    } & {
      healthy: z.ZodBoolean;
      status: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      path: z.ZodString;
      source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
      store_id: z.ZodOptional<z.ZodString>;
    } & {
      healthy: z.ZodBoolean;
      status: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      path: z.ZodString;
      source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
      store_id: z.ZodOptional<z.ZodString>;
    } & {
      healthy: z.ZodBoolean;
      status: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, z.ZodTypeAny, "passthrough">>>;
    storeId: z.ZodNullable<z.ZodString>;
    generation: z.ZodOptional<z.ZodString>;
    cli: z.ZodObject<{
      available: z.ZodBoolean;
      version: z.ZodOptional<z.ZodString>;
      error: z.ZodOptional<z.ZodString>;
      effectiveCommand: z.ZodOptional<z.ZodString>;
      tried: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      available: z.ZodBoolean;
      version: z.ZodOptional<z.ZodString>;
      error: z.ZodOptional<z.ZodString>;
      effectiveCommand: z.ZodOptional<z.ZodString>;
      tried: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      available: z.ZodBoolean;
      version: z.ZodOptional<z.ZodString>;
      error: z.ZodOptional<z.ZodString>;
      effectiveCommand: z.ZodOptional<z.ZodString>;
      tried: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
    }, z.ZodTypeAny, "passthrough">>;
    references: z.ZodArray<z.ZodObject<{
      store_id: z.ZodString;
      root: z.ZodOptional<z.ZodString>;
      status: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      store_id: z.ZodString;
      root: z.ZodOptional<z.ZodString>;
      status: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      store_id: z.ZodString;
      root: z.ZodOptional<z.ZodString>;
      status: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, z.ZodTypeAny, "passthrough">>, "many">;
    contextMembers: z.ZodArray<z.ZodObject<{
      role: z.ZodLiteral<"referenced_store">;
      id: z.ZodString;
      path: z.ZodOptional<z.ZodString>;
      remote: z.ZodOptional<z.ZodString>;
      fetch: z.ZodOptional<z.ZodString>;
      status: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      role: z.ZodLiteral<"referenced_store">;
      id: z.ZodString;
      path: z.ZodOptional<z.ZodString>;
      remote: z.ZodOptional<z.ZodString>;
      fetch: z.ZodOptional<z.ZodString>;
      status: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      role: z.ZodLiteral<"referenced_store">;
      id: z.ZodString;
      path: z.ZodOptional<z.ZodString>;
      remote: z.ZodOptional<z.ZodString>;
      fetch: z.ZodOptional<z.ZodString>;
      status: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, z.ZodTypeAny, "passthrough">>, "many">;
    dataScope: z.ZodObject<{
      path: z.ZodString;
      source: z.ZodEnum<["xdg-data-home", "local-app-data", "user-home-default"]>;
      environmentVariable: z.ZodNullable<z.ZodEnum<["XDG_DATA_HOME", "LOCALAPPDATA"]>>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      path: z.ZodString;
      source: z.ZodEnum<["xdg-data-home", "local-app-data", "user-home-default"]>;
      environmentVariable: z.ZodNullable<z.ZodEnum<["XDG_DATA_HOME", "LOCALAPPDATA"]>>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      path: z.ZodString;
      source: z.ZodEnum<["xdg-data-home", "local-app-data", "user-home-default"]>;
      environmentVariable: z.ZodNullable<z.ZodEnum<["XDG_DATA_HOME", "LOCALAPPDATA"]>>;
    }, z.ZodTypeAny, "passthrough">>;
    diagnostics: z.ZodObject<{
      root: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
      doctor: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
      context: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      root: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
      doctor: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
      context: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      root: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
      doctor: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
      context: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, z.ZodTypeAny, "passthrough">>;
    evidence: z.ZodObject<{
      doctor: z.ZodNullable<z.ZodObject<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>>;
      context: z.ZodNullable<z.ZodObject<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      doctor: z.ZodNullable<z.ZodObject<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>>;
      context: z.ZodNullable<z.ZodObject<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      doctor: z.ZodNullable<z.ZodObject<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>>;
      context: z.ZodNullable<z.ZodObject<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>>;
    }, z.ZodTypeAny, "passthrough">>;
    observedAt: z.ZodNumber;
  }, z.ZodTypeAny, "passthrough">>>;
  attempt: z.ZodObject<{
    launchProject: z.ZodObject<{
      path: z.ZodString;
      physicalPath: z.ZodOptional<z.ZodString>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      path: z.ZodString;
      physicalPath: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      path: z.ZodString;
      physicalPath: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">>;
    planningRoot: z.ZodNullable<z.ZodObject<{
      path: z.ZodString;
      source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
      store_id: z.ZodOptional<z.ZodString>;
    } & {
      healthy: z.ZodBoolean;
      status: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      path: z.ZodString;
      source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
      store_id: z.ZodOptional<z.ZodString>;
    } & {
      healthy: z.ZodBoolean;
      status: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      path: z.ZodString;
      source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
      store_id: z.ZodOptional<z.ZodString>;
    } & {
      healthy: z.ZodBoolean;
      status: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, z.ZodTypeAny, "passthrough">>>;
    storeId: z.ZodNullable<z.ZodString>;
    generation: z.ZodOptional<z.ZodString>;
    cli: z.ZodObject<{
      available: z.ZodBoolean;
      version: z.ZodOptional<z.ZodString>;
      error: z.ZodOptional<z.ZodString>;
      effectiveCommand: z.ZodOptional<z.ZodString>;
      tried: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      available: z.ZodBoolean;
      version: z.ZodOptional<z.ZodString>;
      error: z.ZodOptional<z.ZodString>;
      effectiveCommand: z.ZodOptional<z.ZodString>;
      tried: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      available: z.ZodBoolean;
      version: z.ZodOptional<z.ZodString>;
      error: z.ZodOptional<z.ZodString>;
      effectiveCommand: z.ZodOptional<z.ZodString>;
      tried: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
    }, z.ZodTypeAny, "passthrough">>;
    references: z.ZodArray<z.ZodObject<{
      store_id: z.ZodString;
      root: z.ZodOptional<z.ZodString>;
      status: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      store_id: z.ZodString;
      root: z.ZodOptional<z.ZodString>;
      status: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      store_id: z.ZodString;
      root: z.ZodOptional<z.ZodString>;
      status: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, z.ZodTypeAny, "passthrough">>, "many">;
    contextMembers: z.ZodArray<z.ZodObject<{
      role: z.ZodLiteral<"referenced_store">;
      id: z.ZodString;
      path: z.ZodOptional<z.ZodString>;
      remote: z.ZodOptional<z.ZodString>;
      fetch: z.ZodOptional<z.ZodString>;
      status: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      role: z.ZodLiteral<"referenced_store">;
      id: z.ZodString;
      path: z.ZodOptional<z.ZodString>;
      remote: z.ZodOptional<z.ZodString>;
      fetch: z.ZodOptional<z.ZodString>;
      status: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      role: z.ZodLiteral<"referenced_store">;
      id: z.ZodString;
      path: z.ZodOptional<z.ZodString>;
      remote: z.ZodOptional<z.ZodString>;
      fetch: z.ZodOptional<z.ZodString>;
      status: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, z.ZodTypeAny, "passthrough">>, "many">;
    dataScope: z.ZodObject<{
      path: z.ZodString;
      source: z.ZodEnum<["xdg-data-home", "local-app-data", "user-home-default"]>;
      environmentVariable: z.ZodNullable<z.ZodEnum<["XDG_DATA_HOME", "LOCALAPPDATA"]>>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      path: z.ZodString;
      source: z.ZodEnum<["xdg-data-home", "local-app-data", "user-home-default"]>;
      environmentVariable: z.ZodNullable<z.ZodEnum<["XDG_DATA_HOME", "LOCALAPPDATA"]>>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      path: z.ZodString;
      source: z.ZodEnum<["xdg-data-home", "local-app-data", "user-home-default"]>;
      environmentVariable: z.ZodNullable<z.ZodEnum<["XDG_DATA_HOME", "LOCALAPPDATA"]>>;
    }, z.ZodTypeAny, "passthrough">>;
    diagnostics: z.ZodObject<{
      root: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
      doctor: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
      context: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      root: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
      doctor: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
      context: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      root: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
      doctor: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
      context: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, z.ZodTypeAny, "passthrough">>;
    evidence: z.ZodObject<{
      doctor: z.ZodNullable<z.ZodObject<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>>;
      context: z.ZodNullable<z.ZodObject<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      doctor: z.ZodNullable<z.ZodObject<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>>;
      context: z.ZodNullable<z.ZodObject<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      doctor: z.ZodNullable<z.ZodObject<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>>;
      context: z.ZodNullable<z.ZodObject<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>>;
    }, z.ZodTypeAny, "passthrough">>;
    observedAt: z.ZodNumber;
  }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
    launchProject: z.ZodObject<{
      path: z.ZodString;
      physicalPath: z.ZodOptional<z.ZodString>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      path: z.ZodString;
      physicalPath: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      path: z.ZodString;
      physicalPath: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">>;
    planningRoot: z.ZodNullable<z.ZodObject<{
      path: z.ZodString;
      source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
      store_id: z.ZodOptional<z.ZodString>;
    } & {
      healthy: z.ZodBoolean;
      status: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      path: z.ZodString;
      source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
      store_id: z.ZodOptional<z.ZodString>;
    } & {
      healthy: z.ZodBoolean;
      status: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      path: z.ZodString;
      source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
      store_id: z.ZodOptional<z.ZodString>;
    } & {
      healthy: z.ZodBoolean;
      status: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, z.ZodTypeAny, "passthrough">>>;
    storeId: z.ZodNullable<z.ZodString>;
    generation: z.ZodOptional<z.ZodString>;
    cli: z.ZodObject<{
      available: z.ZodBoolean;
      version: z.ZodOptional<z.ZodString>;
      error: z.ZodOptional<z.ZodString>;
      effectiveCommand: z.ZodOptional<z.ZodString>;
      tried: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      available: z.ZodBoolean;
      version: z.ZodOptional<z.ZodString>;
      error: z.ZodOptional<z.ZodString>;
      effectiveCommand: z.ZodOptional<z.ZodString>;
      tried: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      available: z.ZodBoolean;
      version: z.ZodOptional<z.ZodString>;
      error: z.ZodOptional<z.ZodString>;
      effectiveCommand: z.ZodOptional<z.ZodString>;
      tried: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
    }, z.ZodTypeAny, "passthrough">>;
    references: z.ZodArray<z.ZodObject<{
      store_id: z.ZodString;
      root: z.ZodOptional<z.ZodString>;
      status: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      store_id: z.ZodString;
      root: z.ZodOptional<z.ZodString>;
      status: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      store_id: z.ZodString;
      root: z.ZodOptional<z.ZodString>;
      status: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, z.ZodTypeAny, "passthrough">>, "many">;
    contextMembers: z.ZodArray<z.ZodObject<{
      role: z.ZodLiteral<"referenced_store">;
      id: z.ZodString;
      path: z.ZodOptional<z.ZodString>;
      remote: z.ZodOptional<z.ZodString>;
      fetch: z.ZodOptional<z.ZodString>;
      status: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      role: z.ZodLiteral<"referenced_store">;
      id: z.ZodString;
      path: z.ZodOptional<z.ZodString>;
      remote: z.ZodOptional<z.ZodString>;
      fetch: z.ZodOptional<z.ZodString>;
      status: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      role: z.ZodLiteral<"referenced_store">;
      id: z.ZodString;
      path: z.ZodOptional<z.ZodString>;
      remote: z.ZodOptional<z.ZodString>;
      fetch: z.ZodOptional<z.ZodString>;
      status: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, z.ZodTypeAny, "passthrough">>, "many">;
    dataScope: z.ZodObject<{
      path: z.ZodString;
      source: z.ZodEnum<["xdg-data-home", "local-app-data", "user-home-default"]>;
      environmentVariable: z.ZodNullable<z.ZodEnum<["XDG_DATA_HOME", "LOCALAPPDATA"]>>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      path: z.ZodString;
      source: z.ZodEnum<["xdg-data-home", "local-app-data", "user-home-default"]>;
      environmentVariable: z.ZodNullable<z.ZodEnum<["XDG_DATA_HOME", "LOCALAPPDATA"]>>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      path: z.ZodString;
      source: z.ZodEnum<["xdg-data-home", "local-app-data", "user-home-default"]>;
      environmentVariable: z.ZodNullable<z.ZodEnum<["XDG_DATA_HOME", "LOCALAPPDATA"]>>;
    }, z.ZodTypeAny, "passthrough">>;
    diagnostics: z.ZodObject<{
      root: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
      doctor: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
      context: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      root: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
      doctor: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
      context: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      root: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
      doctor: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
      context: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, z.ZodTypeAny, "passthrough">>;
    evidence: z.ZodObject<{
      doctor: z.ZodNullable<z.ZodObject<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>>;
      context: z.ZodNullable<z.ZodObject<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      doctor: z.ZodNullable<z.ZodObject<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>>;
      context: z.ZodNullable<z.ZodObject<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      doctor: z.ZodNullable<z.ZodObject<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>>;
      context: z.ZodNullable<z.ZodObject<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>>;
    }, z.ZodTypeAny, "passthrough">>;
    observedAt: z.ZodNumber;
  }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
    launchProject: z.ZodObject<{
      path: z.ZodString;
      physicalPath: z.ZodOptional<z.ZodString>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      path: z.ZodString;
      physicalPath: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      path: z.ZodString;
      physicalPath: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">>;
    planningRoot: z.ZodNullable<z.ZodObject<{
      path: z.ZodString;
      source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
      store_id: z.ZodOptional<z.ZodString>;
    } & {
      healthy: z.ZodBoolean;
      status: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      path: z.ZodString;
      source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
      store_id: z.ZodOptional<z.ZodString>;
    } & {
      healthy: z.ZodBoolean;
      status: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      path: z.ZodString;
      source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
      store_id: z.ZodOptional<z.ZodString>;
    } & {
      healthy: z.ZodBoolean;
      status: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, z.ZodTypeAny, "passthrough">>>;
    storeId: z.ZodNullable<z.ZodString>;
    generation: z.ZodOptional<z.ZodString>;
    cli: z.ZodObject<{
      available: z.ZodBoolean;
      version: z.ZodOptional<z.ZodString>;
      error: z.ZodOptional<z.ZodString>;
      effectiveCommand: z.ZodOptional<z.ZodString>;
      tried: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      available: z.ZodBoolean;
      version: z.ZodOptional<z.ZodString>;
      error: z.ZodOptional<z.ZodString>;
      effectiveCommand: z.ZodOptional<z.ZodString>;
      tried: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      available: z.ZodBoolean;
      version: z.ZodOptional<z.ZodString>;
      error: z.ZodOptional<z.ZodString>;
      effectiveCommand: z.ZodOptional<z.ZodString>;
      tried: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
    }, z.ZodTypeAny, "passthrough">>;
    references: z.ZodArray<z.ZodObject<{
      store_id: z.ZodString;
      root: z.ZodOptional<z.ZodString>;
      status: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      store_id: z.ZodString;
      root: z.ZodOptional<z.ZodString>;
      status: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      store_id: z.ZodString;
      root: z.ZodOptional<z.ZodString>;
      status: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, z.ZodTypeAny, "passthrough">>, "many">;
    contextMembers: z.ZodArray<z.ZodObject<{
      role: z.ZodLiteral<"referenced_store">;
      id: z.ZodString;
      path: z.ZodOptional<z.ZodString>;
      remote: z.ZodOptional<z.ZodString>;
      fetch: z.ZodOptional<z.ZodString>;
      status: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      role: z.ZodLiteral<"referenced_store">;
      id: z.ZodString;
      path: z.ZodOptional<z.ZodString>;
      remote: z.ZodOptional<z.ZodString>;
      fetch: z.ZodOptional<z.ZodString>;
      status: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      role: z.ZodLiteral<"referenced_store">;
      id: z.ZodString;
      path: z.ZodOptional<z.ZodString>;
      remote: z.ZodOptional<z.ZodString>;
      fetch: z.ZodOptional<z.ZodString>;
      status: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, z.ZodTypeAny, "passthrough">>, "many">;
    dataScope: z.ZodObject<{
      path: z.ZodString;
      source: z.ZodEnum<["xdg-data-home", "local-app-data", "user-home-default"]>;
      environmentVariable: z.ZodNullable<z.ZodEnum<["XDG_DATA_HOME", "LOCALAPPDATA"]>>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      path: z.ZodString;
      source: z.ZodEnum<["xdg-data-home", "local-app-data", "user-home-default"]>;
      environmentVariable: z.ZodNullable<z.ZodEnum<["XDG_DATA_HOME", "LOCALAPPDATA"]>>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      path: z.ZodString;
      source: z.ZodEnum<["xdg-data-home", "local-app-data", "user-home-default"]>;
      environmentVariable: z.ZodNullable<z.ZodEnum<["XDG_DATA_HOME", "LOCALAPPDATA"]>>;
    }, z.ZodTypeAny, "passthrough">>;
    diagnostics: z.ZodObject<{
      root: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
      doctor: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
      context: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      root: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
      doctor: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
      context: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      root: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
      doctor: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
      context: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, z.ZodTypeAny, "passthrough">>;
    evidence: z.ZodObject<{
      doctor: z.ZodNullable<z.ZodObject<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>>;
      context: z.ZodNullable<z.ZodObject<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      doctor: z.ZodNullable<z.ZodObject<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>>;
      context: z.ZodNullable<z.ZodObject<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      doctor: z.ZodNullable<z.ZodObject<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>>;
      context: z.ZodNullable<z.ZodObject<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>>;
    }, z.ZodTypeAny, "passthrough">>;
    observedAt: z.ZodNumber;
  }, z.ZodTypeAny, "passthrough">>;
  error: z.ZodObject<{
    code: z.ZodEnum<["cli-unavailable", "doctor-command-failed", "doctor-contract-drift", "root-unresolved", "root-unhealthy", "context-command-failed", "context-contract-drift", "context-root-mismatch", "references-unresolved", "resolver-failed"]>;
    message: z.ZodString;
  }, "strip", z.ZodTypeAny, {
    code: "cli-unavailable" | "doctor-command-failed" | "doctor-contract-drift" | "root-unresolved" | "root-unhealthy" | "context-command-failed" | "context-contract-drift" | "context-root-mismatch" | "references-unresolved" | "resolver-failed";
    message: string;
  }, {
    code: "cli-unavailable" | "doctor-command-failed" | "doctor-contract-drift" | "root-unresolved" | "root-unhealthy" | "context-command-failed" | "context-contract-drift" | "context-root-mismatch" | "references-unresolved" | "resolver-failed";
    message: string;
  }>;
  observedAt: z.ZodNumber;
}, "strip", z.ZodTypeAny, {
  error: {
    code: "cli-unavailable" | "doctor-command-failed" | "doctor-contract-drift" | "root-unresolved" | "root-unhealthy" | "context-command-failed" | "context-contract-drift" | "context-root-mismatch" | "references-unresolved" | "resolver-failed";
    message: string;
  };
  state: "error";
  data: z.objectOutputType<{
    launchProject: z.ZodObject<{
      path: z.ZodString;
      physicalPath: z.ZodOptional<z.ZodString>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      path: z.ZodString;
      physicalPath: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      path: z.ZodString;
      physicalPath: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">>;
    planningRoot: z.ZodNullable<z.ZodObject<{
      path: z.ZodString;
      source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
      store_id: z.ZodOptional<z.ZodString>;
    } & {
      healthy: z.ZodBoolean;
      status: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      path: z.ZodString;
      source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
      store_id: z.ZodOptional<z.ZodString>;
    } & {
      healthy: z.ZodBoolean;
      status: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      path: z.ZodString;
      source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
      store_id: z.ZodOptional<z.ZodString>;
    } & {
      healthy: z.ZodBoolean;
      status: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, z.ZodTypeAny, "passthrough">>>;
    storeId: z.ZodNullable<z.ZodString>;
    generation: z.ZodOptional<z.ZodString>;
    cli: z.ZodObject<{
      available: z.ZodBoolean;
      version: z.ZodOptional<z.ZodString>;
      error: z.ZodOptional<z.ZodString>;
      effectiveCommand: z.ZodOptional<z.ZodString>;
      tried: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      available: z.ZodBoolean;
      version: z.ZodOptional<z.ZodString>;
      error: z.ZodOptional<z.ZodString>;
      effectiveCommand: z.ZodOptional<z.ZodString>;
      tried: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      available: z.ZodBoolean;
      version: z.ZodOptional<z.ZodString>;
      error: z.ZodOptional<z.ZodString>;
      effectiveCommand: z.ZodOptional<z.ZodString>;
      tried: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
    }, z.ZodTypeAny, "passthrough">>;
    references: z.ZodArray<z.ZodObject<{
      store_id: z.ZodString;
      root: z.ZodOptional<z.ZodString>;
      status: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      store_id: z.ZodString;
      root: z.ZodOptional<z.ZodString>;
      status: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      store_id: z.ZodString;
      root: z.ZodOptional<z.ZodString>;
      status: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, z.ZodTypeAny, "passthrough">>, "many">;
    contextMembers: z.ZodArray<z.ZodObject<{
      role: z.ZodLiteral<"referenced_store">;
      id: z.ZodString;
      path: z.ZodOptional<z.ZodString>;
      remote: z.ZodOptional<z.ZodString>;
      fetch: z.ZodOptional<z.ZodString>;
      status: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      role: z.ZodLiteral<"referenced_store">;
      id: z.ZodString;
      path: z.ZodOptional<z.ZodString>;
      remote: z.ZodOptional<z.ZodString>;
      fetch: z.ZodOptional<z.ZodString>;
      status: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      role: z.ZodLiteral<"referenced_store">;
      id: z.ZodString;
      path: z.ZodOptional<z.ZodString>;
      remote: z.ZodOptional<z.ZodString>;
      fetch: z.ZodOptional<z.ZodString>;
      status: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, z.ZodTypeAny, "passthrough">>, "many">;
    dataScope: z.ZodObject<{
      path: z.ZodString;
      source: z.ZodEnum<["xdg-data-home", "local-app-data", "user-home-default"]>;
      environmentVariable: z.ZodNullable<z.ZodEnum<["XDG_DATA_HOME", "LOCALAPPDATA"]>>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      path: z.ZodString;
      source: z.ZodEnum<["xdg-data-home", "local-app-data", "user-home-default"]>;
      environmentVariable: z.ZodNullable<z.ZodEnum<["XDG_DATA_HOME", "LOCALAPPDATA"]>>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      path: z.ZodString;
      source: z.ZodEnum<["xdg-data-home", "local-app-data", "user-home-default"]>;
      environmentVariable: z.ZodNullable<z.ZodEnum<["XDG_DATA_HOME", "LOCALAPPDATA"]>>;
    }, z.ZodTypeAny, "passthrough">>;
    diagnostics: z.ZodObject<{
      root: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
      doctor: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
      context: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      root: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
      doctor: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
      context: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      root: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
      doctor: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
      context: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, z.ZodTypeAny, "passthrough">>;
    evidence: z.ZodObject<{
      doctor: z.ZodNullable<z.ZodObject<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>>;
      context: z.ZodNullable<z.ZodObject<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      doctor: z.ZodNullable<z.ZodObject<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>>;
      context: z.ZodNullable<z.ZodObject<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      doctor: z.ZodNullable<z.ZodObject<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>>;
      context: z.ZodNullable<z.ZodObject<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>>;
    }, z.ZodTypeAny, "passthrough">>;
    observedAt: z.ZodNumber;
  }, z.ZodTypeAny, "passthrough"> | null;
  observedAt: number;
  attempt: {
    storeId: string | null;
    diagnostics: {
      root: z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">[];
      context: z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">[];
      doctor: z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">[];
    } & {
      [k: string]: unknown;
    };
    evidence: {
      context: z.objectOutputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough"> | null;
      doctor: z.objectOutputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough"> | null;
    } & {
      [k: string]: unknown;
    };
    cli: {
      available: boolean;
      version?: string | undefined;
      error?: string | undefined;
      effectiveCommand?: string | undefined;
      tried?: string[] | undefined;
    } & {
      [k: string]: unknown;
    };
    references: z.objectOutputType<{
      store_id: z.ZodString;
      root: z.ZodOptional<z.ZodString>;
      status: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, z.ZodTypeAny, "passthrough">[];
    dataScope: {
      path: string;
      source: "xdg-data-home" | "local-app-data" | "user-home-default";
      environmentVariable: "XDG_DATA_HOME" | "LOCALAPPDATA" | null;
    } & {
      [k: string]: unknown;
    };
    observedAt: number;
    launchProject: {
      path: string;
      physicalPath?: string | undefined;
    } & {
      [k: string]: unknown;
    };
    planningRoot: z.objectOutputType<{
      path: z.ZodString;
      source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
      store_id: z.ZodOptional<z.ZodString>;
    } & {
      healthy: z.ZodBoolean;
      status: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, z.ZodTypeAny, "passthrough"> | null;
    contextMembers: z.objectOutputType<{
      role: z.ZodLiteral<"referenced_store">;
      id: z.ZodString;
      path: z.ZodOptional<z.ZodString>;
      remote: z.ZodOptional<z.ZodString>;
      fetch: z.ZodOptional<z.ZodString>;
      status: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, z.ZodTypeAny, "passthrough">[];
    generation?: string | undefined;
  } & {
    [k: string]: unknown;
  };
}, {
  error: {
    code: "cli-unavailable" | "doctor-command-failed" | "doctor-contract-drift" | "root-unresolved" | "root-unhealthy" | "context-command-failed" | "context-contract-drift" | "context-root-mismatch" | "references-unresolved" | "resolver-failed";
    message: string;
  };
  state: "error";
  data: z.objectInputType<{
    launchProject: z.ZodObject<{
      path: z.ZodString;
      physicalPath: z.ZodOptional<z.ZodString>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      path: z.ZodString;
      physicalPath: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      path: z.ZodString;
      physicalPath: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">>;
    planningRoot: z.ZodNullable<z.ZodObject<{
      path: z.ZodString;
      source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
      store_id: z.ZodOptional<z.ZodString>;
    } & {
      healthy: z.ZodBoolean;
      status: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      path: z.ZodString;
      source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
      store_id: z.ZodOptional<z.ZodString>;
    } & {
      healthy: z.ZodBoolean;
      status: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      path: z.ZodString;
      source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
      store_id: z.ZodOptional<z.ZodString>;
    } & {
      healthy: z.ZodBoolean;
      status: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, z.ZodTypeAny, "passthrough">>>;
    storeId: z.ZodNullable<z.ZodString>;
    generation: z.ZodOptional<z.ZodString>;
    cli: z.ZodObject<{
      available: z.ZodBoolean;
      version: z.ZodOptional<z.ZodString>;
      error: z.ZodOptional<z.ZodString>;
      effectiveCommand: z.ZodOptional<z.ZodString>;
      tried: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      available: z.ZodBoolean;
      version: z.ZodOptional<z.ZodString>;
      error: z.ZodOptional<z.ZodString>;
      effectiveCommand: z.ZodOptional<z.ZodString>;
      tried: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      available: z.ZodBoolean;
      version: z.ZodOptional<z.ZodString>;
      error: z.ZodOptional<z.ZodString>;
      effectiveCommand: z.ZodOptional<z.ZodString>;
      tried: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
    }, z.ZodTypeAny, "passthrough">>;
    references: z.ZodArray<z.ZodObject<{
      store_id: z.ZodString;
      root: z.ZodOptional<z.ZodString>;
      status: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      store_id: z.ZodString;
      root: z.ZodOptional<z.ZodString>;
      status: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      store_id: z.ZodString;
      root: z.ZodOptional<z.ZodString>;
      status: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, z.ZodTypeAny, "passthrough">>, "many">;
    contextMembers: z.ZodArray<z.ZodObject<{
      role: z.ZodLiteral<"referenced_store">;
      id: z.ZodString;
      path: z.ZodOptional<z.ZodString>;
      remote: z.ZodOptional<z.ZodString>;
      fetch: z.ZodOptional<z.ZodString>;
      status: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      role: z.ZodLiteral<"referenced_store">;
      id: z.ZodString;
      path: z.ZodOptional<z.ZodString>;
      remote: z.ZodOptional<z.ZodString>;
      fetch: z.ZodOptional<z.ZodString>;
      status: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      role: z.ZodLiteral<"referenced_store">;
      id: z.ZodString;
      path: z.ZodOptional<z.ZodString>;
      remote: z.ZodOptional<z.ZodString>;
      fetch: z.ZodOptional<z.ZodString>;
      status: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, z.ZodTypeAny, "passthrough">>, "many">;
    dataScope: z.ZodObject<{
      path: z.ZodString;
      source: z.ZodEnum<["xdg-data-home", "local-app-data", "user-home-default"]>;
      environmentVariable: z.ZodNullable<z.ZodEnum<["XDG_DATA_HOME", "LOCALAPPDATA"]>>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      path: z.ZodString;
      source: z.ZodEnum<["xdg-data-home", "local-app-data", "user-home-default"]>;
      environmentVariable: z.ZodNullable<z.ZodEnum<["XDG_DATA_HOME", "LOCALAPPDATA"]>>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      path: z.ZodString;
      source: z.ZodEnum<["xdg-data-home", "local-app-data", "user-home-default"]>;
      environmentVariable: z.ZodNullable<z.ZodEnum<["XDG_DATA_HOME", "LOCALAPPDATA"]>>;
    }, z.ZodTypeAny, "passthrough">>;
    diagnostics: z.ZodObject<{
      root: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
      doctor: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
      context: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      root: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
      doctor: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
      context: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      root: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
      doctor: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
      context: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, z.ZodTypeAny, "passthrough">>;
    evidence: z.ZodObject<{
      doctor: z.ZodNullable<z.ZodObject<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>>;
      context: z.ZodNullable<z.ZodObject<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      doctor: z.ZodNullable<z.ZodObject<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>>;
      context: z.ZodNullable<z.ZodObject<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      doctor: z.ZodNullable<z.ZodObject<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>>;
      context: z.ZodNullable<z.ZodObject<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>>;
    }, z.ZodTypeAny, "passthrough">>;
    observedAt: z.ZodNumber;
  }, z.ZodTypeAny, "passthrough"> | null;
  observedAt: number;
  attempt: {
    storeId: string | null;
    diagnostics: {
      root: z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">[];
      context: z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">[];
      doctor: z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">[];
    } & {
      [k: string]: unknown;
    };
    evidence: {
      context: z.objectInputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough"> | null;
      doctor: z.objectInputType<{
        success: z.ZodBoolean;
        stdout: z.ZodString;
        stderr: z.ZodString;
        exitCode: z.ZodNullable<z.ZodNumber>;
        diagnostics: z.ZodArray<z.ZodObject<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
          severity: z.ZodEnum<["error", "warning", "info"]>;
          code: z.ZodString;
          message: z.ZodString;
          target: z.ZodOptional<z.ZodString>;
          fix: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        contractError: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough"> | null;
    } & {
      [k: string]: unknown;
    };
    cli: {
      available: boolean;
      version?: string | undefined;
      error?: string | undefined;
      effectiveCommand?: string | undefined;
      tried?: string[] | undefined;
    } & {
      [k: string]: unknown;
    };
    references: z.objectInputType<{
      store_id: z.ZodString;
      root: z.ZodOptional<z.ZodString>;
      status: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, z.ZodTypeAny, "passthrough">[];
    dataScope: {
      path: string;
      source: "xdg-data-home" | "local-app-data" | "user-home-default";
      environmentVariable: "XDG_DATA_HOME" | "LOCALAPPDATA" | null;
    } & {
      [k: string]: unknown;
    };
    observedAt: number;
    launchProject: {
      path: string;
      physicalPath?: string | undefined;
    } & {
      [k: string]: unknown;
    };
    planningRoot: z.objectInputType<{
      path: z.ZodString;
      source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
      store_id: z.ZodOptional<z.ZodString>;
    } & {
      healthy: z.ZodBoolean;
      status: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, z.ZodTypeAny, "passthrough"> | null;
    contextMembers: z.objectInputType<{
      role: z.ZodLiteral<"referenced_store">;
      id: z.ZodString;
      path: z.ZodOptional<z.ZodString>;
      remote: z.ZodOptional<z.ZodString>;
      fetch: z.ZodOptional<z.ZodString>;
      status: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
    }, z.ZodTypeAny, "passthrough">[];
    generation?: string | undefined;
  } & {
    [k: string]: unknown;
  };
}>]>;
/** Hosted mutation admission shares the Server-owned P3 lifecycle schema. */
declare const HostedStoreMutationStartResponseSchema: z.ZodIntersection<z.ZodDiscriminatedUnion<"status", [z.ZodObject<{
  requestId: z.ZodString;
  envUri: z.ZodString;
  kind: z.ZodEnum<["setup", "register", "unregister", "remove"]>;
  storeId: z.ZodOptional<z.ZodString>;
  observedAt: z.ZodNumber;
} & {
  status: z.ZodEnum<["accepted", "running"]>;
  result: z.ZodOptional<z.ZodUndefined>;
}, "strip", z.ZodTypeAny, {
  status: "accepted" | "running";
  kind: "setup" | "register" | "unregister" | "remove";
  requestId: string;
  envUri: string;
  observedAt: number;
  storeId?: string | undefined;
  result?: undefined;
}, {
  status: "accepted" | "running";
  kind: "setup" | "register" | "unregister" | "remove";
  requestId: string;
  envUri: string;
  observedAt: number;
  storeId?: string | undefined;
  result?: undefined;
}>, z.ZodObject<{
  requestId: z.ZodString;
  envUri: z.ZodString;
  kind: z.ZodEnum<["setup", "register", "unregister", "remove"]>;
  storeId: z.ZodOptional<z.ZodString>;
  observedAt: z.ZodNumber;
} & {
  status: z.ZodEnum<["succeeded", "failed", "indeterminate"]>;
  result: z.ZodObject<{
    exitStatus: z.ZodNullable<z.ZodNumber>;
    stdout: z.ZodOptional<z.ZodString>;
    stderr: z.ZodOptional<z.ZodString>;
    diagnostics: z.ZodOptional<z.ZodArray<z.ZodObject<{
      severity: z.ZodEnum<["error", "warning", "info"]>;
      code: z.ZodString;
      message: z.ZodString;
      target: z.ZodOptional<z.ZodString>;
      fix: z.ZodOptional<z.ZodString>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
      severity: z.ZodEnum<["error", "warning", "info"]>;
      code: z.ZodString;
      message: z.ZodString;
      target: z.ZodOptional<z.ZodString>;
      fix: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
      severity: z.ZodEnum<["error", "warning", "info"]>;
      code: z.ZodString;
      message: z.ZodString;
      target: z.ZodOptional<z.ZodString>;
      fix: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">>, "many">>;
    payload: z.ZodOptional<z.ZodUnknown>;
    contractError: z.ZodOptional<z.ZodString>;
  }, "strip", z.ZodTypeAny, {
    exitStatus: number | null;
    stdout?: string | undefined;
    stderr?: string | undefined;
    payload?: unknown;
    diagnostics?: z.objectOutputType<{
      severity: z.ZodEnum<["error", "warning", "info"]>;
      code: z.ZodString;
      message: z.ZodString;
      target: z.ZodOptional<z.ZodString>;
      fix: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">[] | undefined;
    contractError?: string | undefined;
  }, {
    exitStatus: number | null;
    stdout?: string | undefined;
    stderr?: string | undefined;
    payload?: unknown;
    diagnostics?: z.objectInputType<{
      severity: z.ZodEnum<["error", "warning", "info"]>;
      code: z.ZodString;
      message: z.ZodString;
      target: z.ZodOptional<z.ZodString>;
      fix: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">[] | undefined;
    contractError?: string | undefined;
  }>;
}, "strip", z.ZodTypeAny, {
  status: "failed" | "succeeded" | "indeterminate";
  kind: "setup" | "register" | "unregister" | "remove";
  requestId: string;
  envUri: string;
  observedAt: number;
  result: {
    exitStatus: number | null;
    stdout?: string | undefined;
    stderr?: string | undefined;
    payload?: unknown;
    diagnostics?: z.objectOutputType<{
      severity: z.ZodEnum<["error", "warning", "info"]>;
      code: z.ZodString;
      message: z.ZodString;
      target: z.ZodOptional<z.ZodString>;
      fix: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">[] | undefined;
    contractError?: string | undefined;
  };
  storeId?: string | undefined;
}, {
  status: "failed" | "succeeded" | "indeterminate";
  kind: "setup" | "register" | "unregister" | "remove";
  requestId: string;
  envUri: string;
  observedAt: number;
  result: {
    exitStatus: number | null;
    stdout?: string | undefined;
    stderr?: string | undefined;
    payload?: unknown;
    diagnostics?: z.objectInputType<{
      severity: z.ZodEnum<["error", "warning", "info"]>;
      code: z.ZodString;
      message: z.ZodString;
      target: z.ZodOptional<z.ZodString>;
      fix: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">[] | undefined;
    contractError?: string | undefined;
  };
  storeId?: string | undefined;
}>]>, z.ZodObject<{
  rejoined: z.ZodBoolean;
}, "strip", z.ZodTypeAny, {
  rejoined: boolean;
}, {
  rejoined: boolean;
}>>;
/** One explicit browser-visible contract error, retaining the decoder's parse cause. */
declare class HostedBackendContractError extends Error {
  readonly kind = "contract";
  constructor(message: string, options: ErrorOptions);
}
/** Structural tRPC envelope used by every successful hosted router ingress. */
declare const HostedTrpcResultEnvelopeSchema: z.ZodObject<{
  result: z.ZodObject<{
    data: z.ZodUnknown;
  }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
    data: z.ZodUnknown;
  }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
    data: z.ZodUnknown;
  }, z.ZodTypeAny, "passthrough">>;
}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
  result: z.ZodObject<{
    data: z.ZodUnknown;
  }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
    data: z.ZodUnknown;
  }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
    data: z.ZodUnknown;
  }, z.ZodTypeAny, "passthrough">>;
}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
  result: z.ZodObject<{
    data: z.ZodUnknown;
  }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
    data: z.ZodUnknown;
  }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
    data: z.ZodUnknown;
  }, z.ZodTypeAny, "passthrough">>;
}, z.ZodTypeAny, "passthrough">>;
type HostedTrpcDecodeResult<T> = {
  kind: 'success';
  data: T;
} | {
  kind: 'contract-error';
  error: HostedBackendContractError;
};
/** Decode one successful hosted tRPC `{ result: { data } }` envelope into typed data. */
declare function decodeHostedTrpcData<TSchema extends z.ZodTypeAny>(schema: TSchema, payload: unknown): HostedTrpcDecodeResult<z.output<TSchema>>;
type HostedBackendRootSummary = z.infer<typeof HostedBackendRootSummarySchema>;
type HostedBackendHealthResponse = z.infer<typeof HostedBackendHealthResponseSchema>;
type HostedStoreListEnvelope = z.infer<typeof HostedStoreListEnvelopeSchema>;
type HostedStoreDoctorEnvelope = z.infer<typeof HostedStoreDoctorEnvelopeSchema>;
type HostedStoreListProjectionState = z.infer<typeof HostedStoreListProjectionStateSchema>;
type HostedStoreDoctorProjectionState = z.infer<typeof HostedStoreDoctorProjectionStateSchema>;
type HostedStoreContentSpecsEnvelope = z.infer<typeof HostedStoreContentSpecsEnvelopeSchema>;
type HostedStoreContentChangesEnvelope = z.infer<typeof HostedStoreContentChangesEnvelopeSchema>;
type HostedStoreContentSpecsProjectionState = z.infer<typeof HostedStoreContentSpecsProjectionStateSchema>;
type HostedStoreContentChangesProjectionState = z.infer<typeof HostedStoreContentChangesProjectionStateSchema>;
type HostedCliProjectionNotice = z.infer<typeof HostedCliProjectionNoticeSchema>;
type HostedRootContext = z.infer<typeof HostedRootContextSchema>;
type HostedRootContextResolvedState = z.infer<typeof HostedRootContextResolvedStateSchema>;
type HostedRootContextProjectionState = z.infer<typeof HostedRootContextProjectionStateSchema>;
type HostedRootContextState = z.infer<typeof HostedRootContextStateSchema>;
type HostedRootContextErrorCode = z.infer<typeof HostedRootContextErrorCodeSchema>;
type HostedStoreMutationStartResponse = z.infer<typeof HostedStoreMutationStartResponseSchema>;
type HostedCliDiagnostic = z.infer<typeof CliDiagnosticSchema>;
type HostedRootSource = z.infer<typeof CliRootSourceSchema>;
//#endregion
//#region src/hosted-app.d.ts
/**
 * App-scoped theme preference. Shared by App (master) and embedded Web (slave)
 * for one-directional sync. The App is the single source of truth; child windows
 * inherit and are force-synced but never echo back.
 */
type HostedShellTheme = 'light' | 'dark' | 'system';
declare const OFFICIAL_APP_BASE_URL = "https://app.openspecui.com";
declare const ACCESS_GATE_CREDENTIAL_FRAGMENT_PARAM = "credential";
type OpenSpecUIRuntimeCapability = (typeof OPENSPECUI_RUNTIME_CAPABILITIES)[number];
interface BackendHealthPayloadInput {
  projectDir: string;
  projectName: string;
  watcherEnabled: boolean;
  openspecuiVersion: string;
  embeddedUiUrl: string;
  /** Optional 1.6 hosted-protocol additions. */
  apiBaseUrl?: string;
  cliVersion?: string | null;
  envUri?: string;
  rootSummary?: HostedBackendRootSummary | null;
  accessGateEnabled?: boolean;
  /**
   * Whether this backend implements the demand-driven readonly Store-content projection
   * (Specs and active Changes). When true the additive `stores.content.inspect` compatibility
   * fact is advertised; absence renders Store Detail content unsupported, never empty. P6 server.
   */
  storeContentProjectionEnabled?: boolean;
}
declare function normalizeHostedAppBaseUrl(input: string): string;
declare function resolveHostedAppBaseUrl(options: {
  override?: string | null;
  configured?: string | null;
}): string;
declare function normalizeEmbeddedUiUrl(input: string): string;
declare function isSupportedEmbeddedUiUrl(input: string): boolean;
declare function buildHostedLaunchUrl(options: {
  baseUrl: string;
  apiBaseUrl: string;
  credential?: string | null;
}): string;
declare function buildEmbeddedUiLaunchUrl(options: {
  embeddedUiUrl: string;
  apiBaseUrl: string;
  sessionId: string;
  credential?: string | null;
}): string;
declare function buildBackendHealthPayload(input: BackendHealthPayloadInput): HostedBackendHealthResponse;
declare function isBackendHealthRuntimeMetadata(value: unknown): value is HostedBackendHealthResponse;
declare function isHostedBackendHealthResponse(value: unknown): value is HostedBackendHealthResponse;
//#endregion
//#region src/hosted-protocol.d.ts
/**
 * Compute a stable opaque `envUri` from backend host identity plus effective OpenSpec data home.
 * The inputs are hashed so the returned URI never exposes either component; only pair equality matters.
 */
declare function computeEnvUri(options: {
  hostIdentity: string;
  dataHome: string | null;
}): EnvUri;
/**
 * Backend Access Gate credential.
 *
 * One canonical form: `Authorization: Bearer <credential>`. `--auth` generates a high-entropy
 * credential; `--password` normalizes an operator secret into the same Bearer form. The gate is not
 * an account/role/ACL/permission system and provides no transport confidentiality.
 */
interface AccessGateCredential {
  /** The shared Bearer secret. Never logged in full; only its fingerprint is safe to display. */
  readonly credential: string;
  /** SHA-256 fingerprint for safe display/logging without exposing the secret. */
  readonly fingerprint: string;
  /** The complete `Authorization` header value clients must send. */
  readonly authorizationHeader: string;
}
/** Required byte length of a generated `--auth` credential (256 bits of entropy). */
declare const ACCESS_GATE_CREDENTIAL_BYTES = 32;
/** Compute a short SHA-256 fingerprint suitable for safe display. */
declare function accessGateFingerprint(credential: string): string;
/** Generate a high-entropy Bearer credential for `--auth` and return the complete gate record. */
declare function generateAccessGateCredential(): AccessGateCredential;
/**
 * Normalize an operator-supplied `--password` secret into the same Bearer gate record. The secret is
 * used verbatim as the credential (no hashing) so the gate is a single shared secret comparison.
 */
declare function normalizeAccessGatePassword(password: string): AccessGateCredential;
/** Constant-time comparison of two equal-length secrets to mitigate timing side channels. */
declare function constantTimeEqual(a: string, b: string): boolean;
//#endregion
//#region src/runtime-types.d.ts
type ProjectRecoveryStatus = {
  state: 'idle';
} | {
  state: 'evicted';
  reason: ProjectResidencyEvictionReason;
  detectedAt: number;
} | {
  state: 'resolving';
  reason: ProjectResidencyEvictionReason;
  detectedAt: number;
} | {
  state: 'ready';
  reason: ProjectResidencyEvictionReason;
  detectedAt: number;
  handoff: GitWorktreeHandoff;
} | {
  state: 'unavailable';
  reason: ProjectResidencyEvictionReason;
  detectedAt: number;
  message: string;
} | {
  state: 'failed';
  reason: ProjectResidencyEvictionReason;
  detectedAt: number;
  message: string;
};
//#endregion
//#region src/snapshot-redaction.d.ts
/**
 * Produce a publication-safe copy of `snapshot`. Removes absolute project/Store/data-home/registry
 * paths, host identity, and raw path-bearing diagnostics, and clears the Git remote URL unless the
 * Reference export policy is explicitly `include`. Display-safe relative paths (`displayPath`,
 * repository-relative fragments) and human-readable labels are preserved.
 *
 * This is the single redaction boundary for static export privacy (Section 7.8). Callers must run it
 * immediately before serializing the published `data.json` / SSG site.
 */
declare function redactSnapshotForPublication(snapshot: ExportSnapshot): ExportSnapshot;
/** True when any string field in the snapshot still carries an absolute filesystem path. */
declare function snapshotHasAbsolutePath(snapshot: ExportSnapshot): boolean;
//#endregion
//#region src/opsx-kernel.d.ts
interface GlobArtifactFile {
  path: string;
  type: 'file';
  content: string;
}
declare class OpsxKernel {
  private readonly projectDir;
  private readonly cliExecutor;
  private readonly runtimeInvalidation;
  private readonly rootSelector;
  private cliCapabilitiesPromise;
  private readonly controller;
  private warmupPromise;
  private readonly _streamReady;
  private _statusList;
  private _schemas;
  private _changeIds;
  private _schemaResolutions;
  private _schemaDetails;
  private _schemaFiles;
  private _schemaYamls;
  private _templates;
  private _templateContents;
  private _statuses;
  private _instructions;
  private _applyInstructions;
  private _archiveInstructions;
  private _changeMetadata;
  private _artifactOutputs;
  private _globArtifactFiles;
  private _entityControllers;
  constructor(projectDir: string, cliExecutor: CliExecutor, runtimeInvalidation: RuntimeInvalidationReader, rootSelector: CliRootSelector);
  warmup(): Promise<void>;
  waitForWarmup(): Promise<void>;
  private runWarmup;
  dispose(): void;
  getStatusList(): ChangeStatus[];
  getSchemas(): SchemaInfo[];
  getChangeIds(): string[];
  getTemplates(schema?: string): TemplatesMap;
  getTemplateContents(schema?: string): TemplateContentMap;
  getStatus(changeId: string, schema?: string): ChangeStatus;
  getInstructions(changeId: string, artifact: string, schema?: string): ArtifactInstructions;
  getApplyInstructions(changeId: string, schema?: string): ApplyInstructions;
  getArchiveInstructions(changeId: string, schema?: string): ArchiveInstructions;
  getSchemaResolution(name: string): SchemaResolution;
  peekSchemaResolution(name: string): SchemaResolution | null;
  getSchemaDetail(name: string): SchemaDetail;
  peekSchemaDetail(name: string): SchemaDetail | null;
  getSchemaFiles(name: string): ChangeFile[];
  getSchemaYaml(name: string): string | null;
  /** Non-throwing schema detail read; returns null when the schema is not yet loaded. */
  tryGetSchemaDetail(name: string): SchemaDetail | null;
  /** Non-throwing schema yaml read; returns null when the schema is not yet loaded. */
  tryGetSchemaYaml(name: string): string | null;
  getChangeMetadata(changeId: string): string | null;
  getArtifactOutput(changeId: string, outputPath: string): string | null;
  getGlobArtifactFiles(changeId: string, outputPath: string): GlobArtifactFile[];
  private startStream;
  private startStreamOnce;
  private warmupSchema;
  private warmupChange;
  private watchSchemaChanges;
  private watchChangeIdChanges;
  private teardownEntity;
  private clearStreamReadyByPrefix;
  /**
   * Resolve the admitted CLI's per-command capabilities once per Kernel lifetime.
   *
   * The detected version decides whether version-specific selectors and options are forwarded.
   * A failed availability probe yields no capabilities, so no version-only flag is ever sent
   * to an unverifiable CLI.
   */
  private resolveCliCapabilities;
  private fetchSchemas;
  private fetchSchemasProjection;
  private fetchChangeIds;
  private fetchChangeListProjection;
  private fetchStatus;
  private fetchStatusList;
  private fetchInstructions;
  private fetchApplyInstructions;
  private fetchArchiveInstructions;
  private fetchSchemaResolution;
  private fetchSchemaResolutionProjection;
  private fetchSchemaDetail;
  private fetchSchemaDetailAtResolution;
  private fetchSchemaFiles;
  private fetchSchemaYaml;
  private fetchTemplates;
  private fetchTemplatesProjection;
  private fetchTemplateContents;
  private readTemplateContents;
  private fetchChangeMetadata;
  private fetchArtifactOutput;
  /** Execute one Status projection with dependencies owned by the caller's reactive generation. */
  readStatusProjection(changeId: string, schema?: string): Promise<ChangeStatus>;
  /**
   * Execute CLI-owned Change enumeration with file dependencies owned by the caller's Work
   * generation. `entries` carries the CLI's own per-Change task counts and phase so list
   * surfaces can show CLI-reported progress without UI-side file arithmetic.
   */
  readChangeListProjection(): Promise<{
    value: string[];
    entries: CliChangeListEntry[];
    evidence: CliProjectionCommandEvidence;
  }>;
  /** Execute the current Change Status list without joining the Kernel's retained entity streams. */
  readStatusListProjection(): Promise<{
    value: ChangeStatus[];
    evidence: CliProjectionCommandEvidence;
  }>;
  /** Execute one artifact-instructions projection in the caller-owned Work generation. */
  readInstructionsProjection(changeId: string, artifact: string, schema?: string): Promise<ArtifactInstructions>;
  /** Execute one Apply-instructions projection in the caller-owned Work generation. */
  readApplyInstructionsProjection(changeId: string, schema?: string): Promise<ApplyInstructions>;
  /** Execute one Archive-instructions projection in the caller-owned Work generation. */
  readArchiveInstructionsProjection(changeId: string, schema?: string): Promise<ArchiveInstructions>;
  /** Execute the aggregate Schema bundle while retaining exact resolved-file dependencies. */
  readConfigBundleProjection(): Promise<{
    value: OpsxConfigBundle;
    evidence: {
      schemas: CliProjectionCommandEvidence;
      schemaResolutions: Record<string, CliProjectionCommandEvidence>;
    };
  }>;
  /** Execute one CLI template-index projection. */
  readTemplatesProjection(schema?: string): Promise<{
    value: TemplatesMap;
    evidence: CliProjectionCommandEvidence;
  }>;
  /** Execute one template-content projection from the CLI-selected template index. */
  readTemplateContentsProjection(schema?: string): Promise<{
    value: TemplateContentMap;
    evidence: CliProjectionCommandEvidence;
  }>;
  ensureSchemas(): Promise<void>;
  ensureChangeIds(): Promise<void>;
  ensureStatusList(): Promise<void>;
  ensureStatus(changeId: string, schema?: string): Promise<void>;
  ensureInstructions(changeId: string, artifact: string, schema?: string): Promise<void>;
  ensureApplyInstructions(changeId: string, schema?: string): Promise<void>;
  ensureArchiveInstructions(changeId: string, schema?: string): Promise<void>;
  ensureArtifactOutput(changeId: string, outputPath: string): Promise<void>;
  ensureGlobArtifactFiles(changeId: string, outputPath: string): Promise<void>;
  ensureSchemaResolution(name: string): Promise<void>;
  ensureSchemaDetail(name: string): Promise<void>;
  ensureSchemaFiles(name: string): Promise<void>;
  ensureSchemaYaml(name: string): Promise<void>;
  ensureTemplates(schema?: string): Promise<void>;
  ensureTemplateContents(schema?: string): Promise<void>;
  ensureChangeMetadata(changeId: string): Promise<void>;
  private combineSignals;
}
//#endregion
//#region src/entity-id.d.ts
/**
 * Orthogonal intents (updated 2026-08-01 Asia/Shanghai):
 * 1. Validate filesystem-backed OpenSpec entity ids as canonical single path segments.
 * 2. Validate recursive Spec ids without weakening single-segment Change ids.
 * 3. Validate entity-relative file and glob paths before filesystem access.
 * 4. Share traversal guards across Core adapters, kernels, and Server path resolvers.
 *
 * Original request (2026-07-16): "实际文件变更只能发生在选定的 planning root 内。"
 * Original request (2026-07-17): "Every client-supplied Archive changeId passes the shared canonical entity guard."
 * Original request (2026-08-01): adapt OpenSpec 1.7 nested Spec ids such as `platform/auth`.
 */
type OpenSpecEntityIdField = 'changeId';
/** Public field names accepted by OpenSpec entity path validation. */
type OpenSpecEntityPathField = 'outputPath' | 'path';
/** Return one path-safe OpenSpec entity id or reject it before filesystem access. */
declare function requireCanonicalOpenSpecEntityId(value: string, field: OpenSpecEntityIdField): string;
/** Return one canonical slash-separated Spec id or reject raw and encoded traversal. */
declare function requireCanonicalOpenSpecSpecId(value: string): string;
/** Return one normalized entity-relative path or glob without parent traversal. */
declare function requireOpenSpecEntityRelativePath(value: string, field: OpenSpecEntityPathField): string;
//#endregion
//#region src/dashboard-summary-transport.d.ts
/** Opaque Server-issued identity; it is derived from, but never contains, a Planning-root path. */
declare const DashboardSummaryIdentitySchema: z.ZodString;
type DashboardSummaryIdentity = z.infer<typeof DashboardSummaryIdentitySchema>;
/** Reasons that can wake the migrated Summary adapter in this bounded v2 slice. */
declare const DashboardSummaryInvalidationCauseSchema: z.ZodEnum<["initial", "server-push", "root-rebind"]>;
type DashboardSummaryInvalidationCause = z.infer<typeof DashboardSummaryInvalidationCauseSchema>;
/** Data-free subscription event. Replacement Summary data always arrives through the typed pull. */
declare const DashboardSummaryInvalidationSchema: z.ZodObject<{
  identity: z.ZodString;
  workGeneration: z.ZodNumber;
  snapshotGeneration: z.ZodNullable<z.ZodNumber>;
  state: z.ZodEnum<["loading", "ready", "revalidating", "error", "refresh-error"]>;
  cause: z.ZodEnum<["initial", "server-push", "root-rebind"]>;
}, "strict", z.ZodTypeAny, {
  state: "error" | "loading" | "ready" | "revalidating" | "refresh-error";
  snapshotGeneration: number | null;
  identity: string;
  workGeneration: number;
  cause: "initial" | "server-push" | "root-rebind";
}, {
  state: "error" | "loading" | "ready" | "revalidating" | "refresh-error";
  snapshotGeneration: number | null;
  identity: string;
  workGeneration: number;
  cause: "initial" | "server-push" | "root-rebind";
}>;
type DashboardSummaryInvalidation = z.infer<typeof DashboardSummaryInvalidationSchema>;
/** Full Summary Pull state correlated to the exact Server-owned work identity and generation. */
declare const DashboardSummaryProjectionStateSchema: z.ZodDiscriminatedUnion<"state", [z.ZodObject<{
  state: z.ZodLiteral<"loading">;
  data: z.ZodNull;
  freshness: z.ZodNull;
  snapshotGeneration: z.ZodNull;
  error: z.ZodNull;
  identity: z.ZodString;
  workGeneration: z.ZodNumber;
  invalidationCause: z.ZodEnum<["initial", "dependency", "explicit-refresh", "subscriber-resume"]>;
}, "strip", z.ZodTypeAny, {
  error: null;
  state: "loading";
  data: null;
  freshness: null;
  snapshotGeneration: null;
  identity: string;
  workGeneration: number;
  invalidationCause: "dependency" | "initial" | "explicit-refresh" | "subscriber-resume";
}, {
  error: null;
  state: "loading";
  data: null;
  freshness: null;
  snapshotGeneration: null;
  identity: string;
  workGeneration: number;
  invalidationCause: "dependency" | "initial" | "explicit-refresh" | "subscriber-resume";
}>, z.ZodObject<{
  state: z.ZodLiteral<"ready">;
  data: z.ZodType<{
    summary: {
      specifications: number;
      requirements: number;
      activeChanges: number;
      inProgressChanges: number;
      completedChanges: number;
      archivedTasksCompleted: number;
      tasksTotal: number;
      tasksCompleted: number;
      taskCompletionPercent: number | null;
    };
    specifications: {
      id: string;
      updatedAt: number;
      name: string;
      requirements: number;
    }[];
    activeChanges: {
      id: string;
      updatedAt: number;
      name: string;
      trackedTaskProgress: {
        source: {
          kind: "artifact";
          outputPath: string;
          artifactId: string;
          filePaths: string[];
        } | {
          kind: "top-level-fallback";
          outputPath: "tasks.md";
          artifactId: null;
          filePaths: ["tasks.md"];
        } | {
          kind: "none";
          outputPath: null;
          artifactId: null;
          filePaths: [];
        };
        tasks: {
          id: string;
          text: string;
          completed: boolean;
          location: {
            filePath: string;
            taskIndex: number;
          };
          section?: string | undefined;
        }[];
        total: number;
        remaining: number;
        completed: number;
        phase: "no-tasks" | "complete" | "in-progress";
      };
      cliTaskSummary: {
        status: "no-tasks" | "complete" | "in-progress";
        completedTasks: number;
        totalTasks: number;
      } | null;
    }[];
    trackedTaskPhaseCounts: {
      'no-tasks': number;
      complete: number;
      'in-progress': number;
    };
    recentArchives: {
      id: string;
      updatedAt: number;
      name: string;
      trackedTaskProgress: {
        source: {
          kind: "artifact";
          outputPath: string;
          artifactId: string;
          filePaths: string[];
        } | {
          kind: "top-level-fallback";
          outputPath: "tasks.md";
          artifactId: null;
          filePaths: ["tasks.md"];
        } | {
          kind: "none";
          outputPath: null;
          artifactId: null;
          filePaths: [];
        };
        tasks: {
          id: string;
          text: string;
          completed: boolean;
          location: {
            filePath: string;
            taskIndex: number;
          };
          section?: string | undefined;
        }[];
        total: number;
        remaining: number;
        completed: number;
        phase: "no-tasks" | "complete" | "in-progress";
      };
      archivedAt: number;
    }[];
  }, z.ZodTypeDef, {
    summary: {
      specifications: number;
      requirements: number;
      activeChanges: number;
      inProgressChanges: number;
      completedChanges: number;
      archivedTasksCompleted: number;
      tasksTotal: number;
      tasksCompleted: number;
      taskCompletionPercent: number | null;
    };
    specifications: {
      id: string;
      updatedAt: number;
      name: string;
      requirements: number;
    }[];
    activeChanges: {
      id: string;
      updatedAt: number;
      name: string;
      trackedTaskProgress: {
        source: {
          kind: "artifact";
          outputPath: string;
          artifactId: string;
          filePaths: string[];
        } | {
          kind: "top-level-fallback";
          outputPath: "tasks.md";
          artifactId: null;
          filePaths: ["tasks.md"];
        } | {
          kind: "none";
          outputPath: null;
          artifactId: null;
          filePaths: [];
        };
        tasks: {
          id: string;
          text: string;
          completed: boolean;
          location: {
            filePath: string;
            taskIndex: number;
          };
          section?: string | undefined;
        }[];
        total: number;
        remaining: number;
        completed: number;
        phase: "no-tasks" | "complete" | "in-progress";
      };
      cliTaskSummary: {
        status: "no-tasks" | "complete" | "in-progress";
        completedTasks: number;
        totalTasks: number;
      } | null;
    }[];
    trackedTaskPhaseCounts: {
      'no-tasks': number;
      complete: number;
      'in-progress': number;
    };
    recentArchives: {
      id: string;
      updatedAt: number;
      name: string;
      trackedTaskProgress: {
        source: {
          kind: "artifact";
          outputPath: string;
          artifactId: string;
          filePaths: string[];
        } | {
          kind: "top-level-fallback";
          outputPath: "tasks.md";
          artifactId: null;
          filePaths: ["tasks.md"];
        } | {
          kind: "none";
          outputPath: null;
          artifactId: null;
          filePaths: [];
        };
        tasks: {
          id: string;
          text: string;
          completed: boolean;
          location: {
            filePath: string;
            taskIndex: number;
          };
          section?: string | undefined;
        }[];
        total: number;
        remaining: number;
        completed: number;
        phase: "no-tasks" | "complete" | "in-progress";
      };
      archivedAt: number;
    }[];
  }>;
  freshness: z.ZodLiteral<"current">;
  snapshotGeneration: z.ZodNumber;
  error: z.ZodNull;
  identity: z.ZodString;
  workGeneration: z.ZodNumber;
  invalidationCause: z.ZodEnum<["initial", "dependency", "explicit-refresh", "subscriber-resume"]>;
}, "strip", z.ZodTypeAny, {
  error: null;
  state: "ready";
  data: {
    summary: {
      specifications: number;
      requirements: number;
      activeChanges: number;
      inProgressChanges: number;
      completedChanges: number;
      archivedTasksCompleted: number;
      tasksTotal: number;
      tasksCompleted: number;
      taskCompletionPercent: number | null;
    };
    specifications: {
      id: string;
      updatedAt: number;
      name: string;
      requirements: number;
    }[];
    activeChanges: {
      id: string;
      updatedAt: number;
      name: string;
      trackedTaskProgress: {
        source: {
          kind: "artifact";
          outputPath: string;
          artifactId: string;
          filePaths: string[];
        } | {
          kind: "top-level-fallback";
          outputPath: "tasks.md";
          artifactId: null;
          filePaths: ["tasks.md"];
        } | {
          kind: "none";
          outputPath: null;
          artifactId: null;
          filePaths: [];
        };
        tasks: {
          id: string;
          text: string;
          completed: boolean;
          location: {
            filePath: string;
            taskIndex: number;
          };
          section?: string | undefined;
        }[];
        total: number;
        remaining: number;
        completed: number;
        phase: "no-tasks" | "complete" | "in-progress";
      };
      cliTaskSummary: {
        status: "no-tasks" | "complete" | "in-progress";
        completedTasks: number;
        totalTasks: number;
      } | null;
    }[];
    trackedTaskPhaseCounts: {
      'no-tasks': number;
      complete: number;
      'in-progress': number;
    };
    recentArchives: {
      id: string;
      updatedAt: number;
      name: string;
      trackedTaskProgress: {
        source: {
          kind: "artifact";
          outputPath: string;
          artifactId: string;
          filePaths: string[];
        } | {
          kind: "top-level-fallback";
          outputPath: "tasks.md";
          artifactId: null;
          filePaths: ["tasks.md"];
        } | {
          kind: "none";
          outputPath: null;
          artifactId: null;
          filePaths: [];
        };
        tasks: {
          id: string;
          text: string;
          completed: boolean;
          location: {
            filePath: string;
            taskIndex: number;
          };
          section?: string | undefined;
        }[];
        total: number;
        remaining: number;
        completed: number;
        phase: "no-tasks" | "complete" | "in-progress";
      };
      archivedAt: number;
    }[];
  };
  freshness: "current";
  snapshotGeneration: number;
  identity: string;
  workGeneration: number;
  invalidationCause: "dependency" | "initial" | "explicit-refresh" | "subscriber-resume";
}, {
  error: null;
  state: "ready";
  data: {
    summary: {
      specifications: number;
      requirements: number;
      activeChanges: number;
      inProgressChanges: number;
      completedChanges: number;
      archivedTasksCompleted: number;
      tasksTotal: number;
      tasksCompleted: number;
      taskCompletionPercent: number | null;
    };
    specifications: {
      id: string;
      updatedAt: number;
      name: string;
      requirements: number;
    }[];
    activeChanges: {
      id: string;
      updatedAt: number;
      name: string;
      trackedTaskProgress: {
        source: {
          kind: "artifact";
          outputPath: string;
          artifactId: string;
          filePaths: string[];
        } | {
          kind: "top-level-fallback";
          outputPath: "tasks.md";
          artifactId: null;
          filePaths: ["tasks.md"];
        } | {
          kind: "none";
          outputPath: null;
          artifactId: null;
          filePaths: [];
        };
        tasks: {
          id: string;
          text: string;
          completed: boolean;
          location: {
            filePath: string;
            taskIndex: number;
          };
          section?: string | undefined;
        }[];
        total: number;
        remaining: number;
        completed: number;
        phase: "no-tasks" | "complete" | "in-progress";
      };
      cliTaskSummary: {
        status: "no-tasks" | "complete" | "in-progress";
        completedTasks: number;
        totalTasks: number;
      } | null;
    }[];
    trackedTaskPhaseCounts: {
      'no-tasks': number;
      complete: number;
      'in-progress': number;
    };
    recentArchives: {
      id: string;
      updatedAt: number;
      name: string;
      trackedTaskProgress: {
        source: {
          kind: "artifact";
          outputPath: string;
          artifactId: string;
          filePaths: string[];
        } | {
          kind: "top-level-fallback";
          outputPath: "tasks.md";
          artifactId: null;
          filePaths: ["tasks.md"];
        } | {
          kind: "none";
          outputPath: null;
          artifactId: null;
          filePaths: [];
        };
        tasks: {
          id: string;
          text: string;
          completed: boolean;
          location: {
            filePath: string;
            taskIndex: number;
          };
          section?: string | undefined;
        }[];
        total: number;
        remaining: number;
        completed: number;
        phase: "no-tasks" | "complete" | "in-progress";
      };
      archivedAt: number;
    }[];
  };
  freshness: "current";
  snapshotGeneration: number;
  identity: string;
  workGeneration: number;
  invalidationCause: "dependency" | "initial" | "explicit-refresh" | "subscriber-resume";
}>, z.ZodObject<{
  state: z.ZodLiteral<"revalidating">;
  data: z.ZodType<{
    summary: {
      specifications: number;
      requirements: number;
      activeChanges: number;
      inProgressChanges: number;
      completedChanges: number;
      archivedTasksCompleted: number;
      tasksTotal: number;
      tasksCompleted: number;
      taskCompletionPercent: number | null;
    };
    specifications: {
      id: string;
      updatedAt: number;
      name: string;
      requirements: number;
    }[];
    activeChanges: {
      id: string;
      updatedAt: number;
      name: string;
      trackedTaskProgress: {
        source: {
          kind: "artifact";
          outputPath: string;
          artifactId: string;
          filePaths: string[];
        } | {
          kind: "top-level-fallback";
          outputPath: "tasks.md";
          artifactId: null;
          filePaths: ["tasks.md"];
        } | {
          kind: "none";
          outputPath: null;
          artifactId: null;
          filePaths: [];
        };
        tasks: {
          id: string;
          text: string;
          completed: boolean;
          location: {
            filePath: string;
            taskIndex: number;
          };
          section?: string | undefined;
        }[];
        total: number;
        remaining: number;
        completed: number;
        phase: "no-tasks" | "complete" | "in-progress";
      };
      cliTaskSummary: {
        status: "no-tasks" | "complete" | "in-progress";
        completedTasks: number;
        totalTasks: number;
      } | null;
    }[];
    trackedTaskPhaseCounts: {
      'no-tasks': number;
      complete: number;
      'in-progress': number;
    };
    recentArchives: {
      id: string;
      updatedAt: number;
      name: string;
      trackedTaskProgress: {
        source: {
          kind: "artifact";
          outputPath: string;
          artifactId: string;
          filePaths: string[];
        } | {
          kind: "top-level-fallback";
          outputPath: "tasks.md";
          artifactId: null;
          filePaths: ["tasks.md"];
        } | {
          kind: "none";
          outputPath: null;
          artifactId: null;
          filePaths: [];
        };
        tasks: {
          id: string;
          text: string;
          completed: boolean;
          location: {
            filePath: string;
            taskIndex: number;
          };
          section?: string | undefined;
        }[];
        total: number;
        remaining: number;
        completed: number;
        phase: "no-tasks" | "complete" | "in-progress";
      };
      archivedAt: number;
    }[];
  }, z.ZodTypeDef, {
    summary: {
      specifications: number;
      requirements: number;
      activeChanges: number;
      inProgressChanges: number;
      completedChanges: number;
      archivedTasksCompleted: number;
      tasksTotal: number;
      tasksCompleted: number;
      taskCompletionPercent: number | null;
    };
    specifications: {
      id: string;
      updatedAt: number;
      name: string;
      requirements: number;
    }[];
    activeChanges: {
      id: string;
      updatedAt: number;
      name: string;
      trackedTaskProgress: {
        source: {
          kind: "artifact";
          outputPath: string;
          artifactId: string;
          filePaths: string[];
        } | {
          kind: "top-level-fallback";
          outputPath: "tasks.md";
          artifactId: null;
          filePaths: ["tasks.md"];
        } | {
          kind: "none";
          outputPath: null;
          artifactId: null;
          filePaths: [];
        };
        tasks: {
          id: string;
          text: string;
          completed: boolean;
          location: {
            filePath: string;
            taskIndex: number;
          };
          section?: string | undefined;
        }[];
        total: number;
        remaining: number;
        completed: number;
        phase: "no-tasks" | "complete" | "in-progress";
      };
      cliTaskSummary: {
        status: "no-tasks" | "complete" | "in-progress";
        completedTasks: number;
        totalTasks: number;
      } | null;
    }[];
    trackedTaskPhaseCounts: {
      'no-tasks': number;
      complete: number;
      'in-progress': number;
    };
    recentArchives: {
      id: string;
      updatedAt: number;
      name: string;
      trackedTaskProgress: {
        source: {
          kind: "artifact";
          outputPath: string;
          artifactId: string;
          filePaths: string[];
        } | {
          kind: "top-level-fallback";
          outputPath: "tasks.md";
          artifactId: null;
          filePaths: ["tasks.md"];
        } | {
          kind: "none";
          outputPath: null;
          artifactId: null;
          filePaths: [];
        };
        tasks: {
          id: string;
          text: string;
          completed: boolean;
          location: {
            filePath: string;
            taskIndex: number;
          };
          section?: string | undefined;
        }[];
        total: number;
        remaining: number;
        completed: number;
        phase: "no-tasks" | "complete" | "in-progress";
      };
      archivedAt: number;
    }[];
  }>;
  freshness: z.ZodLiteral<"stale-display-only">;
  snapshotGeneration: z.ZodNumber;
  error: z.ZodNull;
  identity: z.ZodString;
  workGeneration: z.ZodNumber;
  invalidationCause: z.ZodEnum<["initial", "dependency", "explicit-refresh", "subscriber-resume"]>;
}, "strip", z.ZodTypeAny, {
  error: null;
  state: "revalidating";
  data: {
    summary: {
      specifications: number;
      requirements: number;
      activeChanges: number;
      inProgressChanges: number;
      completedChanges: number;
      archivedTasksCompleted: number;
      tasksTotal: number;
      tasksCompleted: number;
      taskCompletionPercent: number | null;
    };
    specifications: {
      id: string;
      updatedAt: number;
      name: string;
      requirements: number;
    }[];
    activeChanges: {
      id: string;
      updatedAt: number;
      name: string;
      trackedTaskProgress: {
        source: {
          kind: "artifact";
          outputPath: string;
          artifactId: string;
          filePaths: string[];
        } | {
          kind: "top-level-fallback";
          outputPath: "tasks.md";
          artifactId: null;
          filePaths: ["tasks.md"];
        } | {
          kind: "none";
          outputPath: null;
          artifactId: null;
          filePaths: [];
        };
        tasks: {
          id: string;
          text: string;
          completed: boolean;
          location: {
            filePath: string;
            taskIndex: number;
          };
          section?: string | undefined;
        }[];
        total: number;
        remaining: number;
        completed: number;
        phase: "no-tasks" | "complete" | "in-progress";
      };
      cliTaskSummary: {
        status: "no-tasks" | "complete" | "in-progress";
        completedTasks: number;
        totalTasks: number;
      } | null;
    }[];
    trackedTaskPhaseCounts: {
      'no-tasks': number;
      complete: number;
      'in-progress': number;
    };
    recentArchives: {
      id: string;
      updatedAt: number;
      name: string;
      trackedTaskProgress: {
        source: {
          kind: "artifact";
          outputPath: string;
          artifactId: string;
          filePaths: string[];
        } | {
          kind: "top-level-fallback";
          outputPath: "tasks.md";
          artifactId: null;
          filePaths: ["tasks.md"];
        } | {
          kind: "none";
          outputPath: null;
          artifactId: null;
          filePaths: [];
        };
        tasks: {
          id: string;
          text: string;
          completed: boolean;
          location: {
            filePath: string;
            taskIndex: number;
          };
          section?: string | undefined;
        }[];
        total: number;
        remaining: number;
        completed: number;
        phase: "no-tasks" | "complete" | "in-progress";
      };
      archivedAt: number;
    }[];
  };
  freshness: "stale-display-only";
  snapshotGeneration: number;
  identity: string;
  workGeneration: number;
  invalidationCause: "dependency" | "initial" | "explicit-refresh" | "subscriber-resume";
}, {
  error: null;
  state: "revalidating";
  data: {
    summary: {
      specifications: number;
      requirements: number;
      activeChanges: number;
      inProgressChanges: number;
      completedChanges: number;
      archivedTasksCompleted: number;
      tasksTotal: number;
      tasksCompleted: number;
      taskCompletionPercent: number | null;
    };
    specifications: {
      id: string;
      updatedAt: number;
      name: string;
      requirements: number;
    }[];
    activeChanges: {
      id: string;
      updatedAt: number;
      name: string;
      trackedTaskProgress: {
        source: {
          kind: "artifact";
          outputPath: string;
          artifactId: string;
          filePaths: string[];
        } | {
          kind: "top-level-fallback";
          outputPath: "tasks.md";
          artifactId: null;
          filePaths: ["tasks.md"];
        } | {
          kind: "none";
          outputPath: null;
          artifactId: null;
          filePaths: [];
        };
        tasks: {
          id: string;
          text: string;
          completed: boolean;
          location: {
            filePath: string;
            taskIndex: number;
          };
          section?: string | undefined;
        }[];
        total: number;
        remaining: number;
        completed: number;
        phase: "no-tasks" | "complete" | "in-progress";
      };
      cliTaskSummary: {
        status: "no-tasks" | "complete" | "in-progress";
        completedTasks: number;
        totalTasks: number;
      } | null;
    }[];
    trackedTaskPhaseCounts: {
      'no-tasks': number;
      complete: number;
      'in-progress': number;
    };
    recentArchives: {
      id: string;
      updatedAt: number;
      name: string;
      trackedTaskProgress: {
        source: {
          kind: "artifact";
          outputPath: string;
          artifactId: string;
          filePaths: string[];
        } | {
          kind: "top-level-fallback";
          outputPath: "tasks.md";
          artifactId: null;
          filePaths: ["tasks.md"];
        } | {
          kind: "none";
          outputPath: null;
          artifactId: null;
          filePaths: [];
        };
        tasks: {
          id: string;
          text: string;
          completed: boolean;
          location: {
            filePath: string;
            taskIndex: number;
          };
          section?: string | undefined;
        }[];
        total: number;
        remaining: number;
        completed: number;
        phase: "no-tasks" | "complete" | "in-progress";
      };
      archivedAt: number;
    }[];
  };
  freshness: "stale-display-only";
  snapshotGeneration: number;
  identity: string;
  workGeneration: number;
  invalidationCause: "dependency" | "initial" | "explicit-refresh" | "subscriber-resume";
}>, z.ZodObject<{
  state: z.ZodLiteral<"error">;
  data: z.ZodNull;
  freshness: z.ZodNull;
  snapshotGeneration: z.ZodNull;
  error: z.ZodObject<{
    name: z.ZodString;
    message: z.ZodString;
    cliEvidence: z.ZodNullable<z.ZodObject<{
      success: z.ZodBoolean;
      stdout: z.ZodString;
      stderr: z.ZodString;
      exitCode: z.ZodNullable<z.ZodNumber>;
      payload: z.ZodNullable<z.ZodType<CliJsonValue, z.ZodTypeDef, CliJsonValue>>;
      diagnostics: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
      contractError: z.ZodOptional<z.ZodString>;
    }, "strip", z.ZodTypeAny, {
      success: boolean;
      stdout: string;
      stderr: string;
      exitCode: number | null;
      payload: CliJsonValue;
      diagnostics: z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">[];
      contractError?: string | undefined;
    }, {
      success: boolean;
      stdout: string;
      stderr: string;
      exitCode: number | null;
      payload: CliJsonValue;
      diagnostics: z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">[];
      contractError?: string | undefined;
    }>>;
  }, "strip", z.ZodTypeAny, {
    message: string;
    name: string;
    cliEvidence: {
      success: boolean;
      stdout: string;
      stderr: string;
      exitCode: number | null;
      payload: CliJsonValue;
      diagnostics: z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">[];
      contractError?: string | undefined;
    } | null;
  }, {
    message: string;
    name: string;
    cliEvidence: {
      success: boolean;
      stdout: string;
      stderr: string;
      exitCode: number | null;
      payload: CliJsonValue;
      diagnostics: z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">[];
      contractError?: string | undefined;
    } | null;
  }>;
  identity: z.ZodString;
  workGeneration: z.ZodNumber;
  invalidationCause: z.ZodEnum<["initial", "dependency", "explicit-refresh", "subscriber-resume"]>;
}, "strip", z.ZodTypeAny, {
  error: {
    message: string;
    name: string;
    cliEvidence: {
      success: boolean;
      stdout: string;
      stderr: string;
      exitCode: number | null;
      payload: CliJsonValue;
      diagnostics: z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">[];
      contractError?: string | undefined;
    } | null;
  };
  state: "error";
  data: null;
  freshness: null;
  snapshotGeneration: null;
  identity: string;
  workGeneration: number;
  invalidationCause: "dependency" | "initial" | "explicit-refresh" | "subscriber-resume";
}, {
  error: {
    message: string;
    name: string;
    cliEvidence: {
      success: boolean;
      stdout: string;
      stderr: string;
      exitCode: number | null;
      payload: CliJsonValue;
      diagnostics: z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">[];
      contractError?: string | undefined;
    } | null;
  };
  state: "error";
  data: null;
  freshness: null;
  snapshotGeneration: null;
  identity: string;
  workGeneration: number;
  invalidationCause: "dependency" | "initial" | "explicit-refresh" | "subscriber-resume";
}>, z.ZodObject<{
  state: z.ZodLiteral<"refresh-error">;
  data: z.ZodType<{
    summary: {
      specifications: number;
      requirements: number;
      activeChanges: number;
      inProgressChanges: number;
      completedChanges: number;
      archivedTasksCompleted: number;
      tasksTotal: number;
      tasksCompleted: number;
      taskCompletionPercent: number | null;
    };
    specifications: {
      id: string;
      updatedAt: number;
      name: string;
      requirements: number;
    }[];
    activeChanges: {
      id: string;
      updatedAt: number;
      name: string;
      trackedTaskProgress: {
        source: {
          kind: "artifact";
          outputPath: string;
          artifactId: string;
          filePaths: string[];
        } | {
          kind: "top-level-fallback";
          outputPath: "tasks.md";
          artifactId: null;
          filePaths: ["tasks.md"];
        } | {
          kind: "none";
          outputPath: null;
          artifactId: null;
          filePaths: [];
        };
        tasks: {
          id: string;
          text: string;
          completed: boolean;
          location: {
            filePath: string;
            taskIndex: number;
          };
          section?: string | undefined;
        }[];
        total: number;
        remaining: number;
        completed: number;
        phase: "no-tasks" | "complete" | "in-progress";
      };
      cliTaskSummary: {
        status: "no-tasks" | "complete" | "in-progress";
        completedTasks: number;
        totalTasks: number;
      } | null;
    }[];
    trackedTaskPhaseCounts: {
      'no-tasks': number;
      complete: number;
      'in-progress': number;
    };
    recentArchives: {
      id: string;
      updatedAt: number;
      name: string;
      trackedTaskProgress: {
        source: {
          kind: "artifact";
          outputPath: string;
          artifactId: string;
          filePaths: string[];
        } | {
          kind: "top-level-fallback";
          outputPath: "tasks.md";
          artifactId: null;
          filePaths: ["tasks.md"];
        } | {
          kind: "none";
          outputPath: null;
          artifactId: null;
          filePaths: [];
        };
        tasks: {
          id: string;
          text: string;
          completed: boolean;
          location: {
            filePath: string;
            taskIndex: number;
          };
          section?: string | undefined;
        }[];
        total: number;
        remaining: number;
        completed: number;
        phase: "no-tasks" | "complete" | "in-progress";
      };
      archivedAt: number;
    }[];
  }, z.ZodTypeDef, {
    summary: {
      specifications: number;
      requirements: number;
      activeChanges: number;
      inProgressChanges: number;
      completedChanges: number;
      archivedTasksCompleted: number;
      tasksTotal: number;
      tasksCompleted: number;
      taskCompletionPercent: number | null;
    };
    specifications: {
      id: string;
      updatedAt: number;
      name: string;
      requirements: number;
    }[];
    activeChanges: {
      id: string;
      updatedAt: number;
      name: string;
      trackedTaskProgress: {
        source: {
          kind: "artifact";
          outputPath: string;
          artifactId: string;
          filePaths: string[];
        } | {
          kind: "top-level-fallback";
          outputPath: "tasks.md";
          artifactId: null;
          filePaths: ["tasks.md"];
        } | {
          kind: "none";
          outputPath: null;
          artifactId: null;
          filePaths: [];
        };
        tasks: {
          id: string;
          text: string;
          completed: boolean;
          location: {
            filePath: string;
            taskIndex: number;
          };
          section?: string | undefined;
        }[];
        total: number;
        remaining: number;
        completed: number;
        phase: "no-tasks" | "complete" | "in-progress";
      };
      cliTaskSummary: {
        status: "no-tasks" | "complete" | "in-progress";
        completedTasks: number;
        totalTasks: number;
      } | null;
    }[];
    trackedTaskPhaseCounts: {
      'no-tasks': number;
      complete: number;
      'in-progress': number;
    };
    recentArchives: {
      id: string;
      updatedAt: number;
      name: string;
      trackedTaskProgress: {
        source: {
          kind: "artifact";
          outputPath: string;
          artifactId: string;
          filePaths: string[];
        } | {
          kind: "top-level-fallback";
          outputPath: "tasks.md";
          artifactId: null;
          filePaths: ["tasks.md"];
        } | {
          kind: "none";
          outputPath: null;
          artifactId: null;
          filePaths: [];
        };
        tasks: {
          id: string;
          text: string;
          completed: boolean;
          location: {
            filePath: string;
            taskIndex: number;
          };
          section?: string | undefined;
        }[];
        total: number;
        remaining: number;
        completed: number;
        phase: "no-tasks" | "complete" | "in-progress";
      };
      archivedAt: number;
    }[];
  }>;
  freshness: z.ZodLiteral<"stale-display-only">;
  snapshotGeneration: z.ZodNumber;
  error: z.ZodObject<{
    name: z.ZodString;
    message: z.ZodString;
    cliEvidence: z.ZodNullable<z.ZodObject<{
      success: z.ZodBoolean;
      stdout: z.ZodString;
      stderr: z.ZodString;
      exitCode: z.ZodNullable<z.ZodNumber>;
      payload: z.ZodNullable<z.ZodType<CliJsonValue, z.ZodTypeDef, CliJsonValue>>;
      diagnostics: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">>, "many">;
      contractError: z.ZodOptional<z.ZodString>;
    }, "strip", z.ZodTypeAny, {
      success: boolean;
      stdout: string;
      stderr: string;
      exitCode: number | null;
      payload: CliJsonValue;
      diagnostics: z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">[];
      contractError?: string | undefined;
    }, {
      success: boolean;
      stdout: string;
      stderr: string;
      exitCode: number | null;
      payload: CliJsonValue;
      diagnostics: z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">[];
      contractError?: string | undefined;
    }>>;
  }, "strip", z.ZodTypeAny, {
    message: string;
    name: string;
    cliEvidence: {
      success: boolean;
      stdout: string;
      stderr: string;
      exitCode: number | null;
      payload: CliJsonValue;
      diagnostics: z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">[];
      contractError?: string | undefined;
    } | null;
  }, {
    message: string;
    name: string;
    cliEvidence: {
      success: boolean;
      stdout: string;
      stderr: string;
      exitCode: number | null;
      payload: CliJsonValue;
      diagnostics: z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">[];
      contractError?: string | undefined;
    } | null;
  }>;
  identity: z.ZodString;
  workGeneration: z.ZodNumber;
  invalidationCause: z.ZodEnum<["initial", "dependency", "explicit-refresh", "subscriber-resume"]>;
}, "strip", z.ZodTypeAny, {
  error: {
    message: string;
    name: string;
    cliEvidence: {
      success: boolean;
      stdout: string;
      stderr: string;
      exitCode: number | null;
      payload: CliJsonValue;
      diagnostics: z.objectOutputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">[];
      contractError?: string | undefined;
    } | null;
  };
  state: "refresh-error";
  data: {
    summary: {
      specifications: number;
      requirements: number;
      activeChanges: number;
      inProgressChanges: number;
      completedChanges: number;
      archivedTasksCompleted: number;
      tasksTotal: number;
      tasksCompleted: number;
      taskCompletionPercent: number | null;
    };
    specifications: {
      id: string;
      updatedAt: number;
      name: string;
      requirements: number;
    }[];
    activeChanges: {
      id: string;
      updatedAt: number;
      name: string;
      trackedTaskProgress: {
        source: {
          kind: "artifact";
          outputPath: string;
          artifactId: string;
          filePaths: string[];
        } | {
          kind: "top-level-fallback";
          outputPath: "tasks.md";
          artifactId: null;
          filePaths: ["tasks.md"];
        } | {
          kind: "none";
          outputPath: null;
          artifactId: null;
          filePaths: [];
        };
        tasks: {
          id: string;
          text: string;
          completed: boolean;
          location: {
            filePath: string;
            taskIndex: number;
          };
          section?: string | undefined;
        }[];
        total: number;
        remaining: number;
        completed: number;
        phase: "no-tasks" | "complete" | "in-progress";
      };
      cliTaskSummary: {
        status: "no-tasks" | "complete" | "in-progress";
        completedTasks: number;
        totalTasks: number;
      } | null;
    }[];
    trackedTaskPhaseCounts: {
      'no-tasks': number;
      complete: number;
      'in-progress': number;
    };
    recentArchives: {
      id: string;
      updatedAt: number;
      name: string;
      trackedTaskProgress: {
        source: {
          kind: "artifact";
          outputPath: string;
          artifactId: string;
          filePaths: string[];
        } | {
          kind: "top-level-fallback";
          outputPath: "tasks.md";
          artifactId: null;
          filePaths: ["tasks.md"];
        } | {
          kind: "none";
          outputPath: null;
          artifactId: null;
          filePaths: [];
        };
        tasks: {
          id: string;
          text: string;
          completed: boolean;
          location: {
            filePath: string;
            taskIndex: number;
          };
          section?: string | undefined;
        }[];
        total: number;
        remaining: number;
        completed: number;
        phase: "no-tasks" | "complete" | "in-progress";
      };
      archivedAt: number;
    }[];
  };
  freshness: "stale-display-only";
  snapshotGeneration: number;
  identity: string;
  workGeneration: number;
  invalidationCause: "dependency" | "initial" | "explicit-refresh" | "subscriber-resume";
}, {
  error: {
    message: string;
    name: string;
    cliEvidence: {
      success: boolean;
      stdout: string;
      stderr: string;
      exitCode: number | null;
      payload: CliJsonValue;
      diagnostics: z.objectInputType<{
        severity: z.ZodEnum<["error", "warning", "info"]>;
        code: z.ZodString;
        message: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        fix: z.ZodOptional<z.ZodString>;
      }, z.ZodTypeAny, "passthrough">[];
      contractError?: string | undefined;
    } | null;
  };
  state: "refresh-error";
  data: {
    summary: {
      specifications: number;
      requirements: number;
      activeChanges: number;
      inProgressChanges: number;
      completedChanges: number;
      archivedTasksCompleted: number;
      tasksTotal: number;
      tasksCompleted: number;
      taskCompletionPercent: number | null;
    };
    specifications: {
      id: string;
      updatedAt: number;
      name: string;
      requirements: number;
    }[];
    activeChanges: {
      id: string;
      updatedAt: number;
      name: string;
      trackedTaskProgress: {
        source: {
          kind: "artifact";
          outputPath: string;
          artifactId: string;
          filePaths: string[];
        } | {
          kind: "top-level-fallback";
          outputPath: "tasks.md";
          artifactId: null;
          filePaths: ["tasks.md"];
        } | {
          kind: "none";
          outputPath: null;
          artifactId: null;
          filePaths: [];
        };
        tasks: {
          id: string;
          text: string;
          completed: boolean;
          location: {
            filePath: string;
            taskIndex: number;
          };
          section?: string | undefined;
        }[];
        total: number;
        remaining: number;
        completed: number;
        phase: "no-tasks" | "complete" | "in-progress";
      };
      cliTaskSummary: {
        status: "no-tasks" | "complete" | "in-progress";
        completedTasks: number;
        totalTasks: number;
      } | null;
    }[];
    trackedTaskPhaseCounts: {
      'no-tasks': number;
      complete: number;
      'in-progress': number;
    };
    recentArchives: {
      id: string;
      updatedAt: number;
      name: string;
      trackedTaskProgress: {
        source: {
          kind: "artifact";
          outputPath: string;
          artifactId: string;
          filePaths: string[];
        } | {
          kind: "top-level-fallback";
          outputPath: "tasks.md";
          artifactId: null;
          filePaths: ["tasks.md"];
        } | {
          kind: "none";
          outputPath: null;
          artifactId: null;
          filePaths: [];
        };
        tasks: {
          id: string;
          text: string;
          completed: boolean;
          location: {
            filePath: string;
            taskIndex: number;
          };
          section?: string | undefined;
        }[];
        total: number;
        remaining: number;
        completed: number;
        phase: "no-tasks" | "complete" | "in-progress";
      };
      archivedAt: number;
    }[];
  };
  freshness: "stale-display-only";
  snapshotGeneration: number;
  identity: string;
  workGeneration: number;
  invalidationCause: "dependency" | "initial" | "explicit-refresh" | "subscriber-resume";
}>]>;
type DashboardSummaryProjectionState = z.infer<typeof DashboardSummaryProjectionStateSchema>;
//#endregion
export { HostedRootContextErrorCodeSchema as $, getProjectWatcher as $a, terminateChildProcessTree as $i, DashboardTrendsProjection as $n, OpenSpecAdapter as $o, RuntimeRootInvalidationRegistry as $r, RunWorkflowContextV2 as $t, buildBackendHealthPayload as A, ObservationEnvironmentRoot as Aa, createPhysicalReactiveDirectory as Ai, ExportReferencePolicy as An, createStaticSpecCatalogOwnedProjection as Ao, applyAgentDeliveryPolicy as Ar, EnvUri as At, HOSTED_STORE_ADVERTISED_CAPABILITIES as B, getWatcherRuntimeStatus as Ba, RuntimePackageInstallCommand as Bi, DashboardGitSnapshot as Bn, FILE_PREVIEW_KINDS as Bo, AIToolOption as Br, DocumentConsumerV1 as Bt, generateAccessGateCredential as C, reactiveStat as Ca, RuntimeInvalidationReader as Ci, GitRepositoryScopeDescriptor as Cn, SpecIdentity as Co, AgentDeliveryModeSchema as Cr, HostedStoreListProjectionStateSchema as Ct, HostedShellTheme as D, ReactiveState as Da, PhysicalReactiveFileWrite as Di, GitWorktreeSummary as Dn, StaticSpecCatalogReferenceProjection as Do, AgentDeliveryProfile as Dr, HostedTrpcResultEnvelopeSchema as Dt, BackendHealthPayloadInput as E, ReactiveContextStreamObserver as Ea, PhysicalReactiveFileCompareWriteResult as Ei, GitWorktreeOverview as En, StaticSpecCatalogOwnedProjection as Eo, AgentDeliveryPolicyUpdateSchema as Er, HostedTrpcDecodeResult as Et, isSupportedEmbeddedUiUrl as F, WatcherRuntimeStatus as Fa, writePhysicalReactiveFile as Fi, DASHBOARD_METRIC_KEYS as Fn, mergeSpecCatalog as Fo, getAvailableTools as Fr, StoreMutationResult as Ft, HostedBackendHealthResponseSchema as G, ProjectResidencyStatus as Ga, detectRuntimePackageManager as Gi, DashboardOverview as Gn, isTextLikeFile as Go, AgentCommandInvocationStyle as Gr, HookLifecycleV1 as Gt, HOSTED_STORE_CONTENT_CAPABILITY as H, subscribeWatcherRuntimeStatus as Ha, RuntimePackageManagerResolution as Hi, DashboardGitUncommittedEntry as Hn, inferFileMime as Ho, AgentCommandArtifact as Hr, DocumentRefV1 as Ht, normalizeEmbeddedUiUrl as I, acquireWatcher as Ia, OPENSPEC_SPAWN_MODE_ENV as Ii, DashboardCardAvailability as In, specDocumentDisplayPath as Io, getConfiguredTools as Ir, StoreMutationStatus as It, HostedCliDiagnostic as J, ProjectWatcherRuntimeStatus as Ja, spawnSafe as Ji, DashboardSummaryProjection as Jn, ChangeProjectionBatch as Jo, AgentDeliveryMigration as Jr, OnReadDocumentHookV1 as Jt, HostedBackendRootSummary as K, ProjectWatcher as Ka, resolveRuntimePackageInstallStrategy as Ki, DashboardOverviewSchema as Kn, isTextLikeMime as Ko, AgentCommandSurfaceCapability as Kr, OPENSPECUI_DOCUMENT_HOOK_VERSION as Kt, normalizeHostedAppBaseUrl as L, acquireWatcherRoot as La, OpenSpecSpawnMode as Li, DashboardGitCommitEntry as Ln, specIdentityFromRoute as Lo, getDetectedProjectTools as Lr, asEnvUri as Lt, buildHostedLaunchUrl as M, ReactiveObservationEnvironment as Ma, replaceFileAtomically as Mi, ExportRootSource as Mn, createStaticSpecCatalogReferenceSource as Mo, getAllToolIds as Mr, StoreCapabilitySet as Mt, isBackendHealthRuntimeMetadata as N, WatcherRootRelease as Na, runPhysicalReactivePathMutation as Ni, ExportSnapshot as Nn, getSpecCatalogEntry as No, getAllTools as Nr, StoreMutation as Nt, OFFICIAL_APP_BASE_URL as O, ReactiveStateOptions as Oa, PhysicalReactivePathTarget as Oi, StaticGitRepositoryScopeDescriptor as On, StaticSpecCatalogReferenceSource as Oo, AgentDeliveryProfileSchema as Or, OPENSPECUI_RUNTIME_CAPABILITIES as Ot, isHostedBackendHealthResponse as P, WatcherRootRuntimeStatus as Pa, writeAtomicPhysicalReactiveFile as Pi, StaticSchemasCaptureFailure as Pn, isReferencedSpecIdentity as Po, getAvailableToolIds as Pr, StoreMutationKind as Pt, HostedRootContextErrorCode as Q, closeAllProjectWatchers as Qa, resolveWindowsCommandInvocation as Qi, DashboardTrendPoint as Qn, ChangeMeta as Qo, RuntimeRootInvalidationOwner as Qr, ReadDocumentResultV1 as Qt, resolveHostedAppBaseUrl as R, closeAllWatchers as Ra, resolveOpenSpecSpawnMode as Ri, DashboardGitDiffStats as Rn, specIdentityKey as Ro, getToolById as Rr, hasCapability as Rt, constantTimeEqual as S, reactiveReadFile as Sa, RuntimeInvalidationListener as Si, GitRepositoryScope as Sn, SpecDocumentProjectionSchema as So, AgentDeliveryMode as Sr, HostedStoreListProjectionState as St, ACCESS_GATE_CREDENTIAL_FRAGMENT_PARAM as T, ReactiveContext as Ta, PhysicalReactiveFileCompareWrite as Ti, GitWorktreeHandoff as Tn, StaticReferencedSpecDocumentProjection as To, AgentDeliveryPolicyUpdate as Tr, HostedStoreMutationStartResponseSchema as Tt, HostedBackendContractError as U, PathCallback as Ua, RuntimePackageManagerSource as Ui, DashboardGitWorktree as Un, inferFilePreviewKind as Uo, AgentCommandContentFormat as Ur, HookDiagnosticLevel as Ut, HOSTED_STORE_CAPABILITIES as V, isWatcherPoolInitialized as Va, RuntimePackageInstallStrategy as Vi, DashboardGitSnapshotSchema as Vn, FilePreviewKind as Vo, AI_TOOLS as Vr, DocumentReadModeV1 as Vt, HostedBackendHealthResponse as W, ProjectResidencyEvictionReason as Wa, buildRuntimePackageInstallCommand as Wi, DashboardMetricKey as Wn, isPreviewableFile as Wo, AgentCommandFormat as Wr, HookDiagnosticV1 as Wt, HostedCliProjectionNoticeSchema as X, WatchEvent as Xa, CommandInvocationOptions as Xi, DashboardTrendKind as Xn, ChangeProjectionRowError as Xo, selectAgentDeliveryRegistry as Xr, OpenSpecUIHooks as Xt, HostedCliProjectionNotice as Y, ProjectWatcherRuntimeStatusListener as Ya, CommandInvocation as Yi, DashboardSummaryProjectionSchema as Yn, ChangeProjectionData as Yo, ToolConfig as Yr, OnRunWorkflowHookV2 as Yt, HostedRootContext as Z, WatchEventType as Za, resolveCommandInvocation as Zi, DashboardTrendMeta as Zn, ArchiveMeta as Zo, RuntimeInvalidationRoot as Zr, ReadDocumentContextV1 as Zt, ProjectRecoveryStatus as _, createFileChangeObservable as _a, OpenSpecDataHomeObserverOptions as _i, GitEntryShell as _n, SpecCatalogReferenceSource as _o, resolveGlobalSkillsInventoryDir as _r, HostedStoreDoctorEnvelopeSchema as _t, DashboardSummaryInvalidationCauseSchema as a, OpenSpecUIGlobalSettingsSchema as aa, EnvironmentGlobalProjectionDataSchema as ai, WorkflowInvocationTargetV2 as an, OwnedSpecCatalogEntry as ao, ToolInitIssue as ar, HostedRootContextState as at, accessGateFingerprint as b, reactiveExists as ba, RuntimeInvalidationFacet as bi, GitPatchState as bn, SpecCommandEvidenceSchema as bo, AgentCommandContentResult as br, HostedStoreListEnvelope as bt, DashboardSummaryProjectionStateSchema as c, PersistedOpenSpecUIGlobalSettings as ca, PlanningCliProjectionData as ci, GitEntryCursor as cn, OwnedSpecIdentitySchema as co, ToolInitReadiness as cr, HostedStoreContentChangesEnvelope as ct, requireCanonicalOpenSpecEntityId as d, ServePresentationModeSchema as da, PlanningCliProjectionSelectorSchema as di, GitEntryFilePatch as dn, ReferencedSpecIdentity as do, ToolSkillsScope as dr, HostedStoreContentKind as dt, terminateWindowsProcessTreeByIdentity as ea, EnvironmentGlobalFileProjectionData as ei, RunWorkflowInputV1 as en, CliShowSpecDocument as eo, DashboardTrendsProjectionSchema as er, SpecMeta as es, HostedRootContextProjectionState as et, requireCanonicalOpenSpecSpecId as f, getDefaultGlobalSettingsPath as fa, PlanningCliProjectionState as fi, GitEntryFileSource as fn, ReferencedSpecIdentitySchema as fo, ToolWorkflowId as fr, HostedStoreContentKindSchema as ft, snapshotHasAbsolutePath as g, OpenSpecWatcher as ga, OpenSpecDataHomeObserver as gi, GitEntrySelector as gn, SpecCatalogReferenceProjection as go, getToolInitStates as gr, HostedStoreDoctorEnvelope as gt, redactSnapshotForPublication as h, FileChangeType as ha, OpenSpecDataHomeObservationState as hi, GitEntryPatch as hn, SpecCatalogOwnedProjection as ho, getExternalCodexCommandObservationRoot as hr, HostedStoreContentSpecsProjectionStateSchema as ht, DashboardSummaryInvalidationCause as i, OpenSpecUIGlobalSettings as ia, EnvironmentGlobalProjectionData as ii, WorkflowInvocationModeResolutionV1 as in, LiveSpecCatalogReferenceSource as io, ToolInitDelivery as ir, HostedRootContextSchema as it, buildEmbeddedUiLaunchUrl as j, ObservationRootOwner as ja, removePhysicalReactivePath as ji, ExportRootProvenance as jn, createStaticSpecCatalogReferenceProjection as jo, normalizeAgentDeliveryPolicy as jr, StoreCapability as jt, OpenSpecUIRuntimeCapability as k, contextStorage as ka, compareAndWriteAtomicPhysicalReactiveFile as ki, StaticGitRepositoryScopes as kn, buildSpecCatalog as ko, AgentDeliveryWorkflowSchema as kr, decodeHostedTrpcData as kt, OpenSpecEntityIdField as l, SERVE_PRESENTATION_MODES as la, PlanningCliProjectionDataSchema as li, GitEntryDetail as ln, ReferencedSpecCatalogEntry as lo, ToolInitState as lr, HostedStoreContentChangesProjectionState as lt, OpsxKernel as m, FileChangeEvent as ma, OPEN_SPEC_DATA_HOME_OBSERVATION_TARGETS as mi, GitEntryFiles as mn, SpecCatalogEntry as mo, getExternalAgentSkillsObservationRoots as mr, HostedStoreContentSpecsProjectionState as mt, DashboardSummaryIdentitySchema as n, DocumentTranslationGlobalSettingsUpdateSchema as na, EnvironmentGlobalFileProjectionState as ni, WorkflowActionEvidenceV2 as nn, LiveSpecCatalogOwnedProjection as no, PINNED_AGENT_GENERATOR_VERSION as nr, ValidationResult as ns, HostedRootContextResolvedState as nt, DashboardSummaryInvalidationSchema as o, OpenSpecUIGlobalSettingsUpdate as oa, EnvironmentGlobalProjectionState as oi, WorkflowRequestedModeV1 as on, OwnedSpecDocumentProjection as oo, ToolInitMigrationState as or, HostedRootContextStateSchema as ot, requireOpenSpecEntityRelativePath as p, toPersistedGlobalSettings as pa, PlanningCliProjectionStateSchema as pi, GitEntryFileSummary as pn, SpecCatalog as po, createToolInitStateProjection as pr, HostedStoreContentSpecsEnvelope as pt, HostedBackendRootSummarySchema as q, ProjectWatcherReinitializeReason as qa, SafeSpawnResult as qi, DashboardSummary as qn, MarkdownParser as qo, AgentDeliveryCleanup as qr, OPENSPECUI_WORKFLOW_HOOK_VERSION as qt, DashboardSummaryInvalidation as r, GlobalSettingsManager as ra, EnvironmentGlobalFileProjectionStateSchema as ri, WorkflowActionV1 as rn, LiveSpecCatalogReferenceProjection as ro, ToolInitCleanupState as rr, Validator as rs, HostedRootContextResolvedStateSchema as rt, DashboardSummaryProjectionState as s, OpenSpecUIGlobalSettingsUpdateSchema as sa, EnvironmentGlobalProjectionStateSchema as si, GitEntriesPage as sn, OwnedSpecIdentity as so, ToolInitProjectionOptions as sr, HostedRootSource as st, DashboardSummaryIdentity as t, DEFAULT_GLOBAL_SETTINGS as ta, EnvironmentGlobalFileProjectionDataSchema as ti, RunWorkflowResultV2 as tn, LiveReferencedSpecDocumentProjection as to, DashboardTriColorTrendPoint as tr, ValidationIssue as ts, HostedRootContextProjectionStateSchema as tt, OpenSpecEntityPathField as u, ServePresentationMode as ua, PlanningCliProjectionSelector as ui, GitEntryFileDiff as un, ReferencedSpecDocumentProjection as uo, ToolInitStatus as ur, HostedStoreContentChangesProjectionStateSchema as ut, ACCESS_GATE_CREDENTIAL_BYTES as v, clearCache as va, RUNTIME_INVALIDATION_FACETS as vi, GitFileChangeType as vn, SpecCatalogSchema as vo, resolveToolSkillsScope as vr, HostedStoreDoctorProjectionState as vt, normalizeAccessGatePassword as w, updateReactiveFileCache as wa, RuntimeInvalidationToken as wi, GitRepositoryScopes as wn, SpecIdentitySchema as wo, AgentDeliveryPolicy as wr, HostedStoreMutationStartResponse as wt, computeEnvUri as x, reactiveReadDir as xa, RuntimeInvalidationIndex as xi, GitRepositoryIdentity as xn, SpecDocumentProjection as xo, loadOpenSpecAgentCommandContents as xr, HostedStoreListEnvelopeSchema as xt, AccessGateCredential as y, getCacheSize as ya, RuntimeInvalidationController as yi, GitPatchFile as yn, SpecCommandEvidence as yo, AgentCommandContentCatalog as yr, HostedStoreDoctorProjectionStateSchema as yt, HOSTED_SHELL_PROTOCOL_VERSION as z, getActiveWatcherCount as za, RuntimePackageDependencyField as zi, DashboardGitEntry as zn, specRoutePath as zo, isToolConfigured as zr, isTerminalMutationStatus as zt };