@cat-factory/contracts 0.319.0 → 0.322.0

package/dist/public-kaizen.js

@@ -0,0 +1,218 @@
+import * as v from 'valibot';
+import { kaizenGradingStatusSchema } from './kaizen.js';
+import { publicTaskStatusSchema } from './public-api.js';
+import { booleanQuerySchema, cursorSchema, epochMsQuerySchema, pageLimitSchema, } from './public-paging.js';
+// ---------------------------------------------------------------------------
+// Public KAIZEN-ENTRY wire shapes (`/api/v1/kaizen/entries`, `…/{entryId}`, `…/acknowledge`).
+//
+// A Kaizen entry is one post-run grading of one agent step: how smooth or chaotic that
+// interaction was, and what the grader recommends changing (`KaizenService`). Inside
+// the app they are read one board at a time — the Kaizen screen's bounded history, and the
+// per-run status strip in the run window — which is enough for a person browsing, and useless
+// for the thing this surface exists for: a continuous-improvement loop that has to consume EVERY
+// entry exactly once, file the recommendations somewhere, and come back for what is new.
+//
+// Three rules shape these shapes:
+//
+//  1. **The list is workspace-wide and keyset-paginated, with NO run or task required up front.**
+//     An improvement loop does not know which runs produced recommendations; that is what it is
+//     asking. Every other Kaizen read makes the caller name a run first, which is the one thing
+//     it cannot supply.
+//  2. **An entry carries the investigative context, not just the grade.** The point of reading
+//     one is deciding whether to act on it, and that decision needs to know WHAT was graded
+//     (agent kind, resolved model, prompt version), WHERE (run, step index, task, service) and
+//     whether the combo it names is already verified and therefore no longer being graded.
+//     Everything here is either on the grading row or one batched lookup away; the run's own
+//     detail stays behind `GET /api/v1/debug/runs/{runId}`, which the `runId` joins onto.
+//  3. **Acknowledgement is the entry's own state**, written only through this surface and never
+//     by the grading sweep. It is what makes the loop incremental: `?acknowledged=false` is the
+//     backlog, and acknowledging is what takes an entry out of it.
+// ---------------------------------------------------------------------------
+/** Machine-readable `details.reason` for an entry id this workspace does not hold. */
+export const KAIZEN_ENTRY_NOT_FOUND_REASON = 'kaizen_entry_not_found';
+/**
+ * Machine-readable `details.reason` for acknowledging an entry that has not settled yet.
+ *
+ * Distinct from a 404 because it is about TIMING rather than identity: the entry exists, the
+ * grader has simply not finished with it, and a caller that acknowledged it now would be marking
+ * recommendations triaged before they were written. Retry once the entry reaches `complete` or
+ * `failed`.
+ */
+export const KAIZEN_ENTRY_NOT_SETTLED_REASON = 'kaizen_entry_not_settled';
+/**
+ * The board coordinates of the graded run, resolved at read time — null when the task block has
+ * since been deleted.
+ *
+ * Separate from the entry's own `taskId` on purpose: the id is a fact the grading row RECORDED
+ * and always answers, while this is what the board says about it NOW. Collapsing the two would
+ * make a deleted task read as an entry that never had one.
+ */
+export const publicKaizenEntryTaskSchema = v.object({
+    title: v.string(),
+    /**
+     * The task's board lifecycle status, in the SAME vocabulary `/api/v1/tasks` speaks
+     * (`publicTaskStatusSchema`) rather than the internal block one it happens to mirror today.
+     *
+     * Typed against the public picklist on purpose: the two are separate closed vocabularies
+     * precisely so the board can gain a status without that widening `/api/v1` by accident. Reading
+     * the internal one here would publish the new member with no version decision, and would let two
+     * endpoints answer differently about the same task. Adding a member internally now fails to
+     * compile until somebody decides what the public surface says about it.
+     */
+    status: publicTaskStatusSchema,
+    /**
+     * The enclosing service frame (`GET /api/v1/services/{serviceId}`), or null for a task outside
+     * one — a headless job's anchor, or a board block that predates services.
+     *
+     * Resolved by walking the block's parent chain to its service frame, which is how every other
+     * `/api/v1` surface answers the same question (`GET /api/v1/services/{serviceId}/tasks`,
+     * `GET /api/v1/tasks/{taskId}`). Deriving it any other way would let one task report a service
+     * here and a different answer (or none) there, for the same board.
+     */
+    serviceId: v.nullable(v.string()),
+    /**
+     * That service's title. Non-null exactly when `serviceId` is: both are read off the SAME
+     * resolved frame block, so a caller never receives an id that `GET /api/v1/services/{serviceId}`
+     * cannot answer for.
+     */
+    serviceTitle: v.nullable(v.string()),
+});
+/**
+ * Where the entry's `(agentKind, model, promptVersion)` combo stands in the verification streak,
+ * or null when nothing has been recorded for it yet.
+ *
+ * Carried because it decides whether an entry is worth acting on: a VERIFIED combo is one the
+ * engine has stopped grading, so its recommendations are historical, and a long streak says the
+ * pairing is behaving even if this one run was not.
+ */
+export const publicKaizenEntryComboSchema = v.object({
+    /** Consecutive high grades (4 or 5, no recommendations) recorded for the combo. */
+    consecutiveHighGrades: v.number(),
+    /** Whether it crossed the streak threshold and is no longer graded. */
+    verified: v.boolean(),
+    /** Epoch ms it crossed, else null. */
+    verifiedAt: v.nullable(v.number()),
+});
+/**
+ * One Kaizen entry as `/api/v1` speaks it: the grading, what produced it, and its triage state.
+ *
+ * The id vocabulary is the public one — `entryId` for the grading, `runId` and `taskId` for the
+ * run and board block the stored row calls `executionId` and `blockId` — so every id here
+ * addresses something on this API. Nothing the row holds is dropped.
+ */
+export const publicKaizenEntrySchema = v.object({
+    /** The id to pass to `GET /api/v1/kaizen/entries/{entryId}` and the acknowledge route. */
+    entryId: v.string(),
+    /** The run whose step was graded (`GET /api/v1/debug/runs/{runId}` for its own detail). */
+    runId: v.string(),
+    /** Index of the graded step within that run's pipeline. */
+    stepIndex: v.number(),
+    /** The board task the run was started on, as the row recorded it. */
+    taskId: v.string(),
+    /** What the board says about that task now, or null when it has been deleted. */
+    task: v.nullable(publicKaizenEntryTaskSchema),
+    /** The graded step's agent kind (`coder`, `architect`, a deployment's own kind, …). */
+    agentKind: v.string(),
+    /** The model the step actually dispatched on, as resolved at dispatch. */
+    model: v.string(),
+    /** The shipped prompt version the step ran, from the agents prompt-version registry. */
+    promptVersion: v.number(),
+    /** `agentKind|model|promptVersion(|revision|variant)` — what the streak is kept against. */
+    comboKey: v.string(),
+    /** The combo's verification progress, or null when nothing has been recorded for it. */
+    combo: v.nullable(publicKaizenEntryComboSchema),
+    /** Where the grading itself got to (`scheduled` / `running` / `complete` / `failed`). */
+    status: kaizenGradingStatusSchema,
+    /** 1..5 once `complete` (5 = smooth, guided, efficient); null while pending or failed. */
+    grade: v.nullable(v.number()),
+    /** The grader's prose account of how the interaction went; empty until it completes. */
+    summary: v.string(),
+    /** What the grader recommends changing. Empty ⇒ it found nothing to improve. */
+    recommendations: v.array(v.string()),
+    /** `provider:model` that produced the grade, so a reader can weigh the grader itself. */
+    graderModel: v.nullable(v.string()),
+    /**
+     * Why the grading `failed`, else null. A failure is a real entry rather than a hidden one: it
+     * usually names a deployment-level problem (prompt recording off, no grader model wired) that
+     * nothing else reports, and it is acknowledgeable for exactly that reason.
+     */
+    error: v.nullable(v.string()),
+    /** Whether somebody has triaged it — the same fact `acknowledgedAt` carries, as the filter. */
+    acknowledged: v.boolean(),
+    /** Epoch ms it was acknowledged, else null. */
+    acknowledgedAt: v.nullable(v.number()),
+    /** The user (`usr_*`) or API key (`pak_*`) that acknowledged it, else null. */
+    acknowledgedBy: v.nullable(v.string()),
+    /** The note left with the acknowledgement, else null. */
+    acknowledgementNote: v.nullable(v.string()),
+    /** Epoch ms the grading was scheduled (also what the list orders and pages on). */
+    createdAt: v.number(),
+    /** Epoch ms the row last changed (a grader transition or an acknowledgement). */
+    updatedAt: v.number(),
+});
+export const publicKaizenEntryListSchema = v.object({
+    entries: v.array(publicKaizenEntrySchema),
+    /**
+     * Cursor to pass as `?cursor=` for the next page, or null when this was the last page. A
+     * non-null cursor means "there may be more", so a client pages until it comes back null.
+     */
+    nextCursor: v.nullable(v.string()),
+});
+/**
+ * Query params for `GET /api/v1/kaizen/entries`. Ordering is newest-first on the grading's
+ * `createdAt`, keyset-paged on `(createdAt, entryId)` so a burst of gradings sharing a
+ * millisecond cannot lose rows between pages.
+ *
+ * The filters are the questions an improvement loop actually asks, each pushed into SQL: what is
+ * untriaged, what the grader has finished with, what one agent kind is being told, and what is new
+ * since the last sweep. They compose, and `?acknowledged=false&settled=true` is the working
+ * backlog: every entry in it is one the acknowledge route accepts.
+ */
+export const listPublicKaizenEntriesQuerySchema = v.object({
+    /** Rows per page (1..100); omitted → 25. */
+    limit: v.optional(pageLimitSchema),
+    /** Opaque cursor from a previous page's `nextCursor`. */
+    cursor: v.optional(cursorSchema),
+    /** `false` for the untriaged backlog, `true` for what has been handled; omitted → both. */
+    acknowledged: v.optional(booleanQuerySchema),
+    /**
+     * `true` for entries the grader has FINISHED with (whatever it concluded), `false` for those
+     * still scheduled or running; omitted → both.
+     *
+     * The filter that makes `?acknowledged=false&settled=true` an actionable backlog: every row it
+     * returns is one the acknowledge route will accept, where `?acknowledged=false` alone also
+     * returns gradings mid-flight that it refuses with `409 kaizen_entry_not_settled`. It is a
+     * separate question from `status` because the settled SET is what the write is gated on, and
+     * spelling it as `status=complete` drops the `failed` entries (which usually name a deployment
+     * problem, and are the ones most worth acting on) while a client-side union of the two would
+     * silently miss any settled state added later.
+     */
+    settled: v.optional(booleanQuerySchema),
+    /** Return only entries whose grading is in this exact state. */
+    status: v.optional(kaizenGradingStatusSchema),
+    /** Return only entries grading this agent kind. */
+    agentKind: v.optional(v.pipe(v.string(), v.trim(), v.minLength(1), v.maxLength(120))),
+    /** Return only entries created at or after this epoch-ms stamp (the incremental-poll filter). */
+    since: v.optional(epochMsQuerySchema),
+});
+/** Longest acknowledgement note the surface stores. */
+export const KAIZEN_ACKNOWLEDGEMENT_NOTE_MAX = 2_000;
+/**
+ * Body for `POST /api/v1/kaizen/entries/{entryId}/acknowledge`.
+ *
+ * `acknowledged` is optional and defaults to `true`, so the ordinary call is an empty body; pass
+ * `false` to put an entry back on the backlog after acknowledging it by mistake. Acknowledging an
+ * already-acknowledged entry is a no-op that returns the row unchanged, which keeps
+ * `acknowledgedAt` naming when it was FIRST triaged rather than when a retrying client last
+ * repeated itself.
+ */
+export const acknowledgeKaizenEntrySchema = v.object({
+    /** `true` (the default) records the acknowledgement; `false` clears it. */
+    acknowledged: v.optional(v.boolean()),
+    /**
+     * What the next reader should know: a ticket id, a decision, why it was dismissed. Stored only
+     * with the acknowledgement that lands, and cleared along with it.
+     */
+    note: v.optional(v.nullable(v.pipe(v.string(), v.trim(), v.maxLength(KAIZEN_ACKNOWLEDGEMENT_NOTE_MAX)))),
+});
+//# sourceMappingURL=public-kaizen.js.map

