@reticlehq/server 3.8.0 → 3.8.2

package/dist/language/flows/recording/flake.d.ts

@@ -8,13 +8,7 @@ import { z } from 'zod';
 declare const FlakeRecordSchema: z.ZodObject<{
     runs: z.ZodNumber;
     fails: z.ZodNumber;
-}, "strip", z.ZodTypeAny, {
-    runs: number;
-    fails: number;
-}, {
-    runs: number;
-    fails: number;
-}>;
+}, z.core.$strip>;
 type FlakeRecord = z.infer<typeof FlakeRecordSchema>;
 /** Per-flow map (flow name → record). */
 export type FlakeLedger = Record<string, FlakeRecord>;
@@ -23,26 +17,8 @@ export declare const FlakeFileSchema: z.ZodObject<{
     flows: z.ZodRecord<z.ZodString, z.ZodObject<{
         runs: z.ZodNumber;
         fails: z.ZodNumber;
-    }, "strip", z.ZodTypeAny, {
-        runs: number;
-        fails: number;
-    }, {
-        runs: number;
-        fails: number;
-    }>>;
-}, "strip", z.ZodTypeAny, {
-    flows: Record<string, {
-        runs: number;
-        fails: number;
-    }>;
-    version: 1;
-}, {
-    flows: Record<string, {
-        runs: number;
-        fails: number;
-    }>;
-    version: 1;
-}>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
 export declare function emptyRecord(): FlakeRecord;
 /** Accrue one unchanged-code replay outcome. */
 export declare function recordOutcome(record: FlakeRecord, passed: boolean): FlakeRecord;

package/dist/language/flows/recording/flake.js

@@ -11,7 +11,7 @@ const FlakeRecordSchema = z.object({
 });
 export const FlakeFileSchema = z.object({
     version: z.literal(1),
-    flows: z.record(FlakeRecordSchema),
+    flows: z.record(z.string(), FlakeRecordSchema),
 });
 /** Minimum unchanged-code replays before flakiness can be judged (too few = noise). */
 const DEFAULT_MIN_FLAKE_RUNS = 5;

package/dist/language/flows/stores/assertion-tiers-store.js

