expandai 0.0.1 → 0.0.3

package/build/dts/Mcp/tools/Citations.d.ts

@@ -1,6 +1,8 @@
 import type { FetchObjectModeResultWithJson, FetchSnapshotSearchResultWithJson } from '@expandai/sdk/FetchJson';
 import * as Generated from '@expandai/sdk/Generated';
 import { Schema as S } from 'effect';
+export declare const FetchInvocationPath: S.Literal<["cli-recovery", "mcp-fetch-search"]>;
+export type FetchInvocationPath = typeof FetchInvocationPath.Type;
 declare const CitedSnippet_base: S.Class<CitedSnippet, {
     type: S.optionalWith<S.Literal<["text"]>, {
         nullable: true;
@@ -33,26 +35,34 @@ declare const CitedSnippet_base: S.Class<CitedSnippet, {
     citationUrl: S.SchemaClass<string, string, never>;
 }>, never, {
     readonly json?: unknown;
-} & {
-    readonly score: number;
-} & {
-    readonly source: "markdown" | "appendix" | "statejson";
-} & {
-    readonly type?: "text" | undefined;
-} & {
-    readonly text: string;
 } & {
     readonly location?: {
+        readonly evidenceId?: number | undefined;
         readonly markdownBlockId?: string | undefined;
         readonly nodeIds?: readonly number[] | undefined;
         readonly stateJsonSourceId?: number | undefined;
         readonly jsonPath?: string | undefined;
     } | undefined;
+} & {
+    readonly type?: "text" | undefined;
 } & {
     readonly citationUrl: string;
+} & {
+    readonly score: number;
+} & {
+    readonly source: "appendix" | "markdown" | "statejson";
+} & {
+    readonly text: string;
 }, {}, {}>;
 export declare class CitedSnippet extends CitedSnippet_base {
 }
+/**
+ * Carried in the tool result itself, not only in `SKILL.md`. A harness may not load
+ * skills at all, and the hook's snapshot note never reaches this path — so without
+ * this the model receives perfect `citationUrl`s and no instruction to use them, and
+ * answers with no citation. Observed on OpenCode before this was added.
+ */
+export declare const CITATION_INSTRUCTIONS: string;
 declare const CitedSearchResult_base: S.Class<CitedSearchResult, {
     query: typeof S.String;
     snippets: S.Array$<typeof CitedSnippet>;
@@ -69,12 +79,12 @@ declare const CitedSearchResult_base: S.Class<CitedSearchResult, {
     readonly meta?: {
         readonly durationMs: number;
         readonly sources: readonly {
-            readonly source: "markdown" | "appendix" | "statejson";
+            readonly source: "appendix" | "markdown" | "statejson";
             readonly chunkCount: number;
             readonly batchCount: number;
-            readonly ranker: "zeroentropy" | "local_lexical";
+            readonly ranker: "local_lexical" | "zeroentropy";
             readonly fallback: boolean;
-            readonly fallbackReason?: "timeout" | "error" | undefined;
+            readonly fallbackReason?: "error" | "timeout" | undefined;
             readonly durationMs: number;
         }[];
     } | undefined;
@@ -86,6 +96,13 @@ declare const CitedSearchResult_base: S.Class<CitedSearchResult, {
 export declare class CitedSearchResult extends CitedSearchResult_base {
 }
 declare const CitedObjectModeResult_base: S.Class<CitedObjectModeResult, {
+    invocationPath: S.Literal<["mcp-fetch-search"]>;
+    citationInstructions: S.optionalWith<typeof S.String, {
+        default: () => string;
+    }>;
+    citationBlock: S.optionalWith<typeof S.String, {
+        default: () => string;
+    }>;
     meta: typeof Generated.FetchObjectModeMeta;
     markdown: typeof S.String;
     json: S.Array$<typeof Generated.FetchObjectModeEvidence>;
@@ -93,9 +110,6 @@ declare const CitedObjectModeResult_base: S.Class<CitedObjectModeResult, {
         assets: S.optionalWith<S.Array$<typeof Generated.FetchAssetReference>, {
             nullable: true;
         }>;
-        captureTelemetry: S.optionalWith<typeof Generated.CaptureTelemetryInfo, {
-            nullable: true;
-        }>;
         search: S.optionalWith<typeof CitedSearchResult, {
             nullable: true;
         }>;
@@ -103,6 +117,13 @@ declare const CitedObjectModeResult_base: S.Class<CitedObjectModeResult, {
         nullable: true;
     }>;
 }, S.Struct.Encoded<{
+    invocationPath: S.Literal<["mcp-fetch-search"]>;
+    citationInstructions: S.optionalWith<typeof S.String, {
+        default: () => string;
+    }>;
+    citationBlock: S.optionalWith<typeof S.String, {
+        default: () => string;
+    }>;
     meta: typeof Generated.FetchObjectModeMeta;
     markdown: typeof S.String;
     json: S.Array$<typeof Generated.FetchObjectModeEvidence>;
@@ -110,9 +131,6 @@ declare const CitedObjectModeResult_base: S.Class<CitedObjectModeResult, {
         assets: S.optionalWith<S.Array$<typeof Generated.FetchAssetReference>, {
             nullable: true;
         }>;
-        captureTelemetry: S.optionalWith<typeof Generated.CaptureTelemetryInfo, {
-            nullable: true;
-        }>;
         search: S.optionalWith<typeof CitedSearchResult, {
             nullable: true;
         }>;
@@ -120,23 +138,41 @@ declare const CitedObjectModeResult_base: S.Class<CitedObjectModeResult, {
         nullable: true;
     }>;
 }>, never, {
+    readonly data?: {
+        readonly assets?: readonly {
+            readonly id: string;
+            readonly kind: "data-url";
+            readonly placeholder: string;
+            readonly archiveKey: string;
+            readonly mimeType: string;
+            readonly sha256: string;
+            readonly bytes: number;
+        }[] | undefined;
+        readonly search?: CitedSearchResult | undefined;
+    } | undefined;
+} & {
+    readonly citationBlock?: string | undefined;
+} & {
+    readonly citationInstructions?: string | undefined;
+} & {
+    readonly invocationPath: "mcp-fetch-search";
+} & {
+    readonly json: readonly {
+        readonly id: number;
+        readonly kind: "inline" | "network";
+        readonly role: "apollo-state" | "application-json" | "data-attribute" | "initial-state" | "ld+json" | "network-json" | "network-response" | "next-data" | "nuxt" | "other" | "script-tag";
+        readonly score: number;
+        readonly url?: string | undefined;
+        readonly method?: string | undefined;
+        readonly moreTokens?: number | undefined;
+        readonly keys?: readonly string[] | undefined;
+    }[];
+} & {
     readonly markdown: string;
 } & {
     readonly meta: {
-        readonly url: string;
-        readonly markdown?: {
-            readonly url: string;
-            readonly moreTokens: number;
-        } | undefined;
-        readonly appendix?: {
-            readonly url: string;
-            readonly links: {
-                readonly sameDomain: number;
-                readonly external: number;
-            };
-        } | undefined;
-        readonly description?: string | undefined;
         readonly version: 1;
+        readonly url: string;
         readonly capturedAt: string;
         readonly snapshotId: string;
         readonly lang: string;
@@ -145,74 +181,68 @@ declare const CitedObjectModeResult_base: S.Class<CitedObjectModeResult, {
         readonly title?: string | undefined;
         readonly finalUrl?: string | undefined;
         readonly canonical?: string | undefined;
+        readonly description?: string | undefined;
         readonly author?: string | undefined;
         readonly createdAt?: string | undefined;
         readonly updatedAt?: string | undefined;
         readonly image?: string | undefined;
         readonly paginationNext?: string | undefined;
+        readonly appendix?: {
+            readonly url: string;
+            readonly links: {
+                readonly sameDomain: number;
+                readonly external: number;
+            };
+        } | undefined;
         readonly stateJson?: {
             readonly moreTokens: number;
         } | undefined;
+        readonly markdown?: {
+            readonly url: string;
+            readonly moreTokens: number;
+        } | undefined;
         readonly blocked?: string | undefined;
         readonly loadingStatus?: string | undefined;
     };
-} & {
-    readonly json: readonly {
-        readonly keys?: readonly string[] | undefined;
-        readonly url?: string | undefined;
-        readonly moreTokens?: number | undefined;
-        readonly id: number;
-        readonly kind: "inline" | "network";
-        readonly role: "ld+json" | "next-data" | "nuxt" | "apollo-state" | "initial-state" | "application-json" | "script-tag" | "data-attribute" | "network-json" | "network-response" | "other";
-        readonly score: number;
-        readonly method?: string | undefined;
-    }[];
-} & {
-    readonly data?: {
-        readonly search?: CitedSearchResult | undefined;
-        readonly assets?: readonly {
-            readonly id: string;
-            readonly kind: "data-url";
-            readonly placeholder: string;
-            readonly archiveKey: string;
-            readonly mimeType: string;
-            readonly sha256: string;
-            readonly bytes: number;
-        }[] | undefined;
-        readonly captureTelemetry?: {
-            readonly requestedStyleMode?: "compat_full" | "native_default" | undefined;
-            readonly selected: "rust";
-            readonly actual: "rust";
-            readonly actualStyleMode?: "compat_full" | "native_default" | undefined;
-            readonly rolloutApplied: boolean;
-            readonly preparedSessionHit?: boolean | undefined;
-            readonly nativePoolHit?: boolean | undefined;
-            readonly preparedPageHit?: boolean | undefined;
-            readonly nativePoolCapacity?: number | undefined;
-            readonly nativePoolProfile?: string | undefined;
-            readonly poolHit?: boolean | undefined;
-            readonly connectMs?: number | undefined;
-            readonly warmConnectionAgeMs?: number | undefined;
-            readonly iconBackendDecision?: "cpu" | "remote_gpu" | undefined;
-        } | undefined;
-    } | undefined;
 }, {}, {}>;
 export declare class CitedObjectModeResult extends CitedObjectModeResult_base {
 }
 declare const CitedSnapshotSearchResult_base: S.Class<CitedSnapshotSearchResult, {
+    invocationPath: S.Literal<["cli-recovery", "mcp-fetch-search"]>;
+    citationInstructions: S.optionalWith<typeof S.String, {
+        default: () => string;
+    }>;
+    citationBlock: S.optionalWith<typeof S.String, {
+        default: () => string;
+    }>;
     snapshotId: S.filter<typeof S.String>;
     response: typeof Generated.ResponseInfo;
     search: typeof CitedSearchResult;
     durationMs: S.filter<typeof S.Number>;
     playground: S.SchemaClass<string, string, never>;
 }, S.Struct.Encoded<{
+    invocationPath: S.Literal<["cli-recovery", "mcp-fetch-search"]>;
+    citationInstructions: S.optionalWith<typeof S.String, {
+        default: () => string;
+    }>;
+    citationBlock: S.optionalWith<typeof S.String, {
+        default: () => string;
+    }>;
     snapshotId: S.filter<typeof S.String>;
     response: typeof Generated.ResponseInfo;
     search: typeof CitedSearchResult;
     durationMs: S.filter<typeof S.Number>;
     playground: S.SchemaClass<string, string, never>;
 }>, never, {
-    readonly search: CitedSearchResult;
+    readonly citationBlock?: string | undefined;
+} & {
+    readonly citationInstructions?: string | undefined;
+} & {
+    readonly durationMs: number;
+} & {
+    readonly invocationPath: "cli-recovery" | "mcp-fetch-search";
+} & {
+    readonly playground: string;
 } & {
     readonly response: {
         readonly url: string;
@@ -222,17 +252,15 @@ declare const CitedSnapshotSearchResult_base: S.Class<CitedSnapshotSearchResult,
         readonly headers?: {} | undefined;
     };
 } & {
-    readonly snapshotId: string;
-} & {
-    readonly playground: string;
+    readonly search: CitedSearchResult;
 } & {
-    readonly durationMs: number;
+    readonly snapshotId: string;
 }, {}, {}>;
 export declare class CitedSnapshotSearchResult extends CitedSnapshotSearchResult_base {
 }
 /** Add `citationUrl` to each snippet of an object-mode fetch result. */
 export declare function enrichObjectModeResult(result: FetchObjectModeResultWithJson, fallbackHost: string): CitedObjectModeResult;
-/** Add `citationUrl` to each snippet of a snapshot-search result (no server `meta.playground`). */
-export declare function enrichSnapshotSearchResult(result: FetchSnapshotSearchResultWithJson, host: string): CitedSnapshotSearchResult;
+/** Add `citationUrl` to each snippet of a snapshot-search result. */
+export declare function enrichSnapshotSearchResult(result: FetchSnapshotSearchResultWithJson, fallbackHost: string, invocationPath?: FetchInvocationPath): CitedSnapshotSearchResult;
 export {};
 //# sourceMappingURL=Citations.d.ts.map

package/build/dts/Mcp/tools/Citations.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Citations.d.ts","sourceRoot":"","sources":["../../../../src/Mcp/tools/Citations.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,6BAA6B,EAAE,iCAAiC,EAAE,MAAM,yBAAyB,CAAA;AAC/G,OAAO,KAAK,SAAS,MAAM,yBAAyB,CAAA;AAEpD,OAAO,EAAE,MAAM,IAAI,CAAC,EAAE,MAAM,QAAQ,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEpC,qBAAa,YAAa,SAAQ,iBAUhC;CAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEL,qBAAa,iBAAkB,SAAQ,sBAIrC;CAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEL,qBAAa,qBAAsB,SAAQ,0BAYzC;CAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEL,qBAAa,yBAA0B,SAAQ,8BAM7C;CAAG;AAyBL,wEAAwE;AACxE,wBAAgB,sBAAsB,CACrC,MAAM,EAAE,6BAA6B,EACrC,YAAY,EAAE,MAAM,GAClB,qBAAqB,CAkBvB;AAED,mGAAmG;AACnG,wBAAgB,0BAA0B,CACzC,MAAM,EAAE,iCAAiC,EACzC,IAAI,EAAE,MAAM,GACV,yBAAyB,CAQ3B"}
+{"version":3,"file":"Citations.d.ts","sourceRoot":"","sources":["../../../../src/Mcp/tools/Citations.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,6BAA6B,EAAE,iCAAiC,EAAE,MAAM,yBAAyB,CAAA;AAC/G,OAAO,KAAK,SAAS,MAAM,yBAAyB,CAAA;AAEpD,OAAO,EAAE,MAAM,IAAI,CAAC,EAAE,MAAM,QAAQ,CAAA;AAEpC,eAAO,MAAM,mBAAmB,iDAAgD,CAAA;AAChF,MAAM,MAAM,mBAAmB,GAAG,OAAO,mBAAmB,CAAC,IAAI,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEjE,qBAAa,YAAa,SAAQ,iBAUhC;CAAG;AAEL;;;;;GAKG;AACH,eAAO,MAAM,qBAAqB,QAO8D,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAmEhG,qBAAa,iBAAkB,SAAQ,sBAIrC;CAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEL,qBAAa,qBAAsB,SAAQ,0BAczC;CAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEL,qBAAa,yBAA0B,SAAQ,8BAS7C;CAAG;AAyBL,wEAAwE;AACxE,wBAAgB,sBAAsB,CACrC,MAAM,EAAE,6BAA6B,EACrC,YAAY,EAAE,MAAM,GAClB,qBAAqB,CA6BvB;AAED,qEAAqE;AACrE,wBAAgB,0BAA0B,CACzC,MAAM,EAAE,iCAAiC,EACzC,YAAY,EAAE,MAAM,EACpB,cAAc,GAAE,mBAAwC,GACtD,yBAAyB,CAiB3B"}

package/build/dts/Mcp/tools/Fetch.d.ts

@@ -2,6 +2,7 @@ import { Tool } from '@effect/ai';
 import { Effect, Schema } from 'effect';
 import { ApiClient } from '../../ApiClient.js';
 import { ConfigManager } from '../../Config.js';
+import { Telemetry } from '../../Telemetry.js';
 import { CitedObjectModeResult, CitedSnapshotSearchResult } from './Citations.js';
 declare const FetchSearchParams_base: Schema.Class<FetchSearchParams, {
     query: Schema.refine<string, typeof Schema.Trimmed>;
@@ -20,11 +21,11 @@ declare const FetchSearchParams_base: Schema.Class<FetchSearchParams, {
         default: () => number;
     }>;
 }>, never, {
-    readonly query: string;
-} & {
     readonly maxResults?: number | undefined;
 } & {
     readonly minScore?: number | undefined;
+} & {
+    readonly query: string;
 }, {}, {}>;
 export declare class FetchSearchParams extends FetchSearchParams_base {
 }
@@ -53,24 +54,24 @@ declare const FetchParams_base: Schema.Class<FetchParams, {
         default: () => true;
     }>;
 }>, never, {
-    readonly url: string;
-} & {
     readonly search?: FetchSearchParams | undefined;
-} & {
-    readonly includeMeta?: boolean | undefined;
 } & {
     readonly includeAppendix?: boolean | undefined;
 } & {
     readonly includeJson?: boolean | undefined;
+} & {
+    readonly includeMeta?: boolean | undefined;
+} & {
+    readonly url: string;
 }, {}, {}>;
 export declare class FetchParams extends FetchParams_base {
 }
 declare const FetchSnapshotSearchParams_base: Schema.Class<FetchSnapshotSearchParams, {
     snapshotId: Schema.refine<string, typeof Schema.String>;
     search: Schema.SchemaClass<FetchSearchParams, {
-        readonly query: string;
         readonly maxResults?: number | undefined;
         readonly minScore?: number | undefined;
+        readonly query: string;
     }, never>;
     includeMarkdown: Schema.optionalWith<typeof Schema.Boolean, {
         default: () => true;
@@ -84,9 +85,9 @@ declare const FetchSnapshotSearchParams_base: Schema.Class<FetchSnapshotSearchPa
 }, Schema.Struct.Encoded<{
     snapshotId: Schema.refine<string, typeof Schema.String>;
     search: Schema.SchemaClass<FetchSearchParams, {
-        readonly query: string;
         readonly maxResults?: number | undefined;
         readonly minScore?: number | undefined;
+        readonly query: string;
     }, never>;
     includeMarkdown: Schema.optionalWith<typeof Schema.Boolean, {
         default: () => true;
@@ -98,15 +99,15 @@ declare const FetchSnapshotSearchParams_base: Schema.Class<FetchSnapshotSearchPa
         default: () => true;
     }>;
 }>, never, {
-    readonly search: FetchSearchParams;
-} & {
-    readonly snapshotId: string;
-} & {
     readonly includeAppendix?: boolean | undefined;
 } & {
     readonly includeJson?: boolean | undefined;
 } & {
     readonly includeMarkdown?: boolean | undefined;
+} & {
+    readonly search: FetchSearchParams;
+} & {
+    readonly snapshotId: string;
 }, {}, {}>;
 export declare class FetchSnapshotSearchParams extends FetchSnapshotSearchParams_base {
 }
@@ -132,9 +133,9 @@ export declare const FetchSearchTool: Tool.Tool<"fetch_search", {
     readonly parameters: Schema.Struct<{
         readonly snapshotId: Schema.refine<string, typeof Schema.String>;
         readonly search: Schema.SchemaClass<FetchSearchParams, {
-            readonly query: string;
             readonly maxResults?: number | undefined;
             readonly minScore?: number | undefined;
+            readonly query: string;
         }, never>;
         readonly includeMarkdown: Schema.optionalWith<typeof Schema.Boolean, {
             default: () => true;
@@ -155,11 +156,11 @@ export interface FetchService {
     readonly fetchSearch: (params: FetchSnapshotSearchParams) => Effect.Effect<CitedSnapshotSearchResult, unknown>;
 }
 declare const Fetch_base: Effect.Service.Class<Fetch, "@expandai/cli/Mcp/Fetch", {
-    readonly dependencies: readonly [import("effect/Layer").Layer<ApiClient, import("effect/ConfigError").ConfigError, never>, import("effect/Layer").Layer<ConfigManager, import("effect/ConfigError").ConfigError, never>];
+    readonly dependencies: readonly [import("effect/Layer").Layer<ApiClient, import("effect/ConfigError").ConfigError, never>, import("effect/Layer").Layer<ConfigManager, import("effect/ConfigError").ConfigError, never>, import("effect/Layer").Layer<Telemetry, import("effect/ConfigError").ConfigError, never>];
     readonly scoped: Effect.Effect<{
         fetch: (params: FetchParams) => Effect.Effect<CitedObjectModeResult, unknown>;
         fetchSearch: (params: FetchSnapshotSearchParams) => Effect.Effect<CitedSnapshotSearchResult, unknown>;
-    }, import("effect/ConfigError").ConfigError, ConfigManager | ApiClient>;
+    }, import("effect/ConfigError").ConfigError, ApiClient | ConfigManager | Telemetry>;
 }>;
 export declare class Fetch extends Fetch_base {
 }

package/build/dts/Mcp/tools/Fetch.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Fetch.d.ts","sourceRoot":"","sources":["../../../../src/Mcp/tools/Fetch.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,MAAM,YAAY,CAAA;AACjC,OAAO,EAAE,MAAM,EAAE,MAAM,EAAU,MAAM,QAAQ,CAAA;AAC/C,OAAO,EAAE,SAAS,EAAE,MAAM,oBAAoB,CAAA;AAC9C,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAA;AAC/C,OAAO,EACN,qBAAqB,EACrB,yBAAyB,EAGzB,MAAM,gBAAgB,CAAA;;;;;;;;;;;;;;;;;;;;;;;;AAEvB,qBAAa,iBAAkB,SAAQ,sBAYrC;CAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEL,qBAAa,WAAY,SAAQ,gBAmB/B;CAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEL,qBAAa,yBAA0B,SAAQ,8BAmB7C;CAAG;AAEL,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;SAea,CAAA;AAEnC,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;SAcO,CAAA;AAEnC,MAAM,WAAW,YAAY;IAC5B,QAAQ,CAAC,KAAK,EAAE,CAAC,MAAM,EAAE,WAAW,KAAK,MAAM,CAAC,MAAM,CAAC,qBAAqB,EAAE,OAAO,CAAC,CAAA;IACtF,QAAQ,CAAC,WAAW,EAAE,CAAC,MAAM,EAAE,yBAAyB,KAAK,MAAM,CAAC,MAAM,CAAC,yBAAyB,EAAE,OAAO,CAAC,CAAA;CAC9G;;;;wBAFyB,WAAW,KAAK,MAAM,CAAC,MAAM,CAAC,qBAAqB,EAAE,OAAO,CAAC;8BACvD,yBAAyB,KAAK,MAAM,CAAC,MAAM,CAAC,yBAAyB,EAAE,OAAO,CAAC;;;AAG/G,qBAAa,KAAM,SAAQ,UAuEzB;CAAG"}
+{"version":3,"file":"Fetch.d.ts","sourceRoot":"","sources":["../../../../src/Mcp/tools/Fetch.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,MAAM,YAAY,CAAA;AACjC,OAAO,EAAE,MAAM,EAAE,MAAM,EAAU,MAAM,QAAQ,CAAA;AAC/C,OAAO,EAAE,SAAS,EAAE,MAAM,oBAAoB,CAAA;AAC9C,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAA;AAC/C,OAAO,EAAE,SAAS,EAAE,MAAM,oBAAoB,CAAA;AAC9C,OAAO,EACN,qBAAqB,EACrB,yBAAyB,EAGzB,MAAM,gBAAgB,CAAA;;;;;;;;;;;;;;;;;;;;;;;;AAEvB,qBAAa,iBAAkB,SAAQ,sBAYrC;CAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEL,qBAAa,WAAY,SAAQ,gBAmB/B;CAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEL,qBAAa,yBAA0B,SAAQ,8BAmB7C;CAAG;AAEL,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;SAmBa,CAAA;AAEnC,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;SAmBO,CAAA;AAEnC,MAAM,WAAW,YAAY;IAC5B,QAAQ,CAAC,KAAK,EAAE,CAAC,MAAM,EAAE,WAAW,KAAK,MAAM,CAAC,MAAM,CAAC,qBAAqB,EAAE,OAAO,CAAC,CAAA;IACtF,QAAQ,CAAC,WAAW,EAAE,CAAC,MAAM,EAAE,yBAAyB,KAAK,MAAM,CAAC,MAAM,CAAC,yBAAyB,EAAE,OAAO,CAAC,CAAA;CAC9G;;;;wBAFyB,WAAW,KAAK,MAAM,CAAC,MAAM,CAAC,qBAAqB,EAAE,OAAO,CAAC;8BACvD,yBAAyB,KAAK,MAAM,CAAC,MAAM,CAAC,yBAAyB,EAAE,OAAO,CAAC;;;AAG/G,qBAAa,KAAM,SAAQ,UAuFzB;CAAG"}

package/build/dts/SecureFile.d.ts

@@ -0,0 +1,23 @@
+import { FileSystem, Error as PlatformError } from '@effect/platform';
+import { Effect, Exit } from 'effect';
+export interface CreatedFileIdentity {
+    readonly dev: number;
+    readonly ino?: number;
+    readonly mode: number;
+    readonly type: FileSystem.File.Type;
+}
+export interface ExclusiveFileCreation {
+    readonly identity: CreatedFileIdentity;
+    readonly writeExit: Exit.Exit<void, PlatformError.PlatformError>;
+    readonly pathMatchesHandle: boolean;
+}
+/** Creates a file exclusively and binds its identity to the opened handle before writing bytes. */
+export declare function createExclusiveFile(fileSystem: FileSystem.FileSystem, targetPath: string, contents: string, mode: number): Effect.Effect<ExclusiveFileCreation, PlatformError.PlatformError>;
+/** Compares a pathname snapshot with identity captured from the creating file handle. */
+export declare function matchesCreatedFile(identity: CreatedFileIdentity, pathIdentity: {
+    readonly exists: boolean;
+    readonly dev?: number;
+    readonly ino?: number;
+    readonly type?: FileSystem.File.Type;
+}): boolean;
+//# sourceMappingURL=SecureFile.d.ts.map

package/build/dts/SecureFile.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SecureFile.d.ts","sourceRoot":"","sources":["../../src/SecureFile.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,KAAK,IAAI,aAAa,EAAE,MAAM,kBAAkB,CAAA;AACrE,OAAO,EAAE,MAAM,EAAE,IAAI,EAAU,MAAM,QAAQ,CAAA;AAE7C,MAAM,WAAW,mBAAmB;IACnC,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAA;IACpB,QAAQ,CAAC,GAAG,CAAC,EAAE,MAAM,CAAA;IACrB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB,QAAQ,CAAC,IAAI,EAAE,UAAU,CAAC,IAAI,CAAC,IAAI,CAAA;CACnC;AAED,MAAM,WAAW,qBAAqB;IACrC,QAAQ,CAAC,QAAQ,EAAE,mBAAmB,CAAA;IACtC,QAAQ,CAAC,SAAS,EAAE,IAAI,CAAC,IAAI,CAAC,IAAI,EAAE,aAAa,CAAC,aAAa,CAAC,CAAA;IAChE,QAAQ,CAAC,iBAAiB,EAAE,OAAO,CAAA;CACnC;AAED,mGAAmG;AACnG,wBAAgB,mBAAmB,CAClC,UAAU,EAAE,UAAU,CAAC,UAAU,EACjC,UAAU,EAAE,MAAM,EAClB,QAAQ,EAAE,MAAM,EAChB,IAAI,EAAE,MAAM,GACV,MAAM,CAAC,MAAM,CAAC,qBAAqB,EAAE,aAAa,CAAC,aAAa,CAAC,CA6BnE;AAED,yFAAyF;AACzF,wBAAgB,kBAAkB,CACjC,QAAQ,EAAE,mBAAmB,EAC7B,YAAY,EAAE;IACb,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAA;IACxB,QAAQ,CAAC,GAAG,CAAC,EAAE,MAAM,CAAA;IACrB,QAAQ,CAAC,GAAG,CAAC,EAAE,MAAM,CAAA;IACrB,QAAQ,CAAC,IAAI,CAAC,EAAE,UAAU,CAAC,IAAI,CAAC,IAAI,CAAA;CACpC,GACC,OAAO,CAOT"}

package/build/dts/Snippets.d.ts

@@ -1,15 +1,14 @@
-import { type CitationSource } from '@expandai/sdk/Playground';
-interface RenderableSnippetLocation {
-    readonly nodeIds?: ReadonlyArray<number> | null;
-    readonly stateJsonSourceId?: number | null;
-}
-interface RenderableSnippet {
-    readonly source: CitationSource;
-    readonly text: string;
-    readonly score: number;
-    readonly location?: RenderableSnippetLocation | null;
-    readonly json?: unknown;
-}
+import type { FetchObjectModeResultWithJson } from '@expandai/sdk/FetchJson';
+type SearchResultWithJson = NonNullable<NonNullable<FetchObjectModeResultWithJson['data']>['search']>;
+type RenderableSnippet = SearchResultWithJson['snippets'][number];
+/**
+ * Attaches the public citation link to each snippet. JSON consumers get the same
+ * auditable URL the text renderer prints in its header — without it, a caller has
+ * the snapshot and the evidence id but no host to build a link against.
+ */
+export declare function withCitationUrls<A extends RenderableSnippet>(snapshotId: string, host: string, snippets: ReadonlyArray<A>): Array<A & {
+    readonly citationUrl: string;
+}>;
 /**
  * Render search snippets as auditable text blocks: a header carrying the source, score, and
  * citation link, the snippet text, and — for State JSON snippets — the extracted JSON value.

package/build/dts/Snippets.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Snippets.d.ts","sourceRoot":"","sources":["../../src/Snippets.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,cAAc,EAAe,MAAM,0BAA0B,CAAA;AAK3E,UAAU,yBAAyB;IAClC,QAAQ,CAAC,OAAO,CAAC,EAAE,aAAa,CAAC,MAAM,CAAC,GAAG,IAAI,CAAA;IAC/C,QAAQ,CAAC,iBAAiB,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;CAC1C;AAED,UAAU,iBAAiB;IAC1B,QAAQ,CAAC,MAAM,EAAE,cAAc,CAAA;IAC/B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAA;IACtB,QAAQ,CAAC,QAAQ,CAAC,EAAE,yBAAyB,GAAG,IAAI,CAAA;IACpD,QAAQ,CAAC,IAAI,CAAC,EAAE,OAAO,CAAA;CACvB;AAED;;;GAGG;AACH,wBAAgB,cAAc,CAAC,UAAU,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,aAAa,CAAC,iBAAiB,CAAC,GAAG,MAAM,CASnH"}
+{"version":3,"file":"Snippets.d.ts","sourceRoot":"","sources":["../../src/Snippets.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,6BAA6B,EAAE,MAAM,yBAAyB,CAAA;AAM5E,KAAK,oBAAoB,GAAG,WAAW,CAAC,WAAW,CAAC,6BAA6B,CAAC,MAAM,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAA;AACrG,KAAK,iBAAiB,GAAG,oBAAoB,CAAC,UAAU,CAAC,CAAC,MAAM,CAAC,CAAA;AAEjE;;;;GAIG;AACH,wBAAgB,gBAAgB,CAAC,CAAC,SAAS,iBAAiB,EAC3D,UAAU,EAAE,MAAM,EAClB,IAAI,EAAE,MAAM,EACZ,QAAQ,EAAE,aAAa,CAAC,CAAC,CAAC,GACxB,KAAK,CAAC,CAAC,GAAG;IAAE,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAA;CAAE,CAAC,CAK7C;AAED;;;GAGG;AACH,wBAAgB,cAAc,CAAC,UAAU,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,aAAa,CAAC,iBAAiB,CAAC,GAAG,MAAM,CASnH"}

package/build/dts/Telemetry.d.ts

@@ -0,0 +1,30 @@
+import { HttpClient } from '@effect/platform';
+import { Config, Effect, Layer, Option } from 'effect';
+import { ConfigManager } from './Config.js';
+export declare const TelemetryEnvironment: Config.Config<{
+    apiKey: string;
+    host: string;
+    doNotTrack: boolean;
+    noTelemetry: boolean;
+    apiUrl: Option.Option<string>;
+    harnessOverride: Option.Option<"claude-code" | "codex" | "cursor" | "opencode" | "unknown">;
+    claudeCode: boolean;
+    cursor: boolean;
+    codex: boolean;
+}>;
+declare const Telemetry_base: Effect.Service.Class<Telemetry, "@expandai/cli/Telemetry", {
+    readonly dependencies: readonly [Layer.Layer<ConfigManager, import("effect/ConfigError").ConfigError, never>, Layer.Layer<HttpClient.HttpClient, never, never>];
+    readonly scoped: Effect.Effect<{
+        readonly capture: (event: string, properties: Record<string, string | number | boolean>) => Effect.Effect<void, never, never>;
+        readonly flush: Effect.Effect<void, never, never>;
+        readonly showNoticeIfNeeded: () => Effect.Effect<void, never, never>;
+        readonly enabled: boolean;
+        readonly distinctId: string;
+    }, import("effect/ConfigError").ConfigError, ConfigManager | HttpClient.HttpClient | import("effect/Scope").Scope>;
+}>;
+export declare class Telemetry extends Telemetry_base {
+    /** A side-effect-free telemetry service for commands whose contract is read-only. */
+    static readonly DISABLED: Layer.Layer<Telemetry, never, never>;
+}
+export {};
+//# sourceMappingURL=Telemetry.d.ts.map

package/build/dts/Telemetry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Telemetry.d.ts","sourceRoot":"","sources":["../../src/Telemetry.ts"],"names":[],"mappings":"AAgBA,OAAO,EAAE,UAAU,EAAqB,MAAM,kBAAkB,CAAA;AAEhE,OAAO,EAAE,MAAM,EAAW,MAAM,EAAY,KAAK,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAA;AACzE,OAAO,EAAE,aAAa,EAAwC,MAAM,aAAa,CAAA;AAOjF,eAAO,MAAM,oBAAoB;;;;;;;;;;EAc/B,CAAA;;;;;;;;;;;AA0BF,qBAAa,SAAU,SAAQ,cA2G7B;IACD,qFAAqF;IACrF,MAAM,CAAC,QAAQ,CAAC,QAAQ,uCASvB;CACD"}

package/build/dts/Version.d.ts

@@ -0,0 +1,2 @@
+export declare const CLI_VERSION = "0.0.3";
+//# sourceMappingURL=Version.d.ts.map

package/build/dts/Version.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Version.d.ts","sourceRoot":"","sources":["../../src/Version.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,WAAW,UAAU,CAAA"}

package/build/dts/Xdg.d.ts

@@ -0,0 +1,11 @@
+import { Path } from '@effect/platform';
+import { Effect } from 'effect';
+/**
+ * XDG base-directory lookup, shared by everything that persists CLI state so
+ * the fallback rules cannot drift apart. The spec treats an unset and an empty
+ * variable identically: fall back to `$HOME/.config`. Without the empty check,
+ * `XDG_CONFIG_HOME=` resolves paths relative to the working directory — which
+ * would drop credentials inside whatever project the CLI happens to run in.
+ */
+export declare const xdgConfigDirectory: Effect.Effect<string, import("effect/ConfigError").ConfigError, Path.Path>;
+//# sourceMappingURL=Xdg.d.ts.map

package/build/dts/Xdg.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Xdg.d.ts","sourceRoot":"","sources":["../../src/Xdg.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,IAAI,EAAE,MAAM,kBAAkB,CAAA;AACvC,OAAO,EAAU,MAAM,EAAE,MAAM,QAAQ,CAAA;AAEvC;;;;;;GAMG;AACH,eAAO,MAAM,kBAAkB,4EAM7B,CAAA"}