package/dist/public-kaizen.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"public-kaizen.js","sourceRoot":"","sources":["../src/public-kaizen.ts"],"names":[],"mappings":"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"}

package/dist/public-paging.d.ts

@@ -0,0 +1,24 @@
+import * as v from 'valibot';
+/** Hard ceiling on rows one page may return, wherever a list is paginated. */
+export declare const PUBLIC_MAX_PAGE_LIMIT = 100;
+/**
+ * An OPAQUE keyset pagination cursor. Callers must treat it as a black box and echo it back
+ * verbatim — its encoding is an implementation detail (today a base64url `<sortKey>|<id>` pair)
+ * that may change. Keyset, not offset: an offset page shifts under concurrent inserts, silently
+ * skipping or repeating rows, which is exactly what a polling integration must never see.
+ */
+export declare const cursorSchema: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 200, undefined>]>;
+/** Rows one page may return (1..{@link PUBLIC_MAX_PAGE_LIMIT}); each list documents its default. */
+export declare const pageLimitSchema: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "Must be a whole number">, v.TransformAction<any, number>, v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 1, undefined>, v.MaxValueAction<number, 100, undefined>]>;
+/** An epoch-ms query filter: digits only, for the same reason as {@link pageLimitSchema}. */
+export declare const epochMsQuerySchema: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "Must be a whole number of epoch milliseconds">, v.TransformAction<any, number>, v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+/**
+ * A boolean query filter, spelled `true` / `false`.
+ *
+ * A closed picklist rather than "anything that is not `false` is true": on a tri-state filter
+ * (omitted / true / false) a typo has to refuse, because coercing `?acknowledged=yes` to `true`
+ * would serve a caller the confident opposite of what it asked for on a `false` typo, with no
+ * way to notice.
+ */
+export declare const booleanQuerySchema: v.SchemaWithPipe<readonly [v.PicklistSchema<["true", "false"], undefined>, v.TransformAction<"false" | "true", boolean>]>;
+//# sourceMappingURL=public-paging.d.ts.map