@@ -19,7 +19,7 @@ import { withFileLock } from '../../../memory/project/file-lock.js';
  */
 const AssertionTiersFileSchema = z.object({
     version: z.literal(1),
-    flows: z.record(z.object({
+    flows: z.record(z.string(), z.object({
         steps: z.array(z.object({ step: z.number(), expect: z.unknown().optional() })),
         /** Source files this flow covered when it last passed — lets the gate scope DELETION findings to
          * the files that actually changed, instead of flagging every intentionally-removed flow. */

package/dist/machine/git-tracks.js

@@ -21,6 +21,7 @@ export function gitTracks(path) {
         cwd: existingAncestor(path),
         stdio: 'ignore',
         timeout: GIT_TIMEOUT_MS,
+        windowsHide: true,
     });
     const answer = CHECK_IGNORE_NOT_IGNORED === result.status;
     tracked.set(path, answer);

package/dist/memory/cloud/cloud-sync.d.ts

@@ -118,31 +118,9 @@ declare const ServerVerificationSchema: z.ZodObject<{
     flows: z.ZodArray<z.ZodObject<{
         name: z.ZodString;
         status: z.ZodString;
-    }, "strip", z.ZodTypeAny, {
-        status: string;
-        name: string;
-    }, {
-        status: string;
-        name: string;
-    }>, "many">;
+    }, z.core.$strip>>;
     summary: z.ZodString;
-}, "strip", z.ZodTypeAny, {
-    flows: {
-        status: string;
-        name: string;
-    }[];
-    verificationId: string;
-    verdict: string | null;
-    summary: string;
-}, {
-    flows: {
-        status: string;
-        name: string;
-    }[];
-    verificationId: string;
-    verdict: string | null;
-    summary: string;
-}>;
+}, z.core.$strip>;
 export type ServerVerification = z.infer<typeof ServerVerificationSchema>;
 /**
  * Delegate a verification to the hosted runner: submit the preview URL + flow names to `POST

package/dist/memory/intent/intent-shard.d.ts

@@ -43,111 +43,39 @@ export type IntentStatus = (typeof IntentStatus)[keyof typeof IntentStatus];
 declare const IntentRecordSchema: z.ZodObject<{
     id: z.ZodString;
     statement: z.ZodString;
-    state: z.ZodEnum<["declared", "bound", "proved"]>;
+    state: z.ZodEnum<{
+        proved: "proved";
+        declared: "declared";
+        bound: "bound";
+    }>;
     declaredAt: z.ZodNumber;
     binding: z.ZodOptional<z.ZodUnknown>;
     surface: z.ZodOptional<z.ZodObject<{
         route: z.ZodOptional<z.ZodString>;
         flow: z.ZodOptional<z.ZodString>;
-        files: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
-    }, "strip", z.ZodTypeAny, {
-        route?: string | undefined;
-        flow?: string | undefined;
-        files?: string[] | undefined;
-    }, {
-        route?: string | undefined;
-        flow?: string | undefined;
-        files?: string[] | undefined;
-    }>>;
+        files: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>>;
     provenBy: z.ZodOptional<z.ZodObject<{
         verdictId: z.ZodString;
         grade: z.ZodString;
         at: z.ZodNumber;
         runId: z.ZodOptional<z.ZodString>;
-    }, "strip", z.ZodTypeAny, {
-        at: number;
-        grade: string;
-        verdictId: string;
-        runId?: string | undefined;
-    }, {
-        at: number;
-        grade: string;
-        verdictId: string;
-        runId?: string | undefined;
-    }>>;
+    }, z.core.$strip>>;
     amended: z.ZodOptional<z.ZodArray<z.ZodObject<{
         statement: z.ZodString;
         at: z.ZodNumber;
-    }, "strip", z.ZodTypeAny, {
-        at: number;
-        statement: string;
-    }, {
-        at: number;
-        statement: string;
-    }>, "many">>;
-} & {
-    /** Which shard this lives in. Stored as well as implied, so a file read alone is self-describing. */
+    }, z.core.$strip>>>;
     subject: z.ZodString;
-    status: z.ZodEnum<["proposed", "agreed", "proved", "stale"]>;
-    /** WHY it must be true. The half the old file had no room for. */
+    status: z.ZodEnum<{
+        proved: "proved";
+        proposed: "proposed";
+        agreed: "agreed";
+        stale: "stale";
+    }>;
     why: z.ZodOptional<z.ZodString>;
-    /** Where it came from — "the user, in conversation" beats an anonymous assertion in six months. */
     source: z.ZodOptional<z.ZodString>;
-    /** When it was last touched, so a stale-looking record can be told from an untouched one. */
     updatedAt: z.ZodOptional<z.ZodNumber>;
-}, "strip", z.ZodTypeAny, {
-    status: "proved" | "proposed" | "agreed" | "stale";
-    state: "proved" | "declared" | "bound";
-    id: string;
-    subject: string;
-    statement: string;
-    declaredAt: number;
-    surface?: {
-        route?: string | undefined;
-        flow?: string | undefined;
-        files?: string[] | undefined;
-    } | undefined;
-    source?: string | undefined;
-    why?: string | undefined;
-    updatedAt?: number | undefined;
-    binding?: unknown;
-    provenBy?: {
-        at: number;
-        grade: string;
-        verdictId: string;
-        runId?: string | undefined;
-    } | undefined;
-    amended?: {
-        at: number;
-        statement: string;
-    }[] | undefined;
-}, {
-    status: "proved" | "proposed" | "agreed" | "stale";
-    state: "proved" | "declared" | "bound";
-    id: string;
-    subject: string;
-    statement: string;
-    declaredAt: number;
-    surface?: {
-        route?: string | undefined;
-        flow?: string | undefined;
-        files?: string[] | undefined;
-    } | undefined;
-    source?: string | undefined;
-    why?: string | undefined;
-    updatedAt?: number | undefined;
-    binding?: unknown;
-    provenBy?: {
-        at: number;
-        grade: string;
-        verdictId: string;
-        runId?: string | undefined;
-    } | undefined;
-    amended?: {
-        at: number;
-        statement: string;
-    }[] | undefined;
-}>;
+}, z.core.$strip>;
 export type IntentRecord = z.infer<typeof IntentRecordSchema>;
 export declare const IntentShardSchema: z.ZodObject<{
     version: z.ZodLiteral<1>;
@@ -155,172 +83,40 @@ export declare const IntentShardSchema: z.ZodObject<{
     intents: z.ZodRecord<z.ZodString, z.ZodObject<{
         id: z.ZodString;
         statement: z.ZodString;
-        state: z.ZodEnum<["declared", "bound", "proved"]>;
+        state: z.ZodEnum<{
+            proved: "proved";
+            declared: "declared";
+            bound: "bound";
+        }>;
         declaredAt: z.ZodNumber;
         binding: z.ZodOptional<z.ZodUnknown>;
         surface: z.ZodOptional<z.ZodObject<{
             route: z.ZodOptional<z.ZodString>;
             flow: z.ZodOptional<z.ZodString>;
-            files: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
-        }, "strip", z.ZodTypeAny, {
-            route?: string | undefined;
-            flow?: string | undefined;
-            files?: string[] | undefined;
-        }, {
-            route?: string | undefined;
-            flow?: string | undefined;
-            files?: string[] | undefined;
-        }>>;
+            files: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        }, z.core.$strip>>;
         provenBy: z.ZodOptional<z.ZodObject<{
             verdictId: z.ZodString;
             grade: z.ZodString;
             at: z.ZodNumber;
             runId: z.ZodOptional<z.ZodString>;
-        }, "strip", z.ZodTypeAny, {
-            at: number;
-            grade: string;
-            verdictId: string;
-            runId?: string | undefined;
-        }, {
-            at: number;
-            grade: string;
-            verdictId: string;
-            runId?: string | undefined;
-        }>>;
+        }, z.core.$strip>>;
         amended: z.ZodOptional<z.ZodArray<z.ZodObject<{
             statement: z.ZodString;
             at: z.ZodNumber;
-        }, "strip", z.ZodTypeAny, {
-            at: number;
-            statement: string;
-        }, {
-            at: number;
-            statement: string;
-        }>, "many">>;
-    } & {
-        /** Which shard this lives in. Stored as well as implied, so a file read alone is self-describing. */
+        }, z.core.$strip>>>;
         subject: z.ZodString;
-        status: z.ZodEnum<["proposed", "agreed", "proved", "stale"]>;
-        /** WHY it must be true. The half the old file had no room for. */
+        status: z.ZodEnum<{
+            proved: "proved";
+            proposed: "proposed";
+            agreed: "agreed";
+            stale: "stale";
+        }>;
         why: z.ZodOptional<z.ZodString>;
-        /** Where it came from — "the user, in conversation" beats an anonymous assertion in six months. */
         source: z.ZodOptional<z.ZodString>;
-        /** When it was last touched, so a stale-looking record can be told from an untouched one. */
         updatedAt: z.ZodOptional<z.ZodNumber>;
-    }, "strip", z.ZodTypeAny, {
-        status: "proved" | "proposed" | "agreed" | "stale";
-        state: "proved" | "declared" | "bound";
-        id: string;
-        subject: string;
-        statement: string;
-        declaredAt: number;
-        surface?: {
-            route?: string | undefined;
-            flow?: string | undefined;
-            files?: string[] | undefined;
-        } | undefined;
-        source?: string | undefined;
-        why?: string | undefined;
-        updatedAt?: number | undefined;
-        binding?: unknown;
-        provenBy?: {
-            at: number;
-            grade: string;
-            verdictId: string;
-            runId?: string | undefined;
-        } | undefined;
-        amended?: {
-            at: number;
-            statement: string;
-        }[] | undefined;
-    }, {
-        status: "proved" | "proposed" | "agreed" | "stale";
-        state: "proved" | "declared" | "bound";
-        id: string;
-        subject: string;
-        statement: string;
-        declaredAt: number;
-        surface?: {
-            route?: string | undefined;
-            flow?: string | undefined;
-            files?: string[] | undefined;
-        } | undefined;
-        source?: string | undefined;
-        why?: string | undefined;
-        updatedAt?: number | undefined;
-        binding?: unknown;
-        provenBy?: {
-            at: number;
-            grade: string;
-            verdictId: string;
-            runId?: string | undefined;
-        } | undefined;
-        amended?: {
-            at: number;
-            statement: string;
-        }[] | undefined;
-    }>>;
-}, "strip", z.ZodTypeAny, {
-    version: 1;
-    intents: Record<string, {
-        status: "proved" | "proposed" | "agreed" | "stale";
-        state: "proved" | "declared" | "bound";
-        id: string;
-        subject: string;
-        statement: string;
-        declaredAt: number;
-        surface?: {
-            route?: string | undefined;
-            flow?: string | undefined;
-            files?: string[] | undefined;
-        } | undefined;
-        source?: string | undefined;
-        why?: string | undefined;
-        updatedAt?: number | undefined;
-        binding?: unknown;
-        provenBy?: {
-            at: number;
-            grade: string;
-            verdictId: string;
-            runId?: string | undefined;
-        } | undefined;
-        amended?: {
-            at: number;
-            statement: string;
-        }[] | undefined;
-    }>;
-    subject: string;
-}, {
-    version: 1;
-    intents: Record<string, {
-        status: "proved" | "proposed" | "agreed" | "stale";
-        state: "proved" | "declared" | "bound";
-        id: string;
-        subject: string;
-        statement: string;
-        declaredAt: number;
-        surface?: {
-            route?: string | undefined;
-            flow?: string | undefined;
-            files?: string[] | undefined;
-        } | undefined;
-        source?: string | undefined;
-        why?: string | undefined;
-        updatedAt?: number | undefined;
-        binding?: unknown;
-        provenBy?: {
-            at: number;
-            grade: string;
-            verdictId: string;
-            runId?: string | undefined;
-        } | undefined;
-        amended?: {
-            at: number;
-            statement: string;
-        }[] | undefined;
-    }>;
-    subject: string;
-}>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
 export type IntentShard = z.infer<typeof IntentShardSchema>;
 export declare const IntentIndexSchema: z.ZodObject<{
     version: z.ZodLiteral<1>;
@@ -328,35 +124,14 @@ export declare const IntentIndexSchema: z.ZodObject<{
         id: z.ZodString;
         subject: z.ZodString;
         statement: z.ZodString;
-        status: z.ZodEnum<["proposed", "agreed", "proved", "stale"]>;
-    }, "strip", z.ZodTypeAny, {
-        status: "proved" | "proposed" | "agreed" | "stale";
-        id: string;
-        subject: string;
-        statement: string;
-    }, {
-        status: "proved" | "proposed" | "agreed" | "stale";
-        id: string;
-        subject: string;
-        statement: string;
-    }>, "many">;
-}, "strip", z.ZodTypeAny, {
-    entries: {
-        status: "proved" | "proposed" | "agreed" | "stale";
-        id: string;
-        subject: string;
-        statement: string;
-    }[];
-    version: 1;
-}, {
-    entries: {
-        status: "proved" | "proposed" | "agreed" | "stale";
-        id: string;
-        subject: string;
-        statement: string;
-    }[];
-    version: 1;
-}>;
+        status: z.ZodEnum<{
+            proved: "proved";
+            proposed: "proposed";
+            agreed: "agreed";
+            stale: "stale";
+        }>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
 export type IntentIndex = z.infer<typeof IntentIndexSchema>;
 export declare const emptyShard: (subject: string) => IntentShard;
 /** The verification lifecycle a legacy record carried, mapped onto the settledness axis. */

