@owlmeans/viable-common 0.0.4

package/build/blueprint/types.d.ts

@@ -0,0 +1,186 @@
+import type { SubProject } from '../slot/consts.js';
+import type { ViableSkill } from '../skills/consts.js';
+import type { ViablePersona } from '../skills/roles.js';
+import type { TopologyDescriptor } from '../topology/types.js';
+/**
+ * A BLUEPRINT is everything that decides what kind of project the pipeline is building — the
+ * language, the framework, the scaffolder, the seed files and the dependencies — as one named,
+ * layered value carried on an execution.
+ *
+ * Before it, each of those was a constant somewhere: one template directory, one hardwired set of
+ * five package names, one `VIABLE_SKILLS` catalogue, one `Libraries*` allow-list per area. Nothing
+ * was wrong with any of them individually; what was wrong is that they could not be ANSWERED — a
+ * helper could not ask "which stack am I generating for", because there was only ever one.
+ *
+ * Deliberately NOT called a preset: `presets/` in the agent library already means the LLM
+ * model/provider configurations, and the two are asked at different moments about different
+ * things.
+ */
+export interface Blueprint {
+    id: string;
+    title: string;
+    technology: TechnologyLayer;
+    stack: StackLayer;
+    template: TemplateLayer;
+    createApp: CreateAppLayer;
+    packages: PackagesLayer;
+}
+/**
+ * The layers, lowest first. A higher layer's value replaces the same key from a lower one.
+ *
+ * The ordering is the point: `technology` overrides everything, because a change of language
+ * invalidates every template, prompt and package below it. Nothing today has more than one
+ * technology — the ladder exists so that adding one is a data change.
+ */
+export declare enum BlueprintLayer {
+    Technology = "technology",
+    Stack = "stack",
+    Template = "template",
+    CreateApp = "create-app",
+    Packages = "packages"
+}
+export declare const BLUEPRINT_LAYER_ORDER: BlueprintLayer[];
+/** Language and toolchain. Overrides everything below it. */
+export interface TechnologyLayer {
+    id: string;
+    language: string;
+    runtime: string;
+    /** Extensions a source file may carry, most specific first. Used by the location ladder. */
+    extensions: string[];
+    /** What a package's manifest must declare, per package kind. */
+    buildScripts: Record<string, string>;
+    packageManager: string;
+}
+/** Framework family — what the generated code is written AGAINST. */
+export interface StackLayer {
+    id: string;
+    framework: string;
+    /** The arrangement a new project of this stack is created with. */
+    topology: TopologyDescriptor;
+    /** The skills every prompt of this stack carries, before any per-helper persona. */
+    skills: ViableSkill[];
+}
+/**
+ * The seed: what is laid over the scaffolder's output, and what is then patched.
+ *
+ * `overlay` is a REFERENCE, never a path — the host resolves it, because the same blueprint is
+ * read in an agent container, in a test and (eventually) from a published package, and a path
+ * baked in here would be right in exactly one of them.
+ */
+export interface TemplateLayer {
+    id: string;
+    overlay: string;
+    /**
+     * Paths the scaffolder writes that this overlay SUPERSEDES — deleted after the overlay lands.
+     *
+     * Not tidiness. The two seeds are both complete, opinionated projects, and where they disagree
+     * the loser's file does not become inert: it stays in the workspace, is compiled by `tsc`, and
+     * imports packages the winner's manifest never declared. The scaffolder's Vite entry, its
+     * `vite.config.ts` and its shell layout each name a dependency or an export the overlay's own
+     * wiring does not have, and every one of them fails the type check of a project that is
+     * otherwise perfectly correct.
+     *
+     * A directory takes its whole subtree. A path that is not there is a no-op, because the two
+     * seeds move independently and an overlay must not break when the scaffolder stops shipping
+     * something it used to supersede.
+     */
+    remove?: string[];
+    /** Deterministic patches applied after the overlay, in order. */
+    patches: BlueprintPatchSpec[];
+    /** Overlay subtrees that belong to one role only — the per-package half of a template. */
+    perRole?: Partial<Record<SubProject, string>>;
+}
+export interface BlueprintPatchSpec {
+    /** Target path, relative to the project root. */
+    path: string;
+    kind: BlueprintPatchKind;
+}
+export declare enum BlueprintPatchKind {
+    /** Deep-merge a JSON document — the manifests, the tsconfigs. */
+    JsonMerge = "json-merge",
+    /** Rewrite the `<head>` of an HTML document from the project's identity. */
+    HtmlHead = "html-head",
+    /** Write a document composed from the project's identity. */
+    Compose = "compose"
+}
+/** Which scaffolder runs first, and how. */
+export interface CreateAppLayer {
+    id: string;
+    /** The npm name, for the record. The template itself is always resolved as DATA. */
+    package: string;
+    /** Scaffold the shell without the example/demo code. Always true for a generated target. */
+    bare: boolean;
+    /** A reference the host resolves to the scaffolder's template directory. */
+    template: string;
+}
+/**
+ * The dependency choices — and therefore the prompts and skills those choices imply.
+ *
+ * This is the layer that makes "postgres or mongo" a blueprint question rather than a hardwired
+ * catalogue. `capabilities` is what a design stage gates on; `libraries` is what a coder prompt is
+ * allowed to import; `skills` is what gets loaded on top of the stack's.
+ */
+export interface PackagesLayer {
+    id: string;
+    capabilities: BlueprintCapabilities;
+    /** Per-topic allow-lists, rendered verbatim into coder prompts. */
+    libraries: Record<string, string[]>;
+    skills: ViableSkill[];
+    /**
+     * Skills added to ONE persona, rather than to every prompt of the blueprint.
+     *
+     * The additive twin of {@link skillsForBlueprint}, which subtracts. `skills` above is what is
+     * true of the whole stack; this is what is true of one performer — the analyst who has to know
+     * that a game brief is a core loop rather than a numbered flow, the architect who has to know
+     * when a tool loop is warranted. Without it a case could only change what a CODER is told, and
+     * a case changes the product analysis first.
+     */
+    personaSkills?: Partial<Record<ViablePersona, ViableSkill[]>>;
+    /** Extra dependencies a role's manifest carries, beyond what the overlay ships. */
+    deps?: Partial<Record<SubProject, Record<string, string>>>;
+}
+/**
+ * What a target of this blueprint is ABLE to do — read by the design stage before it decides
+ * whether a story needs any of it.
+ *
+ * A capability being on never means a story uses it. It means the question may be asked.
+ */
+export interface BlueprintCapabilities {
+    /** Relational persistence — the default resource kind. */
+    postgres: boolean;
+    /** A pod-local key/value store: TTL, locks, counters, fan-out. */
+    kv: boolean;
+    /** A broker, and therefore the possibility of work off the request path. */
+    queue: boolean;
+    /** A separate process consuming that broker. */
+    worker: boolean;
+    /** LLM agents and pipelines generated INTO the target. */
+    agents: boolean;
+    /** Request-body validation from generated AJV schemas. */
+    validation: boolean;
+}
+/** A partial override of a blueprint, deep-merged over the resolved value. */
+export type BlueprintPatch = {
+    [K in keyof Blueprint]?: Blueprint[K] extends string ? Blueprint[K] : Partial<Blueprint[K]>;
+};
+/**
+ * What an EXECUTION carries — an id and an override patch, never the resolved blueprint.
+ *
+ * An execution state is serialized into a pipeline run row at every step boundary, and that row
+ * holds keys, never artifacts. A resolved blueprint is an artifact: it embeds a whole topology, a
+ * patch list and two skill sets, and it is reconstructible from these two fields at any time.
+ */
+export interface BlueprintRef {
+    id: string;
+    /**
+     * WHICH KIND of product is being built on that blueprint — the case.
+     *
+     * A key like the id beside it, resolved into a patch on demand, so a run row still holds no
+     * artifact and a case the platform has since corrected reaches a resumed run. Absent applies no
+     * patch at all: every project created before cases existed keeps exactly the blueprint it had,
+     * which is the only reading that cannot silently take a capability away from a live project.
+     */
+    case?: string;
+    overrides?: BlueprintPatch;
+}
+//# sourceMappingURL=types.d.ts.map