package/dist/public-paging.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"public-paging.d.ts","sourceRoot":"","sources":["../src/public-paging.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,SAAS,CAAA;AAoB5B,8EAA8E;AAC9E,eAAO,MAAM,qBAAqB,MAAM,CAAA;AAExC;;;;;GAKG;AACH,eAAO,MAAM,YAAY,0JAAiE,CAAA;AAE1F,oGAAoG;AACpG,eAAO,MAAM,eAAe,0RAQ3B,CAAA;AAED,6FAA6F;AAC7F,eAAO,MAAM,kBAAkB,sQAO9B,CAAA;AAED;;;;;;;GAOG;AACH,eAAO,MAAM,kBAAkB,2HAG9B,CAAA"}

package/dist/public-paging.js

@@ -0,0 +1,41 @@
+import * as v from 'valibot';
+// ---------------------------------------------------------------------------
+// The query-parameter primitives every bounded `/api/v1` list shares: the opaque keyset
+// cursor, the page limit, an epoch-ms lower bound and a boolean flag.
+//
+// One module rather than a private copy per contract file, because these ARE the surface's
+// pagination contract (`backend/docs/public-api.md`, "Pagination") rather than four
+// independent local details: a list whose `limit` ceiling or cursor length drifted from its
+// siblings would be a difference a caller discovers by getting a 400 from one endpoint and
+// not another. `/jobs`, the task list, the whole `/debug` surface and the Kaizen entries all
+// read them from here.
+//
+// Query params arrive as STRINGS, so each numeric one is digit-checked BEFORE the coercion:
+// `Number()` alone also accepts `1e9`, `0x64` and `' '`, which would read as plausible values
+// rather than the 400 a malformed request deserves. The `maxValue` ceilings are what make the
+// bounds real backstops rather than suggestions (a caller cannot ask for the whole table back
+// by passing a huge limit).
+// ---------------------------------------------------------------------------
+/** Hard ceiling on rows one page may return, wherever a list is paginated. */
+export const PUBLIC_MAX_PAGE_LIMIT = 100;
+/**
+ * An OPAQUE keyset pagination cursor. Callers must treat it as a black box and echo it back
+ * verbatim — its encoding is an implementation detail (today a base64url `<sortKey>|<id>` pair)
+ * that may change. Keyset, not offset: an offset page shifts under concurrent inserts, silently
+ * skipping or repeating rows, which is exactly what a polling integration must never see.
+ */
+export const cursorSchema = v.pipe(v.string(), v.trim(), v.minLength(1), v.maxLength(200));
+/** Rows one page may return (1..{@link PUBLIC_MAX_PAGE_LIMIT}); each list documents its default. */
+export const pageLimitSchema = v.pipe(v.string(), v.regex(/^\d+$/, 'Must be a whole number'), v.transform(Number), v.number(), v.integer(), v.minValue(1), v.maxValue(PUBLIC_MAX_PAGE_LIMIT));
+/** An epoch-ms query filter: digits only, for the same reason as {@link pageLimitSchema}. */
+export const epochMsQuerySchema = v.pipe(v.string(), v.regex(/^\d+$/, 'Must be a whole number of epoch milliseconds'), v.transform(Number), v.number(), v.integer(), v.minValue(0));
+/**
+ * A boolean query filter, spelled `true` / `false`.
+ *
+ * A closed picklist rather than "anything that is not `false` is true": on a tri-state filter
+ * (omitted / true / false) a typo has to refuse, because coercing `?acknowledged=yes` to `true`
+ * would serve a caller the confident opposite of what it asked for on a `false` typo, with no
+ * way to notice.
+ */
+export const booleanQuerySchema = v.pipe(v.picklist(['true', 'false']), v.transform((value) => value === 'true'));
+//# sourceMappingURL=public-paging.js.map

