@anthropologies/claudestory 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,769 @@
+import { z } from 'zod';
+
+declare const TicketSchema: z.ZodObject<{
+    id: z.ZodString;
+    title: z.ZodString;
+    description: z.ZodString;
+    type: z.ZodEnum<["task", "feature", "chore"]>;
+    status: z.ZodEnum<["open", "inprogress", "complete"]>;
+    phase: z.ZodNullable<z.ZodString>;
+    order: z.ZodNumber;
+    createdDate: z.ZodEffects<z.ZodString, string, string>;
+    completedDate: z.ZodNullable<z.ZodEffects<z.ZodString, string, string>>;
+    blockedBy: z.ZodArray<z.ZodString, "many">;
+    parentTicket: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    createdBy: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    assignedTo: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    lastModifiedBy: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+    id: z.ZodString;
+    title: z.ZodString;
+    description: z.ZodString;
+    type: z.ZodEnum<["task", "feature", "chore"]>;
+    status: z.ZodEnum<["open", "inprogress", "complete"]>;
+    phase: z.ZodNullable<z.ZodString>;
+    order: z.ZodNumber;
+    createdDate: z.ZodEffects<z.ZodString, string, string>;
+    completedDate: z.ZodNullable<z.ZodEffects<z.ZodString, string, string>>;
+    blockedBy: z.ZodArray<z.ZodString, "many">;
+    parentTicket: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    createdBy: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    assignedTo: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    lastModifiedBy: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+    id: z.ZodString;
+    title: z.ZodString;
+    description: z.ZodString;
+    type: z.ZodEnum<["task", "feature", "chore"]>;
+    status: z.ZodEnum<["open", "inprogress", "complete"]>;
+    phase: z.ZodNullable<z.ZodString>;
+    order: z.ZodNumber;
+    createdDate: z.ZodEffects<z.ZodString, string, string>;
+    completedDate: z.ZodNullable<z.ZodEffects<z.ZodString, string, string>>;
+    blockedBy: z.ZodArray<z.ZodString, "many">;
+    parentTicket: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    createdBy: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    assignedTo: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    lastModifiedBy: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+}, z.ZodTypeAny, "passthrough">>;
+type Ticket = z.infer<typeof TicketSchema>;
+
+declare const IssueSchema: z.ZodObject<{
+    id: z.ZodString;
+    title: z.ZodString;
+    status: z.ZodEnum<["open", "inprogress", "resolved"]>;
+    severity: z.ZodEnum<["critical", "high", "medium", "low"]>;
+    components: z.ZodArray<z.ZodString, "many">;
+    impact: z.ZodString;
+    resolution: z.ZodNullable<z.ZodString>;
+    location: z.ZodArray<z.ZodString, "many">;
+    discoveredDate: z.ZodEffects<z.ZodString, string, string>;
+    resolvedDate: z.ZodNullable<z.ZodEffects<z.ZodString, string, string>>;
+    relatedTickets: z.ZodArray<z.ZodString, "many">;
+    order: z.ZodOptional<z.ZodNumber>;
+    phase: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    createdBy: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    assignedTo: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    lastModifiedBy: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+    id: z.ZodString;
+    title: z.ZodString;
+    status: z.ZodEnum<["open", "inprogress", "resolved"]>;
+    severity: z.ZodEnum<["critical", "high", "medium", "low"]>;
+    components: z.ZodArray<z.ZodString, "many">;
+    impact: z.ZodString;
+    resolution: z.ZodNullable<z.ZodString>;
+    location: z.ZodArray<z.ZodString, "many">;
+    discoveredDate: z.ZodEffects<z.ZodString, string, string>;
+    resolvedDate: z.ZodNullable<z.ZodEffects<z.ZodString, string, string>>;
+    relatedTickets: z.ZodArray<z.ZodString, "many">;
+    order: z.ZodOptional<z.ZodNumber>;
+    phase: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    createdBy: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    assignedTo: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    lastModifiedBy: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+    id: z.ZodString;
+    title: z.ZodString;
+    status: z.ZodEnum<["open", "inprogress", "resolved"]>;
+    severity: z.ZodEnum<["critical", "high", "medium", "low"]>;
+    components: z.ZodArray<z.ZodString, "many">;
+    impact: z.ZodString;
+    resolution: z.ZodNullable<z.ZodString>;
+    location: z.ZodArray<z.ZodString, "many">;
+    discoveredDate: z.ZodEffects<z.ZodString, string, string>;
+    resolvedDate: z.ZodNullable<z.ZodEffects<z.ZodString, string, string>>;
+    relatedTickets: z.ZodArray<z.ZodString, "many">;
+    order: z.ZodOptional<z.ZodNumber>;
+    phase: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    createdBy: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    assignedTo: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    lastModifiedBy: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+}, z.ZodTypeAny, "passthrough">>;
+type Issue = z.infer<typeof IssueSchema>;
+
+declare const BlockerSchema: z.ZodObject<{
+    name: z.ZodString;
+    cleared: z.ZodOptional<z.ZodBoolean>;
+    createdDate: z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>;
+    clearedDate: z.ZodOptional<z.ZodNullable<z.ZodEffects<z.ZodString, string, string>>>;
+    note: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+    name: z.ZodString;
+    cleared: z.ZodOptional<z.ZodBoolean>;
+    createdDate: z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>;
+    clearedDate: z.ZodOptional<z.ZodNullable<z.ZodEffects<z.ZodString, string, string>>>;
+    note: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+    name: z.ZodString;
+    cleared: z.ZodOptional<z.ZodBoolean>;
+    createdDate: z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>;
+    clearedDate: z.ZodOptional<z.ZodNullable<z.ZodEffects<z.ZodString, string, string>>>;
+    note: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+}, z.ZodTypeAny, "passthrough">>;
+type Blocker = z.infer<typeof BlockerSchema>;
+declare const PhaseSchema: z.ZodObject<{
+    id: z.ZodString;
+    label: z.ZodString;
+    name: z.ZodString;
+    description: z.ZodString;
+    summary: z.ZodOptional<z.ZodString>;
+}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+    id: z.ZodString;
+    label: z.ZodString;
+    name: z.ZodString;
+    description: z.ZodString;
+    summary: z.ZodOptional<z.ZodString>;
+}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+    id: z.ZodString;
+    label: z.ZodString;
+    name: z.ZodString;
+    description: z.ZodString;
+    summary: z.ZodOptional<z.ZodString>;
+}, z.ZodTypeAny, "passthrough">>;
+type Phase = z.infer<typeof PhaseSchema>;
+declare const RoadmapSchema: z.ZodObject<{
+    title: z.ZodString;
+    date: z.ZodEffects<z.ZodString, string, string>;
+    phases: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        label: z.ZodString;
+        name: z.ZodString;
+        description: z.ZodString;
+        summary: z.ZodOptional<z.ZodString>;
+    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+        id: z.ZodString;
+        label: z.ZodString;
+        name: z.ZodString;
+        description: z.ZodString;
+        summary: z.ZodOptional<z.ZodString>;
+    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+        id: z.ZodString;
+        label: z.ZodString;
+        name: z.ZodString;
+        description: z.ZodString;
+        summary: z.ZodOptional<z.ZodString>;
+    }, z.ZodTypeAny, "passthrough">>, "many">;
+    blockers: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        cleared: z.ZodOptional<z.ZodBoolean>;
+        createdDate: z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>;
+        clearedDate: z.ZodOptional<z.ZodNullable<z.ZodEffects<z.ZodString, string, string>>>;
+        note: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+        name: z.ZodString;
+        cleared: z.ZodOptional<z.ZodBoolean>;
+        createdDate: z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>;
+        clearedDate: z.ZodOptional<z.ZodNullable<z.ZodEffects<z.ZodString, string, string>>>;
+        note: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+        name: z.ZodString;
+        cleared: z.ZodOptional<z.ZodBoolean>;
+        createdDate: z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>;
+        clearedDate: z.ZodOptional<z.ZodNullable<z.ZodEffects<z.ZodString, string, string>>>;
+        note: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    }, z.ZodTypeAny, "passthrough">>, "many">;
+}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+    title: z.ZodString;
+    date: z.ZodEffects<z.ZodString, string, string>;
+    phases: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        label: z.ZodString;
+        name: z.ZodString;
+        description: z.ZodString;
+        summary: z.ZodOptional<z.ZodString>;
+    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+        id: z.ZodString;
+        label: z.ZodString;
+        name: z.ZodString;
+        description: z.ZodString;
+        summary: z.ZodOptional<z.ZodString>;
+    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+        id: z.ZodString;
+        label: z.ZodString;
+        name: z.ZodString;
+        description: z.ZodString;
+        summary: z.ZodOptional<z.ZodString>;
+    }, z.ZodTypeAny, "passthrough">>, "many">;
+    blockers: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        cleared: z.ZodOptional<z.ZodBoolean>;
+        createdDate: z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>;
+        clearedDate: z.ZodOptional<z.ZodNullable<z.ZodEffects<z.ZodString, string, string>>>;
+        note: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+        name: z.ZodString;
+        cleared: z.ZodOptional<z.ZodBoolean>;
+        createdDate: z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>;
+        clearedDate: z.ZodOptional<z.ZodNullable<z.ZodEffects<z.ZodString, string, string>>>;
+        note: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+        name: z.ZodString;
+        cleared: z.ZodOptional<z.ZodBoolean>;
+        createdDate: z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>;
+        clearedDate: z.ZodOptional<z.ZodNullable<z.ZodEffects<z.ZodString, string, string>>>;
+        note: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    }, z.ZodTypeAny, "passthrough">>, "many">;
+}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+    title: z.ZodString;
+    date: z.ZodEffects<z.ZodString, string, string>;
+    phases: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        label: z.ZodString;
+        name: z.ZodString;
+        description: z.ZodString;
+        summary: z.ZodOptional<z.ZodString>;
+    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+        id: z.ZodString;
+        label: z.ZodString;
+        name: z.ZodString;
+        description: z.ZodString;
+        summary: z.ZodOptional<z.ZodString>;
+    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+        id: z.ZodString;
+        label: z.ZodString;
+        name: z.ZodString;
+        description: z.ZodString;
+        summary: z.ZodOptional<z.ZodString>;
+    }, z.ZodTypeAny, "passthrough">>, "many">;
+    blockers: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        cleared: z.ZodOptional<z.ZodBoolean>;
+        createdDate: z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>;
+        clearedDate: z.ZodOptional<z.ZodNullable<z.ZodEffects<z.ZodString, string, string>>>;
+        note: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+        name: z.ZodString;
+        cleared: z.ZodOptional<z.ZodBoolean>;
+        createdDate: z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>;
+        clearedDate: z.ZodOptional<z.ZodNullable<z.ZodEffects<z.ZodString, string, string>>>;
+        note: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+        name: z.ZodString;
+        cleared: z.ZodOptional<z.ZodBoolean>;
+        createdDate: z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>;
+        clearedDate: z.ZodOptional<z.ZodNullable<z.ZodEffects<z.ZodString, string, string>>>;
+        note: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    }, z.ZodTypeAny, "passthrough">>, "many">;
+}, z.ZodTypeAny, "passthrough">>;
+type Roadmap = z.infer<typeof RoadmapSchema>;
+
+declare const FeaturesSchema: z.ZodObject<{
+    tickets: z.ZodBoolean;
+    issues: z.ZodBoolean;
+    handovers: z.ZodBoolean;
+    roadmap: z.ZodBoolean;
+    reviews: z.ZodBoolean;
+}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+    tickets: z.ZodBoolean;
+    issues: z.ZodBoolean;
+    handovers: z.ZodBoolean;
+    roadmap: z.ZodBoolean;
+    reviews: z.ZodBoolean;
+}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+    tickets: z.ZodBoolean;
+    issues: z.ZodBoolean;
+    handovers: z.ZodBoolean;
+    roadmap: z.ZodBoolean;
+    reviews: z.ZodBoolean;
+}, z.ZodTypeAny, "passthrough">>;
+type Features = z.infer<typeof FeaturesSchema>;
+declare const ConfigSchema: z.ZodObject<{
+    version: z.ZodNumber;
+    schemaVersion: z.ZodOptional<z.ZodNumber>;
+    project: z.ZodString;
+    type: z.ZodString;
+    language: z.ZodString;
+    features: z.ZodObject<{
+        tickets: z.ZodBoolean;
+        issues: z.ZodBoolean;
+        handovers: z.ZodBoolean;
+        roadmap: z.ZodBoolean;
+        reviews: z.ZodBoolean;
+    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+        tickets: z.ZodBoolean;
+        issues: z.ZodBoolean;
+        handovers: z.ZodBoolean;
+        roadmap: z.ZodBoolean;
+        reviews: z.ZodBoolean;
+    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+        tickets: z.ZodBoolean;
+        issues: z.ZodBoolean;
+        handovers: z.ZodBoolean;
+        roadmap: z.ZodBoolean;
+        reviews: z.ZodBoolean;
+    }, z.ZodTypeAny, "passthrough">>;
+}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+    version: z.ZodNumber;
+    schemaVersion: z.ZodOptional<z.ZodNumber>;
+    project: z.ZodString;
+    type: z.ZodString;
+    language: z.ZodString;
+    features: z.ZodObject<{
+        tickets: z.ZodBoolean;
+        issues: z.ZodBoolean;
+        handovers: z.ZodBoolean;
+        roadmap: z.ZodBoolean;
+        reviews: z.ZodBoolean;
+    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+        tickets: z.ZodBoolean;
+        issues: z.ZodBoolean;
+        handovers: z.ZodBoolean;
+        roadmap: z.ZodBoolean;
+        reviews: z.ZodBoolean;
+    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+        tickets: z.ZodBoolean;
+        issues: z.ZodBoolean;
+        handovers: z.ZodBoolean;
+        roadmap: z.ZodBoolean;
+        reviews: z.ZodBoolean;
+    }, z.ZodTypeAny, "passthrough">>;
+}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+    version: z.ZodNumber;
+    schemaVersion: z.ZodOptional<z.ZodNumber>;
+    project: z.ZodString;
+    type: z.ZodString;
+    language: z.ZodString;
+    features: z.ZodObject<{
+        tickets: z.ZodBoolean;
+        issues: z.ZodBoolean;
+        handovers: z.ZodBoolean;
+        roadmap: z.ZodBoolean;
+        reviews: z.ZodBoolean;
+    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+        tickets: z.ZodBoolean;
+        issues: z.ZodBoolean;
+        handovers: z.ZodBoolean;
+        roadmap: z.ZodBoolean;
+        reviews: z.ZodBoolean;
+    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+        tickets: z.ZodBoolean;
+        issues: z.ZodBoolean;
+        handovers: z.ZodBoolean;
+        roadmap: z.ZodBoolean;
+        reviews: z.ZodBoolean;
+    }, z.ZodTypeAny, "passthrough">>;
+}, z.ZodTypeAny, "passthrough">>;
+type Config = z.infer<typeof ConfigSchema>;
+
+/** Matches T-001, T-077a, T-079b */
+declare const TICKET_ID_REGEX: RegExp;
+/** Matches ISS-001, ISS-009 */
+declare const ISSUE_ID_REGEX: RegExp;
+declare const TICKET_STATUSES: readonly ["open", "inprogress", "complete"];
+type TicketStatus = (typeof TICKET_STATUSES)[number];
+declare const TICKET_TYPES: readonly ["task", "feature", "chore"];
+type TicketType = (typeof TICKET_TYPES)[number];
+declare const ISSUE_STATUSES: readonly ["open", "inprogress", "resolved"];
+type IssueStatus = (typeof ISSUE_STATUSES)[number];
+declare const ISSUE_SEVERITIES: readonly ["critical", "high", "medium", "low"];
+type IssueSeverity = (typeof ISSUE_SEVERITIES)[number];
+declare const OUTPUT_FORMATS: readonly ["json", "md"];
+type OutputFormat = (typeof OUTPUT_FORMATS)[number];
+declare const ERROR_CODES: readonly ["not_found", "validation_failed", "io_error", "project_corrupt", "invalid_input", "conflict", "version_mismatch"];
+type ErrorCode = (typeof ERROR_CODES)[number];
+declare const DATE_REGEX: RegExp;
+declare const DateSchema: z.ZodEffects<z.ZodString, string, string>;
+declare const TicketIdSchema: z.ZodString;
+declare const IssueIdSchema: z.ZodString;
+
+type PhaseStatus = "notstarted" | "inprogress" | "complete";
+/**
+ * Pure derived-data container. All derivation happens eagerly in the constructor.
+ * Direct port of Swift `ProjectState` — same 7-step pipeline, same query semantics.
+ */
+declare class ProjectState {
+    readonly tickets: readonly Ticket[];
+    readonly issues: readonly Issue[];
+    readonly roadmap: Readonly<Roadmap>;
+    readonly config: Readonly<Config>;
+    readonly handoverFilenames: readonly string[];
+    readonly umbrellaIDs: ReadonlySet<string>;
+    readonly leafTickets: readonly Ticket[];
+    private readonly leafTicketsByPhase;
+    private readonly childrenByParent;
+    private readonly reverseBlocksMap;
+    private readonly ticketsByID;
+    private readonly issuesByID;
+    readonly totalTicketCount: number;
+    readonly openTicketCount: number;
+    readonly completeTicketCount: number;
+    readonly openIssueCount: number;
+    readonly issuesBySeverity: ReadonlyMap<IssueSeverity, number>;
+    constructor(input: {
+        tickets: Ticket[];
+        issues: Issue[];
+        roadmap: Roadmap;
+        config: Config;
+        handoverFilenames: string[];
+    });
+    isUmbrella(ticket: Ticket): boolean;
+    phaseTickets(phaseId: string | null): readonly Ticket[];
+    /** Phase status derived from leaf tickets only. Umbrella stored status is ignored. */
+    phaseStatus(phaseId: string | null): PhaseStatus;
+    umbrellaChildren(ticketId: string): readonly Ticket[];
+    /** Umbrella status derived from descendant leaf tickets (recursive traversal). */
+    umbrellaStatus(ticketId: string): PhaseStatus;
+    reverseBlocks(ticketId: string): readonly Ticket[];
+    /**
+     * A ticket is blocked if any blockedBy reference points to a non-complete ticket.
+     * Unknown blocker IDs treated as blocked (conservative — unknown dependency = assume not cleared).
+     */
+    isBlocked(ticket: Ticket): boolean;
+    get blockedCount(): number;
+    ticketByID(id: string): Ticket | undefined;
+    issueByID(id: string): Issue | undefined;
+    /** IDs of tickets that list `ticketId` in their blockedBy. */
+    ticketsBlocking(ticketId: string): string[];
+    /** IDs of tickets that have `ticketId` as their parentTicket. */
+    childrenOf(ticketId: string): string[];
+    /** IDs of issues that reference `ticketId` in relatedTickets. */
+    issuesReferencing(ticketId: string): string[];
+    /**
+     * Recursively collects all descendant leaf tickets of an umbrella.
+     * Uses a visited set to guard against cycles in malformed data.
+     */
+    private descendantLeaves;
+    /**
+     * Shared aggregation logic for phase and umbrella status.
+     * - all complete → complete
+     * - any inprogress OR any complete (but not all) → inprogress
+     * - else → notstarted (nothing started)
+     */
+    private static aggregateStatus;
+}
+
+/** Schema version this loader understands. Config.schemaVersion > this → version_mismatch. */
+declare const CURRENT_SCHEMA_VERSION = 1;
+declare class ProjectLoaderError extends Error {
+    readonly code: ErrorCode;
+    readonly cause?: unknown | undefined;
+    readonly name = "ProjectLoaderError";
+    constructor(code: ErrorCode, message: string, cause?: unknown | undefined);
+}
+type LoadWarningType = "parse_error" | "schema_error" | "duplicate_id" | "naming_convention";
+/** Integrity warnings fail strict mode. Cosmetic warnings are collected but never block. */
+declare const INTEGRITY_WARNING_TYPES: readonly LoadWarningType[];
+interface LoadWarning {
+    readonly file: string;
+    readonly message: string;
+    readonly type: LoadWarningType;
+}
+
+interface LoadOptions {
+    /** In strict mode, integrity warnings become thrown errors. Default: false */
+    strict?: boolean;
+    /** Maximum schemaVersion this loader supports. Default: CURRENT_SCHEMA_VERSION */
+    maxSchemaVersion?: number;
+}
+interface LoadResult {
+    readonly state: ProjectState;
+    readonly warnings: readonly LoadWarning[];
+}
+/**
+ * Loads all .story/ data and assembles a ProjectState.
+ * Critical files (config, roadmap) throw on failure.
+ * Best-effort files (tickets, issues) skip corrupt entries with warnings.
+ */
+declare function loadProject(root: string, options?: LoadOptions): Promise<LoadResult>;
+/**
+ * Writes a ticket file WITHOUT acquiring the project lock.
+ * Use inside withProjectLock when the lock is already held.
+ * Performs Zod parse + guardPath + atomicWrite.
+ */
+declare function writeTicketUnlocked(ticket: Ticket, root: string): Promise<void>;
+declare function writeTicket(ticket: Ticket, root: string): Promise<void>;
+/**
+ * Writes an issue file WITHOUT acquiring the project lock.
+ * Use inside withProjectLock when the lock is already held.
+ */
+declare function writeIssueUnlocked(issue: Issue, root: string): Promise<void>;
+declare function writeIssue(issue: Issue, root: string): Promise<void>;
+/**
+ * Writes a roadmap file WITHOUT acquiring the project lock.
+ * Use inside withProjectLock when the lock is already held.
+ * Performs Zod parse + guardPath + atomicWrite.
+ */
+declare function writeRoadmapUnlocked(roadmap: Roadmap, root: string): Promise<void>;
+declare function writeRoadmap(roadmap: Roadmap, root: string): Promise<void>;
+declare function writeConfig(config: Config, root: string): Promise<void>;
+/**
+ * Deletes a ticket file with referential integrity checks.
+ * Acquires lock, reloads fresh state from disk, checks all references.
+ * With force: true, skips integrity checks and state reload.
+ */
+declare function deleteTicket(id: string, root: string, options?: {
+    force?: boolean;
+}): Promise<void>;
+declare function deleteIssue(id: string, root: string): Promise<void>;
+interface WithProjectLockOptions {
+    strict?: boolean;
+}
+/**
+ * Acquires the project lock, loads fresh state, optionally enforces strict mode,
+ * then calls the handler. Released in finally.
+ * Use for create/update operations that need atomic load→validate→write.
+ */
+declare function withProjectLock(root: string, options: WithProjectLockOptions, handler: (result: LoadResult) => Promise<void>): Promise<void>;
+/**
+ * Executes multiple file operations atomically with a transaction journal.
+ * Forward-only recovery: if any rename succeeds, complete remaining.
+ * Does NOT acquire the lock — caller must hold it.
+ *
+ * The journal persists a `commitStarted` flag so recovery can distinguish
+ * "prepared" (safe to roll back) from "committing" (must complete forward).
+ */
+declare function runTransactionUnlocked(root: string, operations: Array<{
+    op: "write";
+    target: string;
+    content: string;
+} | {
+    op: "delete";
+    target: string;
+}>): Promise<void>;
+/**
+ * Executes multiple file operations atomically with a transaction journal.
+ * Acquires the project lock, then delegates to runTransactionUnlocked.
+ */
+declare function runTransaction(root: string, operations: Array<{
+    op: "write";
+    target: string;
+    content: string;
+} | {
+    op: "delete";
+    target: string;
+}>): Promise<void>;
+/** Deep-sorts object keys recursively for deterministic JSON output. */
+declare function sortKeysDeep(value: unknown): unknown;
+/** Serializes to pretty-printed JSON with deep-sorted keys. */
+declare function serializeJSON(obj: unknown): string;
+
+/**
+ * Discovers the project root by walking up from `startDir` (default: cwd)
+ * looking for `.story/config.json`.
+ *
+ * CLAUDESTORY_PROJECT_ROOT env var overrides walk-up discovery.
+ * Returns the canonical absolute path, or null if not found.
+ */
+declare function discoverProjectRoot(startDir?: string): string | null;
+
+/**
+ * Lists handover markdown files, sorted by date (newest first).
+ * Non-conforming filenames (no YYYY-MM-DD prefix) are appended at end
+ * and flagged as naming_convention warnings.
+ */
+declare function listHandovers(handoversDir: string, root: string, warnings: LoadWarning[]): Promise<string[]>;
+/** Reads the content of a handover markdown file. */
+declare function readHandover(handoversDir: string, filename: string): Promise<string>;
+/**
+ * Extracts the YYYY-MM-DD date prefix from a handover filename.
+ * Returns the date string or null if the filename does not conform.
+ */
+declare function extractHandoverDate(filename: string): string | null;
+
+interface UmbrellaProgress {
+    readonly total: number;
+    readonly complete: number;
+    readonly status: PhaseStatus;
+}
+interface UnblockImpact {
+    readonly ticketId: string;
+    readonly wouldUnblock: readonly Ticket[];
+}
+interface NextTicketResult {
+    readonly kind: "found";
+    readonly ticket: Ticket;
+    readonly unblockImpact: UnblockImpact;
+    readonly umbrellaProgress: UmbrellaProgress | null;
+}
+interface NextTicketAllComplete {
+    readonly kind: "all_complete";
+}
+interface NextTicketAllBlocked {
+    readonly kind: "all_blocked";
+    readonly phaseId: string;
+    readonly blockedCount: number;
+}
+interface NextTicketEmpty {
+    readonly kind: "empty_project";
+}
+type NextTicketOutcome = NextTicketResult | NextTicketAllComplete | NextTicketAllBlocked | NextTicketEmpty;
+interface PhaseWithStatus {
+    readonly phase: Phase;
+    readonly status: PhaseStatus;
+    readonly leafCount: number;
+}
+/**
+ * First non-complete, unblocked leaf ticket in the first non-complete phase
+ * (roadmap order). Skips phases with zero leaf tickets.
+ * Returns discriminated outcome for exhaustive handling.
+ */
+declare function nextTicket(state: ProjectState): NextTicketOutcome;
+/**
+ * All currently blocked incomplete leaf tickets.
+ */
+declare function blockedTickets(state: ProjectState): readonly Ticket[];
+/**
+ * Tickets that would become unblocked if ticketId were completed.
+ * Direct unblocking only — no transitive chains.
+ */
+declare function ticketsUnblockedBy(ticketId: string, state: ProjectState): readonly Ticket[];
+/**
+ * Progress of an umbrella's descendant leaves.
+ * Returns null if ticketId is not an umbrella.
+ */
+declare function umbrellaProgress(ticketId: string, state: ProjectState): UmbrellaProgress | null;
+/**
+ * First phase in roadmap order that is not complete and has leaf tickets.
+ */
+declare function currentPhase(state: ProjectState): Phase | null;
+/**
+ * All roadmap phases with their derived status and leaf count.
+ */
+declare function phasesWithStatus(state: ProjectState): readonly PhaseWithStatus[];
+/**
+ * Normalizes blocker cleared state across legacy and new formats.
+ * Legacy: cleared boolean. New: clearedDate non-null.
+ */
+declare function isBlockerCleared(blocker: Blocker): boolean;
+
+/**
+ * Next ticket ID: scan existing IDs, find max numeric part, return T-(max+1).
+ * Zero-padded to 3 digits minimum. Handles suffixed IDs (T-077a → numeric 77).
+ * Malformed IDs (not matching TICKET_ID_REGEX) are silently skipped.
+ */
+declare function nextTicketID(tickets: readonly Ticket[]): string;
+/**
+ * Next issue ID: scan existing IDs, find max numeric part, return ISS-(max+1).
+ * Zero-padded to 3 digits minimum.
+ */
+declare function nextIssueID(issues: readonly Issue[]): string;
+/**
+ * Next order value for a phase: max leaf ticket order + 10, or 10 if empty.
+ */
+declare function nextOrder(phaseId: string | null, state: ProjectState): number;
+
+type ValidationLevel = "error" | "warning" | "info";
+interface ValidationFinding {
+    readonly level: ValidationLevel;
+    readonly code: string;
+    readonly message: string;
+    readonly entity: string | null;
+}
+interface ValidationResult {
+    readonly valid: boolean;
+    readonly errorCount: number;
+    readonly warningCount: number;
+    readonly infoCount: number;
+    readonly findings: readonly ValidationFinding[];
+}
+/**
+ * Validates a fully loaded ProjectState for reference integrity.
+ * Pure function — no I/O. Returns structured findings, never throws.
+ */
+declare function validateProject(state: ProjectState): ValidationResult;
+/**
+ * Merges LoadResult.warnings into a ValidationResult.
+ * parse_error/schema_error → error level. naming_convention → info level.
+ */
+declare function mergeValidation(result: ValidationResult, loaderWarnings: readonly LoadWarning[]): ValidationResult;
+
+interface InitOptions {
+    name: string;
+    force?: boolean;
+    type?: string;
+    language?: string;
+}
+interface InitResult {
+    readonly root: string;
+    readonly created: readonly string[];
+}
+/**
+ * Scaffolds a new .story/ directory structure.
+ * Refuses if .story/ already exists unless force is true.
+ * Force mode overwrites config.json + roadmap.json only — preserves existing data files.
+ */
+declare function initProject(root: string, options: InitOptions): Promise<InitResult>;
+
+declare const ExitCode: {
+    readonly OK: 0;
+    readonly USER_ERROR: 1;
+    readonly VALIDATION_ERROR: 2;
+    readonly PARTIAL: 3;
+};
+type ExitCodeValue = (typeof ExitCode)[keyof typeof ExitCode];
+interface SuccessEnvelope<T> {
+    readonly version: 1;
+    readonly data: T;
+}
+interface ErrorEnvelope {
+    readonly version: 1;
+    readonly error: {
+        readonly code: ErrorCode;
+        readonly message: string;
+    };
+}
+interface PartialEnvelope<T> {
+    readonly version: 1;
+    readonly data: T;
+    readonly warnings: readonly {
+        type: string;
+        file: string;
+        message: string;
+    }[];
+    readonly partial: true;
+}
+declare function successEnvelope<T>(data: T): SuccessEnvelope<T>;
+declare function errorEnvelope(code: ErrorCode, message: string): ErrorEnvelope;
+declare function partialEnvelope<T>(data: T, warnings: readonly LoadWarning[]): PartialEnvelope<T>;
+/**
+ * Escapes characters that would create Markdown structure in inline text.
+ * Handles heading, list, blockquote, ordered list at line start.
+ * Handles inline structural characters.
+ */
+declare function escapeMarkdownInline(text: string): string;
+/**
+ * Wraps multi-line content in a fenced code block.
+ * Uses a fence length longer than any backtick sequence in the content.
+ */
+declare function fencedBlock(content: string, lang?: string): string;
+declare function formatStatus(state: ProjectState, format: OutputFormat): string;
+declare function formatPhaseList(state: ProjectState, format: OutputFormat): string;
+declare function formatPhaseTickets(phaseId: string, state: ProjectState, format: OutputFormat): string;
+declare function formatTicket(ticket: Ticket, state: ProjectState, format: OutputFormat): string;
+declare function formatNextTicketOutcome(outcome: NextTicketOutcome, state: ProjectState, format: OutputFormat): string;
+declare function formatTicketList(tickets: readonly Ticket[], format: OutputFormat): string;
+declare function formatIssue(issue: Issue, format: OutputFormat): string;
+declare function formatIssueList(issues: readonly Issue[], format: OutputFormat): string;
+declare function formatBlockedTickets(tickets: readonly Ticket[], state: ProjectState, format: OutputFormat): string;
+declare function formatValidation(result: ValidationResult, format: OutputFormat): string;
+declare function formatBlockerList(roadmap: Roadmap, format: OutputFormat): string;
+declare function formatError(code: ErrorCode, message: string, format: OutputFormat): string;
+declare function formatInitResult(result: {
+    root: string;
+    created: readonly string[];
+}, format: OutputFormat): string;
+declare function formatHandoverList(filenames: readonly string[], format: OutputFormat): string;
+declare function formatHandoverContent(filename: string, content: string, format: OutputFormat): string;
+
+export { type Blocker, BlockerSchema, CURRENT_SCHEMA_VERSION, type Config, ConfigSchema, DATE_REGEX, DateSchema, ERROR_CODES, type ErrorCode, type ErrorEnvelope, ExitCode, type ExitCodeValue, type Features, FeaturesSchema, INTEGRITY_WARNING_TYPES, ISSUE_ID_REGEX, ISSUE_SEVERITIES, ISSUE_STATUSES, type InitOptions, type InitResult, type Issue, IssueIdSchema, IssueSchema, type IssueSeverity, type IssueStatus, type LoadOptions, type LoadResult, type LoadWarning, type LoadWarningType, type NextTicketAllBlocked, type NextTicketAllComplete, type NextTicketEmpty, type NextTicketOutcome, type NextTicketResult, OUTPUT_FORMATS, type OutputFormat, type PartialEnvelope, type Phase, PhaseSchema, type PhaseStatus, type PhaseWithStatus, ProjectLoaderError, ProjectState, type Roadmap, RoadmapSchema, type SuccessEnvelope, TICKET_ID_REGEX, TICKET_STATUSES, TICKET_TYPES, type Ticket, TicketIdSchema, TicketSchema, type TicketStatus, type TicketType, type UmbrellaProgress, type UnblockImpact, type ValidationFinding, type ValidationLevel, type ValidationResult, type WithProjectLockOptions, blockedTickets, currentPhase, deleteIssue, deleteTicket, discoverProjectRoot, errorEnvelope, escapeMarkdownInline, extractHandoverDate, fencedBlock, formatBlockedTickets, formatBlockerList, formatError, formatHandoverContent, formatHandoverList, formatInitResult, formatIssue, formatIssueList, formatNextTicketOutcome, formatPhaseList, formatPhaseTickets, formatStatus, formatTicket, formatTicketList, formatValidation, initProject, isBlockerCleared, listHandovers, loadProject, mergeValidation, nextIssueID, nextOrder, nextTicket, nextTicketID, partialEnvelope, phasesWithStatus, readHandover, runTransaction, runTransactionUnlocked, serializeJSON, sortKeysDeep, successEnvelope, ticketsUnblockedBy, umbrellaProgress, validateProject, withProjectLock, writeConfig, writeIssue, writeIssueUnlocked, writeRoadmap, writeRoadmapUnlocked, writeTicket, writeTicketUnlocked };