package/build/blueprint/types.d.ts.map

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

package/build/blueprint/types.js

@@ -0,0 +1,32 @@
+/**
+ * The layers, lowest first. A higher layer's value replaces the same key from a lower one.
+ *
+ * The ordering is the point: `technology` overrides everything, because a change of language
+ * invalidates every template, prompt and package below it. Nothing today has more than one
+ * technology — the ladder exists so that adding one is a data change.
+ */
+export var BlueprintLayer;
+(function (BlueprintLayer) {
+    BlueprintLayer["Technology"] = "technology";
+    BlueprintLayer["Stack"] = "stack";
+    BlueprintLayer["Template"] = "template";
+    BlueprintLayer["CreateApp"] = "create-app";
+    BlueprintLayer["Packages"] = "packages";
+})(BlueprintLayer || (BlueprintLayer = {}));
+export const BLUEPRINT_LAYER_ORDER = [
+    BlueprintLayer.Technology,
+    BlueprintLayer.Stack,
+    BlueprintLayer.Template,
+    BlueprintLayer.CreateApp,
+    BlueprintLayer.Packages,
+];
+export var BlueprintPatchKind;
+(function (BlueprintPatchKind) {
+    /** Deep-merge a JSON document — the manifests, the tsconfigs. */
+    BlueprintPatchKind["JsonMerge"] = "json-merge";
+    /** Rewrite the `<head>` of an HTML document from the project's identity. */
+    BlueprintPatchKind["HtmlHead"] = "html-head";
+    /** Write a document composed from the project's identity. */
+    BlueprintPatchKind["Compose"] = "compose";
+})(BlueprintPatchKind || (BlueprintPatchKind = {}));
+//# sourceMappingURL=types.js.map