package/dist/public-paging.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"public-paging.js","sourceRoot":"","sources":["../src/public-paging.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,SAAS,CAAA;AAE5B,8EAA8E;AAC9E,wFAAwF;AACxF,sEAAsE;AACtE,EAAE;AACF,2FAA2F;AAC3F,oFAAoF;AACpF,4FAA4F;AAC5F,2FAA2F;AAC3F,6FAA6F;AAC7F,uBAAuB;AACvB,EAAE;AACF,4FAA4F;AAC5F,8FAA8F;AAC9F,8FAA8F;AAC9F,8FAA8F;AAC9F,4BAA4B;AAC5B,8EAA8E;AAE9E,8EAA8E;AAC9E,MAAM,CAAC,MAAM,qBAAqB,GAAG,GAAG,CAAA;AAExC;;;;;GAKG;AACH,MAAM,CAAC,MAAM,YAAY,GAAG,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,SAAS,CAAC,GAAG,CAAC,CAAC,CAAA;AAE1F,oGAAoG;AACpG,MAAM,CAAC,MAAM,eAAe,GAAG,CAAC,CAAC,IAAI,CACnC,CAAC,CAAC,MAAM,EAAE,EACV,CAAC,CAAC,KAAK,CAAC,OAAO,EAAE,wBAAwB,CAAC,EAC1C,CAAC,CAAC,SAAS,CAAC,MAAM,CAAC,EACnB,CAAC,CAAC,MAAM,EAAE,EACV,CAAC,CAAC,OAAO,EAAE,EACX,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,EACb,CAAC,CAAC,QAAQ,CAAC,qBAAqB,CAAC,CAClC,CAAA;AAED,6FAA6F;AAC7F,MAAM,CAAC,MAAM,kBAAkB,GAAG,CAAC,CAAC,IAAI,CACtC,CAAC,CAAC,MAAM,EAAE,EACV,CAAC,CAAC,KAAK,CAAC,OAAO,EAAE,8CAA8C,CAAC,EAChE,CAAC,CAAC,SAAS,CAAC,MAAM,CAAC,EACnB,CAAC,CAAC,MAAM,EAAE,EACV,CAAC,CAAC,OAAO,EAAE,EACX,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,CACd,CAAA;AAED;;;;;;;GAOG;AACH,MAAM,CAAC,MAAM,kBAAkB,GAAG,CAAC,CAAC,IAAI,CACtC,CAAC,CAAC,QAAQ,CAAC,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,EAC7B,CAAC,CAAC,SAAS,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,KAAK,MAAM,CAAC,CACzC,CAAA"}