package/dist/memory/journal/envelope-store.js

@@ -7,7 +7,7 @@ import { RouteEnvelopeSchema } from './envelope.js';
 const ENVELOPE_FILE_VERSION = 1;
 const EnvelopeFileSchema = z.object({
     version: z.literal(ENVELOPE_FILE_VERSION),
-    routes: z.record(RouteEnvelopeSchema),
+    routes: z.record(z.string(), RouteEnvelopeSchema),
 });
 /**
  * Persists the learned per-route envelopes at `.reticle/envelopes.json`. Local, single-project statistics

package/dist/memory/journal/envelope.d.ts

@@ -41,175 +41,27 @@ export declare const RouteEnvelopeSchema: z.ZodObject<{
             mean: z.ZodNumber;
             m2: z.ZodNumber;
             max: z.ZodNumber;
-        }, "strip", z.ZodTypeAny, {
-            count: number;
-            mean: number;
-            m2: number;
-            max: number;
-        }, {
-            count: number;
-            mean: number;
-            m2: number;
-            max: number;
-        }>;
+        }, z.core.$strip>;
         net: z.ZodObject<{
             count: z.ZodNumber;
             mean: z.ZodNumber;
             m2: z.ZodNumber;
             max: z.ZodNumber;
-        }, "strip", z.ZodTypeAny, {
-            count: number;
-            mean: number;
-            m2: number;
-            max: number;
-        }, {
-            count: number;
-            mean: number;
-            m2: number;
-            max: number;
-        }>;
+        }, z.core.$strip>;
         netErrors: z.ZodObject<{
             count: z.ZodNumber;
             mean: z.ZodNumber;
             m2: z.ZodNumber;
             max: z.ZodNumber;
-        }, "strip", z.ZodTypeAny, {
-            count: number;
-            mean: number;
-            m2: number;
-            max: number;
-        }, {
-            count: number;
-            mean: number;
-            m2: number;
-            max: number;
-        }>;
+        }, z.core.$strip>;
         consoleErrors: z.ZodObject<{
             count: z.ZodNumber;
             mean: z.ZodNumber;
             m2: z.ZodNumber;
             max: z.ZodNumber;
-        }, "strip", z.ZodTypeAny, {
-            count: number;
-            mean: number;
-            m2: number;
-            max: number;
-        }, {
-            count: number;
-            mean: number;
-            m2: number;
-            max: number;
-        }>;
-    }, "strip", z.ZodTypeAny, {
-        net: {
-            count: number;
-            mean: number;
-            m2: number;
-            max: number;
-        };
-        durationMs: {
-            count: number;
-            mean: number;
-            m2: number;
-            max: number;
-        };
-        consoleErrors: {
-            count: number;
-            mean: number;
-            m2: number;
-            max: number;
-        };
-        netErrors: {
-            count: number;
-            mean: number;
-            m2: number;
-            max: number;
-        };
-    }, {
-        net: {
-            count: number;
-            mean: number;
-            m2: number;
-            max: number;
-        };
-        durationMs: {
-            count: number;
-            mean: number;
-            m2: number;
-            max: number;
-        };
-        consoleErrors: {
-            count: number;
-            mean: number;
-            m2: number;
-            max: number;
-        };
-        netErrors: {
-            count: number;
-            mean: number;
-            m2: number;
-            max: number;
-        };
-    }>;
-}, "strip", z.ZodTypeAny, {
-    route: string;
-    samples: number;
-    stats: {
-        net: {
-            count: number;
-            mean: number;
-            m2: number;
-            max: number;
-        };
-        durationMs: {
-            count: number;
-            mean: number;
-            m2: number;
-            max: number;
-        };
-        consoleErrors: {
-            count: number;
-            mean: number;
-            m2: number;
-            max: number;
-        };
-        netErrors: {
-            count: number;
-            mean: number;
-            m2: number;
-            max: number;
-        };
-    };
-}, {
-    route: string;
-    samples: number;
-    stats: {
-        net: {
-            count: number;
-            mean: number;
-            m2: number;
-            max: number;
-        };
-        durationMs: {
-            count: number;
-            mean: number;
-            m2: number;
-            max: number;
-        };
-        consoleErrors: {
-            count: number;
-            mean: number;
-            m2: number;
-            max: number;
-        };
-        netErrors: {
-            count: number;
-            mean: number;
-            m2: number;
-            max: number;
-        };
-    };
-}>;
+        }, z.core.$strip>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
 export declare function emptyEnvelope(route: string): RouteEnvelope;
 /** Fold one observed segment into the envelope as a new sample. */
 export declare function addSegmentToEnvelope(envelope: RouteEnvelope, segment: SegmentRollup): RouteEnvelope;

package/dist/memory/journal/on-disk/ambient-file.d.ts

@@ -12,10 +12,4 @@ import { z } from 'zod';
 export declare const AmbientFileSchema: z.ZodObject<{
     version: z.ZodLiteral<1>;
     regions: z.ZodRecord<z.ZodString, z.ZodNumber>;
-}, "strip", z.ZodTypeAny, {
-    version: 1;
-    regions: Record<string, number>;
-}, {
-    version: 1;
-    regions: Record<string, number>;
-}>;
+}, z.core.$strip>;

package/dist/memory/journal/on-disk/ambient-file.js

@@ -11,5 +11,5 @@ import { z } from 'zod';
  */
 export const AmbientFileSchema = z.object({
     version: z.literal(1),
-    regions: z.record(z.number()),
+    regions: z.record(z.string(), z.number()),
 });