package/build/blueprint/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../src/blueprint/types.ts"],"names":[],"mappings":"AA6BA;;;;;;GAMG;AACH,MAAM,CAAN,IAAY,cAMX;AAND,WAAY,cAAc;IACxB,2CAAyB,CAAA;IACzB,iCAAe,CAAA;IACf,uCAAqB,CAAA;IACrB,0CAAwB,CAAA;IACxB,uCAAqB,CAAA;AACvB,CAAC,EANW,cAAc,KAAd,cAAc,QAMzB;AAED,MAAM,CAAC,MAAM,qBAAqB,GAAqB;IACrD,cAAc,CAAC,UAAU;IACzB,cAAc,CAAC,KAAK;IACpB,cAAc,CAAC,QAAQ;IACvB,cAAc,CAAC,SAAS;IACxB,cAAc,CAAC,QAAQ;CACxB,CAAA;AA6DD,MAAM,CAAN,IAAY,kBAOX;AAPD,WAAY,kBAAkB;IAC5B,iEAAiE;IACjE,8CAAwB,CAAA;IACxB,4EAA4E;IAC5E,4CAAsB,CAAA;IACtB,6DAA6D;IAC7D,yCAAmB,CAAA;AACrB,CAAC,EAPW,kBAAkB,KAAlB,kBAAkB,QAO7B"}

package/build/branding.d.ts

@@ -0,0 +1,19 @@
+import type { SlotMetadata } from './types.js';
+/**
+ * The build-time environment keys a generated application reads its branding from.
+ *
+ * Named here, once, because two processes emit them — the publisher for the preview and the agent
+ * for a production publish — and a key spelled differently in one of them produces an application
+ * that silently falls back to its defaults with nothing anywhere reporting it.
+ */
+export declare const BRANDING_ENV_KEYS: readonly ['BRANDING_COPYRIGHT', 'BRANDING_ORGANIZATION', 'BRANDING_TERMS_URL', 'BRANDING_PRIVACY_URL', 'BRANDING_CREDIT', 'BRANDING_PRODUCT'];
+/**
+ * Slot metadata as build-time environment.
+ *
+ * `BRANDING_CREDIT` is the one value whose ABSENCE means something: only an explicit empty string
+ * hides the platform credit, so a metadata set that never carried the key keeps it. That is the
+ * safe direction — the opposite failure hands out a paid feature and nobody reports getting more
+ * than they paid for.
+ */
+export declare const brandingEnv: (meta: Partial<SlotMetadata>) => Record<string, string>;
+//# sourceMappingURL=branding.d.ts.map