package/dist/public-provisioning.d.ts

@@ -240,6 +240,83 @@ export declare const linkPublicRepoSchema: v.ObjectSchema<{
     readonly name: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.RegexAction<string, "Only letters, digits, '.', '_' and '-' are allowed">, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 100, undefined>]>;
 }, undefined>;
 export type LinkPublicRepoInput = v.InferOutput<typeof linkPublicRepoSchema>;
+/**
+ * Characters ONE file read may answer with, past which it is REFUSED rather than truncated.
+ *
+ * A caller reading a file to grade what an agent committed is joining on its exact bytes, and a
+ * silently shortened answer is indistinguishable from an agent that wrote a shorter file. So the
+ * cap refuses (`422`, `details.reason: 'file_too_large'`) and names the size, which is a fact the
+ * caller can act on where a truncation is not. Generous enough for source: 256 KiB is past any
+ * hand-written manifest, workflow or module.
+ *
+ * It is not the only ceiling in play, and the refusal is deliberately the SAME one either way: a
+ * provider's own contents API stops serving a blob at a limit of its own (1 MB on GitHub), which
+ * arrives here as a `403` that says nothing about the file. That is mapped to this reason too, with
+ * the provider's limit in `details` and no `size`, because nothing measured one.
+ */
+export declare const MAX_REPO_FILE_CHARS = 262144;
+/**
+ * A repo-root-relative file path, refused here rather than left to the provider's 404.
+ *
+ * The provider would answer "no such file" for a traversal or an absolute path anyway, so this is
+ * not a security boundary and does not claim to be one: the resolution is already scoped to a
+ * repository this workspace LINKED, which is what actually bounds the read. What it buys is an
+ * honest refusal. `..` and a leading `/` are the two ways a caller means something other than what
+ * it typed, and answering both as `file_not_found` sends someone hunting for a file that is right
+ * where they left it.
+ */
+export declare const publicRepoFilePathSchema: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 1000, undefined>, v.CheckAction<string, "A path is relative to the repository root">, v.CheckAction<string, "No path segment may be '..'">]>;
+/**
+ * ONE file from a repository this workspace has LINKED, at a ref.
+ *
+ * The read that closes the loop on everything else this surface can start: a caller can create a
+ * repository, adopt one, file work against it and watch a run merge, and then had no way to see WHAT
+ * the run committed. The only alternative was grepping the agent's final reply, which is asserting on
+ * model prose (swap the model and it goes red having found nothing wrong), so anything that wanted a
+ * real answer had to hold a VCS credential of its own: a second token in an operator's config, with
+ * its own scopes to get right, for data the workspace's own connection can already read.
+ *
+ * **A single file, deliberately, and no directory listing.** A listing is a separate decision with
+ * its own frozen-forever questions (pagination, recursion, what a large tree does), and this surface
+ * may not answer one badly and then keep answering it. `GET /api/v1/services/:id/spec` remains the
+ * structured read for the one tree the platform itself understands.
+ *
+ * **Only what the workspace has LINKED.** The scope is the same one every other read here takes, so
+ * this publishes nothing a caller could not already reach through the board, and a repository the
+ * connection can see but this workspace has not adopted is a `404` exactly as it is everywhere else.
+ */
+export declare const publicRepoFileSchema: v.ObjectSchema<{
+    readonly owner: v.StringSchema<undefined>;
+    readonly name: v.StringSchema<undefined>;
+    /** The repo-root-relative path that was read, as the request gave it. */
+    readonly path: v.StringSchema<undefined>;
+    /**
+     * The ref the read was pinned to, or `null` when the request named none and the PROVIDER resolved
+     * the repository's own default branch.
+     *
+     * Null rather than the branch name, because this read does not learn which branch that was and the
+     * platform's own idea of it is a value it may have INVENTED: a projection row that carries no
+     * default branch is defaulted to `main` for the benefit of clone targets, and reporting that as the
+     * ref graded would name a branch the repository may not have. `sha` is the value to record either
+     * way, being the one identifier that cannot drift.
+     */
+    readonly ref: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+    /**
+     * The file's blob sha: the byte-exact handle, for a caller comparing two reads without diffing
+     * their bodies, or joining what it graded to what the repository holds.
+     */
+    readonly sha: v.StringSchema<undefined>;
+    /**
+     * The file's content, decoded as UTF-8.
+     *
+     * Text only. A file whose bytes are not valid UTF-8 is REFUSED (`422`,
+     * `details.reason: 'file_not_text'`, carrying the `sha`) rather than answered as the replacement
+     * characters a lossy decode produces: mojibake presented as a file's content is the same lie a
+     * truncation would be, and a caller hashing it would be hashing the decoder's output.
+     */
+    readonly content: v.StringSchema<undefined>;
+}, undefined>;
+export type PublicRepoFile = v.InferOutput<typeof publicRepoFileSchema>;
 /**
  * How the manifests at `path` are rendered. `raw` (the default) treats the path as a manifest file
  * or a flat directory of valid YAML; `kustomize` treats it as an overlay directory, which only the
@@ -620,12 +697,106 @@ export declare const publicEnvironmentConnectionViewSchema: v.ObjectSchema<{
     readonly secretKeys: v.ArraySchema<v.StringSchema<undefined>, undefined>;
 }, undefined>;
 export type PublicEnvironmentConnectionView = v.InferOutput<typeof publicEnvironmentConnectionViewSchema>;
+/**
+ * One registered handler as the LIST reports it, whatever engine services it.
+ *
+ * Its own shape rather than a reuse of {@link publicEnvironmentConnectionViewSchema}, and the reason
+ * is the difference between the two calls. That one answers a `POST` this surface only ever makes
+ * with `engine: 'kubernetes'`, so its literal is exactly true. A list has to report every handler a
+ * workspace holds, including the `remote-custom` ones a deployment SEEDS from its composition root,
+ * and widening the shipped literal to a string would retype a field a released client already
+ * narrows on. Additive beats a retype (ADR 0034), so the list gets its own view.
+ *
+ * `endpoint` and not `apiServerUrl`: the noun is only true of Kubernetes, and the same mistake in a
+ * shared reduction is what makes an operator whose environment is a VM go looking for an apiserver.
+ *
+ * The write is what makes this read worth having. Handlers are the one half of provisioning a
+ * headless caller could WRITE and never READ, so a deployment that seeds them programmatically (the
+ * documented path for a multi-tenant Node deployment, and the one local mode takes) had no way for
+ * any caller to confirm the seed landed. "Kargo accepts our token" and "this workspace has a Kargo
+ * handler" are different failures with different fixes, and only one of them was checkable.
+ */
+export declare const publicEnvironmentHandlerSchema: v.ObjectSchema<{
+    /** The provision type this handler serves (`kubernetes`, `docker-compose`, `custom`, …). */
+    readonly provisionType: v.StringSchema<undefined>;
+    /**
+     * For a `custom` handler, the manifest id it is KEYED to; null for every other type.
+     *
+     * Both this and {@link acceptsManifestId} are reported because the engine's own resolution matches
+     * a service's pinned `manifestId` against EITHER, and only one of the two is set by either way of
+     * registering a handler: a seed that keys a handler to `kargo` sets this one and leaves the other
+     * null, while a `remote-custom` connection sets the other. Publishing one of them made the
+     * commonest seed shape indistinguishable from a handler that serves nothing, which is the exact
+     * question this read exists to answer.
+     */
+    readonly manifestId: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+    /** For a `custom` handler, the manifest id it declares it ACCEPTS; null for every other type. */
+    readonly acceptsManifestId: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+    /** The internal engine servicing it, as an open string: a deployment may register its own. */
+    readonly engine: v.StringSchema<undefined>;
+    /** The registry backend kind that builds this handler's provider. */
+    readonly backendKind: v.StringSchema<undefined>;
+    readonly label: v.StringSchema<undefined>;
+    /** The connection's own endpoint (an apiserver for Kubernetes, the management API otherwise). */
+    readonly endpoint: v.StringSchema<undefined>;
+    /** The secret-bundle keys this handler holds, never their values. */
+    readonly secretKeys: v.ArraySchema<v.StringSchema<undefined>, undefined>;
+    readonly connectedAt: v.NumberSchema<undefined>;
+}, undefined>;
+export type PublicEnvironmentHandler = v.InferOutput<typeof publicEnvironmentHandlerSchema>;
+export declare const publicEnvironmentHandlerListSchema: v.ObjectSchema<{
+    readonly connections: v.ArraySchema<v.ObjectSchema<{
+        /** The provision type this handler serves (`kubernetes`, `docker-compose`, `custom`, …). */
+        readonly provisionType: v.StringSchema<undefined>;
+        /**
+         * For a `custom` handler, the manifest id it is KEYED to; null for every other type.
+         *
+         * Both this and {@link acceptsManifestId} are reported because the engine's own resolution matches
+         * a service's pinned `manifestId` against EITHER, and only one of the two is set by either way of
+         * registering a handler: a seed that keys a handler to `kargo` sets this one and leaves the other
+         * null, while a `remote-custom` connection sets the other. Publishing one of them made the
+         * commonest seed shape indistinguishable from a handler that serves nothing, which is the exact
+         * question this read exists to answer.
+         */
+        readonly manifestId: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+        /** For a `custom` handler, the manifest id it declares it ACCEPTS; null for every other type. */
+        readonly acceptsManifestId: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+        /** The internal engine servicing it, as an open string: a deployment may register its own. */
+        readonly engine: v.StringSchema<undefined>;
+        /** The registry backend kind that builds this handler's provider. */
+        readonly backendKind: v.StringSchema<undefined>;
+        readonly label: v.StringSchema<undefined>;
+        /** The connection's own endpoint (an apiserver for Kubernetes, the management API otherwise). */
+        readonly endpoint: v.StringSchema<undefined>;
+        /** The secret-bundle keys this handler holds, never their values. */
+        readonly secretKeys: v.ArraySchema<v.StringSchema<undefined>, undefined>;
+        readonly connectedAt: v.NumberSchema<undefined>;
+    }, undefined>, undefined>;
+}, undefined>;
+export type PublicEnvironmentHandlerList = v.InferOutput<typeof publicEnvironmentHandlerListSchema>;
 /**
  * Where ONE service's per-run manifests live: the half the engine connection does not carry.
  *
  * The platform keeps these two apart deliberately (one cluster, many services, each with its own
  * manifests), and this surface keeps the same seam rather than collapsing them into one call, so a
  * caller adding a second service to an existing cluster changes one thing.
+ *
+ * **`custom` is here because a deployment that ships its OWN environment backend could not say so.**
+ * The registry model exists precisely so one can (`EnvironmentBackendRegistry`,
+ * `CustomManifestTypeRegistry`, `seedEnvironmentHandlers`), and everything such a backend needs is
+ * reachable from a composition root; none of it was reachable from this surface. A Kargo-backed or
+ * Nomad-backed service could therefore neither be pinned nor READ BACK here, and that second half is
+ * the one that hurts: the projection omitted what it could not describe, so a pinned service and an
+ * unpinned one answered identically (`provisioning: undefined`) and a headless caller could not
+ * report the state, let alone check it.
+ *
+ * **It pins by `manifestId` and carries no backend config**, and that is deliberate rather than
+ * partial. The engine side of a custom backend is an `environmentManifest` whose `providerConfig` is
+ * an open `Record<string, unknown>` by design, so publishing it would freeze a shape this repo
+ * evolves freely onto a surface that may never be reshaped (ADR 0034). What a caller pins here is an
+ * id the DEPLOYMENT already registered, which is a closed, stable value; registering the handler
+ * behind it stays a composition-root act, and `GET /api/v1/environments/connections` is how a caller
+ * confirms one landed.
  */
 export declare const publicServiceProvisioningSchema: v.VariantSchema<"type", [v.ObjectSchema<{
     readonly type: v.LiteralSchema<"kubernetes", undefined>;
@@ -646,6 +817,15 @@ export declare const publicServiceProvisioningSchema: v.VariantSchema<"type", [v
         /** Omitted ⇒ `raw`. */
         readonly renderer: v.OptionalSchema<v.PicklistSchema<["raw", "kustomize"], undefined>, undefined>;
     }, undefined>], undefined>;
+}, undefined>, v.ObjectSchema<{
+    readonly type: v.LiteralSchema<"custom", undefined>;
+    /**
+     * The custom-manifest-type id this service produces, matched to a `remote-custom` handler that
+     * declares it accepts the same one.
+     */
+    readonly manifestId: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.RegexAction<string, "Only lowercase letters, digits and hyphens are allowed">, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 64, undefined>]>;
+    /** Where the manifest lives in the repository; omitted ⇒ the manifest type's own default. */
+    readonly manifestPath: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MaxLengthAction<string, 500, undefined>]>, undefined>;
 }, undefined>], undefined>;
 export type PublicServiceProvisioning = v.InferOutput<typeof publicServiceProvisioningSchema>;
 /**
@@ -680,6 +860,15 @@ export declare const updatePublicServiceSchema: v.SchemaWithPipe<readonly [v.Obj
             /** Omitted ⇒ `raw`. */
             readonly renderer: v.OptionalSchema<v.PicklistSchema<["raw", "kustomize"], undefined>, undefined>;
         }, undefined>], undefined>;
