@wildo-ai/platform-core-shared 1.1.5 → 1.1.6

package/dist/esm/workbench/workbench-creation-console.custom.shared.schemas.d.ts

@@ -0,0 +1,279 @@
+import { z } from 'zod';
+import { WorkbenchCreationHomeLineKind, WorkbenchCreationHomeSection } from './workbench-creation-plane.custom.shared.schemas';
+/**
+ * The CREATION CONSOLE contract — how a coding-agent session (Claude Code, or any agent driving
+ * `wildo`) follows what the companion did and answers what the companion asks.
+ *
+ * ## Why a console needs its own contract beside the workbench's resources
+ *
+ * The companion is the master of application creation: it runs playbooks, dispatches coding
+ * workers over ACP, runs judges and generation steps. The person drives it from a CONSOLE — the
+ * coding-agent session they are already working in — and the workbench becomes the dashboard of
+ * that state (Paul, 2026-09-25). Two things are then owed to the console:
+ *
+ * 1. FEEDBACK: what the companion did (a run completed or was refused, a dispatch settled, a judge
+ *    verdict) and what it now waits for.
+ * 2. ANSWERS: every question the companion asks must be answerable from the console, once, and
+ *    the answer must reach the same service the workbench's own operation reaches.
+ *
+ * The facts already exist as creation-plane rows (Home's lines, the waiting runs, the parked coding
+ * questions, the dossier). The workbench reaches them through the resource plane, which needs a
+ * signed-in PERSON; a console reaches the companion through the local-token plane
+ * (`/api/companion/*`), which is how every `wildo` verb already talks to it. This contract is that
+ * plane's view of the SAME rows — no second derivation, and no second implementation of an answer:
+ * each answer kind calls the companion service the matching workbench operation calls.
+ *
+ * ## Why the question queue is ONE list rather than one read per kind
+ *
+ * A person (or an agent acting for them) asks "what is waiting on me?" once. Four reads, each with
+ * its own identity and answer route, is what makes a console skip one. So the companion folds the
+ * four row kinds into one list with one identity scheme and one answer door, and says per question
+ * which actions it admits — the console restates no policy.
+ */
+/**
+ * WHAT KIND of question a queued item is — which companion lane asked it, and so which service an
+ * answer reaches.
+ */
+export declare enum CreationConsoleQuestionKind {
+    /**
+     * A playbook run SUSPENDED mid-derivation on a round of questions it cannot decide alone. One item
+     * per round, carrying every question of the round: the run resumes on one answer to the round.
+     */
+    CLARIFICATION = "clarification",
+    /** A coding worker (an ACP session the companion dispatched) PARKED on a question it asked. */
+    PARKED_CODING_QUESTION = "parked-coding-question",
+    /**
+     * An interview question a step can run as soon as it is answered — the dossier entry the workbench
+     * shows as "asked of you now". Answering lands `creator-inputs`; a commit accepts it.
+     */
+    INTERVIEW = "interview",
+    /**
+     * A fact a drafted governed document still needs. LISTED so the queue is total over what waits on
+     * the person, NOT answerable here: landing governance facts is a whole-document sitting that also
+     * names the governance scope and who decided, and `compliance-is-derived-from-the-product.md`
+     * holds that questionnaire where it is until the evidence tier exists. Answer it in the workbench.
+     */
+    GOVERNANCE_FACT = "governance-fact"
+}
+/**
+ * WHAT an answer does — the industry three-action model the playbook clarification already uses
+ * (MCP elicitation's vocabulary), so every kind of question speaks it.
+ */
+export declare enum CreationConsoleAnswerAction {
+    /** Give the answer(s). */
+    ANSWER = "answer",
+    /**
+     * Let the asking derivation decide and state its assumption. Clarifications only. May carry the answers
+     * the person did give: the run then decides only the questions left unanswered.
+     */
+    DECLINE = "decline",
+    /** Abandon the run that asked. Clarifications and parked coding questions. */
+    CANCEL = "cancel"
+}
+/** One question inside a queued item — a clarification round carries several, the others one. */
+export declare const CreationConsole_QuestionField_Schema: z.ZodObject<{
+    ref: z.ZodString;
+    question: z.ZodString;
+    why: z.ZodNullable<z.ZodString>;
+    kind: z.ZodString;
+    options: z.ZodArray<z.ZodString>;
+}, z.core.$strip>;
+export type CreationConsole_QuestionField = z.infer<typeof CreationConsole_QuestionField_Schema>;
+export declare const CreationConsole_Question_Schema: z.ZodObject<{
+    questionId: z.ZodString;
+    kind: z.ZodEnum<typeof CreationConsoleQuestionKind>;
+    askedAt: z.ZodNullable<z.ZodString>;
+    playbookRef: z.ZodNullable<z.ZodString>;
+    taskRef: z.ZodNullable<z.ZodString>;
+    instanceKey: z.ZodNullable<z.ZodString>;
+    definitionRef: z.ZodNullable<z.ZodString>;
+    revision: z.ZodNullable<z.ZodString>;
+    fields: z.ZodArray<z.ZodObject<{
+        ref: z.ZodString;
+        question: z.ZodString;
+        why: z.ZodNullable<z.ZodString>;
+        kind: z.ZodString;
+        options: z.ZodArray<z.ZodString>;
+    }, z.core.$strip>>;
+    actions: z.ZodArray<z.ZodEnum<typeof CreationConsoleAnswerAction>>;
+    producingFamily: z.ZodNullable<z.ZodString>;
+    dryRun: z.ZodNullable<z.ZodBoolean>;
+    resumable: z.ZodNullable<z.ZodBoolean>;
+    affectsFamilies: z.ZodArray<z.ZodString>;
+    routedToUserId: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+export type CreationConsole_Question = z.infer<typeof CreationConsole_Question_Schema>;
+export declare const CreationConsole_QuestionQueue_Schema: z.ZodObject<{
+    computedAt: z.ZodString;
+    questions: z.ZodArray<z.ZodObject<{
+        questionId: z.ZodString;
+        kind: z.ZodEnum<typeof CreationConsoleQuestionKind>;
+        askedAt: z.ZodNullable<z.ZodString>;
+        playbookRef: z.ZodNullable<z.ZodString>;
+        taskRef: z.ZodNullable<z.ZodString>;
+        instanceKey: z.ZodNullable<z.ZodString>;
+        definitionRef: z.ZodNullable<z.ZodString>;
+        revision: z.ZodNullable<z.ZodString>;
+        fields: z.ZodArray<z.ZodObject<{
+            ref: z.ZodString;
+            question: z.ZodString;
+            why: z.ZodNullable<z.ZodString>;
+            kind: z.ZodString;
+            options: z.ZodArray<z.ZodString>;
+        }, z.core.$strip>>;
+        actions: z.ZodArray<z.ZodEnum<typeof CreationConsoleAnswerAction>>;
+        producingFamily: z.ZodNullable<z.ZodString>;
+        dryRun: z.ZodNullable<z.ZodBoolean>;
+        resumable: z.ZodNullable<z.ZodBoolean>;
+        affectsFamilies: z.ZodArray<z.ZodString>;
+        routedToUserId: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type CreationConsole_QuestionQueue = z.infer<typeof CreationConsole_QuestionQueue_Schema>;
+/**
+ * One answer to one field. It carries its OWN author because a round is answered in one call while its
+ * fields may be answered by different parties (#1658): an agent derives one from a declared fact, the
+ * person decides the next. With one author per request, a mixed round either stamped the person's name
+ * on the agent's derivation or was refused as incomplete — the agent answering alone could not cover the
+ * judgement half, and the resume refuses a round answered in part.
+ */
+export declare const CreationConsole_Answer_Schema: z.ZodObject<{
+    ref: z.ZodString;
+    value: z.ZodString;
+    answeredByRef: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type CreationConsole_Answer = z.infer<typeof CreationConsole_Answer_Schema>;
+export declare const CreationConsole_AnswerRequest_Schema: z.ZodObject<{
+    questionId: z.ZodString;
+    revision: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    action: z.ZodEnum<typeof CreationConsoleAnswerAction>;
+    answers: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        ref: z.ZodString;
+        value: z.ZodString;
+        answeredByRef: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
+    answeredByRef: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type CreationConsole_AnswerRequest = z.infer<typeof CreationConsole_AnswerRequest_Schema>;
+export declare const CreationConsole_AnswerOutcome_Schema: z.ZodObject<{
+    questionId: z.ZodString;
+    kind: z.ZodEnum<typeof CreationConsoleQuestionKind>;
+    action: z.ZodEnum<typeof CreationConsoleAnswerAction>;
+    /** What the answering service returned — its own shape (a resumed run's outcome, a landed dossier file). */
+    outcome: z.ZodUnknown;
+}, z.core.$loose>;
+export type CreationConsole_AnswerOutcome = z.infer<typeof CreationConsole_AnswerOutcome_Schema>;
+/**
+ * One FEED line: a Home line (what happened, what is asked, what could come next) with the row it
+ * points at attached, so a console reads a run's verdict or a dispatch's error without a second call.
+ *
+ * `at` is ISO-8601 here — this is a JSON contract, not a resource row.
+ */
+export declare const CreationConsole_FeedLine_Schema: z.ZodObject<{
+    lineId: z.ZodString;
+    section: z.ZodEnum<typeof WorkbenchCreationHomeSection>;
+    kind: z.ZodEnum<typeof WorkbenchCreationHomeLineKind>;
+    at: z.ZodNullable<z.ZodString>;
+    playbookRef: z.ZodNullable<z.ZodString>;
+    taskRef: z.ZodNullable<z.ZodString>;
+    subject: z.ZodNullable<z.ZodString>;
+    failed: z.ZodBoolean;
+    acceptable: z.ZodBoolean;
+    needsAnswers: z.ZodBoolean;
+    stuckReason: z.ZodNullable<z.ZodString>;
+    targetResourceType: z.ZodString;
+    targetResourceId: z.ZodString;
+    target: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    questionId: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+export type CreationConsole_FeedLine = z.infer<typeof CreationConsole_FeedLine_Schema>;
+export declare const CreationConsole_Feed_Schema: z.ZodObject<{
+    computedAt: z.ZodString;
+    lines: z.ZodArray<z.ZodObject<{
+        lineId: z.ZodString;
+        section: z.ZodEnum<typeof WorkbenchCreationHomeSection>;
+        kind: z.ZodEnum<typeof WorkbenchCreationHomeLineKind>;
+        at: z.ZodNullable<z.ZodString>;
+        playbookRef: z.ZodNullable<z.ZodString>;
+        taskRef: z.ZodNullable<z.ZodString>;
+        subject: z.ZodNullable<z.ZodString>;
+        failed: z.ZodBoolean;
+        acceptable: z.ZodBoolean;
+        needsAnswers: z.ZodBoolean;
+        stuckReason: z.ZodNullable<z.ZodString>;
+        targetResourceType: z.ZodString;
+        targetResourceId: z.ZodString;
+        target: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        questionId: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type CreationConsole_Feed = z.infer<typeof CreationConsole_Feed_Schema>;
+/** The one identity rule, applied by the companion when it emits and when it resolves an answer. */
+export declare function formatCreationConsoleQuestionId(kind: CreationConsoleQuestionKind, rowId: string): string;
+/** The inverse of {@link formatCreationConsoleQuestionId}; `null` for anything that is not one. */
+export declare function parseCreationConsoleQuestionId(questionId: string): {
+    kind: CreationConsoleQuestionKind;
+    rowId: string;
+} | null;
+/**
+ * The workbench DEEP LINK (#1652): `?open=<resourceType>:<resourceId>` opens that creation-plane row
+ * in the workbench's detail pane, the way clicking its Home line does. `wildo workbench open <ref>`
+ * writes it; the workbench reads it once and drops it. One format, owned here, so the writer and the
+ * reader cannot disagree about it.
+ *
+ * The FIRST `:` separates the two, because a resource type never contains one and a row id may.
+ */
+export declare const WORKBENCH_OPEN_DETAIL_QUERY_PARAM = "open";
+export declare function formatWorkbenchOpenDetailParam(resourceType: string, resourceId: string): string;
+/** The inverse of {@link formatWorkbenchOpenDetailParam}; `null` for anything that is not one. */
+export declare function parseWorkbenchOpenDetailParam(value: string): {
+    resourceType: string;
+    resourceId: string;
+} | null;
+/**
+ * The PULSE (#1657): a read cheap enough to poll every few seconds from a hook or a status line.
+ *
+ * Nothing in it is derived on request. `sequence` and `changedAt` move whenever the creation plane's
+ * boards are invalidated (every mutation path ends there) or a watched board is republished;
+ * `runsInFlight` is the process's own running-run count; `summary` is what the most recent FEED read
+ * counted, with its instant — `null` until someone has read the feed, because computing it here would
+ * make the pulse as slow as the feed. A poller compares pulses and reads the feed only when one moved.
+ */
+export declare const CreationConsole_PulseSummary_Schema: z.ZodObject<{
+    asked: z.ZodNumber;
+    acceptable: z.ZodNumber;
+    failed: z.ZodNumber;
+    computedAt: z.ZodString;
+}, z.core.$strip>;
+export type CreationConsole_PulseSummary = z.infer<typeof CreationConsole_PulseSummary_Schema>;
+export declare const CreationConsole_Pulse_Schema: z.ZodObject<{
+    sequence: z.ZodNumber;
+    changedAt: z.ZodNullable<z.ZodString>;
+    runsInFlight: z.ZodNumber;
+    summary: z.ZodNullable<z.ZodObject<{
+        asked: z.ZodNumber;
+        acceptable: z.ZodNumber;
+        failed: z.ZodNumber;
+        computedAt: z.ZodString;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type CreationConsole_Pulse = z.infer<typeof CreationConsole_Pulse_Schema>;
+/** The pulse a feed's lines imply — one counting rule, used by the companion when it serves a feed. */
+export declare function summarizeCreationConsoleFeed(feed: CreationConsole_Feed): CreationConsole_PulseSummary;
+/**
+ * Where a running dev companion says it listens (#1657) — `<app>/.wildo-saas/state/companion-endpoint.json`.
+ *
+ * Written by the companion once its server is up, beside `companion.token`, because the one party that
+ * KNOWS the address is the process listening on it. It exists for callers that must answer in
+ * milliseconds — the console's per-prompt hook and its status line — which cannot afford the CLI's own
+ * address resolution (it evaluates the authored infrastructure config). The record may outlive the
+ * process; a caller treats a refused connection as "not running", never the file's presence.
+ */
+export declare const COMPANION_ENDPOINT_FILE_NAME = "companion-endpoint.json";
+export declare const CompanionEndpointRecord_Schema: z.ZodObject<{
+    origin: z.ZodString;
+    pid: z.ZodNumber;
+    startedAt: z.ZodString;
+}, z.core.$strip>;
+export type CompanionEndpointRecord = z.infer<typeof CompanionEndpointRecord_Schema>;
+//# sourceMappingURL=workbench-creation-console.custom.shared.schemas.d.ts.map

package/dist/esm/workbench/workbench-creation-console.custom.shared.schemas.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"workbench-creation-console.custom.shared.schemas.d.ts","sourceRoot":"","sources":["../../../../src/workbench/workbench-creation-console.custom.shared.schemas.ts"],"names":[],"mappings":"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"}

package/dist/esm/workbench/workbench-creation-console.custom.shared.schemas.js

@@ -0,0 +1,303 @@
+import { z } from 'zod';
+import { WorkbenchCreationHomeLineKind, WorkbenchCreationHomeSection } from './workbench-creation-plane.custom.shared.schemas.js';
+/**
+ * The CREATION CONSOLE contract — how a coding-agent session (Claude Code, or any agent driving
+ * `wildo`) follows what the companion did and answers what the companion asks.
+ *
+ * ## Why a console needs its own contract beside the workbench's resources
+ *
+ * The companion is the master of application creation: it runs playbooks, dispatches coding
+ * workers over ACP, runs judges and generation steps. The person drives it from a CONSOLE — the
+ * coding-agent session they are already working in — and the workbench becomes the dashboard of
+ * that state (Paul, 2026-09-25). Two things are then owed to the console:
+ *
+ * 1. FEEDBACK: what the companion did (a run completed or was refused, a dispatch settled, a judge
+ *    verdict) and what it now waits for.
+ * 2. ANSWERS: every question the companion asks must be answerable from the console, once, and
+ *    the answer must reach the same service the workbench's own operation reaches.
+ *
+ * The facts already exist as creation-plane rows (Home's lines, the waiting runs, the parked coding
+ * questions, the dossier). The workbench reaches them through the resource plane, which needs a
+ * signed-in PERSON; a console reaches the companion through the local-token plane
+ * (`/api/companion/*`), which is how every `wildo` verb already talks to it. This contract is that
+ * plane's view of the SAME rows — no second derivation, and no second implementation of an answer:
+ * each answer kind calls the companion service the matching workbench operation calls.
+ *
+ * ## Why the question queue is ONE list rather than one read per kind
+ *
+ * A person (or an agent acting for them) asks "what is waiting on me?" once. Four reads, each with
+ * its own identity and answer route, is what makes a console skip one. So the companion folds the
+ * four row kinds into one list with one identity scheme and one answer door, and says per question
+ * which actions it admits — the console restates no policy.
+ */
+/**
+ * WHAT KIND of question a queued item is — which companion lane asked it, and so which service an
+ * answer reaches.
+ */
+export var CreationConsoleQuestionKind;
+(function (CreationConsoleQuestionKind) {
+    /**
+     * A playbook run SUSPENDED mid-derivation on a round of questions it cannot decide alone. One item
+     * per round, carrying every question of the round: the run resumes on one answer to the round.
+     */
+    CreationConsoleQuestionKind["CLARIFICATION"] = "clarification";
+    /** A coding worker (an ACP session the companion dispatched) PARKED on a question it asked. */
+    CreationConsoleQuestionKind["PARKED_CODING_QUESTION"] = "parked-coding-question";
+    /**
+     * An interview question a step can run as soon as it is answered — the dossier entry the workbench
+     * shows as "asked of you now". Answering lands `creator-inputs`; a commit accepts it.
+     */
+    CreationConsoleQuestionKind["INTERVIEW"] = "interview";
+    /**
+     * A fact a drafted governed document still needs. LISTED so the queue is total over what waits on
+     * the person, NOT answerable here: landing governance facts is a whole-document sitting that also
+     * names the governance scope and who decided, and `compliance-is-derived-from-the-product.md`
+     * holds that questionnaire where it is until the evidence tier exists. Answer it in the workbench.
+     */
+    CreationConsoleQuestionKind["GOVERNANCE_FACT"] = "governance-fact";
+})(CreationConsoleQuestionKind || (CreationConsoleQuestionKind = {}));
+/**
+ * WHAT an answer does — the industry three-action model the playbook clarification already uses
+ * (MCP elicitation's vocabulary), so every kind of question speaks it.
+ */
+export var CreationConsoleAnswerAction;
+(function (CreationConsoleAnswerAction) {
+    /** Give the answer(s). */
+    CreationConsoleAnswerAction["ANSWER"] = "answer";
+    /**
+     * Let the asking derivation decide and state its assumption. Clarifications only. May carry the answers
+     * the person did give: the run then decides only the questions left unanswered.
+     */
+    CreationConsoleAnswerAction["DECLINE"] = "decline";
+    /** Abandon the run that asked. Clarifications and parked coding questions. */
+    CreationConsoleAnswerAction["CANCEL"] = "cancel";
+})(CreationConsoleAnswerAction || (CreationConsoleAnswerAction = {}));
+/** One question inside a queued item — a clarification round carries several, the others one. */
+export const CreationConsole_QuestionField_Schema = z.object({
+    /** The ref an answer names. */
+    ref: z.string().min(1),
+    /** The question as a person reads it, verbatim from whoever asked. */
+    question: z.string().min(1),
+    /** Why it is asked — what cannot be decided without it. NULL when the asker states none. */
+    why: z.string().min(1).nullable(),
+    /**
+     * The answer's shape, in the ASKER's own vocabulary — deliberately a string, because this field carries
+     * two: `HumanDecision_FieldKind` (`free_text` | `choice` | `confirm`) for a playbook round, a parked run
+     * and an interview question, and the governed-document questionnaire's answer kind for a governance
+     * fact. One enum here would be false for one of them.
+     */
+    kind: z.string().min(1),
+    /** The closed answer set for a `choice`; empty otherwise. */
+    options: z.array(z.string()),
+});
+export const CreationConsole_Question_Schema = z.object({
+    /**
+     * `<kind>:<creation-plane row id>`. Row ids are sanitized to `[a-zA-Z0-9_-]`, so the first `:`
+     * always separates the kind — see {@link parseCreationConsoleQuestionId}.
+     */
+    questionId: z.string().min(1),
+    kind: z.enum(CreationConsoleQuestionKind),
+    /** When it was asked, ISO-8601. NULL when the row records no instant (an interview question has none). */
+    askedAt: z.string().nullable(),
+    /** The playbook that asks, when a playbook asks. */
+    playbookRef: z.string().nullable(),
+    /** The build-plan task the asking coding run was working on, for a parked coding question. */
+    taskRef: z.string().nullable(),
+    /**
+     * The opened INSTANCE of the step the question is asked for (#1609), for an interview question; NULL for
+     * the step itself and for other kinds. An answer lands on that instance, so the reader must see which.
+     */
+    instanceKey: z.string().nullable(),
+    /** The governed document, for a governance fact. */
+    definitionRef: z.string().nullable(),
+    /**
+     * WHICH revision of the question the console read — the clarification's round, the parked run's
+     * suspension ref. An answer must echo it: a run that has moved on to another question refuses an
+     * answer written for the previous one (#1584, #1581) instead of applying it to the wrong question.
+     * NULL for kinds that have no revision.
+     */
+    revision: z.string().nullable(),
+    /** The questions to answer, in order. */
+    fields: z.array(CreationConsole_QuestionField_Schema),
+    /** What an answer may do for THIS item — empty when the console cannot answer it. */
+    actions: z.array(z.enum(CreationConsoleAnswerAction)),
+    /*
+     * Facts that change what answering MEANS, for the reader to weigh first. Carried as facts rather
+     * than as a sentence: the words belong to whoever renders them (`display-text-comes-from-i18n.md`).
+     */
+    /** The family a suspended run was producing when it stopped to ask. */
+    producingFamily: z.string().nullable(),
+    /** The suspended run was a dry run: answering it writes nothing. NULL for other kinds. */
+    dryRun: z.boolean().nullable(),
+    /** FALSE when the parked coding run cannot re-enter its own session, so an answer starts a new one. NULL for other kinds. */
+    resumable: z.boolean().nullable(),
+    /** Every family an interview answer feeds — what goes stale when it changes. Empty for other kinds. */
+    affectsFamilies: z.array(z.string()),
+    /**
+     * The signed-in person a clarification is ROUTED to (#1751) — whoever started its run from the workbench
+     * or the conversation. Only they may answer it, and the console carries no person, so such an item has
+     * no actions here: it is answered in the workbench, signed in as them. NULL when it is unrouted.
+     */
+    routedToUserId: z.string().nullable(),
+});
+export const CreationConsole_QuestionQueue_Schema = z.object({
+    /** When the queue was read, ISO-8601. */
+    computedAt: z.string(),
+    questions: z.array(CreationConsole_Question_Schema),
+});
+/**
+ * One answer to one field. It carries its OWN author because a round is answered in one call while its
+ * fields may be answered by different parties (#1658): an agent derives one from a declared fact, the
+ * person decides the next. With one author per request, a mixed round either stamped the person's name
+ * on the agent's derivation or was refused as incomplete — the agent answering alone could not cover the
+ * judgement half, and the resume refuses a round answered in part.
+ */
+export const CreationConsole_Answer_Schema = z.object({
+    ref: z.string().min(1),
+    value: z.string().min(1),
+    /** Who gave THIS answer; overrides the request's `answeredByRef` for this field. Same vocabulary. */
+    answeredByRef: z.string().min(1).optional(),
+});
+export const CreationConsole_AnswerRequest_Schema = z.object({
+    questionId: z.string().min(1),
+    /** The `revision` of the item as it was READ. Required for the kinds that carry one. */
+    revision: z.string().min(1).nullable().optional(),
+    action: z.enum(CreationConsoleAnswerAction),
+    /**
+     * One entry per answered field, by its `ref`. Required for `answer`, which must cover every field.
+     * A clarification's `decline` may carry the fields the person DID answer and delegates only the rest
+     * (#1658), so one round can mix what a person decided with what they left to the run.
+     */
+    answers: z.array(CreationConsole_Answer_Schema).optional(),
+    /**
+     * WHO answered — recorded for EVERY kind (#1658): on an interview answer in the dossier, on a
+     * clarification in the committed `DECISIONS.md`, on a parked coding answer in `CODING-ANSWERS.md`.
+     * The local-token plane proves only that the caller
+     * is on this machine — the same trust as a git commit author, which is what accepts the answer
+     * anyway (`one-source-of-truth.md` rule 7) — so `wildo` sends the workspace's git identity as
+     * `git:<email>` unless told otherwise, and an agent answering on its own sends `agent:<name>`. The
+     * prefix matters because the same dossier field holds the workbench's signed-in user ids: it says
+     * which door an answer came through. Required for an interview answer (the dossier cannot record
+     * one without it); optional for the others, which then record nothing rather than a guess.
+     *
+     * The DEFAULT author of every answer in the request: an answer carrying its own `answeredByRef` keeps
+     * it. A parked coding question and an interview answer are one field each, so the two cannot differ.
+     */
+    answeredByRef: z.string().min(1).optional(),
+});
+export const CreationConsole_AnswerOutcome_Schema = z.looseObject({
+    questionId: z.string().min(1),
+    kind: z.enum(CreationConsoleQuestionKind),
+    action: z.enum(CreationConsoleAnswerAction),
+    /** What the answering service returned — its own shape (a resumed run's outcome, a landed dossier file). */
+    outcome: z.unknown(),
+});
+/**
+ * One FEED line: a Home line (what happened, what is asked, what could come next) with the row it
+ * points at attached, so a console reads a run's verdict or a dispatch's error without a second call.
+ *
+ * `at` is ISO-8601 here — this is a JSON contract, not a resource row.
+ */
+export const CreationConsole_FeedLine_Schema = z.object({
+    lineId: z.string().min(1),
+    section: z.enum(WorkbenchCreationHomeSection),
+    kind: z.enum(WorkbenchCreationHomeLineKind),
+    at: z.string().nullable(),
+    playbookRef: z.string().nullable(),
+    taskRef: z.string().nullable(),
+    subject: z.string().nullable(),
+    failed: z.boolean(),
+    acceptable: z.boolean(),
+    needsAnswers: z.boolean(),
+    stuckReason: z.string().nullable(),
+    targetResourceType: z.string().min(1),
+    targetResourceId: z.string().min(1),
+    /** The row the line points at, as the creation plane serves it. NULL when it has gone since. */
+    target: z.record(z.string(), z.unknown()).nullable(),
+    /** The queued question this line is about, when it is about exactly one — answer it by this id. */
+    questionId: z.string().nullable(),
+});
+export const CreationConsole_Feed_Schema = z.object({
+    computedAt: z.string(),
+    lines: z.array(CreationConsole_FeedLine_Schema),
+});
+/** The one identity rule, applied by the companion when it emits and when it resolves an answer. */
+export function formatCreationConsoleQuestionId(kind, rowId) {
+    return `${kind}:${rowId}`;
+}
+/** The inverse of {@link formatCreationConsoleQuestionId}; `null` for anything that is not one. */
+export function parseCreationConsoleQuestionId(questionId) {
+    const separator = questionId.indexOf(':');
+    if (separator <= 0 || separator === questionId.length - 1)
+        return null;
+    const kind = Object.values(CreationConsoleQuestionKind).find((candidate) => candidate === questionId.slice(0, separator));
+    return kind ? { kind, rowId: questionId.slice(separator + 1) } : null;
+}
+/**
+ * The workbench DEEP LINK (#1652): `?open=<resourceType>:<resourceId>` opens that creation-plane row
+ * in the workbench's detail pane, the way clicking its Home line does. `wildo workbench open <ref>`
+ * writes it; the workbench reads it once and drops it. One format, owned here, so the writer and the
+ * reader cannot disagree about it.
+ *
+ * The FIRST `:` separates the two, because a resource type never contains one and a row id may.
+ */
+export const WORKBENCH_OPEN_DETAIL_QUERY_PARAM = 'open';
+export function formatWorkbenchOpenDetailParam(resourceType, resourceId) {
+    return `${resourceType}:${resourceId}`;
+}
+/** The inverse of {@link formatWorkbenchOpenDetailParam}; `null` for anything that is not one. */
+export function parseWorkbenchOpenDetailParam(value) {
+    const separator = value.indexOf(':');
+    if (separator <= 0 || separator === value.length - 1)
+        return null;
+    return { resourceType: value.slice(0, separator), resourceId: value.slice(separator + 1) };
+}
+/**
+ * The PULSE (#1657): a read cheap enough to poll every few seconds from a hook or a status line.
+ *
+ * Nothing in it is derived on request. `sequence` and `changedAt` move whenever the creation plane's
+ * boards are invalidated (every mutation path ends there) or a watched board is republished;
+ * `runsInFlight` is the process's own running-run count; `summary` is what the most recent FEED read
+ * counted, with its instant — `null` until someone has read the feed, because computing it here would
+ * make the pulse as slow as the feed. A poller compares pulses and reads the feed only when one moved.
+ */
+export const CreationConsole_PulseSummary_Schema = z.object({
+    /** Lines in the ASKED section: questions waiting on the person. */
+    asked: z.number().int().nonnegative(),
+    /** Lines marked acceptable: finished work waiting to be committed. */
+    acceptable: z.number().int().nonnegative(),
+    /** SINCE lines that failed. */
+    failed: z.number().int().nonnegative(),
+    computedAt: z.string(),
+});
+export const CreationConsole_Pulse_Schema = z.object({
+    sequence: z.number().int().nonnegative(),
+    changedAt: z.string().nullable(),
+    runsInFlight: z.number().int().nonnegative(),
+    summary: CreationConsole_PulseSummary_Schema.nullable(),
+});
+/** The pulse a feed's lines imply — one counting rule, used by the companion when it serves a feed. */
+export function summarizeCreationConsoleFeed(feed) {
+    return {
+        asked: feed.lines.filter((line) => line.section === WorkbenchCreationHomeSection.ASKED).length,
+        acceptable: feed.lines.filter((line) => line.acceptable).length,
+        failed: feed.lines.filter((line) => line.section === WorkbenchCreationHomeSection.SINCE && line.failed).length,
+        computedAt: feed.computedAt,
+    };
+}
+/**
+ * Where a running dev companion says it listens (#1657) — `<app>/.wildo-saas/state/companion-endpoint.json`.
+ *
+ * Written by the companion once its server is up, beside `companion.token`, because the one party that
+ * KNOWS the address is the process listening on it. It exists for callers that must answer in
+ * milliseconds — the console's per-prompt hook and its status line — which cannot afford the CLI's own
+ * address resolution (it evaluates the authored infrastructure config). The record may outlive the
+ * process; a caller treats a refused connection as "not running", never the file's presence.
+ */
+export const COMPANION_ENDPOINT_FILE_NAME = 'companion-endpoint.json';
+export const CompanionEndpointRecord_Schema = z.object({
+    origin: z.string().url(),
+    pid: z.number().int().positive(),
+    startedAt: z.string(),
+});
+//# sourceMappingURL=workbench-creation-console.custom.shared.schemas.js.map

package/dist/esm/workbench/workbench-creation-console.custom.shared.schemas.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"workbench-creation-console.custom.shared.schemas.js","sourceRoot":"","sources":["../../../../src/workbench/workbench-creation-console.custom.shared.schemas.ts"],"names":[],"mappings":"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","sourcesContent":["import { z } from 'zod';\n\nimport { WorkbenchCreationHomeLineKind, WorkbenchCreationHomeSection } from './workbench-creation-plane.custom.shared.schemas';\n\n/**\n * The CREATION CONSOLE contract — how a coding-agent session (Claude Code, or any agent driving\n * `wildo`) follows what the companion did and answers what the companion asks.\n *\n * ## Why a console needs its own contract beside the workbench's resources\n *\n * The companion is the master of application creation: it runs playbooks, dispatches coding\n * workers over ACP, runs judges and generation steps. The person drives it from a CONSOLE — the\n * coding-agent session they are already working in — and the workbench becomes the dashboard of\n * that state (Paul, 2026-09-25). Two things are then owed to the console:\n *\n * 1. FEEDBACK: what the companion did (a run completed or was refused, a dispatch settled, a judge\n *    verdict) and what it now waits for.\n * 2. ANSWERS: every question the companion asks must be answerable from the console, once, and\n *    the answer must reach the same service the workbench's own operation reaches.\n *\n * The facts already exist as creation-plane rows (Home's lines, the waiting runs, the parked coding\n * questions, the dossier). The workbench reaches them through the resource plane, which needs a\n * signed-in PERSON; a console reaches the companion through the local-token plane\n * (`/api/companion/*`), which is how every `wildo` verb already talks to it. This contract is that\n * plane's view of the SAME rows — no second derivation, and no second implementation of an answer:\n * each answer kind calls the companion service the matching workbench operation calls.\n *\n * ## Why the question queue is ONE list rather than one read per kind\n *\n * A person (or an agent acting for them) asks \"what is waiting on me?\" once. Four reads, each with\n * its own identity and answer route, is what makes a console skip one. So the companion folds the\n * four row kinds into one list with one identity scheme and one answer door, and says per question\n * which actions it admits — the console restates no policy.\n */\n\n/**\n * WHAT KIND of question a queued item is — which companion lane asked it, and so which service an\n * answer reaches.\n */\nexport enum CreationConsoleQuestionKind {\n  /**\n   * A playbook run SUSPENDED mid-derivation on a round of questions it cannot decide alone. One item\n   * per round, carrying every question of the round: the run resumes on one answer to the round.\n   */\n  CLARIFICATION = 'clarification',\n  /** A coding worker (an ACP session the companion dispatched) PARKED on a question it asked. */\n  PARKED_CODING_QUESTION = 'parked-coding-question',\n  /**\n   * An interview question a step can run as soon as it is answered — the dossier entry the workbench\n   * shows as \"asked of you now\". Answering lands `creator-inputs`; a commit accepts it.\n   */\n  INTERVIEW = 'interview',\n  /**\n   * A fact a drafted governed document still needs. LISTED so the queue is total over what waits on\n   * the person, NOT answerable here: landing governance facts is a whole-document sitting that also\n   * names the governance scope and who decided, and `compliance-is-derived-from-the-product.md`\n   * holds that questionnaire where it is until the evidence tier exists. Answer it in the workbench.\n   */\n  GOVERNANCE_FACT = 'governance-fact',\n}\n\n/**\n * WHAT an answer does — the industry three-action model the playbook clarification already uses\n * (MCP elicitation's vocabulary), so every kind of question speaks it.\n */\nexport enum CreationConsoleAnswerAction {\n  /** Give the answer(s). */\n  ANSWER = 'answer',\n  /**\n   * Let the asking derivation decide and state its assumption. Clarifications only. May carry the answers\n   * the person did give: the run then decides only the questions left unanswered.\n   */\n  DECLINE = 'decline',\n  /** Abandon the run that asked. Clarifications and parked coding questions. */\n  CANCEL = 'cancel',\n}\n\n/** One question inside a queued item — a clarification round carries several, the others one. */\nexport const CreationConsole_QuestionField_Schema = z.object({\n  /** The ref an answer names. */\n  ref: z.string().min(1),\n  /** The question as a person reads it, verbatim from whoever asked. */\n  question: z.string().min(1),\n  /** Why it is asked — what cannot be decided without it. NULL when the asker states none. */\n  why: z.string().min(1).nullable(),\n  /**\n   * The answer's shape, in the ASKER's own vocabulary — deliberately a string, because this field carries\n   * two: `HumanDecision_FieldKind` (`free_text` | `choice` | `confirm`) for a playbook round, a parked run\n   * and an interview question, and the governed-document questionnaire's answer kind for a governance\n   * fact. One enum here would be false for one of them.\n   */\n  kind: z.string().min(1),\n  /** The closed answer set for a `choice`; empty otherwise. */\n  options: z.array(z.string()),\n});\nexport type CreationConsole_QuestionField = z.infer<typeof CreationConsole_QuestionField_Schema>;\n\nexport const CreationConsole_Question_Schema = z.object({\n  /**\n   * `<kind>:<creation-plane row id>`. Row ids are sanitized to `[a-zA-Z0-9_-]`, so the first `:`\n   * always separates the kind — see {@link parseCreationConsoleQuestionId}.\n   */\n  questionId: z.string().min(1),\n  kind: z.enum(CreationConsoleQuestionKind),\n  /** When it was asked, ISO-8601. NULL when the row records no instant (an interview question has none). */\n  askedAt: z.string().nullable(),\n  /** The playbook that asks, when a playbook asks. */\n  playbookRef: z.string().nullable(),\n  /** The build-plan task the asking coding run was working on, for a parked coding question. */\n  taskRef: z.string().nullable(),\n  /**\n   * The opened INSTANCE of the step the question is asked for (#1609), for an interview question; NULL for\n   * the step itself and for other kinds. An answer lands on that instance, so the reader must see which.\n   */\n  instanceKey: z.string().nullable(),\n  /** The governed document, for a governance fact. */\n  definitionRef: z.string().nullable(),\n  /**\n   * WHICH revision of the question the console read — the clarification's round, the parked run's\n   * suspension ref. An answer must echo it: a run that has moved on to another question refuses an\n   * answer written for the previous one (#1584, #1581) instead of applying it to the wrong question.\n   * NULL for kinds that have no revision.\n   */\n  revision: z.string().nullable(),\n  /** The questions to answer, in order. */\n  fields: z.array(CreationConsole_QuestionField_Schema),\n  /** What an answer may do for THIS item — empty when the console cannot answer it. */\n  actions: z.array(z.enum(CreationConsoleAnswerAction)),\n  /*\n   * Facts that change what answering MEANS, for the reader to weigh first. Carried as facts rather\n   * than as a sentence: the words belong to whoever renders them (`display-text-comes-from-i18n.md`).\n   */\n  /** The family a suspended run was producing when it stopped to ask. */\n  producingFamily: z.string().nullable(),\n  /** The suspended run was a dry run: answering it writes nothing. NULL for other kinds. */\n  dryRun: z.boolean().nullable(),\n  /** FALSE when the parked coding run cannot re-enter its own session, so an answer starts a new one. NULL for other kinds. */\n  resumable: z.boolean().nullable(),\n  /** Every family an interview answer feeds — what goes stale when it changes. Empty for other kinds. */\n  affectsFamilies: z.array(z.string()),\n  /**\n   * The signed-in person a clarification is ROUTED to (#1751) — whoever started its run from the workbench\n   * or the conversation. Only they may answer it, and the console carries no person, so such an item has\n   * no actions here: it is answered in the workbench, signed in as them. NULL when it is unrouted.\n   */\n  routedToUserId: z.string().nullable(),\n});\nexport type CreationConsole_Question = z.infer<typeof CreationConsole_Question_Schema>;\n\nexport const CreationConsole_QuestionQueue_Schema = z.object({\n  /** When the queue was read, ISO-8601. */\n  computedAt: z.string(),\n  questions: z.array(CreationConsole_Question_Schema),\n});\nexport type CreationConsole_QuestionQueue = z.infer<typeof CreationConsole_QuestionQueue_Schema>;\n\n/**\n * One answer to one field. It carries its OWN author because a round is answered in one call while its\n * fields may be answered by different parties (#1658): an agent derives one from a declared fact, the\n * person decides the next. With one author per request, a mixed round either stamped the person's name\n * on the agent's derivation or was refused as incomplete — the agent answering alone could not cover the\n * judgement half, and the resume refuses a round answered in part.\n */\nexport const CreationConsole_Answer_Schema = z.object({\n  ref: z.string().min(1),\n  value: z.string().min(1),\n  /** Who gave THIS answer; overrides the request's `answeredByRef` for this field. Same vocabulary. */\n  answeredByRef: z.string().min(1).optional(),\n});\nexport type CreationConsole_Answer = z.infer<typeof CreationConsole_Answer_Schema>;\n\nexport const CreationConsole_AnswerRequest_Schema = z.object({\n  questionId: z.string().min(1),\n  /** The `revision` of the item as it was READ. Required for the kinds that carry one. */\n  revision: z.string().min(1).nullable().optional(),\n  action: z.enum(CreationConsoleAnswerAction),\n  /**\n   * One entry per answered field, by its `ref`. Required for `answer`, which must cover every field.\n   * A clarification's `decline` may carry the fields the person DID answer and delegates only the rest\n   * (#1658), so one round can mix what a person decided with what they left to the run.\n   */\n  answers: z.array(CreationConsole_Answer_Schema).optional(),\n  /**\n   * WHO answered — recorded for EVERY kind (#1658): on an interview answer in the dossier, on a\n   * clarification in the committed `DECISIONS.md`, on a parked coding answer in `CODING-ANSWERS.md`.\n   * The local-token plane proves only that the caller\n   * is on this machine — the same trust as a git commit author, which is what accepts the answer\n   * anyway (`one-source-of-truth.md` rule 7) — so `wildo` sends the workspace's git identity as\n   * `git:<email>` unless told otherwise, and an agent answering on its own sends `agent:<name>`. The\n   * prefix matters because the same dossier field holds the workbench's signed-in user ids: it says\n   * which door an answer came through. Required for an interview answer (the dossier cannot record\n   * one without it); optional for the others, which then record nothing rather than a guess.\n   *\n   * The DEFAULT author of every answer in the request: an answer carrying its own `answeredByRef` keeps\n   * it. A parked coding question and an interview answer are one field each, so the two cannot differ.\n   */\n  answeredByRef: z.string().min(1).optional(),\n});\nexport type CreationConsole_AnswerRequest = z.infer<typeof CreationConsole_AnswerRequest_Schema>;\n\nexport const CreationConsole_AnswerOutcome_Schema = z.looseObject({\n  questionId: z.string().min(1),\n  kind: z.enum(CreationConsoleQuestionKind),\n  action: z.enum(CreationConsoleAnswerAction),\n  /** What the answering service returned — its own shape (a resumed run's outcome, a landed dossier file). */\n  outcome: z.unknown(),\n});\nexport type CreationConsole_AnswerOutcome = z.infer<typeof CreationConsole_AnswerOutcome_Schema>;\n\n/**\n * One FEED line: a Home line (what happened, what is asked, what could come next) with the row it\n * points at attached, so a console reads a run's verdict or a dispatch's error without a second call.\n *\n * `at` is ISO-8601 here — this is a JSON contract, not a resource row.\n */\nexport const CreationConsole_FeedLine_Schema = z.object({\n  lineId: z.string().min(1),\n  section: z.enum(WorkbenchCreationHomeSection),\n  kind: z.enum(WorkbenchCreationHomeLineKind),\n  at: z.string().nullable(),\n  playbookRef: z.string().nullable(),\n  taskRef: z.string().nullable(),\n  subject: z.string().nullable(),\n  failed: z.boolean(),\n  acceptable: z.boolean(),\n  needsAnswers: z.boolean(),\n  stuckReason: z.string().nullable(),\n  targetResourceType: z.string().min(1),\n  targetResourceId: z.string().min(1),\n  /** The row the line points at, as the creation plane serves it. NULL when it has gone since. */\n  target: z.record(z.string(), z.unknown()).nullable(),\n  /** The queued question this line is about, when it is about exactly one — answer it by this id. */\n  questionId: z.string().nullable(),\n});\nexport type CreationConsole_FeedLine = z.infer<typeof CreationConsole_FeedLine_Schema>;\n\nexport const CreationConsole_Feed_Schema = z.object({\n  computedAt: z.string(),\n  lines: z.array(CreationConsole_FeedLine_Schema),\n});\nexport type CreationConsole_Feed = z.infer<typeof CreationConsole_Feed_Schema>;\n\n/** The one identity rule, applied by the companion when it emits and when it resolves an answer. */\nexport function formatCreationConsoleQuestionId(kind: CreationConsoleQuestionKind, rowId: string): string {\n  return `${kind}:${rowId}`;\n}\n\n/** The inverse of {@link formatCreationConsoleQuestionId}; `null` for anything that is not one. */\nexport function parseCreationConsoleQuestionId(questionId: string): { kind: CreationConsoleQuestionKind; rowId: string } | null {\n  const separator = questionId.indexOf(':');\n  if (separator <= 0 || separator === questionId.length - 1) return null;\n  const kind = Object.values(CreationConsoleQuestionKind).find((candidate) => candidate === questionId.slice(0, separator));\n  return kind ? { kind, rowId: questionId.slice(separator + 1) } : null;\n}\n\n/**\n * The workbench DEEP LINK (#1652): `?open=<resourceType>:<resourceId>` opens that creation-plane row\n * in the workbench's detail pane, the way clicking its Home line does. `wildo workbench open <ref>`\n * writes it; the workbench reads it once and drops it. One format, owned here, so the writer and the\n * reader cannot disagree about it.\n *\n * The FIRST `:` separates the two, because a resource type never contains one and a row id may.\n */\nexport const WORKBENCH_OPEN_DETAIL_QUERY_PARAM = 'open';\n\nexport function formatWorkbenchOpenDetailParam(resourceType: string, resourceId: string): string {\n  return `${resourceType}:${resourceId}`;\n}\n\n/** The inverse of {@link formatWorkbenchOpenDetailParam}; `null` for anything that is not one. */\nexport function parseWorkbenchOpenDetailParam(value: string): { resourceType: string; resourceId: string } | null {\n  const separator = value.indexOf(':');\n  if (separator <= 0 || separator === value.length - 1) return null;\n  return { resourceType: value.slice(0, separator), resourceId: value.slice(separator + 1) };\n}\n\n/**\n * The PULSE (#1657): a read cheap enough to poll every few seconds from a hook or a status line.\n *\n * Nothing in it is derived on request. `sequence` and `changedAt` move whenever the creation plane's\n * boards are invalidated (every mutation path ends there) or a watched board is republished;\n * `runsInFlight` is the process's own running-run count; `summary` is what the most recent FEED read\n * counted, with its instant — `null` until someone has read the feed, because computing it here would\n * make the pulse as slow as the feed. A poller compares pulses and reads the feed only when one moved.\n */\nexport const CreationConsole_PulseSummary_Schema = z.object({\n  /** Lines in the ASKED section: questions waiting on the person. */\n  asked: z.number().int().nonnegative(),\n  /** Lines marked acceptable: finished work waiting to be committed. */\n  acceptable: z.number().int().nonnegative(),\n  /** SINCE lines that failed. */\n  failed: z.number().int().nonnegative(),\n  computedAt: z.string(),\n});\nexport type CreationConsole_PulseSummary = z.infer<typeof CreationConsole_PulseSummary_Schema>;\n\nexport const CreationConsole_Pulse_Schema = z.object({\n  sequence: z.number().int().nonnegative(),\n  changedAt: z.string().nullable(),\n  runsInFlight: z.number().int().nonnegative(),\n  summary: CreationConsole_PulseSummary_Schema.nullable(),\n});\nexport type CreationConsole_Pulse = z.infer<typeof CreationConsole_Pulse_Schema>;\n\n/** The pulse a feed's lines imply — one counting rule, used by the companion when it serves a feed. */\nexport function summarizeCreationConsoleFeed(feed: CreationConsole_Feed): CreationConsole_PulseSummary {\n  return {\n    asked: feed.lines.filter((line) => line.section === WorkbenchCreationHomeSection.ASKED).length,\n    acceptable: feed.lines.filter((line) => line.acceptable).length,\n    failed: feed.lines.filter((line) => line.section === WorkbenchCreationHomeSection.SINCE && line.failed).length,\n    computedAt: feed.computedAt,\n  };\n}\n\n/**\n * Where a running dev companion says it listens (#1657) — `<app>/.wildo-saas/state/companion-endpoint.json`.\n *\n * Written by the companion once its server is up, beside `companion.token`, because the one party that\n * KNOWS the address is the process listening on it. It exists for callers that must answer in\n * milliseconds — the console's per-prompt hook and its status line — which cannot afford the CLI's own\n * address resolution (it evaluates the authored infrastructure config). The record may outlive the\n * process; a caller treats a refused connection as \"not running\", never the file's presence.\n */\nexport const COMPANION_ENDPOINT_FILE_NAME = 'companion-endpoint.json';\n\nexport const CompanionEndpointRecord_Schema = z.object({\n  origin: z.string().url(),\n  pid: z.number().int().positive(),\n  startedAt: z.string(),\n});\nexport type CompanionEndpointRecord = z.infer<typeof CompanionEndpointRecord_Schema>;\n"]}