@mossbear/protocol 0.1.0-alpha.26

package/dist/schemas.d.ts

@@ -0,0 +1,1782 @@
+/**
+ * Runtime validation schemas using Valibot.
+ *
+ * Schemas are the single source of truth — TypeScript types in types.ts are
+ * derived from these via `v.InferOutput<typeof Schema>`.
+ *
+ * Callers can use the exported `parse*` wrappers (throw ValiError on invalid
+ * input) or call `v.safeParse(Schema, data)` directly for non-throwing checks.
+ */
+import * as v from 'valibot';
+export declare const VerdictSchema: v.PicklistSchema<["aligned", "unguided", "misaligned"], undefined>;
+export declare const GuidingTierSchema: v.PicklistSchema<["pattern_match", "cached", "llm", "batch"], undefined>;
+export declare const PlatformKindSchema: v.PicklistSchema<["claude_code", "cursor", "copilot", "windsurf", "other"], undefined>;
+export declare const GuideFileFormatSchema: v.PicklistSchema<["agents-md", "agents-dir", "claude-md", "claude-rules", "cursorrules", "cursor-rules", "skill-md"], undefined>;
+/** Max serialized size (UTF-8 bytes) of an imported guide file's raw content. */
+export declare const MAX_RAW_GUIDE_CONTENT_BYTES: number;
+/** Max member files a single skill-md payload may carry. */
+export declare const MAX_SKILL_MEMBER_FILES = 64;
+export declare const SafeRelativePosixPathSchema: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 512, undefined>, v.CheckAction<string, "path must use forward slashes">, v.CheckAction<string, "path must be relative">, v.CheckAction<string, "path must not contain control characters">, v.CheckAction<string, "path must not contain empty, \".\" or \"..\" segments">]>;
+export declare const SkillMemberPathSchema: v.SchemaWithPipe<readonly [v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 512, undefined>, v.CheckAction<string, "path must use forward slashes">, v.CheckAction<string, "path must be relative">, v.CheckAction<string, "path must not contain control characters">, v.CheckAction<string, "path must not contain empty, \".\" or \"..\" segments">]>, v.CheckAction<string, "path must not shadow the skill’s own SKILL.md">]>;
+export declare const RawSkillMemberFileSchema: v.ObjectSchema<{
+    readonly path: v.SchemaWithPipe<readonly [v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 512, undefined>, v.CheckAction<string, "path must use forward slashes">, v.CheckAction<string, "path must be relative">, v.CheckAction<string, "path must not contain control characters">, v.CheckAction<string, "path must not contain empty, \".\" or \"..\" segments">]>, v.CheckAction<string, "path must not shadow the skill’s own SKILL.md">]>;
+    readonly rawContent: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.CheckAction<string, "rawContent must be at most 524288 bytes">]>;
+    readonly lastModified: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+    readonly content_hash: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, undefined>]>;
+}, undefined>;
+/** Max skipped-member paths a skill-md payload may report alongside `members`. */
+export declare const MAX_SKILL_SKIPPED_MEMBER_PATHS = 256;
+/**
+ * Which root a discovered guide file's `path` is relative to: the repo checkout
+ * (`project`) or the user's homedir (`global`, e.g. `.claude/CLAUDE.md`).
+ * Part of the import resolution key — see `RawGuideFilePayloadSchema.root`.
+ */
+export declare const GuideDiscoveryRootSchema: v.PicklistSchema<["project", "global"], undefined>;
+export declare const GuideSnapshotSchema: v.ObjectSchema<{
+    readonly id: v.StringSchema<undefined>;
+    readonly title: v.StringSchema<undefined>;
+    readonly content: v.StringSchema<undefined>;
+    readonly enabled: v.BooleanSchema<undefined>;
+    readonly updatedAt: v.StringSchema<undefined>;
+    readonly origin: v.OptionalSchema<v.NullableSchema<v.StringSchema<undefined>, undefined>, undefined>;
+    readonly contentHash: v.OptionalSchema<v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, undefined>]>, undefined>, undefined>;
+    readonly root: v.OptionalSchema<v.NullableSchema<v.PicklistSchema<["project", "global"], undefined>, undefined>, undefined>;
+    readonly path: v.OptionalSchema<v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 512, undefined>, v.CheckAction<string, "path must use forward slashes">, v.CheckAction<string, "path must be relative">, v.CheckAction<string, "path must not contain control characters">, v.CheckAction<string, "path must not contain empty, \".\" or \"..\" segments">]>, undefined>, undefined>;
+}, undefined>;
+export declare const GuideBundleResponseSchema: v.ObjectSchema<{
+    readonly guides: v.ArraySchema<v.ObjectSchema<{
+        readonly id: v.StringSchema<undefined>;
+        readonly title: v.StringSchema<undefined>;
+        readonly content: v.StringSchema<undefined>;
+        readonly enabled: v.BooleanSchema<undefined>;
+        readonly updatedAt: v.StringSchema<undefined>;
+        readonly origin: v.OptionalSchema<v.NullableSchema<v.StringSchema<undefined>, undefined>, undefined>;
+        readonly contentHash: v.OptionalSchema<v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, undefined>]>, undefined>, undefined>;
+        readonly root: v.OptionalSchema<v.NullableSchema<v.PicklistSchema<["project", "global"], undefined>, undefined>, undefined>;
+        readonly path: v.OptionalSchema<v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 512, undefined>, v.CheckAction<string, "path must use forward slashes">, v.CheckAction<string, "path must be relative">, v.CheckAction<string, "path must not contain control characters">, v.CheckAction<string, "path must not contain empty, \".\" or \"..\" segments">]>, undefined>, undefined>;
+    }, undefined>, undefined>;
+    readonly pulledAt: v.StringSchema<undefined>;
+}, undefined>;
+export declare const RawGuideFilePayloadSchema: v.SchemaWithPipe<readonly [v.ObjectSchema<{
+    readonly path: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 512, undefined>, v.CheckAction<string, "path must use forward slashes">, v.CheckAction<string, "path must be relative">, v.CheckAction<string, "path must not contain control characters">, v.CheckAction<string, "path must not contain empty, \".\" or \"..\" segments">]>;
+    readonly root: v.OptionalSchema<v.PicklistSchema<["project", "global"], undefined>, undefined>;
+    readonly format: v.PicklistSchema<["agents-md", "agents-dir", "claude-md", "claude-rules", "cursorrules", "cursor-rules", "skill-md"], undefined>;
+    readonly rawContent: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.CheckAction<string, "rawContent must be at most 524288 bytes">]>;
+    readonly lastModified: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+    readonly content_hash: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, undefined>]>;
+    readonly members: v.OptionalSchema<v.SchemaWithPipe<readonly [v.ArraySchema<v.ObjectSchema<{
+        readonly path: v.SchemaWithPipe<readonly [v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 512, undefined>, v.CheckAction<string, "path must use forward slashes">, v.CheckAction<string, "path must be relative">, v.CheckAction<string, "path must not contain control characters">, v.CheckAction<string, "path must not contain empty, \".\" or \"..\" segments">]>, v.CheckAction<string, "path must not shadow the skill’s own SKILL.md">]>;
+        readonly rawContent: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.CheckAction<string, "rawContent must be at most 524288 bytes">]>;
+        readonly lastModified: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+        readonly content_hash: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, undefined>]>;
+    }, undefined>, undefined>, v.MaxLengthAction<{
+        path: string;
+        rawContent: string;
+        lastModified: number;
+        content_hash: string;
+    }[], 64, undefined>]>, undefined>;
+    /**
+     * The body-item version this machine last agreed with the server about for
+     * this `(scope, root, path)` — the machine-local baseline
+     * (`guide-versioned-identity-plan.md` → slice 2b-B, D10 in
+     * `context-bundle-authoring-plan.md`).
+     *
+     * It is the *client* half of the reconcile precondition, and it exists to
+     * answer a question the server cannot: whether the bytes on this disk were
+     * edited **from** the version the server currently holds, or from an older
+     * one. The server-only guard shipped in 2b-A can see that a dashboard edit
+     * exists, never that this machine has already seen it — so a guide the
+     * dashboard edited and the user then re-synced to disk forks forever.
+     *
+     * **Optional, and its absence is not an error.** A CLI predating the
+     * baseline store, a fresh machine, or a deleted `~/.mossbear/state/` sends
+     * none, and the payload falls back to the server-only guard exactly as it
+     * behaves today. Absence therefore degrades to "decline and fork", never to
+     * an overwrite; a *stale* value degrades to a reported conflict.
+     */
+    readonly expectedVersion: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 1, undefined>]>, undefined>;
+    readonly skippedMemberPaths: v.OptionalSchema<v.SchemaWithPipe<readonly [v.ArraySchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 512, undefined>]>, undefined>, v.MaxLengthAction<string[], 256, undefined>]>, undefined>;
+}, undefined>, v.CheckAction<{
+    path: string;
+    root?: "project" | "global" | undefined;
+    format: "agents-md" | "agents-dir" | "claude-md" | "claude-rules" | "cursorrules" | "cursor-rules" | "skill-md";
+    rawContent: string;
+    lastModified: number;
+    content_hash: string;
+    members?: {
+        path: string;
+        rawContent: string;
+        lastModified: number;
+        content_hash: string;
+    }[] | undefined;
+    expectedVersion?: number | undefined;
+    skippedMemberPaths?: string[] | undefined;
+}, "members are only supported on skill-md payloads">, v.CheckAction<{
+    path: string;
+    root?: "project" | "global" | undefined;
+    format: "agents-md" | "agents-dir" | "claude-md" | "claude-rules" | "cursorrules" | "cursor-rules" | "skill-md";
+    rawContent: string;
+    lastModified: number;
+    content_hash: string;
+    members?: {
+        path: string;
+        rawContent: string;
+        lastModified: number;
+        content_hash: string;
+    }[] | undefined;
+    expectedVersion?: number | undefined;
+    skippedMemberPaths?: string[] | undefined;
+}, "skippedMemberPaths requires members">, v.CheckAction<{
+    path: string;
+    root?: "project" | "global" | undefined;
+    format: "agents-md" | "agents-dir" | "claude-md" | "claude-rules" | "cursorrules" | "cursor-rules" | "skill-md";
+    rawContent: string;
+    lastModified: number;
+    content_hash: string;
+    members?: {
+        path: string;
+        rawContent: string;
+        lastModified: number;
+        content_hash: string;
+    }[] | undefined;
+    expectedVersion?: number | undefined;
+    skippedMemberPaths?: string[] | undefined;
+}, "member paths must be unique (case-insensitive)">]>;
+export declare const GuideMemberFileSchema: v.ObjectSchema<{
+    readonly path: v.SchemaWithPipe<readonly [v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 512, undefined>, v.CheckAction<string, "path must use forward slashes">, v.CheckAction<string, "path must be relative">, v.CheckAction<string, "path must not contain control characters">, v.CheckAction<string, "path must not contain empty, \".\" or \"..\" segments">]>, v.CheckAction<string, "path must not shadow the skill’s own SKILL.md">]>;
+    readonly content: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.CheckAction<string, "rawContent must be at most 524288 bytes">]>;
+    readonly contentHash: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, undefined>]>;
+}, undefined>;
+export declare const GuideMemberFilesResponseSchema: v.SchemaWithPipe<readonly [v.ObjectSchema<{
+    readonly memberFiles: v.SchemaWithPipe<readonly [v.ArraySchema<v.ObjectSchema<{
+        readonly path: v.SchemaWithPipe<readonly [v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 512, undefined>, v.CheckAction<string, "path must use forward slashes">, v.CheckAction<string, "path must be relative">, v.CheckAction<string, "path must not contain control characters">, v.CheckAction<string, "path must not contain empty, \".\" or \"..\" segments">]>, v.CheckAction<string, "path must not shadow the skill’s own SKILL.md">]>;
+        readonly content: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.CheckAction<string, "rawContent must be at most 524288 bytes">]>;
+        readonly contentHash: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, undefined>]>;
+    }, undefined>, undefined>, v.MaxLengthAction<{
+        path: string;
+        content: string;
+        contentHash: string;
+    }[], 64, undefined>]>;
+}, undefined>, v.CheckAction<{
+    memberFiles: {
+        path: string;
+        content: string;
+        contentHash: string;
+    }[];
+}, "member file paths must be unique (case-insensitive)">]>;
+/** Max number of rules accepted in a single `POST /api/rules/import` request. */
+export declare const MAX_RULES_IMPORT_BATCH = 100;
+/** Opaque checkout digest shared by run logs, manifests, and `runs.repo_id`. */
+export declare const RepoIdSchema: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "repoId must be repo_ followed by 32 hex chars">]>;
+/**
+ * A repo's declared portable identity. See `RulesImportRequestSchema.projectId`
+ * for why this is looser than {@link RepoIdSchema} — a declared id is
+ * human-authored and predates any prefix rule.
+ */
+export declare const ProjectIdSchema: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 128, undefined>, v.RegexAction<string, "projectId must contain only letters, digits, underscore, dot or hyphen">]>;
+export declare const RulesImportRequestSchema: v.ObjectSchema<{
+    readonly rules: v.SchemaWithPipe<readonly [v.ArraySchema<v.UnknownSchema, undefined>, v.MaxLengthAction<unknown[], 100, undefined>]>;
+    /**
+     * Which checkout these files came from — the same opaque digest the hook and
+     * the rule manifest already carry (`packages/cli/src/repo-id.ts`,
+     * `RuleManifestSchema.repoId`). Envelope-level, not per-file: every file in
+     * one import comes from one repo, and the per-file payload stays lean (the
+     * "Import endpoint payload" resolved decision).
+     *
+     * It is what lets the server reconcile an edited file back onto the guide it
+     * already created instead of inserting a second one. `origin` alone cannot:
+     * it is `file:{format}:{path}` with no repo component, so two checkouts
+     * sharing `.agents/code-style.md` would collide.
+     *
+     * **Optional, and its absence is not an error.** A CLI predating this field
+     * sends none, and the server falls back to the content-hash dedupe it always
+     * used. Never send a repo id derived anywhere but `repoIdFromRoot` — the
+     * digest is keyed by a machine-local secret precisely so the server never
+     * learns a path.
+     *
+     * Shaped by the canonical `RepoIdSchema` (shared with run logs and manifests)
+     * rather than a looser local check: a row storing anything but
+     * a real digest could never match one, so a malformed identity has to be
+     * rejected at the boundary instead of persisted as a permanent orphan.
+     */
+    readonly repoId: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "repoId must be repo_ followed by 32 hex chars">]>, undefined>;
+    /**
+     * The repo's **portable** identity — `project.id` from the committed
+     * `<repo>/.mossbear/config.json` (`guide-write-side-identity` slice 1, shipped in
+     * #540). This is what makes `(scope, path)` reconciliation portable, and it is
+     * the field `unified-item-sync` slice 2 exists to put on the wire.
+     *
+     * **Why `repoId` is not enough, even though it is already here.**
+     * `repoIdFromRoot` is an HMAC keyed by a machine-local secret
+     * (`packages/cli/src/repo-id.ts`), so the same checkout on two machines — or
+     * one teammate's clone versus another's — produces two different digests. A
+     * guide reconciled on it therefore forks the moment anyone else edits the
+     * file, which is the one-way trip this item is closing. `projectId` is
+     * declared in a committed file, so every clone agrees on it.
+     *
+     * **Optional, and its absence is not an error.** A CLI predating this field
+     * sends none and the server falls back to `repoId` scoping, which is exactly
+     * the behaviour those clients already have. A repo that has never run
+     * `mossbear init` also has no declaration, and must keep importing.
+     *
+     * Deliberately looser than `RepoIdSchema`: a generated id is
+     * `proj_`+hex, but a *declared* one is whatever a human committed —
+     * `readRepoProjectId` accepts any non-empty trimmed string
+     * (`packages/cli/src/docs/repo-config.ts`), and rejecting those here would
+     * break a shipped contract. Constrained only as far as it must be to serve as
+     * a storage key: no whitespace, no path separators, no control characters,
+     * bounded length.
+     */
+    readonly projectId: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 128, undefined>, v.RegexAction<string, "projectId must contain only letters, digits, underscore, dot or hyphen">]>, undefined>;
+}, undefined>;
+/**
+ * What the server did with one payload, reported per file so the CLI can update
+ * its machine-local baseline (`guide-versioned-identity-plan.md` → slice 2b-B).
+ *
+ * The distinction that matters is not "did something change" but **do disk and
+ * server now agree**: `imported`, `updated` and `skipped` all mean they do, and
+ * only those license recording a new baseline. `conflict` means the disk bytes
+ * did *not* land — recording the server's version for one would hand the next
+ * import a matching `expectedVersion` and turn a refused overwrite into an
+ * automatic one on the following run, which is the failure this whole precondition
+ * exists to prevent.
+ */
+export declare const GuideImportOutcomeSchema: v.PicklistSchema<["imported", "updated", "skipped", "conflict"], undefined>;
+/**
+ * Per-payload import outcome, addressed by the same `(root, path)` pair the
+ * server reconciles on so the CLI can key its baseline identically without
+ * re-deriving anything.
+ *
+ * `version` is the body item's version **as the server holds it after this
+ * request** — the value a later import should send as `expectedVersion` once
+ * disk and server agree. It is reported for a `conflict` too, deliberately: the
+ * conflict report needs it to offer explicit resolution, and reporting it is not
+ * the same as recording it.
+ *
+ * Entries are omitted for a payload the server could not address at all (no
+ * `root`, or a pre-R0 row): there is no identity to key a baseline on, and
+ * inventing one would let a later import claim a precondition it never observed.
+ */
+export declare const GuideImportResultSchema: v.ObjectSchema<{
+    readonly root: v.PicklistSchema<["project", "global"], undefined>;
+    readonly path: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 512, undefined>, v.CheckAction<string, "path must use forward slashes">, v.CheckAction<string, "path must be relative">, v.CheckAction<string, "path must not contain control characters">, v.CheckAction<string, "path must not contain empty, \".\" or \"..\" segments">]>;
+    readonly outcome: v.PicklistSchema<["imported", "updated", "skipped", "conflict"], undefined>;
+    readonly version: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 1, undefined>]>;
+}, undefined>;
+export type GuideImportResult = v.InferOutput<typeof GuideImportResultSchema>;
+export declare const RawGuideFileDeletionSchema: v.ObjectSchema<{
+    readonly path: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
+    readonly format: v.PicklistSchema<["agents-md", "agents-dir", "claude-md", "claude-rules", "cursorrules", "cursor-rules", "skill-md"], undefined>;
+}, undefined>;
+/** Max number of deletions accepted in a single `POST /api/rules/deletions` request. */
+export declare const MAX_RULE_DELETIONS_BATCH = 500;
+export declare const RuleDeletionsRequestSchema: v.ObjectSchema<{
+    readonly deletions: v.SchemaWithPipe<readonly [v.ArraySchema<v.UnknownSchema, undefined>, v.MaxLengthAction<unknown[], 500, undefined>]>;
+}, undefined>;
+export declare const BundleSchema: v.ObjectSchema<{
+    readonly id: v.StringSchema<undefined>;
+    readonly slug: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 64, undefined>, v.RegexAction<string, "slug must be lowercase alphanumeric with hyphens">]>;
+    readonly name: v.StringSchema<undefined>;
+    readonly createdAt: v.StringSchema<undefined>;
+}, undefined>;
+export declare const BundleListResponseSchema: v.ObjectSchema<{
+    readonly bundles: v.ArraySchema<v.ObjectSchema<{
+        readonly id: v.StringSchema<undefined>;
+        readonly slug: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 64, undefined>, v.RegexAction<string, "slug must be lowercase alphanumeric with hyphens">]>;
+        readonly name: v.StringSchema<undefined>;
+        readonly createdAt: v.StringSchema<undefined>;
+    }, undefined>, undefined>;
+}, undefined>;
+export declare const CreateBundleRequestSchema: v.ObjectSchema<{
+    readonly slug: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 64, undefined>, v.RegexAction<string, "slug must be lowercase alphanumeric with hyphens">]>;
+    readonly name: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 200, undefined>]>;
+}, undefined>;
+export declare const CreateBundleResponseSchema: v.ObjectSchema<{
+    readonly bundle: v.ObjectSchema<{
+        readonly id: v.StringSchema<undefined>;
+        readonly slug: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 64, undefined>, v.RegexAction<string, "slug must be lowercase alphanumeric with hyphens">]>;
+        readonly name: v.StringSchema<undefined>;
+        readonly createdAt: v.StringSchema<undefined>;
+    }, undefined>;
+}, undefined>;
+export declare const BundleMemberTypeSchema: v.PicklistSchema<["guide_file", "guide"], undefined>;
+export declare const AttachBundleMemberRequestSchema: v.ObjectSchema<{
+    readonly itemId: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
+    readonly itemType: v.OptionalSchema<v.PicklistSchema<["guide_file", "guide"], undefined>, undefined>;
+}, undefined>;
+export declare const AttachBundleMemberResponseSchema: v.ObjectSchema<{
+    readonly attached: v.BooleanSchema<undefined>;
+}, undefined>;
+export declare const DetachBundleMemberResponseSchema: v.ObjectSchema<{
+    readonly detached: v.BooleanSchema<undefined>;
+}, undefined>;
+export declare const RenameBundleRequestSchema: v.ObjectSchema<{
+    readonly name: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 200, undefined>]>;
+}, undefined>;
+export declare const RenameBundleResponseSchema: v.ObjectSchema<{
+    readonly bundle: v.ObjectSchema<{
+        readonly id: v.StringSchema<undefined>;
+        readonly slug: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 64, undefined>, v.RegexAction<string, "slug must be lowercase alphanumeric with hyphens">]>;
+        readonly name: v.StringSchema<undefined>;
+        readonly createdAt: v.StringSchema<undefined>;
+    }, undefined>;
+}, undefined>;
+export declare const DeleteBundleResponseSchema: v.ObjectSchema<{
+    readonly deleted: v.BooleanSchema<undefined>;
+}, undefined>;
+export declare const ContextItemTypeSchema: v.PicklistSchema<["guide", "document", "reference", "asset"], undefined>;
+export declare const PushContentTypeSchema: v.PicklistSchema<["document", "reference", "asset"], undefined>;
+export declare const InboxContentTypeSchema: v.PicklistSchema<["document", "asset"], undefined>;
+/** Max serialized size (UTF-8 bytes) of a pushed or captured item's content. */
+export declare const MAX_CONTEXT_CONTENT_BYTES: number;
+export declare const ContextItemSchema: v.ObjectSchema<{
+    readonly id: v.StringSchema<undefined>;
+    readonly type: v.PicklistSchema<["guide", "document", "reference", "asset"], undefined>;
+    readonly name: v.StringSchema<undefined>;
+    readonly contentType: v.StringSchema<undefined>;
+    readonly content: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+    readonly origin: v.OptionalSchema<v.NullableSchema<v.StringSchema<undefined>, undefined>, undefined>;
+    readonly version: v.OptionalSchema<v.NumberSchema<undefined>, undefined>;
+    readonly root: v.OptionalSchema<v.NullableSchema<v.PicklistSchema<["project", "global"], undefined>, undefined>, undefined>;
+    readonly path: v.OptionalSchema<v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 512, undefined>, v.CheckAction<string, "path must use forward slashes">, v.CheckAction<string, "path must be relative">, v.CheckAction<string, "path must not contain control characters">, v.CheckAction<string, "path must not contain empty, \".\" or \"..\" segments">]>, undefined>, undefined>;
+    readonly updatedAt: v.StringSchema<undefined>;
+}, undefined>;
+export declare const ContextItemsResponseSchema: v.ObjectSchema<{
+    readonly items: v.ArraySchema<v.ObjectSchema<{
+        readonly id: v.StringSchema<undefined>;
+        readonly type: v.PicklistSchema<["guide", "document", "reference", "asset"], undefined>;
+        readonly name: v.StringSchema<undefined>;
+        readonly contentType: v.StringSchema<undefined>;
+        readonly content: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+        readonly origin: v.OptionalSchema<v.NullableSchema<v.StringSchema<undefined>, undefined>, undefined>;
+        readonly version: v.OptionalSchema<v.NumberSchema<undefined>, undefined>;
+        readonly root: v.OptionalSchema<v.NullableSchema<v.PicklistSchema<["project", "global"], undefined>, undefined>, undefined>;
+        readonly path: v.OptionalSchema<v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 512, undefined>, v.CheckAction<string, "path must use forward slashes">, v.CheckAction<string, "path must be relative">, v.CheckAction<string, "path must not contain control characters">, v.CheckAction<string, "path must not contain empty, \".\" or \"..\" segments">]>, undefined>, undefined>;
+        readonly updatedAt: v.StringSchema<undefined>;
+    }, undefined>, undefined>;
+}, undefined>;
+/** Max number of context item ids a push may cite as its transform sources. */
+export declare const MAX_TRANSFORM_SOURCE_IDS = 100;
+/**
+ * The ids of the caller-owned context items a pushed document was produced
+ * from (inbox captures, bundle items — any item the caller owns). Shared
+ * between the REST contract and the MCP tool's client-side arg validation so
+ * the two can't drift.
+ */
+export declare const SourceItemIdsSchema: v.SchemaWithPipe<readonly [v.ArraySchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>, undefined>, v.MinLengthAction<string[], 1, undefined>, v.MaxLengthAction<string[], 100, undefined>]>;
+export declare const UpdatableSourceItemIdsSchema: v.SchemaWithPipe<readonly [v.ArraySchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>, undefined>, v.MaxLengthAction<string[], 100, undefined>]>;
+export declare const PushContextRequestSchema: v.ObjectSchema<{
+    readonly name: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 200, undefined>]>;
+    readonly contentType: v.PicklistSchema<["document", "reference", "asset"], undefined>;
+    readonly content: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.CheckAction<string, "content must be at most 262144 bytes">]>;
+    readonly itemId: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+    readonly origin: v.OptionalSchema<v.NullableSchema<v.StringSchema<undefined>, undefined>, undefined>;
+    readonly sourceItemIds: v.OptionalSchema<v.SchemaWithPipe<readonly [v.ArraySchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>, undefined>, v.MinLengthAction<string[], 1, undefined>, v.MaxLengthAction<string[], 100, undefined>]>, undefined>;
+}, undefined>;
+export declare const PushContextResponseSchema: v.ObjectSchema<{
+    readonly item: v.ObjectSchema<{
+        readonly id: v.StringSchema<undefined>;
+        readonly type: v.PicklistSchema<["guide", "document", "reference", "asset"], undefined>;
+        readonly name: v.StringSchema<undefined>;
+        readonly contentType: v.StringSchema<undefined>;
+        readonly content: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+        readonly origin: v.OptionalSchema<v.NullableSchema<v.StringSchema<undefined>, undefined>, undefined>;
+        readonly version: v.OptionalSchema<v.NumberSchema<undefined>, undefined>;
+        readonly root: v.OptionalSchema<v.NullableSchema<v.PicklistSchema<["project", "global"], undefined>, undefined>, undefined>;
+        readonly path: v.OptionalSchema<v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 512, undefined>, v.CheckAction<string, "path must use forward slashes">, v.CheckAction<string, "path must be relative">, v.CheckAction<string, "path must not contain control characters">, v.CheckAction<string, "path must not contain empty, \".\" or \"..\" segments">]>, undefined>, undefined>;
+        readonly updatedAt: v.StringSchema<undefined>;
+    }, undefined>;
+    readonly created: v.BooleanSchema<undefined>;
+}, undefined>;
+export declare const UpdateContextItemRequestSchema: v.ObjectSchema<{
+    readonly itemId: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
+    readonly name: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 200, undefined>]>, undefined>;
+    readonly content: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.CheckAction<string, "content must be at most 524288 bytes">]>, undefined>;
+    readonly expectedVersion: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 1, undefined>]>, undefined>;
+    readonly sourceItemIds: v.OptionalSchema<v.SchemaWithPipe<readonly [v.ArraySchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>, undefined>, v.MaxLengthAction<string[], 100, undefined>]>, undefined>;
+}, undefined>;
+export declare const UpdateContextItemResponseSchema: v.ObjectSchema<{
+    readonly item: v.ObjectSchema<{
+        readonly id: v.StringSchema<undefined>;
+        readonly type: v.PicklistSchema<["guide", "document", "reference", "asset"], undefined>;
+        readonly name: v.StringSchema<undefined>;
+        readonly contentType: v.StringSchema<undefined>;
+        readonly content: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+        readonly origin: v.OptionalSchema<v.NullableSchema<v.StringSchema<undefined>, undefined>, undefined>;
+        readonly version: v.OptionalSchema<v.NumberSchema<undefined>, undefined>;
+        readonly root: v.OptionalSchema<v.NullableSchema<v.PicklistSchema<["project", "global"], undefined>, undefined>, undefined>;
+        readonly path: v.OptionalSchema<v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 512, undefined>, v.CheckAction<string, "path must use forward slashes">, v.CheckAction<string, "path must be relative">, v.CheckAction<string, "path must not contain control characters">, v.CheckAction<string, "path must not contain empty, \".\" or \"..\" segments">]>, undefined>, undefined>;
+        readonly updatedAt: v.StringSchema<undefined>;
+    }, undefined>;
+    readonly updated: v.BooleanSchema<undefined>;
+}, undefined>;
+export declare const UpdateContextItemBodySchema: Omit<v.ObjectSchema<{
+    readonly itemId: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
+    readonly name: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 200, undefined>]>, undefined>;
+    readonly content: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.CheckAction<string, "content must be at most 524288 bytes">]>, undefined>;
+    readonly expectedVersion: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 1, undefined>]>, undefined>;
+    readonly sourceItemIds: v.OptionalSchema<v.SchemaWithPipe<readonly [v.ArraySchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>, undefined>, v.MaxLengthAction<string[], 100, undefined>]>, undefined>;
+}, undefined>, "~types" | "~run" | "~standard" | "entries"> & {
+    readonly entries: Omit<{
+        readonly itemId: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
+        readonly name: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 200, undefined>]>, undefined>;
+        readonly content: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.CheckAction<string, "content must be at most 524288 bytes">]>, undefined>;
+        readonly expectedVersion: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 1, undefined>]>, undefined>;
+        readonly sourceItemIds: v.OptionalSchema<v.SchemaWithPipe<readonly [v.ArraySchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>, undefined>, v.MaxLengthAction<string[], 100, undefined>]>, undefined>;
+    }, "itemId">;
+    readonly "~standard": v.StandardProps<{
+        content?: string | undefined;
+        expectedVersion?: number | undefined;
+        name?: string | undefined;
+        sourceItemIds?: string[] | undefined;
+    }, {
+        content?: string | undefined;
+        expectedVersion?: number | undefined;
+        name?: string | undefined;
+        sourceItemIds?: string[] | undefined;
+    }>;
+    readonly "~run": (dataset: v.UnknownDataset, config: v.Config<v.BaseIssue<unknown>>) => v.OutputDataset<{
+        content?: string | undefined;
+        expectedVersion?: number | undefined;
+        name?: string | undefined;
+        sourceItemIds?: string[] | undefined;
+    }, v.StringIssue | v.MinLengthIssue<string, 1> | v.CheckIssue<string> | v.NumberIssue | v.IntegerIssue<number> | v.ArrayIssue | v.ObjectIssue | v.MinValueIssue<number, 1> | v.MaxLengthIssue<string, 200> | v.MaxLengthIssue<string[], 100>>;
+    readonly "~types"?: {
+        readonly input: {
+            content?: string | undefined;
+            expectedVersion?: number | undefined;
+            name?: string | undefined;
+            sourceItemIds?: string[] | undefined;
+        };
+        readonly output: {
+            content?: string | undefined;
+            expectedVersion?: number | undefined;
+            name?: string | undefined;
+            sourceItemIds?: string[] | undefined;
+        };
+        readonly issue: v.StringIssue | v.MinLengthIssue<string, 1> | v.CheckIssue<string> | v.NumberIssue | v.IntegerIssue<number> | v.ArrayIssue | v.ObjectIssue | v.MinValueIssue<number, 1> | v.MaxLengthIssue<string, 200> | v.MaxLengthIssue<string[], 100>;
+    } | undefined;
+};
+/** A single canonical item, for the item-scoped read route. */
+export declare const ContextItemResponseSchema: v.ObjectSchema<{
+    readonly item: v.ObjectSchema<{
+        readonly id: v.StringSchema<undefined>;
+        readonly type: v.PicklistSchema<["guide", "document", "reference", "asset"], undefined>;
+        readonly name: v.StringSchema<undefined>;
+        readonly contentType: v.StringSchema<undefined>;
+        readonly content: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+        readonly origin: v.OptionalSchema<v.NullableSchema<v.StringSchema<undefined>, undefined>, undefined>;
+        readonly version: v.OptionalSchema<v.NumberSchema<undefined>, undefined>;
+        readonly root: v.OptionalSchema<v.NullableSchema<v.PicklistSchema<["project", "global"], undefined>, undefined>, undefined>;
+        readonly path: v.OptionalSchema<v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 512, undefined>, v.CheckAction<string, "path must use forward slashes">, v.CheckAction<string, "path must be relative">, v.CheckAction<string, "path must not contain control characters">, v.CheckAction<string, "path must not contain empty, \".\" or \"..\" segments">]>, undefined>, undefined>;
+        readonly updatedAt: v.StringSchema<undefined>;
+    }, undefined>;
+}, undefined>;
+export declare const ArchiveContextItemResponseSchema: v.ObjectSchema<{
+    readonly archived: v.BooleanSchema<undefined>;
+    readonly item: v.ObjectSchema<{
+        readonly id: v.StringSchema<undefined>;
+        readonly type: v.PicklistSchema<["guide", "document", "reference", "asset"], undefined>;
+        readonly name: v.StringSchema<undefined>;
+        readonly contentType: v.StringSchema<undefined>;
+        readonly content: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+        readonly origin: v.OptionalSchema<v.NullableSchema<v.StringSchema<undefined>, undefined>, undefined>;
+        readonly version: v.OptionalSchema<v.NumberSchema<undefined>, undefined>;
+        readonly root: v.OptionalSchema<v.NullableSchema<v.PicklistSchema<["project", "global"], undefined>, undefined>, undefined>;
+        readonly path: v.OptionalSchema<v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 512, undefined>, v.CheckAction<string, "path must use forward slashes">, v.CheckAction<string, "path must be relative">, v.CheckAction<string, "path must not contain control characters">, v.CheckAction<string, "path must not contain empty, \".\" or \"..\" segments">]>, undefined>, undefined>;
+        readonly updatedAt: v.StringSchema<undefined>;
+    }, undefined>;
+}, undefined>;
+export declare const InboxCaptureRequestSchema: v.ObjectSchema<{
+    readonly contentType: v.PicklistSchema<["document", "asset"], undefined>;
+    readonly content: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.CheckAction<string, "content must be at most 262144 bytes">]>;
+    readonly name: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 200, undefined>]>, undefined>;
+    readonly source: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+}, undefined>;
+export declare const InboxItemSchema: v.ObjectSchema<{
+    readonly id: v.StringSchema<undefined>;
+    readonly type: v.PicklistSchema<["guide", "document", "reference", "asset"], undefined>;
+    readonly name: v.StringSchema<undefined>;
+    readonly contentType: v.StringSchema<undefined>;
+    readonly content: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+    readonly source: v.OptionalSchema<v.NullableSchema<v.StringSchema<undefined>, undefined>, undefined>;
+    readonly version: v.OptionalSchema<v.NumberSchema<undefined>, undefined>;
+    readonly capturedAt: v.StringSchema<undefined>;
+    readonly updatedAt: v.StringSchema<undefined>;
+}, undefined>;
+export declare const InboxCaptureResponseSchema: v.ObjectSchema<{
+    readonly item: v.ObjectSchema<{
+        readonly id: v.StringSchema<undefined>;
+        readonly type: v.PicklistSchema<["guide", "document", "reference", "asset"], undefined>;
+        readonly name: v.StringSchema<undefined>;
+        readonly contentType: v.StringSchema<undefined>;
+        readonly content: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+        readonly source: v.OptionalSchema<v.NullableSchema<v.StringSchema<undefined>, undefined>, undefined>;
+        readonly version: v.OptionalSchema<v.NumberSchema<undefined>, undefined>;
+        readonly capturedAt: v.StringSchema<undefined>;
+        readonly updatedAt: v.StringSchema<undefined>;
+    }, undefined>;
+}, undefined>;
+export declare const InboxListResponseSchema: v.ObjectSchema<{
+    readonly items: v.ArraySchema<v.ObjectSchema<{
+        readonly id: v.StringSchema<undefined>;
+        readonly type: v.PicklistSchema<["guide", "document", "reference", "asset"], undefined>;
+        readonly name: v.StringSchema<undefined>;
+        readonly contentType: v.StringSchema<undefined>;
+        readonly content: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+        readonly source: v.OptionalSchema<v.NullableSchema<v.StringSchema<undefined>, undefined>, undefined>;
+        readonly version: v.OptionalSchema<v.NumberSchema<undefined>, undefined>;
+        readonly capturedAt: v.StringSchema<undefined>;
+        readonly updatedAt: v.StringSchema<undefined>;
+    }, undefined>, undefined>;
+}, undefined>;
+/** Max number of ids accepted in a single `POST /api/v1/context/inbox/archive` request. */
+export declare const MAX_INBOX_ARCHIVE_BATCH = 500;
+export declare const InboxArchiveRequestSchema: v.ObjectSchema<{
+    readonly ids: v.SchemaWithPipe<readonly [v.ArraySchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>, undefined>, v.MinLengthAction<string[], 1, undefined>, v.MaxLengthAction<string[], 500, undefined>]>;
+}, undefined>;
+export declare const InboxArchiveResponseSchema: v.ObjectSchema<{
+    readonly archived: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+}, undefined>;
+export declare const ContextItemVersionSchema: v.ObjectSchema<{
+    readonly id: v.StringSchema<undefined>;
+    readonly version: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 1, undefined>]>;
+    readonly contentHash: v.StringSchema<undefined>;
+    readonly authorType: v.StringSchema<undefined>;
+    readonly metadata: v.OptionalSchema<v.NullableSchema<v.RecordSchema<v.StringSchema<undefined>, v.UnknownSchema, undefined>, undefined>, undefined>;
+    readonly createdAt: v.StringSchema<undefined>;
+}, undefined>;
+export declare const ContextItemVersionDetailSchema: v.ObjectSchema<{
+    readonly id: v.StringSchema<undefined>;
+    readonly version: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 1, undefined>]>;
+    readonly content: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+    readonly contentHash: v.StringSchema<undefined>;
+    readonly authorType: v.StringSchema<undefined>;
+    readonly metadata: v.OptionalSchema<v.NullableSchema<v.RecordSchema<v.StringSchema<undefined>, v.UnknownSchema, undefined>, undefined>, undefined>;
+    readonly createdAt: v.StringSchema<undefined>;
+}, undefined>;
+export declare const ContextItemVersionsResponseSchema: v.ObjectSchema<{
+    readonly versions: v.ArraySchema<v.ObjectSchema<{
+        readonly id: v.StringSchema<undefined>;
+        readonly version: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 1, undefined>]>;
+        readonly contentHash: v.StringSchema<undefined>;
+        readonly authorType: v.StringSchema<undefined>;
+        readonly metadata: v.OptionalSchema<v.NullableSchema<v.RecordSchema<v.StringSchema<undefined>, v.UnknownSchema, undefined>, undefined>, undefined>;
+        readonly createdAt: v.StringSchema<undefined>;
+    }, undefined>, undefined>;
+    readonly nextCursor: v.NullableSchema<v.NumberSchema<undefined>, undefined>;
+}, undefined>;
+export declare const ContextItemVersionResponseSchema: v.ObjectSchema<{
+    readonly version: v.ObjectSchema<{
+        readonly id: v.StringSchema<undefined>;
+        readonly version: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 1, undefined>]>;
+        readonly content: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+        readonly contentHash: v.StringSchema<undefined>;
+        readonly authorType: v.StringSchema<undefined>;
+        readonly metadata: v.OptionalSchema<v.NullableSchema<v.RecordSchema<v.StringSchema<undefined>, v.UnknownSchema, undefined>, undefined>, undefined>;
+        readonly createdAt: v.StringSchema<undefined>;
+    }, undefined>;
+}, undefined>;
+/** Default and max page size for the version-history list endpoint. */
+export declare const DEFAULT_VERSIONS_LIMIT = 50;
+export declare const MAX_VERSIONS_LIMIT = 200;
+export declare const ProposalCitationSchema: v.ObjectSchema<{
+    readonly sessionId: v.StringSchema<undefined>;
+    readonly timestamp: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+    readonly summary: v.StringSchema<undefined>;
+}, undefined>;
+/** Max serialized size of an action's `metadata` field — bounds storage bloat. */
+export declare const MAX_ACTION_METADATA_BYTES: number;
+/**
+ * Identity of the skill an agent loaded, captured by the logger hook from a
+ * `Skill` tool call (docs/plans/run-level-grading-plan.md, Slice 0).
+ *
+ * Two fields because the hook can only ever be sure of one of them:
+ *
+ * - `name` is `tool_input.skill` verbatim — always present, never qualified.
+ *   Two skills that share a directory name (`.claude/skills/review` and
+ *   `.agents/skills/review`) are indistinguishable by it, which is review
+ *   finding 5 on PR #387.
+ * - `path` is the skill's *directory*, relative to the discovery root the
+ *   guide import walks and in the same posix form its `origin` carries
+ *   (`.claude/skills/review`). This is the qualified identity: it is exactly
+ *   `guides.origin`'s path with the trailing `/SKILL.md` removed, so the two
+ *   sides of the join are the same string rather than two derivations of it.
+ *   Optional because the hook resolves it by probing the filesystem: a skill
+ *   that lives somewhere the probe does not look (a plugin skill, a
+ *   `~/.claude/skills` skill, a session whose cwd is not the repo root) has a
+ *   name and no path, and matching falls back to the name.
+ */
+export declare const ActionSkillLoadSchema: v.ObjectSchema<{
+    readonly name: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
+    readonly path: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>, undefined>;
+}, undefined>;
+/**
+ * The `actions.action_type` a skill load is stored under.
+ *
+ * Deliberately **not** a member of `KNOWN_ACTION_TYPES` below, even though the
+ * CLI emits it on purpose. A skill load is evidence about what was in the
+ * agent's *context*, not a piece of work anyone should grade — it is an input to
+ * `inContextGuides`, never a row the grader judges (`gradeableActions.ts`
+ * filters it out). Keeping it out of the known-vocabulary list is what stops it
+ * being treated as gradeable work by anything that enumerates that list.
+ */
+export declare const SKILL_LOAD_ACTION_TYPE = "skill_load";
+/**
+ * A machine-shaped label for *why* a tool call failed — `ENOENT`, `TimeoutError`,
+ * `permission_denied`.
+ *
+ * Deliberately not free text. An error *message* is content: it quotes file
+ * contents, stderr and third-party data, which is exactly the class
+ * `content-sync-privacy` gates and `sanitizeCommand` cannot redact (it targets
+ * shell syntax, not prose). A class is metadata, so it rides the same
+ * unblocked path as the exit code. The character set admits identifiers and
+ * dotted/namespaced codes and nothing else; anything failing it is dropped
+ * rather than truncated, because half an error class is not a smaller fact, it
+ * is a different one.
+ */
+export declare const ActionErrorClassSchema: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "errorClass must be 1-32 chars of [A-Za-z0-9_.:-]">]>;
+/**
+ * Whether a logged tool call actually succeeded
+ * (docs/plans/action-evidence-sync-plan.md — the outcome-metadata slice).
+ *
+ * The logger hook parsed `tool_input` and dropped the `tool_response` beside
+ * it, so every action reached the grader looking like it had happened. A failed
+ * edit and a successful one rendered identically, and the run grader has no
+ * other way to tell them apart.
+ *
+ * **Absent means unknown, never success.** The hook emits this only from a
+ * response shape it recognizes (`extractActionOutcome`), and agent tool
+ * responses vary per tool and per platform; a guess here would be worse than
+ * silence, because the grader would weigh it. `status` is therefore the only
+ * required field, and the whole object is optional everywhere it appears.
+ */
+export declare const ActionOutcomeSchema: v.ObjectSchema<{
+    readonly status: v.PicklistSchema<["ok", "error"], undefined>;
+    readonly errorClass: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "errorClass must be 1-32 chars of [A-Za-z0-9_.:-]">]>, undefined>;
+    /**
+     * Bounded to a signed 16-bit range, which covers every real exit status
+     * (0-255, 128+signal, and Node's -1) with room to spare. The bound is a line
+     * length bound as much as a validity one: this renders into the grading
+     * prompt, where every field is capped.
+     */
+    readonly exitCode: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, -32768, undefined>, v.MaxValueAction<number, 32767, undefined>]>, undefined>;
+}, undefined>;
+/**
+ * Longest narration field accepted on the wire.
+ *
+ * Matches `MAX_PROSE_CHARS` in `@mossbear/eval-core`, which is the cap the
+ * client-side redactor already applies. Duplicated as a literal rather than
+ * imported because the dependency runs the other way — `@mossbear/eval-core`
+ * depends on this package — and inverting it to share one constant would make
+ * the wire contract depend on the evaluation package. The number is a bound, so
+ * a drift between them fails safe in the direction that matters: the server
+ * refusing something the client would have sent, never the reverse.
+ */
+export declare const MAX_ACTION_NARRATION_CHARS = 2000;
+/**
+ * Transcript evidence attached to an action
+ * (docs/plans/transcript-content-classes-plan.md — the founder's class call of
+ * 2026-08-13).
+ *
+ * **Two fields, and the omissions are the specification.** The class table
+ * decides that user turns and assistant *prose* sync prose-redacted, assistant
+ * code blocks are stripped to a language-and-line-count placeholder, and
+ * tool-result bodies **never** sync. There is therefore no field here for a
+ * tool result, no field for a code-block body, and no field for a diff.
+ *
+ * **`strictObject`, so a body that carries one is rejected rather than
+ * trimmed.** This is the same decision `StrictActionOutcomeSchema` above makes
+ * and for a sharper version of the same reason. A permissive `v.object` strips
+ * unknown keys on output, which would turn a client sending
+ * `narration.toolResult` into a *silently accepted* request: the sender is told
+ * it worked, learns nothing, and keeps sending. Trimming is a policy that fails
+ * open — it makes an over-sharing client indistinguishable from a correct one.
+ * Rejecting makes the class table enforceable against a client the server does
+ * not control, which is the only kind of enforcement worth having here; the
+ * CLI's own choke point (`packages/cli/src/transcript/narration.ts`) is the
+ * first line, not the last.
+ *
+ * The forward-compatibility cost is the same as `outcome`'s, and so is the
+ * ordering that pays it: widen this schema and deploy the server before any
+ * CLI starts sending a new narration field.
+ */
+export declare const ActionNarrationSchema: v.StrictObjectSchema<{
+    /**
+     * The user turn this action followed — prose-redacted on the user's machine.
+     *
+     * **Not every message with `role: 'user'`.** A tool result is delivered as a
+     * user-role message whose content is a `tool_result` block, so the client
+     * selects on content-block type rather than role
+     * (`packages/cli/src/transcript/messages.ts`). Nothing on this side can tell
+     * the difference after the fact, which is why the client selects
+     * structurally and this schema constrains the shape rather than the content.
+     */
+    readonly userText: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MaxLengthAction<string, 2000, undefined>, v.CheckAction<string, "narration must not contain a code block — code is stripped structurally on the client before upload">]>, undefined>;
+    /**
+     * Assistant prose adjacent to the tool call — code blocks structurally
+     * removed, then prose-redacted, then windowed, all on the user's machine.
+     */
+    readonly assistantText: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MaxLengthAction<string, 2000, undefined>, v.CheckAction<string, "narration must not contain a code block — code is stripped structurally on the client before upload">]>, undefined>;
+}, undefined>;
+export type ActionNarration = v.InferOutput<typeof ActionNarrationSchema>;
+export declare const TokenUsageSchema: v.ObjectSchema<{
+    readonly model: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
+    readonly provider: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+    readonly inputTokens: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+    readonly outputTokens: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+    readonly cacheReadTokens: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>, undefined>;
+    readonly cacheWriteTokens: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>, undefined>;
+}, undefined>;
+export declare const DashboardRunUsageSchema: v.ObjectSchema<{
+    readonly runId: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+    readonly sessionId: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
+    readonly usage: v.ArraySchema<v.ObjectSchema<{
+        readonly model: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
+        readonly provider: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+        readonly inputTokens: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+        readonly outputTokens: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+        readonly cacheReadTokens: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>, undefined>;
+        readonly cacheWriteTokens: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>, undefined>;
+    }, undefined>, undefined>;
+}, undefined>;
+export declare const SkillUsageEntrySchema: v.ObjectSchema<{
+    readonly skillName: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
+    readonly model: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
+    readonly inputTokens: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+    readonly cacheWriteTokens: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>, undefined>;
+}, undefined>;
+export declare const DashboardSkillUsageSchema: v.ObjectSchema<{
+    readonly runId: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+    readonly sessionId: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
+    readonly usage: v.ArraySchema<v.ObjectSchema<{
+        readonly skillName: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
+        readonly model: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
+        readonly inputTokens: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+        readonly cacheWriteTokens: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>, undefined>;
+    }, undefined>, undefined>;
+}, undefined>;
+export declare const DashboardSyncActionSchema: v.ObjectSchema<{
+    readonly id: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MaxLengthAction<string, 128, undefined>, v.RegexAction<string, "id must not contain whitespace or control characters">]>, undefined>;
+    readonly adapterId: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+    readonly runId: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+    /**
+     * Optional on the wire, but **required to be graded**: runs are the only
+     * grading unit, and an action with no session joins no run
+     * (docs/plans/run-level-grading-plan.md). The field stays optional because
+     * tightening it would 400 a whole batch — a poison pill for any queue file
+     * carrying one — and no shipped CLI omits it: the hook always writes a
+     * session id, falling back to the literal `'unknown'`
+     * (`packages/cli/src/hook-logger.ts:129`), which groups into a run like any
+     * other. A direct API caller that omits it gets its actions stored and
+     * ungraded, and the server logs `sync.actions_without_session` so the case is
+     * visible rather than silent.
+     */
+    readonly sessionId: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+    readonly actionType: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MaxLengthAction<string, 128, undefined>]>;
+    readonly summary: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MaxLengthAction<string, 4000, undefined>]>;
+    readonly filePaths: v.OptionalSchema<v.SchemaWithPipe<readonly [v.ArraySchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MaxLengthAction<string, 1024, undefined>]>, undefined>, v.MaxLengthAction<string[], 100, undefined>]>, undefined>;
+    readonly verdict: v.OptionalSchema<v.PicklistSchema<["aligned", "unguided", "misaligned"], undefined>, undefined>;
+    readonly gradingTier: v.OptionalSchema<v.PicklistSchema<["pattern_match", "cached", "llm", "batch", "unguided"], undefined>, undefined>;
+    readonly guideIds: v.OptionalSchema<v.ArraySchema<v.StringSchema<undefined>, undefined>, undefined>;
+    readonly violatedGuideId: v.OptionalSchema<v.NullableSchema<v.StringSchema<undefined>, undefined>, undefined>;
+    readonly evalReasoning: v.OptionalSchema<v.NullableSchema<v.StringSchema<undefined>, undefined>, undefined>;
+    readonly metadata: v.OptionalSchema<v.NullableSchema<v.SchemaWithPipe<readonly [v.RecordSchema<v.StringSchema<undefined>, v.UnknownSchema, undefined>, v.CheckAction<{
+        [x: string]: unknown;
+    }, "metadata must serialize to at most 16384 bytes">, v.CheckAction<{
+        [x: string]: unknown;
+    }, "metadata.skill must be { name: string, path?: string }">, v.CheckAction<{
+        [x: string]: unknown;
+    }, "metadata.repoId must be repo_ followed by 32 hex chars">, v.CheckAction<{
+        [x: string]: unknown;
+    }, "metadata.outcome must be { status: \"ok\" | \"error\", errorClass?: string, exitCode?: number } with no other keys">]>, undefined>, undefined>;
+    /**
+     * Transcript evidence for this action. See {@link ActionNarrationSchema}.
+     *
+     * A top-level field rather than a `metadata` key, and that is a decision
+     * rather than a style choice (design review, 2026-08-15): `metadata` is an
+     * open record holding *metadata* under one shared 16 KB budget, and this is
+     * content — the first content an action carries. It lands in its own column
+     * server-side for the same reason.
+     *
+     * **No shipped CLI sends this yet.** Slice 2 builds the extraction and both
+     * halves of the enforcement; Slice 3 adds the column and the disclosure
+     * surface and is what turns it on, so nothing begins leaving a user's machine
+     * a release before the panel describing it.
+     */
+    readonly narration: v.OptionalSchema<v.StrictObjectSchema<{
+        /**
+         * The user turn this action followed — prose-redacted on the user's machine.
+         *
+         * **Not every message with `role: 'user'`.** A tool result is delivered as a
+         * user-role message whose content is a `tool_result` block, so the client
+         * selects on content-block type rather than role
+         * (`packages/cli/src/transcript/messages.ts`). Nothing on this side can tell
+         * the difference after the fact, which is why the client selects
+         * structurally and this schema constrains the shape rather than the content.
+         */
+        readonly userText: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MaxLengthAction<string, 2000, undefined>, v.CheckAction<string, "narration must not contain a code block — code is stripped structurally on the client before upload">]>, undefined>;
+        /**
+         * Assistant prose adjacent to the tool call — code blocks structurally
+         * removed, then prose-redacted, then windowed, all on the user's machine.
+         */
+        readonly assistantText: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MaxLengthAction<string, 2000, undefined>, v.CheckAction<string, "narration must not contain a code block — code is stripped structurally on the client before upload">]>, undefined>;
+    }, undefined>, undefined>;
+    /**
+     * Version of the CLI that *produced* this action's verdict.
+     *
+     * **No shipped CLI sends this any more.** Its only writer was `mossbear verdict
+     * record`, whose queue files could outlive an upgrade, which is why the
+     * per-action version was distinguished from the request-level one at all.
+     * That command is gone (docs/plans/cli-local-grading-removal-plan.md) and no
+     * client-side verdict exists to attribute.
+     *
+     * Kept on the wire for one release so an un-upgraded CLI's queued verdicts
+     * are not rejected mid-migration; the field and the `actions.cli_version`
+     * column it feeds are dropped together (`action-cli-version-column-drop`).
+     * For the CLI making the request — which is live, and what
+     * `enforceCliVersionFloor` reads — see `DashboardSyncRequestSchema`.
+     */
+    readonly cliVersion: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, 64, undefined>]>, undefined>;
+}, undefined>;
+export declare const DashboardGuideSuggestionSchema: v.ObjectSchema<{
+    readonly id: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+    readonly content: v.StringSchema<undefined>;
+    readonly reasoning: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+    readonly triggerType: v.PicklistSchema<["uncovered", "ambiguous", "performance_pattern", "conversational_feedback"], undefined>;
+    readonly sourceActionIds: v.OptionalSchema<v.ArraySchema<v.UnionSchema<[v.StringSchema<undefined>, v.ObjectSchema<{
+        readonly sessionId: v.StringSchema<undefined>;
+        readonly timestamp: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+        readonly summary: v.StringSchema<undefined>;
+    }, undefined>], undefined>, undefined>, undefined>;
+    readonly status: v.OptionalSchema<v.PicklistSchema<["pending", "accepted", "dismissed"], undefined>, undefined>;
+}, undefined>;
+export declare const DashboardFeedbackCandidateSchema: v.ObjectSchema<{
+    readonly id: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+    readonly signal: v.StringSchema<undefined>;
+    readonly signalType: v.PicklistSchema<["correction", "approval", "implied_preference", "stated_preference", "skill_suggestion"], undefined>;
+    readonly confidence: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, 0, undefined>, v.MaxValueAction<number, 1, undefined>]>, undefined>;
+    readonly occurrences: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 1, undefined>]>, undefined>;
+    readonly status: v.OptionalSchema<v.PicklistSchema<["inferred", "confirmed", "dismissed"], undefined>, undefined>;
+}, undefined>;
+/** Max number of actions accepted in a single `POST /api/sync` request. */
+export declare const MAX_SYNC_ACTIONS_BATCH = 500;
+/** Max number of guideSuggestions/feedbackCandidates/runUsage entries per sync request. */
+export declare const MAX_SYNC_AUX_BATCH = 100;
+/**
+ * Max rule files one delivery manifest enumerates. Well above what a real repo
+ * carries (this one: ~20), and bounded because the manifest rides every
+ * action-carrying batch: an unbounded list would multiply across a chunked
+ * sync. Overflow sets `truncated` rather than being dropped silently.
+ */
+export declare const MAX_RULE_MANIFEST_FILES = 500;
+/**
+ * A rule file observed on disk in the repo `mossbear sync` ran from.
+ *
+ * `path` is relative to that repo root, in exactly the form `payloadPath`
+ * takes at import time (`packages/cli/src/rules/discover.ts`), so
+ * `file:{format}:{path}` reconstructs the `origin` the dashboard stored for
+ * the guide this file produced. That reconstruction is the whole join; nothing
+ * else about the file is needed and nothing else is sent.
+ *
+ * **Never any content.** `contentHash` is the same sha256 the import payload
+ * carries, present so a later slice can tell "delivered" from "delivered but
+ * edited since import" without shipping the bytes again.
+ */
+export declare const RuleManifestFileSchema: v.ObjectSchema<{
+    readonly path: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 512, undefined>]>;
+    readonly format: v.PicklistSchema<["agents-md", "agents-dir", "claude-md", "claude-rules", "cursorrules", "cursor-rules", "skill-md"], undefined>;
+    readonly contentHash: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, undefined>]>;
+}, undefined>;
+/**
+ * Which rule files were actually on disk in the repo this sync ran from —
+ * observed delivery, replacing the assumption that every non-skill active
+ * guide reached the agent (docs/plans/run-level-grading-plan.md, review
+ * finding 3). Without it, an account with several repos, or a
+ * dashboard-authored guide never exported anywhere, is graded against
+ * instructions the agent never received.
+ *
+ * `repoId` is an opaque, machine-local digest — deliberately not a path, a
+ * remote URL, or a repo name. Its only job is to keep two checkouts on the
+ * same account distinguishable, which is the half of review finding 5 that
+ * repo-root-relative origins cannot express: two repos each holding
+ * `.claude/skills/review` produce byte-identical origins by construction. See
+ * `repoIdFromRoot` (`packages/cli/src/rules/manifest.ts`) for how it is
+ * derived and why that derivation is privacy-safe.
+ */
+export declare const RuleFileManifestSchema: v.ObjectSchema<{
+    readonly repoId: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "repoId must be repo_ followed by 32 hex chars">]>;
+    readonly files: v.SchemaWithPipe<readonly [v.ArraySchema<v.ObjectSchema<{
+        readonly path: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 512, undefined>]>;
+        readonly format: v.PicklistSchema<["agents-md", "agents-dir", "claude-md", "claude-rules", "cursorrules", "cursor-rules", "skill-md"], undefined>;
+        readonly contentHash: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, undefined>]>;
+    }, undefined>, undefined>, v.MaxLengthAction<{
+        path: string;
+        format: "agents-md" | "agents-dir" | "claude-md" | "claude-rules" | "cursorrules" | "cursor-rules" | "skill-md";
+        contentHash: string;
+    }[], 500, undefined>]>;
+    /**
+     * The repo held more rule files than the cap, so `files` is a prefix. Set
+     * rather than silently trimmed: a manifest read as complete would mark the
+     * omitted files' guides undelivered, which is the exact wrong-verdict
+     * failure this field exists to prevent.
+     */
+    readonly truncated: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
+}, undefined>;
+export declare const DashboardSyncRequestSchema: v.ObjectSchema<{
+    readonly actions: v.OptionalSchema<v.SchemaWithPipe<readonly [v.ArraySchema<v.ObjectSchema<{
+        readonly id: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MaxLengthAction<string, 128, undefined>, v.RegexAction<string, "id must not contain whitespace or control characters">]>, undefined>;
+        readonly adapterId: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+        readonly runId: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+        /**
+         * Optional on the wire, but **required to be graded**: runs are the only
+         * grading unit, and an action with no session joins no run
+         * (docs/plans/run-level-grading-plan.md). The field stays optional because
+         * tightening it would 400 a whole batch — a poison pill for any queue file
+         * carrying one — and no shipped CLI omits it: the hook always writes a
+         * session id, falling back to the literal `'unknown'`
+         * (`packages/cli/src/hook-logger.ts:129`), which groups into a run like any
+         * other. A direct API caller that omits it gets its actions stored and
+         * ungraded, and the server logs `sync.actions_without_session` so the case is
+         * visible rather than silent.
+         */
+        readonly sessionId: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+        readonly actionType: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MaxLengthAction<string, 128, undefined>]>;
+        readonly summary: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MaxLengthAction<string, 4000, undefined>]>;
+        readonly filePaths: v.OptionalSchema<v.SchemaWithPipe<readonly [v.ArraySchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MaxLengthAction<string, 1024, undefined>]>, undefined>, v.MaxLengthAction<string[], 100, undefined>]>, undefined>;
+        readonly verdict: v.OptionalSchema<v.PicklistSchema<["aligned", "unguided", "misaligned"], undefined>, undefined>;
+        readonly gradingTier: v.OptionalSchema<v.PicklistSchema<["pattern_match", "cached", "llm", "batch", "unguided"], undefined>, undefined>;
+        readonly guideIds: v.OptionalSchema<v.ArraySchema<v.StringSchema<undefined>, undefined>, undefined>;
+        readonly violatedGuideId: v.OptionalSchema<v.NullableSchema<v.StringSchema<undefined>, undefined>, undefined>;
+        readonly evalReasoning: v.OptionalSchema<v.NullableSchema<v.StringSchema<undefined>, undefined>, undefined>;
+        readonly metadata: v.OptionalSchema<v.NullableSchema<v.SchemaWithPipe<readonly [v.RecordSchema<v.StringSchema<undefined>, v.UnknownSchema, undefined>, v.CheckAction<{
+            [x: string]: unknown;
+        }, "metadata must serialize to at most 16384 bytes">, v.CheckAction<{
+            [x: string]: unknown;
+        }, "metadata.skill must be { name: string, path?: string }">, v.CheckAction<{
+            [x: string]: unknown;
+        }, "metadata.repoId must be repo_ followed by 32 hex chars">, v.CheckAction<{
+            [x: string]: unknown;
+        }, "metadata.outcome must be { status: \"ok\" | \"error\", errorClass?: string, exitCode?: number } with no other keys">]>, undefined>, undefined>;
+        /**
+         * Transcript evidence for this action. See {@link ActionNarrationSchema}.
+         *
+         * A top-level field rather than a `metadata` key, and that is a decision
+         * rather than a style choice (design review, 2026-08-15): `metadata` is an
+         * open record holding *metadata* under one shared 16 KB budget, and this is
+         * content — the first content an action carries. It lands in its own column
+         * server-side for the same reason.
+         *
+         * **No shipped CLI sends this yet.** Slice 2 builds the extraction and both
+         * halves of the enforcement; Slice 3 adds the column and the disclosure
+         * surface and is what turns it on, so nothing begins leaving a user's machine
+         * a release before the panel describing it.
+         */
+        readonly narration: v.OptionalSchema<v.StrictObjectSchema<{
+            /**
+             * The user turn this action followed — prose-redacted on the user's machine.
+             *
+             * **Not every message with `role: 'user'`.** A tool result is delivered as a
+             * user-role message whose content is a `tool_result` block, so the client
+             * selects on content-block type rather than role
+             * (`packages/cli/src/transcript/messages.ts`). Nothing on this side can tell
+             * the difference after the fact, which is why the client selects
+             * structurally and this schema constrains the shape rather than the content.
+             */
+            readonly userText: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MaxLengthAction<string, 2000, undefined>, v.CheckAction<string, "narration must not contain a code block — code is stripped structurally on the client before upload">]>, undefined>;
+            /**
+             * Assistant prose adjacent to the tool call — code blocks structurally
+             * removed, then prose-redacted, then windowed, all on the user's machine.
+             */
+            readonly assistantText: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MaxLengthAction<string, 2000, undefined>, v.CheckAction<string, "narration must not contain a code block — code is stripped structurally on the client before upload">]>, undefined>;
+        }, undefined>, undefined>;
+        /**
+         * Version of the CLI that *produced* this action's verdict.
+         *
+         * **No shipped CLI sends this any more.** Its only writer was `mossbear verdict
+         * record`, whose queue files could outlive an upgrade, which is why the
+         * per-action version was distinguished from the request-level one at all.
+         * That command is gone (docs/plans/cli-local-grading-removal-plan.md) and no
+         * client-side verdict exists to attribute.
+         *
+         * Kept on the wire for one release so an un-upgraded CLI's queued verdicts
+         * are not rejected mid-migration; the field and the `actions.cli_version`
+         * column it feeds are dropped together (`action-cli-version-column-drop`).
+         * For the CLI making the request — which is live, and what
+         * `enforceCliVersionFloor` reads — see `DashboardSyncRequestSchema`.
+         */
+        readonly cliVersion: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, 64, undefined>]>, undefined>;
+    }, undefined>, undefined>, v.MaxLengthAction<{
+        id?: string | undefined;
+        adapterId?: string | undefined;
+        runId?: string | undefined;
+        sessionId?: string | undefined;
+        actionType: string;
+        summary: string;
+        filePaths?: string[] | undefined;
+        verdict?: "aligned" | "unguided" | "misaligned" | undefined;
+        gradingTier?: "unguided" | "pattern_match" | "cached" | "llm" | "batch" | undefined;
+        guideIds?: string[] | undefined;
+        violatedGuideId?: string | null | undefined;
+        evalReasoning?: string | null | undefined;
+        metadata?: {
+            [x: string]: unknown;
+        } | null | undefined;
+        narration?: {
+            userText?: string | undefined;
+            assistantText?: string | undefined;
+        } | undefined;
+        cliVersion?: string | undefined;
+    }[], 500, undefined>]>, undefined>;
+    readonly guideSuggestions: v.OptionalSchema<v.SchemaWithPipe<readonly [v.ArraySchema<v.ObjectSchema<{
+        readonly id: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+        readonly content: v.StringSchema<undefined>;
+        readonly reasoning: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+        readonly triggerType: v.PicklistSchema<["uncovered", "ambiguous", "performance_pattern", "conversational_feedback"], undefined>;
+        readonly sourceActionIds: v.OptionalSchema<v.ArraySchema<v.UnionSchema<[v.StringSchema<undefined>, v.ObjectSchema<{
+            readonly sessionId: v.StringSchema<undefined>;
+            readonly timestamp: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+            readonly summary: v.StringSchema<undefined>;
+        }, undefined>], undefined>, undefined>, undefined>;
+        readonly status: v.OptionalSchema<v.PicklistSchema<["pending", "accepted", "dismissed"], undefined>, undefined>;
+    }, undefined>, undefined>, v.MaxLengthAction<{
+        id?: string | undefined;
+        content: string;
+        reasoning?: string | undefined;
+        triggerType: "uncovered" | "ambiguous" | "performance_pattern" | "conversational_feedback";
+        sourceActionIds?: (string | {
+            sessionId: string;
+            timestamp?: string | undefined;
+            summary: string;
+        })[] | undefined;
+        status?: "pending" | "accepted" | "dismissed" | undefined;
+    }[], 100, undefined>]>, undefined>;
+    readonly feedbackCandidates: v.OptionalSchema<v.SchemaWithPipe<readonly [v.ArraySchema<v.ObjectSchema<{
+        readonly id: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+        readonly signal: v.StringSchema<undefined>;
+        readonly signalType: v.PicklistSchema<["correction", "approval", "implied_preference", "stated_preference", "skill_suggestion"], undefined>;
+        readonly confidence: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, 0, undefined>, v.MaxValueAction<number, 1, undefined>]>, undefined>;
+        readonly occurrences: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 1, undefined>]>, undefined>;
+        readonly status: v.OptionalSchema<v.PicklistSchema<["inferred", "confirmed", "dismissed"], undefined>, undefined>;
+    }, undefined>, undefined>, v.MaxLengthAction<{
+        id?: string | undefined;
+        signal: string;
+        signalType: "correction" | "approval" | "implied_preference" | "stated_preference" | "skill_suggestion";
+        confidence?: number | undefined;
+        occurrences?: number | undefined;
+        status?: "dismissed" | "inferred" | "confirmed" | undefined;
+    }[], 100, undefined>]>, undefined>;
+    readonly runUsage: v.OptionalSchema<v.SchemaWithPipe<readonly [v.ArraySchema<v.ObjectSchema<{
+        readonly runId: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+        readonly sessionId: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
+        readonly usage: v.ArraySchema<v.ObjectSchema<{
+            readonly model: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
+            readonly provider: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+            readonly inputTokens: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+            readonly outputTokens: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+            readonly cacheReadTokens: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>, undefined>;
+            readonly cacheWriteTokens: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>, undefined>;
+        }, undefined>, undefined>;
+    }, undefined>, undefined>, v.MaxLengthAction<{
+        runId?: string | undefined;
+        sessionId: string;
+        usage: {
+            model: string;
+            provider?: string | undefined;
+            inputTokens: number;
+            outputTokens: number;
+            cacheReadTokens?: number | undefined;
+            cacheWriteTokens?: number | undefined;
+        }[];
+    }[], 100, undefined>]>, undefined>;
+    readonly skillUsage: v.OptionalSchema<v.SchemaWithPipe<readonly [v.ArraySchema<v.ObjectSchema<{
+        readonly runId: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+        readonly sessionId: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
+        readonly usage: v.ArraySchema<v.ObjectSchema<{
+            readonly skillName: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
+            readonly model: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
+            readonly inputTokens: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+            readonly cacheWriteTokens: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>, undefined>;
+        }, undefined>, undefined>;
+    }, undefined>, undefined>, v.MaxLengthAction<{
+        runId?: string | undefined;
+        sessionId: string;
+        usage: {
+            skillName: string;
+            model: string;
+            inputTokens: number;
+            cacheWriteTokens?: number | undefined;
+        }[];
+    }[], 100, undefined>]>, undefined>;
+    /**
+     * Version of the CLI making *this request* — the live one, and the only
+     * `cliVersion` a shipped CLI still sends (the per-action field is a
+     * migration leftover; see `DashboardSyncActionSchema`). It sits on the
+     * envelope because the server reads it before touching any row, to
+     * compare against its version floor and reject an incompatible client with
+     * 426 rather than half-ingesting the batch. Optional: clients predating this
+     * field send none, and are never blocked for it.
+     */
+    readonly cliVersion: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, 64, undefined>]>, undefined>;
+    /**
+     * Sessions whose agent context has ended, named by the CLI's `SessionEnd`
+     * hook (`mossbear sync --session-complete`) — never by its per-turn `Stop` hook.
+     * The server closes those sessions' runs; every other session in the payload
+     * stays open.
+     *
+     * Session-keyed rather than a single envelope-level boolean, because one
+     * `mossbear sync` uploads every session with pending actions and chunks them
+     * across several requests. A boolean would close sessions that merely had a
+     * backlog, and would close a session before the batches carrying the rest of
+     * its actions had arrived. The CLI therefore names a session here only on the
+     * final batch that carries that session's actions.
+     *
+     * Deliberately an assertion, not a fact: `SessionEnd` also fires on
+     * `/clear`, `--resume` and `logout`, and a reclaimed cloud container may fire
+     * nothing at all. Closing is therefore reversible — later actions for a
+     * closed run reopen it — and the server's idle sweep, not this field, is what
+     * runs actually depend on being closed by. See
+     * docs/plans/run-level-grading-plan.md Slice 1.
+     */
+    readonly completedSessionIds: v.OptionalSchema<v.SchemaWithPipe<readonly [v.ArraySchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>, undefined>, v.MaxLengthAction<string[], 100, undefined>]>, undefined>;
+    /**
+     * The rule files present in the repo this sync ran from — see
+     * {@link RuleFileManifestSchema}.
+     *
+     * Envelope-level rather than per-action because it describes the machine and
+     * the checkout, not any one tool call; the server attaches it to the runs it
+     * materializes from this request. Present on every batch that carries
+     * actions, so a session chunked across several requests has the manifest
+     * available wherever its run is touched.
+     *
+     * Optional: a CLI predating this sends none, and the server must read its
+     * absence as "delivery unobserved", never as "nothing was delivered".
+     */
+    readonly ruleManifest: v.OptionalSchema<v.ObjectSchema<{
+        readonly repoId: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "repoId must be repo_ followed by 32 hex chars">]>;
+        readonly files: v.SchemaWithPipe<readonly [v.ArraySchema<v.ObjectSchema<{
+            readonly path: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 512, undefined>]>;
+            readonly format: v.PicklistSchema<["agents-md", "agents-dir", "claude-md", "claude-rules", "cursorrules", "cursor-rules", "skill-md"], undefined>;
+            readonly contentHash: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, undefined>]>;
+        }, undefined>, undefined>, v.MaxLengthAction<{
+            path: string;
+            format: "agents-md" | "agents-dir" | "claude-md" | "claude-rules" | "cursorrules" | "cursor-rules" | "skill-md";
+            contentHash: string;
+        }[], 500, undefined>]>;
+        /**
+         * The repo held more rule files than the cap, so `files` is a prefix. Set
+         * rather than silently trimmed: a manifest read as complete would mark the
+         * omitted files' guides undelivered, which is the exact wrong-verdict
+         * failure this field exists to prevent.
+         */
+        readonly truncated: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
+    }, undefined>, undefined>;
+}, undefined>;
+export declare const ExtractedGuideSuggestionSchema: v.ObjectSchema<{
+    readonly id: v.StringSchema<undefined>;
+    readonly content: v.StringSchema<undefined>;
+    readonly reasoning: v.StringSchema<undefined>;
+    readonly triggerType: v.PicklistSchema<["conversational_feedback"], undefined>;
+    readonly confidence: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, 0, undefined>, v.MaxValueAction<number, 1, undefined>]>;
+    readonly occurrences: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 1, undefined>]>;
+    readonly citations: v.ArraySchema<v.ObjectSchema<{
+        readonly sessionId: v.StringSchema<undefined>;
+        readonly timestamp: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+        readonly summary: v.StringSchema<undefined>;
+    }, undefined>, undefined>;
+    readonly source: v.PicklistSchema<["claude_code", "cursor", "copilot", "windsurf", "other"], undefined>;
+}, undefined>;
+export declare const ExtractedSkillSuggestionSchema: v.ObjectSchema<{
+    readonly id: v.StringSchema<undefined>;
+    readonly signal: v.StringSchema<undefined>;
+    readonly confidence: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, 0, undefined>, v.MaxValueAction<number, 1, undefined>]>;
+    readonly occurrences: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 1, undefined>]>;
+    readonly citations: v.ArraySchema<v.ObjectSchema<{
+        readonly sessionId: v.StringSchema<undefined>;
+        readonly timestamp: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+        readonly summary: v.StringSchema<undefined>;
+    }, undefined>, undefined>;
+    readonly source: v.PicklistSchema<["claude_code", "cursor", "copilot", "windsurf", "other"], undefined>;
+}, undefined>;
+export declare const ExtractedFeedbackBatchSchema: v.ObjectSchema<{
+    readonly guideSuggestions: v.ArraySchema<v.ObjectSchema<{
+        readonly id: v.StringSchema<undefined>;
+        readonly content: v.StringSchema<undefined>;
+        readonly reasoning: v.StringSchema<undefined>;
+        readonly triggerType: v.PicklistSchema<["conversational_feedback"], undefined>;
+        readonly confidence: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, 0, undefined>, v.MaxValueAction<number, 1, undefined>]>;
+        readonly occurrences: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 1, undefined>]>;
+        readonly citations: v.ArraySchema<v.ObjectSchema<{
+            readonly sessionId: v.StringSchema<undefined>;
+            readonly timestamp: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+            readonly summary: v.StringSchema<undefined>;
+        }, undefined>, undefined>;
+        readonly source: v.PicklistSchema<["claude_code", "cursor", "copilot", "windsurf", "other"], undefined>;
+    }, undefined>, undefined>;
+    readonly skillSuggestions: v.ArraySchema<v.ObjectSchema<{
+        readonly id: v.StringSchema<undefined>;
+        readonly signal: v.StringSchema<undefined>;
+        readonly confidence: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, 0, undefined>, v.MaxValueAction<number, 1, undefined>]>;
+        readonly occurrences: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 1, undefined>]>;
+        readonly citations: v.ArraySchema<v.ObjectSchema<{
+            readonly sessionId: v.StringSchema<undefined>;
+            readonly timestamp: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+            readonly summary: v.StringSchema<undefined>;
+        }, undefined>, undefined>;
+        readonly source: v.PicklistSchema<["claude_code", "cursor", "copilot", "windsurf", "other"], undefined>;
+    }, undefined>, undefined>;
+}, undefined>;
+export declare const AgentConfigSchema: v.ObjectSchema<{
+    readonly id: v.StringSchema<undefined>;
+    readonly name: v.StringSchema<undefined>;
+    readonly description: v.StringSchema<undefined>;
+    readonly capabilities: v.ArraySchema<v.StringSchema<undefined>, undefined>;
+    readonly meta: v.OptionalSchema<v.RecordSchema<v.StringSchema<undefined>, v.UnknownSchema, undefined>, undefined>;
+}, undefined>;
+export declare const ActionEntrySchema: v.ObjectSchema<{
+    /**
+     * Stable identity, assigned by the logger hook when the action happens.
+     *
+     * Serves two jobs at once (docs/plans/action-evidence-sync-plan.md): it is
+     * the `actions.id` a sync sends, so re-syncing the same append-only run log
+     * is a no-op against the server's `onConflictDoNothing`; and it is the
+     * correlation key for joining transcript evidence to an action, which
+     * adjacency cannot do once one assistant message emits several tool calls.
+     *
+     * Optional because run logs written before this field existed must stay
+     * readable. Sync derives an id for those from `(sessionId, line index)`; see
+     * `deriveLegacyActionId`.
+     */
+    readonly id: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+    readonly timestamp: v.StringSchema<undefined>;
+    readonly sessionId: v.StringSchema<undefined>;
+    readonly toolName: v.StringSchema<undefined>;
+    readonly filePath: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+    readonly command: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+    /**
+     * Set only for a `Skill` tool call: which skill the agent loaded.
+     *
+     * This is what makes a skill load ride the action stream instead of the
+     * transcript. `skill_usage` — the other place a loaded skill name is
+     * recorded — is populated by `extractRunUsage`, which returns empty unless
+     * `mossbear sync` is given `--transcripts-dir`, and the hook `mossbear init`
+     * installs never passes one. So the transcript path has no data in a normal
+     * session, while an action definitionally syncs.
+     */
+    readonly skill: v.OptionalSchema<v.ObjectSchema<{
+        readonly name: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
+        readonly path: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>, undefined>;
+    }, undefined>, undefined>;
+    /**
+     * Where this session's transcript lives on *this machine*, as the agent
+     * itself reported it.
+     *
+     * **Local-only, and it must stay that way.** `toSyncAction`
+     * (`packages/cli/src/action-queue.ts`) builds the wire payload field by
+     * field and does not include this one; transcripts are disclosed as
+     * local-only (`apps/dashboard/src/lib/privacy/whatSyncs.ts`), and a path is
+     * still a fact about the user's filesystem. It exists so `mossbear sync` can
+     * find the transcript for a session it is already uploading without
+     * searching for it (docs/plans/default-transcript-discovery-plan.md →
+     * "Session resolution").
+     *
+     * Optional three times over: run logs written before this field existed must
+     * stay readable, a hook protocol other than Claude Code's may not send it,
+     * and resolution falls back to the `<sessionId>.jsonl` filename convention
+     * when it is absent or stale.
+     */
+    readonly transcriptPath: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+    /**
+     * Which checkout produced this action — the same digest as
+     * {@link RuleFileManifestSchema}'s `repoId`, stamped by the logger hook from
+     * the event's `cwd` so a sync in repo A does not attach A's manifest to
+     * sessions that ran in repo B (`run-repo-attribution`).
+     */
+    readonly repoId: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "repoId must be repo_ followed by 32 hex chars">]>, undefined>;
+    /**
+     * Whether the tool call succeeded, when the hook could tell.
+     *
+     * Optional twice over: run logs written before this field existed must stay
+     * readable, and a recognized response shape is not guaranteed even now. See
+     * {@link ActionOutcomeSchema} — absent is "unknown", not "fine".
+     */
+    readonly outcome: v.OptionalSchema<v.ObjectSchema<{
+        readonly status: v.PicklistSchema<["ok", "error"], undefined>;
+        readonly errorClass: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "errorClass must be 1-32 chars of [A-Za-z0-9_.:-]">]>, undefined>;
+        /**
+         * Bounded to a signed 16-bit range, which covers every real exit status
+         * (0-255, 128+signal, and Node's -1) with room to spare. The bound is a line
+         * length bound as much as a validity one: this renders into the grading
+         * prompt, where every field is capped.
+         */
+        readonly exitCode: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, -32768, undefined>, v.MaxValueAction<number, 32767, undefined>]>, undefined>;
+    }, undefined>, undefined>;
+}, undefined>;
+/**
+ * Action types the CLI maps agent tool calls onto.
+ *
+ * Deliberately **not** a closed schema. `DashboardSyncAction.actionType` stays
+ * an open string so a tool the CLI has never seen still syncs as itself
+ * (`packages/cli/src/action-queue.ts` normalizes an unknown tool name rather
+ * than collapsing it into a catch-all) — a closed picklist would silently drop
+ * those. This list is the *known* vocabulary: what the CLI produces on purpose.
+ *
+ * It lives here because it is a contract between two packages that never import
+ * each other. It used to also be the vocabulary the guide-trigger picker
+ * offered; that picker is gone (docs/plans/run-level-grading-plan.md, Slice 4)
+ * and nothing matches against this list any more — relevance is observed from
+ * what was in the agent's context, not asserted against an action type.
+ *
+ * `SKILL_LOAD_ACTION_TYPE` is the one type the CLI emits on purpose that is
+ * deliberately absent here; see its own comment for why.
+ */
+declare const KNOWN_ACTION_TYPES: readonly ["file_edit", "file_read", "shell_command", "search", "web_access"];
+export type KnownActionType = (typeof KNOWN_ACTION_TYPES)[number];
+/** True when `value` is one of the action types the CLI produces on purpose. */
+export declare function isKnownActionType(value: string): value is KnownActionType;
+export declare function parseAgentConfig(data: unknown): {
+    id: string;
+    name: string;
+    description: string;
+    capabilities: string[];
+    meta?: {
+        [x: string]: unknown;
+    } | undefined;
+};
+export declare function parseGuideSnapshot(data: unknown): {
+    id: string;
+    title: string;
+    content: string;
+    enabled: boolean;
+    updatedAt: string;
+    origin?: string | null | undefined;
+    contentHash?: string | null | undefined;
+    root?: "project" | "global" | null | undefined;
+    path?: string | null | undefined;
+};
+export declare function parseGuideBundleResponse(data: unknown): {
+    guides: {
+        id: string;
+        title: string;
+        content: string;
+        enabled: boolean;
+        updatedAt: string;
+        origin?: string | null | undefined;
+        contentHash?: string | null | undefined;
+        root?: "project" | "global" | null | undefined;
+        path?: string | null | undefined;
+    }[];
+    pulledAt: string;
+};
+export declare function parseRawGuideFilePayload(data: unknown): {
+    path: string;
+    root?: "project" | "global" | undefined;
+    format: "agents-md" | "agents-dir" | "claude-md" | "claude-rules" | "cursorrules" | "cursor-rules" | "skill-md";
+    rawContent: string;
+    lastModified: number;
+    content_hash: string;
+    members?: {
+        path: string;
+        rawContent: string;
+        lastModified: number;
+        content_hash: string;
+    }[] | undefined;
+    expectedVersion?: number | undefined;
+    skippedMemberPaths?: string[] | undefined;
+};
+export declare function parseGuideMemberFilesResponse(data: unknown): {
+    memberFiles: {
+        path: string;
+        content: string;
+        contentHash: string;
+    }[];
+};
+export declare function parseRawGuideFileDeletion(data: unknown): {
+    path: string;
+    format: "agents-md" | "agents-dir" | "claude-md" | "claude-rules" | "cursorrules" | "cursor-rules" | "skill-md";
+};
+export declare function parseRuleDeletionsRequest(data: unknown): {
+    deletions: unknown[];
+};
+export declare function parseRulesImportRequest(data: unknown): {
+    rules: unknown[];
+    repoId?: string | undefined;
+    projectId?: string | undefined;
+};
+export declare function parseBundle(data: unknown): {
+    id: string;
+    slug: string;
+    name: string;
+    createdAt: string;
+};
+export declare function parseBundleListResponse(data: unknown): {
+    bundles: {
+        id: string;
+        slug: string;
+        name: string;
+        createdAt: string;
+    }[];
+};
+export declare function parseCreateBundleRequest(data: unknown): {
+    slug: string;
+    name: string;
+};
+export declare function parseCreateBundleResponse(data: unknown): {
+    bundle: {
+        id: string;
+        slug: string;
+        name: string;
+        createdAt: string;
+    };
+};
+export declare function parseAttachBundleMemberRequest(data: unknown): {
+    itemId: string;
+    itemType?: "guide_file" | "guide" | undefined;
+};
+export declare function parseAttachBundleMemberResponse(data: unknown): {
+    attached: boolean;
+};
+export declare function parseDetachBundleMemberResponse(data: unknown): {
+    detached: boolean;
+};
+export declare function parseRenameBundleRequest(data: unknown): {
+    name: string;
+};
+export declare function parseRenameBundleResponse(data: unknown): {
+    bundle: {
+        id: string;
+        slug: string;
+        name: string;
+        createdAt: string;
+    };
+};
+export declare function parseDeleteBundleResponse(data: unknown): {
+    deleted: boolean;
+};
+export declare function parseContextItem(data: unknown): {
+    id: string;
+    type: "reference" | "guide" | "document" | "asset";
+    name: string;
+    contentType: string;
+    content: string | null;
+    origin?: string | null | undefined;
+    version?: number | undefined;
+    root?: "project" | "global" | null | undefined;
+    path?: string | null | undefined;
+    updatedAt: string;
+};
+export declare function parseContextItemsResponse(data: unknown): {
+    items: {
+        id: string;
+        type: "reference" | "guide" | "document" | "asset";
+        name: string;
+        contentType: string;
+        content: string | null;
+        origin?: string | null | undefined;
+        version?: number | undefined;
+        root?: "project" | "global" | null | undefined;
+        path?: string | null | undefined;
+        updatedAt: string;
+    }[];
+};
+export declare function parsePushContextRequest(data: unknown): {
+    name: string;
+    contentType: "reference" | "document" | "asset";
+    content: string;
+    itemId?: string | undefined;
+    origin?: string | null | undefined;
+    sourceItemIds?: string[] | undefined;
+};
+export declare function parsePushContextResponse(data: unknown): {
+    item: {
+        id: string;
+        type: "reference" | "guide" | "document" | "asset";
+        name: string;
+        contentType: string;
+        content: string | null;
+        origin?: string | null | undefined;
+        version?: number | undefined;
+        root?: "project" | "global" | null | undefined;
+        path?: string | null | undefined;
+        updatedAt: string;
+    };
+    created: boolean;
+};
+export declare function parseUpdateContextItemRequest(data: unknown): {
+    itemId: string;
+    name?: string | undefined;
+    content?: string | undefined;
+    expectedVersion?: number | undefined;
+    sourceItemIds?: string[] | undefined;
+};
+export declare function parseUpdateContextItemResponse(data: unknown): {
+    item: {
+        id: string;
+        type: "reference" | "guide" | "document" | "asset";
+        name: string;
+        contentType: string;
+        content: string | null;
+        origin?: string | null | undefined;
+        version?: number | undefined;
+        root?: "project" | "global" | null | undefined;
+        path?: string | null | undefined;
+        updatedAt: string;
+    };
+    updated: boolean;
+};
+export declare function parseUpdateContextItemBody(data: unknown): {
+    content?: string | undefined;
+    expectedVersion?: number | undefined;
+    name?: string | undefined;
+    sourceItemIds?: string[] | undefined;
+};
+export declare function parseContextItemResponse(data: unknown): {
+    item: {
+        id: string;
+        type: "reference" | "guide" | "document" | "asset";
+        name: string;
+        contentType: string;
+        content: string | null;
+        origin?: string | null | undefined;
+        version?: number | undefined;
+        root?: "project" | "global" | null | undefined;
+        path?: string | null | undefined;
+        updatedAt: string;
+    };
+};
+export declare function parseArchiveContextItemResponse(data: unknown): {
+    archived: boolean;
+    item: {
+        id: string;
+        type: "reference" | "guide" | "document" | "asset";
+        name: string;
+        contentType: string;
+        content: string | null;
+        origin?: string | null | undefined;
+        version?: number | undefined;
+        root?: "project" | "global" | null | undefined;
+        path?: string | null | undefined;
+        updatedAt: string;
+    };
+};
+export declare function parseInboxCaptureRequest(data: unknown): {
+    contentType: "document" | "asset";
+    content: string;
+    name?: string | undefined;
+    source?: string | undefined;
+};
+export declare function parseInboxCaptureResponse(data: unknown): {
+    item: {
+        id: string;
+        type: "reference" | "guide" | "document" | "asset";
+        name: string;
+        contentType: string;
+        content: string | null;
+        source?: string | null | undefined;
+        version?: number | undefined;
+        capturedAt: string;
+        updatedAt: string;
+    };
+};
+export declare function parseInboxListResponse(data: unknown): {
+    items: {
+        id: string;
+        type: "reference" | "guide" | "document" | "asset";
+        name: string;
+        contentType: string;
+        content: string | null;
+        source?: string | null | undefined;
+        version?: number | undefined;
+        capturedAt: string;
+        updatedAt: string;
+    }[];
+};
+export declare function parseContextItemVersionsResponse(data: unknown): {
+    versions: {
+        id: string;
+        version: number;
+        contentHash: string;
+        authorType: string;
+        metadata?: {
+            [x: string]: unknown;
+        } | null | undefined;
+        createdAt: string;
+    }[];
+    nextCursor: number | null;
+};
+export declare function parseContextItemVersionResponse(data: unknown): {
+    version: {
+        id: string;
+        version: number;
+        content: string | null;
+        contentHash: string;
+        authorType: string;
+        metadata?: {
+            [x: string]: unknown;
+        } | null | undefined;
+        createdAt: string;
+    };
+};
+export declare function parseInboxArchiveRequest(data: unknown): {
+    ids: string[];
+};
+export declare function parseInboxArchiveResponse(data: unknown): {
+    archived: number;
+};
+export declare function parseDashboardSyncRequest(data: unknown): {
+    actions?: {
+        id?: string | undefined;
+        adapterId?: string | undefined;
+        runId?: string | undefined;
+        sessionId?: string | undefined;
+        actionType: string;
+        summary: string;
+        filePaths?: string[] | undefined;
+        verdict?: "aligned" | "unguided" | "misaligned" | undefined;
+        gradingTier?: "unguided" | "pattern_match" | "cached" | "llm" | "batch" | undefined;
+        guideIds?: string[] | undefined;
+        violatedGuideId?: string | null | undefined;
+        evalReasoning?: string | null | undefined;
+        metadata?: {
+            [x: string]: unknown;
+        } | null | undefined;
+        narration?: {
+            userText?: string | undefined;
+            assistantText?: string | undefined;
+        } | undefined;
+        cliVersion?: string | undefined;
+    }[] | undefined;
+    guideSuggestions?: {
+        id?: string | undefined;
+        content: string;
+        reasoning?: string | undefined;
+        triggerType: "uncovered" | "ambiguous" | "performance_pattern" | "conversational_feedback";
+        sourceActionIds?: (string | {
+            sessionId: string;
+            timestamp?: string | undefined;
+            summary: string;
+        })[] | undefined;
+        status?: "pending" | "accepted" | "dismissed" | undefined;
+    }[] | undefined;
+    feedbackCandidates?: {
+        id?: string | undefined;
+        signal: string;
+        signalType: "correction" | "approval" | "implied_preference" | "stated_preference" | "skill_suggestion";
+        confidence?: number | undefined;
+        occurrences?: number | undefined;
+        status?: "dismissed" | "inferred" | "confirmed" | undefined;
+    }[] | undefined;
+    runUsage?: {
+        runId?: string | undefined;
+        sessionId: string;
+        usage: {
+            model: string;
+            provider?: string | undefined;
+            inputTokens: number;
+            outputTokens: number;
+            cacheReadTokens?: number | undefined;
+            cacheWriteTokens?: number | undefined;
+        }[];
+    }[] | undefined;
+    skillUsage?: {
+        runId?: string | undefined;
+        sessionId: string;
+        usage: {
+            skillName: string;
+            model: string;
+            inputTokens: number;
+            cacheWriteTokens?: number | undefined;
+        }[];
+    }[] | undefined;
+    cliVersion?: string | undefined;
+    completedSessionIds?: string[] | undefined;
+    ruleManifest?: {
+        repoId: string;
+        files: {
+            path: string;
+            format: "agents-md" | "agents-dir" | "claude-md" | "claude-rules" | "cursorrules" | "cursor-rules" | "skill-md";
+            contentHash: string;
+        }[];
+        truncated?: boolean | undefined;
+    } | undefined;
+};
+export declare function parseProposalCitation(data: unknown): {
+    sessionId: string;
+    timestamp?: string | undefined;
+    summary: string;
+};
+export declare function parseExtractedGuideSuggestion(data: unknown): {
+    id: string;
+    content: string;
+    reasoning: string;
+    triggerType: "conversational_feedback";
+    confidence: number;
+    occurrences: number;
+    citations: {
+        sessionId: string;
+        timestamp?: string | undefined;
+        summary: string;
+    }[];
+    source: "claude_code" | "cursor" | "copilot" | "windsurf" | "other";
+};
+export declare function parseExtractedSkillSuggestion(data: unknown): {
+    id: string;
+    signal: string;
+    confidence: number;
+    occurrences: number;
+    citations: {
+        sessionId: string;
+        timestamp?: string | undefined;
+        summary: string;
+    }[];
+    source: "claude_code" | "cursor" | "copilot" | "windsurf" | "other";
+};
+export declare function parseExtractedFeedbackBatch(data: unknown): {
+    guideSuggestions: {
+        id: string;
+        content: string;
+        reasoning: string;
+        triggerType: "conversational_feedback";
+        confidence: number;
+        occurrences: number;
+        citations: {
+            sessionId: string;
+            timestamp?: string | undefined;
+            summary: string;
+        }[];
+        source: "claude_code" | "cursor" | "copilot" | "windsurf" | "other";
+    }[];
+    skillSuggestions: {
+        id: string;
+        signal: string;
+        confidence: number;
+        occurrences: number;
+        citations: {
+            sessionId: string;
+            timestamp?: string | undefined;
+            summary: string;
+        }[];
+        source: "claude_code" | "cursor" | "copilot" | "windsurf" | "other";
+    }[];
+};
+export declare function parseActionEntry(data: unknown): {
+    id?: string | undefined;
+    timestamp: string;
+    sessionId: string;
+    toolName: string;
+    filePath?: string | undefined;
+    command?: string | undefined;
+    skill?: {
+        name: string;
+        path?: string | undefined;
+    } | undefined;
+    transcriptPath?: string | undefined;
+    repoId?: string | undefined;
+    outcome?: {
+        status: "ok" | "error";
+        errorClass?: string | undefined;
+        exitCode?: number | undefined;
+    } | undefined;
+};
+export {};
+//# sourceMappingURL=schemas.d.ts.map