+    }, undefined>, v.ObjectSchema<{
+        readonly type: v.LiteralSchema<"custom", undefined>;
+        /**
+         * The custom-manifest-type id this service produces, matched to a `remote-custom` handler that
+         * declares it accepts the same one.
+         */
+        readonly manifestId: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.RegexAction<string, "Only lowercase letters, digits and hyphens are allowed">, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 64, undefined>]>;
+        /** Where the manifest lives in the repository; omitted ⇒ the manifest type's own default. */
+        readonly manifestPath: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MaxLengthAction<string, 500, undefined>]>, undefined>;
     }, undefined>], undefined>, undefined>;
 }, undefined>, v.CheckAction<{
     title?: string | undefined;
@@ -697,6 +886,10 @@ export declare const updatePublicServiceSchema: v.SchemaWithPipe<readonly [v.Obj
             path: string;
             renderer?: "kustomize" | "raw" | undefined;
         };
+    } | {
+        type: "custom";
+        manifestId: string;
+        manifestPath?: string | undefined;
     } | undefined;
 }, "Supply at least one of title, description or provisioning.">]>;
 export type UpdatePublicServiceInput = v.InferOutput<typeof updatePublicServiceSchema>;

package/dist/public-provisioning.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"public-provisioning.d.ts","sourceRoot":"","sources":["../src/public-provisioning.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"public-provisioning.d.ts","sourceRoot":"","sources":["../src/public-provisioning.ts"],"names":[],"mappings":"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"}