package/build/branding.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"branding.d.ts","sourceRoot":"","sources":["../src/branding.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,YAAY,CAAA;AAE9C;;;;;;GAMG;AACH,eAAO,MAAM,iBAAiB,YAC5B,oBAAoB,EACpB,uBAAuB,EACvB,oBAAoB,EACpB,sBAAsB,EACtB,iBAAiB,EACjB,kBAAkB,CACV,CAAA;AAEV;;;;;;;GAOG;AACH,eAAO,MAAM,WAAW,SAAU,OAAO,CAAC,YAAY,CAAC,KAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAO7E,CAAA"}

package/build/branding.js

@@ -0,0 +1,32 @@
+/**
+ * The build-time environment keys a generated application reads its branding from.
+ *
+ * Named here, once, because two processes emit them — the publisher for the preview and the agent
+ * for a production publish — and a key spelled differently in one of them produces an application
+ * that silently falls back to its defaults with nothing anywhere reporting it.
+ */
+export const BRANDING_ENV_KEYS = [
+    'BRANDING_COPYRIGHT',
+    'BRANDING_ORGANIZATION',
+    'BRANDING_TERMS_URL',
+    'BRANDING_PRIVACY_URL',
+    'BRANDING_CREDIT',
+    'BRANDING_PRODUCT',
+];
+/**
+ * Slot metadata as build-time environment.
+ *
+ * `BRANDING_CREDIT` is the one value whose ABSENCE means something: only an explicit empty string
+ * hides the platform credit, so a metadata set that never carried the key keeps it. That is the
+ * safe direction — the opposite failure hands out a paid feature and nobody reports getting more
+ * than they paid for.
+ */
+export const brandingEnv = (meta) => ({
+    BRANDING_COPYRIGHT: meta.brandingCopyright ?? '',
+    BRANDING_ORGANIZATION: meta.brandingOrganization ?? '',
+    BRANDING_TERMS_URL: meta.brandingTermsUrl ?? '',
+    BRANDING_PRIVACY_URL: meta.brandingPrivacyUrl ?? '',
+    BRANDING_CREDIT: meta.brandingCredit === '' ? '' : '1',
+    BRANDING_PRODUCT: meta.projectName ?? '',
+});
+//# sourceMappingURL=branding.js.map

package/build/branding.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"branding.js","sourceRoot":"","sources":["../src/branding.ts"],"names":[],"mappings":"AAEA;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,iBAAiB,GAAG;IAC/B,oBAAoB;IACpB,uBAAuB;IACvB,oBAAoB;IACpB,sBAAsB;IACtB,iBAAiB;IACjB,kBAAkB;CACV,CAAA;AAEV;;;;;;;GAOG;AACH,MAAM,CAAC,MAAM,WAAW,GAAG,CAAC,IAA2B,EAA0B,EAAE,CAAC,CAAC;IACnF,kBAAkB,EAAE,IAAI,CAAC,iBAAiB,IAAI,EAAE;IAChD,qBAAqB,EAAE,IAAI,CAAC,oBAAoB,IAAI,EAAE;IACtD,kBAAkB,EAAE,IAAI,CAAC,gBAAgB,IAAI,EAAE;IAC/C,oBAAoB,EAAE,IAAI,CAAC,kBAAkB,IAAI,EAAE;IACnD,eAAe,EAAE,IAAI,CAAC,cAAc,KAAK,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,GAAG;IACtD,gBAAgB,EAAE,IAAI,CAAC,WAAW,IAAI,EAAE;CACzC,CAAC,CAAA"}

package/build/connect/consts.d.ts

@@ -0,0 +1,378 @@
+/**
+ * The connector contract — how an external coding agent drives the platform.
+ *
+ * A "connector session" is one external agent (Claude Code, Codex, Copilot, OpenCode, a CLI, a
+ * test) attached to one project. Two axes decide what the platform asks of it:
+ *
+ * - **target** — where the generated project's tree lives. `Cloud` is a publisher slot and the
+ *   platform reaches it as it always has; `Local` is a directory on the user's own machine, and
+ *   every file, shell and git command is executed THERE, by the connector, over this contract.
+ * - **llm** — who performs the model calls. `Cloud` is the platform's own configured presets,
+ *   billed in credits; `Local` hands each call to the parent agent as a MODEL TASK, which it runs
+ *   in a clean subagent and submits back.
+ *
+ * Everything here is serializable and runtime-free: the SDK, the manager API and the agent all
+ * read the same declarations, and none of them may reinvent a name the others parse.
+ */
+/** Where the target project's tree lives for this session. */
+export declare enum ConnectTarget {
+    /** A publisher slot: the platform executes commands inside the pod, as it always has. */
+    Cloud = "cloud",
+    /** A directory on the user's machine: the connector executes the commands. */
+    Local = "local"
+}
+/** Who performs the model calls of a run. */
+export declare enum ConnectLlm {
+    /** The platform's configured presets — billed against the organization's credits. */
+    Cloud = "cloud",
+    /**
+     * The parent agent. Each call becomes a `ModelTask` the connector delivers, the parent runs in
+     * a clean subagent at low reasoning, and submits back as a `ModelTaskResult`.
+     *
+     * A paid capability, and an experimental one — see `CONNECT_CAP_LOCAL_LLM_KEY`.
+     */
+    Local = "local"
+}
+/**
+ * The parent agents the connector knows how to instruct.
+ *
+ * It decides ONE thing: the wording of "how to run this task" in a model-task envelope, and the
+ * files `install_harness` writes. Anything the platform does differently per harness beyond those
+ * two is a bug — the protocol is the same for all of them.
+ */
+export declare enum ConnectHarness {
+    ClaudeCode = "claude-code",
+    Codex = "codex",
+    Copilot = "copilot",
+    OpenCode = "opencode",
+    Other = "other"
+}
+/** What a session is doing. */
+export declare enum ConnectSessionStatus {
+    Active = "active",
+    /** The connector said goodbye. */
+    Closed = "closed",
+    /** No presence for {@link CONNECT_SESSION_EXPIRE_MS}; nothing said goodbye. */
+    Expired = "expired",
+    /** A newer session for the same project took over. */
+    Superseded = "superseded"
+}
+/** What a connector is able to execute on this session. */
+export declare enum ConnectExecutor {
+    Files = "files",
+    Shell = "shell",
+    Git = "git",
+    /**
+     * The parent agent PERFORMS the model calls of a run: each one arrives as a `ModelTask`, is run
+     * in a clean subagent and submitted back. Present exactly when `llm` is `Local`.
+     */
+    Model = "model",
+    /**
+     * A PERSON can be asked a question and their answer brought back.
+     *
+     * Advertised always, and by every connector: a parent agent has a human in front of it by
+     * definition, which is the whole reason the platform can ask one anything at all. It is not a
+     * narrower `Model` — a model task is inference the platform pays for either way, an inquiry is
+     * a decision only a person can make, and a run that cannot ask assumes instead.
+     */
+    Human = "human"
+}
+/** What one operation asks a connector to do. */
+export declare enum ConnectOpKind {
+    /** Run a slot command against the local tree — the same vocabulary a publisher answers. */
+    SlotCommand = "slot-command",
+    /** Run one model call and submit its answer. */
+    ModelTask = "model-task",
+    /** Write the target's configuration (its `.env` files) and report what services are reachable. */
+    Configure = "configure",
+    /**
+     * Put one question to the person the connector is working for, and bring back their answer.
+     *
+     * An operation like any other — queued to the project, redelivered to whichever session is
+     * attached, answered against its own op id — because the alternative was a second channel with
+     * its own delivery, expiry and reattachment rules for the one payload that already had them.
+     */
+    Inquiry = "inquiry"
+}
+/** How a connector is receiving operations. */
+export declare enum ConnectTransport {
+    Socket = "socket",
+    Pull = "pull"
+}
+/** Why an operation failed, in the terms the platform reacts to. */
+export declare enum ConnectOpErrorKind {
+    /** The answer did not match the shape asked for; ask again. */
+    Malformed = "malformed",
+    /** The connector executed and refused — a path outside the project, a protected file. */
+    Refused = "refused",
+    /** The connector cannot serve this at all; the run should stop. */
+    Unavailable = "unavailable",
+    /** The connector ran out of time. */
+    Timeout = "timeout"
+}
+/** What shape a model task's answer came back in. */
+export declare enum ModelTaskResultKind {
+    Text = "text",
+    Json = "json",
+    ToolCalls = "tool-calls",
+    Error = "error"
+}
+/**
+ * The power classes a parent agent offers, and the platform asks for.
+ *
+ * Three, because a parent has at most a few models and the platform has seventeen roles. The
+ * mapping is data ({@link MODEL_TIER_ROLES}) rather than a per-role negotiation: a parent says
+ * which of its models is strong, standard and cheap, and the platform stamps each role's tier onto
+ * the task it hands out. A parent offering fewer tiers gets its best available one — never a
+ * silent downgrade to nothing.
+ */
+export declare enum ModelTier {
+    Strong = "strong",
+    Standard = "standard",
+    Cheap = "cheap"
+}
+/**
+ * Role → tier.
+ *
+ * Keyed by the role names the platform's model presets use (`ChatModelPurpose` in
+ * `@owlmeans/viable`), listed here because the parent-facing contract must not depend on the
+ * library that defines them. A role absent from this table gets {@link ModelTier.Standard}.
+ */
+export declare const MODEL_TIER_ROLES: Record<string, ModelTier>;
+export declare const tierOfRole: (role: string) => ModelTier;
+/**
+ * Pick the best tier a parent actually offers, never below what was asked for by more than the
+ * offer allows.
+ *
+ * A parent that offers only one model answers every task with it; a parent that offers two gets
+ * the nearer of the two. Silence is not an option — a task the connector cannot place is a run
+ * that stops.
+ */
+export declare const clampTier: (wanted: ModelTier, offered: ModelTier[]) => ModelTier;
+/** What the model task asks the parent's subagent to produce. */
+export declare enum ModelTaskMode {
+    /** Prose or code. */
+    Text = "text",
+    /** Exactly one JSON object matching `outputSchema`. */
+    Json = "json",
+    /** A JSON array of tool calls chosen from `tools`. */
+    Tools = "tools"
+}
+/** Who a message in a model task's conversation came from. */
+export declare enum ModelTaskRole {
+    System = "system",
+    User = "user",
+    Assistant = "assistant",
+    Tool = "tool"
+}
+/** The KIND of thing a job is, so a parent can be told what it is waiting for. */
+export declare enum ConnectJobKind {
+    ProjectCreate = "project-create",
+    ProjectInit = "project-init",
+    ProjectReinit = "project-reinit",
+    StoryDevelop = "story-develop",
+    FreeFlight = "free-flight",
+    PipelineResume = "pipeline-resume",
+    /**
+     * The four stages of a conversion, plus the purge.
+     *
+     * One kind per stage rather than one for the whole conversion: each stage is its own platform
+     * pipeline run, ends at a decision the user makes, and is looked up by the pipeline alias its
+     * kind names. A single `convert` kind would match whichever run row happened to be newest.
+     */
+    ConvertIntake = "convert-intake",
+    ConvertAnalysis = "convert-analysis",
+    ConvertExtraction = "convert-extraction",
+    ConvertImplementation = "convert-implementation",
+    ConvertPurge = "convert-purge"
+}
+export declare enum ConnectJobStatus {
+    Queued = "queued",
+    Running = "running",
+    /** Running, but waiting on the connector — see `ConnectJob.blockedOn`. */
+    Blocked = "blocked",
+    Done = "done",
+    Failed = "failed"
+}
+/** What a blocked job is waiting for. */
+export declare enum ConnectJobBlock {
+    /** Model tasks are queued and nobody is answering them. */
+    ModelTask = "model-task",
+    /** Slot commands are queued and no connector is attached. */
+    LocalOp = "local-op",
+    /** The local target has no database configured and the run needs one. */
+    Env = "env",
+    /** A question is waiting for a person and nobody has answered it. */
+    Question = "question"
+}
+/**
+ * The shapes a question can take on the wire.
+ *
+ * Mirrors `InquiryKind` in `@owlmeans/llm-common` value for value, and is deliberately a SEPARATE
+ * name rather than an import: the connect module is the wire contract and owns its own vocabulary
+ * — the same reason `ModelTask` mirrors `DelegatedTask` — which also keeps `manager-api`, which
+ * does not depend on the model runtime, free of `@owlmeans/llm-common`. Values are byte-identical,
+ * so the platform's mapper is a widening rather than a translation table, and a test pins that.
+ */
+export declare enum ConnectInquiryKind {
+    /** Pick one of the offered options, or several when `multiple` is set. */
+    Choice = "choice",
+    /** Free text. */
+    Text = "text",
+    /** Yes or no. */
+    Confirm = "confirm"
+}
+/**
+ * How long the platform waits for a person to answer one question.
+ *
+ * The same forty-five minutes a model task gets, and for the same reason: the bound exists so a
+ * parent that has gone away eventually fails the step rather than holding a project lock forever,
+ * not to pace somebody who is thinking.
+ */
+export declare const CONNECT_INQUIRY_TIMEOUT_MS = 2700000;
+/** Options one choice question may offer. Beyond this it is a text question with a hint. */
+export declare const CONNECT_INQUIRY_MAX_OPTIONS = 12;
+/**
+ * The ceiling on an answer's text.
+ *
+ * ONE ceiling for the whole stack: the twin is `DEFAULT_INQUIRY_ANSWER_CHARS` in
+ * `@owlmeans/llm-common`, and the two must stay equal. Two ceilings means the layer with the
+ * larger one truncates silently at the smaller, and the caller records an assumption about an
+ * answer the person actually gave.
+ */
+export declare const CONNECT_INQUIRY_MAX_TEXT = 2000;
+/**
+ * How long a session survives without a sign of life.
+ *
+ * A connector refreshes its presence on every socket ping, every long-poll and every submit. Ten
+ * minutes is generous on purpose: a parent agent running one model task in a subagent can be
+ * silent for several, and expiring a session under it would fail a run that was progressing.
+ */
+export declare const CONNECT_SESSION_EXPIRE_MS = 600000;
+/** Presence key lifetime. Refreshed far more often than it expires. */
+export declare const CONNECT_PRESENCE_TTL_MS = 90000;
+/**
+ * The longest a `pull` may hold its response open.
+ *
+ * Under the ~100 s an edge proxy allows an idle response, and under every MCP host's per-tool
+ * ceiling — Codex's default is 60 s. A poll that answers empty is not a failure; it is how a
+ * connector with nothing to do stays cheap.
+ */
+export declare const CONNECT_PULL_MAX_WAIT_MS = 45000;
+/** Ops in flight for one project before a dispatcher waits for room. */
+export declare const CONNECT_MAX_PENDING = 32;
+/**
+ * How long the platform waits for a parent agent to answer one model task.
+ *
+ * Forty-five minutes: a subagent on a large refactor, a rate-limited provider, a human who walked
+ * away mid-turn. The bound exists so a dead parent eventually fails the step rather than holding a
+ * project lock forever — not to pace a working one.
+ */
+export declare const CONNECT_MODEL_TASK_TIMEOUT_MS = 2700000;
+/** How long the platform waits for a connector to write the target's configuration. */
+export declare const CONNECT_CONFIGURE_TIMEOUT_MS = 60000;
+/**
+ * The capability key that gates the local-LLM mode.
+ *
+ * The scoped parameter a route passes to `entitled(...)` is composed by the platform, which owns
+ * the payment vocabulary — this is only the key a capability set stores.
+ */
+export declare const CONNECT_CAP_LOCAL_LLM_KEY = "connect--local-llm";
+/** The access-token prefix the platform issues. Every connector token starts with it. */
+export declare const CONNECT_TOKEN_PREFIX = "vib_";
+/**
+ * The marker a local project keeps so a connector attaching later knows which platform project it
+ * is. No secrets: an id, a slug and the API it belongs to.
+ */
+export declare const CONNECT_MARKER_FILE = ".viable/connect.json";
+/** Where a local run records its child processes. Never committed. */
+export declare const CONNECT_RUN_FILE = ".viable/run.json";
+/** Where a local target keeps the keypair its backend signs internal calls with. Never committed. */
+export declare const CONNECT_LOCAL_SECRETS_FILE = ".viable/local.json";
+/** The directory all three live in; a re-initialization must keep it. */
+export declare const CONNECT_MARKER_DIR = ".viable";
+/**
+ * The block a connector owns inside a target's `.env`.
+ *
+ * Everything between the markers is rewritten on every configure push; everything outside is the
+ * user's and is never touched. A local target's database URL is the user's line — the platform
+ * provisions no database on a developer's machine.
+ */
+export declare const CONNECT_ENV_BEGIN = "# --- viable:managed ---";
+export declare const CONNECT_ENV_END = "# --- /viable:managed ---";
+/** Socket events a connector session carries. */
+export declare const CONNECT_EVENT_OP = "connect:op";
+export declare const CONNECT_EVENT_SESSION = "connect:session";
+/** Redis resource aliases the platform registers for the relay. */
+export declare const CONNECT_OP_PUBSUB = "connect-op-pubsub";
+export declare const CONNECT_RESULT_PUBSUB = "connect-result-pubsub";
+export declare const CONNECT_OP_STORE = "connect-op-store";
+export declare const CONNECT_SESSION_PUBSUB = "connect-session-pubsub";
+/** The backend resource alias for session records. */
+export declare const RES_CONNECT_SESSION = "connect-session";
+/**
+ * The connector's route ids.
+ *
+ * Owned here rather than by the platform because they ARE the contract: the SDK, the MCP host and
+ * the manager API all address the same aliases, and a client that had to be handed its own copy of
+ * the tree would be a second place for a name to drift. The platform spreads the declarations
+ * these produce into its own entrypoint list and elevates handlers onto them.
+ */
+export declare const connect: Readonly<{
+    base: "viable:manager-api:connect:base";
+    capabilities: "viable:manager-api:connect:capabilities";
+    session: Readonly<{
+        open: "viable:manager-api:connect:session:open";
+        openDelegated: "viable:manager-api:connect:session:open-delegated";
+        get: "viable:manager-api:connect:session:get";
+        heartbeat: "viable:manager-api:connect:session:heartbeat";
+        close: "viable:manager-api:connect:session:close";
+        socket: "viable:manager-api:connect:session:socket";
+    }>;
+    op: Readonly<{
+        pull: "viable:manager-api:connect:op:pull";
+        submit: "viable:manager-api:connect:op:submit";
+    }>;
+    project: Readonly<{
+        create: "viable:manager-api:connect:project:create";
+        confirm: "viable:manager-api:connect:project:confirm";
+        list: "viable:manager-api:connect:project:list";
+        status: "viable:manager-api:connect:project:status";
+        attach: "viable:manager-api:connect:project:attach";
+        reinit: "viable:manager-api:connect:project:reinit";
+        modify: "viable:manager-api:connect:project:modify";
+        settings: "viable:manager-api:connect:project:settings";
+        llm: "viable:manager-api:connect:project:llm";
+        /** The per-project converter inference mode. Separate from `llm`: it is not a paid capability. */
+        converterLlm: "viable:manager-api:connect:project:converter-llm";
+        job: "viable:manager-api:connect:project:job";
+    }>;
+    convert: Readonly<{
+        create: "viable:manager-api:connect:convert:create";
+        check: "viable:manager-api:connect:convert:check";
+        start: "viable:manager-api:connect:convert:start";
+        proceed: "viable:manager-api:connect:convert:proceed";
+        cancel: "viable:manager-api:connect:convert:cancel";
+        status: "viable:manager-api:connect:convert:status";
+        purge: "viable:manager-api:connect:convert:purge";
+    }>;
+    inquiry: Readonly<{
+        answer: "viable:manager-api:connect:inquiry:answer";
+    }>;
+    story: Readonly<{
+        list: "viable:manager-api:connect:story:list";
+        get: "viable:manager-api:connect:story:get";
+        create: "viable:manager-api:connect:story:create";
+        update: "viable:manager-api:connect:story:update";
+        delete: "viable:manager-api:connect:story:delete";
+        develop: "viable:manager-api:connect:story:develop";
+    }>;
+    files: Readonly<{
+        list: "viable:manager-api:connect:files:list";
+    }>;
+    pipeline: Readonly<{
+        state: "viable:manager-api:connect:pipeline:state";
+        resume: "viable:manager-api:connect:pipeline:resume";
+    }>;
+}>;
+//# sourceMappingURL=consts.d.ts.map