@knpkv/relay 0.0.0-stage → 0.1.0

package/dist/model.d.ts

@@ -0,0 +1,188 @@
+import { Schema } from "effect";
+/** The products Relay can be about. */
+export declare const RelayProduct: Schema.Literals<readonly ["codecommit", "jcf", "agent-usage", "control-center", "herdr"]>;
+export type RelayProduct = typeof RelayProduct.Type;
+/** A product object a Relay session is about. Relay keeps sessions only for the products it knows. */
+export declare const ObjectRef: Schema.Struct<{
+    readonly product: Schema.Literals<readonly ["codecommit", "jcf", "agent-usage", "control-center", "herdr"]>;
+    readonly kind: Schema.String;
+    readonly id: Schema.String;
+}>;
+export interface ObjectRef extends Schema.Schema.Type<typeof ObjectRef> {
+}
+/** The key a session is stored under. Unique per product, kind and id: JSON-encoded, so no field can contain the separator. */
+export declare const objectRefKey: (ref: ObjectRef) => string;
+/** Who must agree before a capability runs, as the dock lists it. */
+export declare const CapabilityAccess: Schema.Literals<readonly ["read", "write", "host"]>;
+export type CapabilityAccess = typeof CapabilityAccess.Type;
+/** Why a backend can't answer yet, and the one action that fixes it. */
+export declare const BackendUnavailableCause: Schema.Literals<readonly ["NotInstalled", "SignedOut", "Misconfigured", "NoCapability"]>;
+export type BackendUnavailableCause = typeof BackendUnavailableCause.Type;
+/** The backends Relay supports: each runs on the user's own CLI login, never on a token Relay holds. */
+export declare const RelayBackendId: Schema.Literals<readonly ["claude-code", "codex-cli"]>;
+export type RelayBackendId = typeof RelayBackendId.Type;
+/**
+ * What setup shows for one backend. `Unverified` (installed, version known, never answered yet) until a turn
+ * answers (`Ready`) or is refused for sign-in (`Unavailable` with `SignedOut`). Not persisted: every start is
+ * `Unverified` or `Unavailable` again. `fix` is one line the person can act on.
+ */
+export declare const BackendStatus: Schema.TaggedUnion<{
+    readonly Ready: Schema.TaggedStruct<"Ready", {
+        readonly backend: Schema.Literals<readonly ["claude-code", "codex-cli"]>;
+        readonly label: Schema.String;
+        readonly version: Schema.String;
+    }>;
+    readonly Unavailable: Schema.TaggedStruct<"Unavailable", {
+        readonly backend: Schema.Literals<readonly ["claude-code", "codex-cli"]>;
+        readonly label: Schema.String;
+        readonly version: Schema.optionalKey<Schema.String>;
+        readonly cause: Schema.Literals<readonly ["NotInstalled", "SignedOut", "Misconfigured", "NoCapability"]>;
+        readonly fix: Schema.String;
+    }>;
+    readonly Unverified: Schema.TaggedStruct<"Unverified", {
+        readonly backend: Schema.Literals<readonly ["claude-code", "codex-cli"]>;
+        readonly label: Schema.String;
+        readonly version: Schema.String;
+    }>;
+}>;
+export type BackendStatus = typeof BackendStatus.Type;
+/** Why a confirmation can't be answered: answered already, withdrawn with its run, or never asked. */
+export declare const DecisionState: Schema.TaggedUnion<{
+    readonly Decided: Schema.TaggedStruct<"Decided", {
+        readonly allow: Schema.Boolean;
+    }>;
+    readonly Expired: Schema.TaggedStruct<"Expired", {}>;
+    readonly Unknown: Schema.TaggedStruct<"Unknown", {}>;
+}>;
+export type DecisionState = typeof DecisionState.Type;
+/** One tool as the dock lists it for a session. */
+export declare const SessionTool: Schema.Struct<{
+    readonly name: Schema.String;
+    readonly access: Schema.Literals<readonly ["read", "write", "host"]>;
+    readonly available: Schema.Boolean;
+    readonly unavailableReason: Schema.optional<Schema.String>;
+}>;
+export interface SessionTool extends Schema.Schema.Type<typeof SessionTool> {
+}
+/**
+ * What the dock shows for a session: its tools, the backend its next turn runs on, and whether a run can
+ * be stopped (the dock offers Stop only when `cancel` is true).
+ */
+export declare const SessionInfo: Schema.Struct<{
+    readonly tools: Schema.$Array<Schema.Struct<{
+        readonly name: Schema.String;
+        readonly access: Schema.Literals<readonly ["read", "write", "host"]>;
+        readonly available: Schema.Boolean;
+        readonly unavailableReason: Schema.optional<Schema.String>;
+    }>>;
+    readonly backend: Schema.Literals<readonly ["claude-code", "codex-cli"]>;
+    readonly cancel: Schema.Boolean;
+}>;
+export interface SessionInfo extends Schema.Schema.Type<typeof SessionInfo> {
+}
+/**
+ * What a confirmed write did, as the product projects it: a display-safe line, the provider's id for what
+ * was made, and where to see it.
+ */
+export declare const WriteReceipt: Schema.Struct<{
+    readonly summary: Schema.String;
+    readonly providerId: Schema.String;
+    readonly link: Schema.optionalKey<Schema.String>;
+}>;
+export interface WriteReceipt extends Schema.Schema.Type<typeof WriteReceipt> {
+}
+/** Everything the dock renders. `seq` counts up within one subscription; a reconnect starts from a `Snapshot`. */
+export declare const RelayEvent: Schema.TaggedUnion<{
+    readonly ApprovalPending: Schema.TaggedStruct<"ApprovalPending", {
+        readonly session: Schema.String;
+        readonly seq: Schema.Int;
+        readonly call: Schema.String;
+        readonly approvalId: Schema.String;
+    }>;
+    readonly Cancelled: Schema.TaggedStruct<"Cancelled", {
+        readonly session: Schema.String;
+        readonly seq: Schema.Int;
+        readonly runIds: Schema.$Array<Schema.String>;
+    }>;
+    readonly ConfirmationRequired: Schema.TaggedStruct<"ConfirmationRequired", {
+        readonly session: Schema.String;
+        readonly seq: Schema.Int;
+        readonly call: Schema.String;
+        readonly action: Schema.Struct<{
+            readonly verb: Schema.String;
+            readonly target: Schema.Struct<{
+                readonly product: Schema.String;
+                readonly kind: Schema.String;
+                readonly id: Schema.String;
+            }>;
+            readonly args: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+        }>;
+        readonly reversible: Schema.Boolean;
+    }>;
+    readonly ConfirmationResolved: Schema.TaggedStruct<"ConfirmationResolved", {
+        readonly session: Schema.String;
+        readonly seq: Schema.Int;
+        readonly call: Schema.String;
+        readonly decision: Schema.Literals<readonly ["confirmed", "declined", "expired"]>;
+    }>;
+    readonly RunFailed: Schema.TaggedStruct<"RunFailed", {
+        readonly session: Schema.String;
+        readonly seq: Schema.Int;
+        readonly runIds: Schema.$Array<Schema.String>;
+        readonly cause: Schema.String;
+        readonly fix: Schema.String;
+    }>;
+    readonly RunFinished: Schema.TaggedStruct<"RunFinished", {
+        readonly session: Schema.String;
+        readonly seq: Schema.Int;
+        readonly runIds: Schema.$Array<Schema.String>;
+    }>;
+    readonly RunStarted: Schema.TaggedStruct<"RunStarted", {
+        readonly session: Schema.String;
+        readonly seq: Schema.Int;
+        readonly runIds: Schema.$Array<Schema.String>;
+    }>;
+    readonly Snapshot: Schema.TaggedStruct<"Snapshot", {
+        readonly session: Schema.String;
+        readonly seq: Schema.Int;
+        readonly messages: Schema.$Array<Schema.Struct<{
+            readonly id: Schema.String;
+            readonly role: Schema.Literals<readonly ["user", "relay"]>;
+            readonly text: Schema.String;
+        }>>;
+        /** The run in flight, empty when idle. */
+        readonly runIds: Schema.$Array<Schema.String>;
+    }>;
+    readonly TextDelta: Schema.TaggedStruct<"TextDelta", {
+        readonly session: Schema.String;
+        readonly seq: Schema.Int;
+        readonly text: Schema.String;
+    }>;
+    readonly ToolFinished: Schema.TaggedStruct<"ToolFinished", {
+        readonly session: Schema.String;
+        readonly seq: Schema.Int;
+        readonly call: Schema.String;
+        readonly ok: Schema.Boolean;
+        readonly summary: Schema.String;
+        readonly cites: Schema.$Array<Schema.Struct<{
+            readonly product: Schema.String;
+            readonly kind: Schema.String;
+            readonly id: Schema.String;
+        }>>;
+        readonly receipt: Schema.optionalKey<Schema.Struct<{
+            readonly summary: Schema.String;
+            readonly providerId: Schema.String;
+            readonly link: Schema.optionalKey<Schema.String>;
+        }>>;
+    }>;
+    readonly ToolStarted: Schema.TaggedStruct<"ToolStarted", {
+        readonly session: Schema.String;
+        readonly seq: Schema.Int;
+        readonly call: Schema.String;
+        readonly capability: Schema.String;
+        readonly summary: Schema.String;
+        readonly input: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+    }>;
+}>;
+export type RelayEvent = typeof RelayEvent.Type;
+//# sourceMappingURL=model.d.ts.map

package/dist/model.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"model.d.ts","sourceRoot":"","sources":["../src/model.ts"],"names":[],"mappings":"AAoBA,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAA;AAI/B,uCAAuC;AACvC,eAAO,MAAM,YAAY,2FAAmF,CAAA;AAC5G,MAAM,MAAM,YAAY,GAAG,OAAO,YAAY,CAAC,IAAI,CAAA;AAEnD,sGAAsG;AACtG,eAAO,MAAM,SAAS;;;;EAIpB,CAAA;AACF,MAAM,WAAW,SAAU,SAAQ,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,SAAS,CAAC;CAAG;AAE1E,+HAA+H;AAC/H,eAAO,MAAM,YAAY,QAAS,SAAS,KAAG,MAAyD,CAAA;AAEvG,qEAAqE;AACrE,eAAO,MAAM,gBAAgB,qDAA6C,CAAA;AAC1E,MAAM,MAAM,gBAAgB,GAAG,OAAO,gBAAgB,CAAC,IAAI,CAAA;AAE3D,wEAAwE;AACxE,eAAO,MAAM,uBAAuB,0FAAkF,CAAA;AACtH,MAAM,MAAM,uBAAuB,GAAG,OAAO,uBAAuB,CAAC,IAAI,CAAA;AAEzE,wGAAwG;AACxG,eAAO,MAAM,cAAc,wDAAgD,CAAA;AAC3E,MAAM,MAAM,cAAc,GAAG,OAAO,cAAc,CAAC,IAAI,CAAA;AAIvD;;;;GAIG;AACH,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;EASxB,CAAA;AACF,MAAM,MAAM,aAAa,GAAG,OAAO,aAAa,CAAC,IAAI,CAAA;AAErD,sGAAsG;AACtG,eAAO,MAAM,aAAa;;;;;;EAIxB,CAAA;AACF,MAAM,MAAM,aAAa,GAAG,OAAO,aAAa,CAAC,IAAI,CAAA;AAErD,mDAAmD;AACnD,eAAO,MAAM,WAAW;;;;;EAKtB,CAAA;AACF,MAAM,WAAW,WAAY,SAAQ,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,WAAW,CAAC;CAAG;AAE9E;;;GAGG;AACH,eAAO,MAAM,WAAW;;;;;;;;;EAItB,CAAA;AACF,MAAM,WAAW,WAAY,SAAQ,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,WAAW,CAAC;CAAG;AAE9E;;;GAGG;AACH,eAAO,MAAM,YAAY;;;;EAIvB,CAAA;AACF,MAAM,WAAW,YAAa,SAAQ,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,YAAY,CAAC;CAAG;AAShF,kHAAkH;AAClH,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAMnB,0CAA0C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA2B5C,CAAA;AACF,MAAM,MAAM,UAAU,GAAG,OAAO,UAAU,CAAC,IAAI,CAAA"}

package/dist/registry.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Capabilities as the harness holds them: one list of `@knpkv/capability` capabilities with their
+ * types closed over, so the harness can run any of them from the model's JSON without `any`.
+ *
+ * Decoding, encoding and failure handling are the capability package's (`invoke`, `describeCall`);
+ * this module only erases types and records what the gate needs.
+ *
+ * @module
+ */
+import { type Capability, type CapabilityEncodingFailed, type CapabilityFailed, type CapabilityInputInvalid, type FailureSchema, type InputSchema, type InvocationResult, type PendingAction, type PlainSchema } from "@knpkv/capability";
+import { Schema } from "effect";
+import type { Effect } from "effect";
+import type * as JsonSchema from "effect/JsonSchema";
+import type { WriteReceipt } from "./model.js";
+/** What a person must agree to before a gated capability runs. */
+export interface Gate {
+    readonly access: "write" | "host";
+    readonly reversible: boolean;
+    readonly describe: (args: Schema.Json) => Effect.Effect<PendingAction, CapabilityInputInvalid | CapabilityEncodingFailed>;
+}
+/** One registered capability, its types erased behind closures. */
+export interface RegisteredCapability<Requirements> {
+    readonly name: string;
+    readonly description: string;
+    /** `undefined` for a read: it runs without anyone agreeing first. */
+    readonly gate: Gate | undefined;
+    /** A short display name, for activity rows. */
+    readonly label: string;
+    /** A display-safe line for one call: a write's action verb, or the label. */
+    readonly summarize: (args: Schema.Json) => string;
+    /** What a completed call made, for writes whose product projects a receipt. */
+    readonly receipt: (result: InvocationResult) => WriteReceipt | undefined;
+    /** JSON Schema of the input, for the model's tool list and argument validation. */
+    readonly parameters: JsonSchema.JsonSchema;
+    /** `args` is the model's JSON for this call; the capability decodes it at the boundary. */
+    readonly run: (args: Schema.Json) => Effect.Effect<InvocationResult, CapabilityInputInvalid | CapabilityFailed | CapabilityEncodingFailed, Requirements>;
+}
+/** How the dock shows a capability's calls. Every field has a default. */
+export interface DisplayOptions<Output extends PlainSchema> {
+    /** Defaults to the capability name with spaces: `get_pull_request` is "get pull request". */
+    readonly label?: string;
+    /** A write's receipt, from its decoded output: a display-safe line, the provider's id, a link. */
+    readonly receipt?: (output: Output["Type"]) => WriteReceipt;
+}
+/** Register a capability for Relay, with how the dock shows its calls. */
+export declare const register: <Name extends string, Input extends InputSchema, Output extends PlainSchema, Failure extends FailureSchema, Requirements>(capability: Capability<Name, Input, Output, Failure, Requirements>, display?: DisplayOptions<Output>) => RegisteredCapability<Requirements>;
+//# sourceMappingURL=registry.d.ts.map

package/dist/registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"registry.d.ts","sourceRoot":"","sources":["../src/registry.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,OAAO,EACL,KAAK,UAAU,EACf,KAAK,wBAAwB,EAC7B,KAAK,gBAAgB,EACrB,KAAK,sBAAsB,EAE3B,KAAK,aAAa,EAElB,KAAK,WAAW,EAChB,KAAK,gBAAgB,EAErB,KAAK,aAAa,EAClB,KAAK,WAAW,EACjB,MAAM,mBAAmB,CAAA;AAC1B,OAAO,EAAU,MAAM,EAAE,MAAM,QAAQ,CAAA;AACvC,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAA;AACpC,OAAO,KAAK,KAAK,UAAU,MAAM,mBAAmB,CAAA;AACpD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,YAAY,CAAA;AAE9C,kEAAkE;AAClE,MAAM,WAAW,IAAI;IACnB,QAAQ,CAAC,MAAM,EAAE,OAAO,GAAG,MAAM,CAAA;IACjC,QAAQ,CAAC,UAAU,EAAE,OAAO,CAAA;IAC5B,QAAQ,CAAC,QAAQ,EAAE,CACjB,IAAI,EAAE,MAAM,CAAC,IAAI,KACd,MAAM,CAAC,MAAM,CAAC,aAAa,EAAE,sBAAsB,GAAG,wBAAwB,CAAC,CAAA;CACrF;AAED,mEAAmE;AACnE,MAAM,WAAW,oBAAoB,CAAC,YAAY;IAChD,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAA;IAC5B,qEAAqE;IACrE,QAAQ,CAAC,IAAI,EAAE,IAAI,GAAG,SAAS,CAAA;IAC/B,+CAA+C;IAC/C,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAA;IACtB,6EAA6E;IAC7E,QAAQ,CAAC,SAAS,EAAE,CAAC,IAAI,EAAE,MAAM,CAAC,IAAI,KAAK,MAAM,CAAA;IACjD,+EAA+E;IAC/E,QAAQ,CAAC,OAAO,EAAE,CAAC,MAAM,EAAE,gBAAgB,KAAK,YAAY,GAAG,SAAS,CAAA;IACxE,mFAAmF;IACnF,QAAQ,CAAC,UAAU,EAAE,UAAU,CAAC,UAAU,CAAA;IAC1C,2FAA2F;IAC3F,QAAQ,CAAC,GAAG,EAAE,CACZ,IAAI,EAAE,MAAM,CAAC,IAAI,KACd,MAAM,CAAC,MAAM,CAChB,gBAAgB,EAChB,sBAAsB,GAAG,gBAAgB,GAAG,wBAAwB,EACpE,YAAY,CACb,CAAA;CACF;AAED,0EAA0E;AAC1E,MAAM,WAAW,cAAc,CAAC,MAAM,SAAS,WAAW;IACxD,6FAA6F;IAC7F,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAA;IACvB,kGAAkG;IAClG,QAAQ,CAAC,OAAO,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,CAAC,KAAK,YAAY,CAAA;CAC5D;AAED,0EAA0E;AAC1E,eAAO,MAAM,QAAQ,GACnB,IAAI,SAAS,MAAM,EACnB,KAAK,SAAS,WAAW,EACzB,MAAM,SAAS,WAAW,EAC1B,OAAO,SAAS,aAAa,EAC7B,YAAY,cAEA,UAAU,CAAC,IAAI,EAAE,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE,YAAY,CAAC,YACzD,cAAc,CAAC,MAAM,CAAC,KAC9B,oBAAoB,CAAC,YAAY,CA0BnC,CAAA"}

package/dist/turn.d.ts

@@ -0,0 +1,68 @@
+/**
+ * One model turn over a CLI-backed `LanguageModel`, with tool calls carried in a JSON schema.
+ *
+ * **Mental model**
+ *
+ * - **The CLI never runs tools.** `claude --print` and `codex exec` are asked for one structured
+ *   answer: either tool calls or a final reply. The harness runs the tools, behind its gate, and the
+ *   next turn sees their results. That keeps the user's own CLI login as the only credential and the
+ *   permission gate as the only path to a product.
+ * - **The transcript is rendered, not replayed into provider sessions.** Each turn gets the whole
+ *   visible transcript, so switching backends mid-session needs no provider state.
+ *
+ * @module
+ */
+import { Effect, Schema } from "effect";
+import { LanguageModel } from "effect/ai";
+/** A tool as the model is told about it. */
+export interface TurnTool {
+    readonly name: string;
+    readonly description: string;
+    readonly parameters: Schema.Json;
+}
+/** One transcript line as the model reads it. */
+export type TurnLine = {
+    readonly _tag: "User";
+    readonly text: string;
+} | {
+    readonly _tag: "Relay";
+    readonly text: string;
+} | {
+    readonly _tag: "ToolCall";
+    readonly id: string;
+    readonly name: string;
+    readonly arguments: Schema.Json;
+} | {
+    readonly _tag: "ToolResult";
+    readonly id: string;
+    readonly name: string;
+    readonly text: string;
+    readonly isError: boolean;
+};
+export interface TurnRequest {
+    readonly instructions: string;
+    readonly tools: ReadonlyArray<TurnTool>;
+    readonly transcript: ReadonlyArray<TurnLine>;
+}
+/** What the model returns for one turn. An empty `toolCalls` means `reply` is the final answer. */
+export declare const Turn: Schema.Struct<{
+    readonly reply: Schema.String;
+    readonly toolCalls: Schema.$Array<Schema.Struct<{
+        readonly name: Schema.String;
+        readonly arguments: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+    }>>;
+}>;
+export type Turn = typeof Turn.Type;
+/** The prompt one turn sends: instructions, the tool list with schemas, the transcript, the answer rule. */
+export declare const renderTurnPrompt: (request: TurnRequest) => string;
+/** Run one turn on whatever `LanguageModel` is provided: the user's Claude Code or Codex CLI. */
+export declare const runTurn: (request: TurnRequest) => Effect.Effect<{
+    readonly reply: string;
+    readonly toolCalls: readonly {
+        readonly name: string;
+        readonly arguments: {
+            readonly [x: string]: Schema.Json;
+        };
+    }[];
+}, import("effect/ai/AiError").AiError, LanguageModel.LanguageModel>;
+//# sourceMappingURL=turn.d.ts.map

package/dist/turn.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"turn.d.ts","sourceRoot":"","sources":["../src/turn.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AACH,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAA;AACvC,OAAO,EAAE,aAAa,EAAE,MAAM,WAAW,CAAA;AAEzC,4CAA4C;AAC5C,MAAM,WAAW,QAAQ;IACvB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAA;IAC5B,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC,IAAI,CAAA;CACjC;AAED,iDAAiD;AACjD,MAAM,MAAM,QAAQ,GAChB;IAAE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;CAAE,GAChD;IAAE,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAC;IAAC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;CAAE,GACjD;IAAE,QAAQ,CAAC,IAAI,EAAE,UAAU,CAAC;IAAC,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC,IAAI,CAAA;CAAE,GAC1G;IACA,QAAQ,CAAC,IAAI,EAAE,YAAY,CAAA;IAC3B,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAA;IACnB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAA;CAC1B,CAAA;AAEH,MAAM,WAAW,WAAW;IAC1B,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAA;IAC7B,QAAQ,CAAC,KAAK,EAAE,aAAa,CAAC,QAAQ,CAAC,CAAA;IACvC,QAAQ,CAAC,UAAU,EAAE,aAAa,CAAC,QAAQ,CAAC,CAAA;CAC7C;AAED,mGAAmG;AACnG,eAAO,MAAM,IAAI;;;;;;EAGf,CAAA;AACF,MAAM,MAAM,IAAI,GAAG,OAAO,IAAI,CAAC,IAAI,CAAA;AAenC,4GAA4G;AAC5G,eAAO,MAAM,gBAAgB,YAAa,WAAW,KAAG,MAmB1C,CAAA;AAEd,iGAAiG;AACjG,eAAO,MAAM,OAAO;;;;;;;;oEAOlB,CAAA"}

package/package.json

@@ -1,6 +1,72 @@
 {
   "name": "@knpkv/relay",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "version": "0.1.0",
+  "description": "Relay agent harness: durable sessions per product object, typed capabilities, a central permission gate, and model turns through the user's own Claude Code or Codex CLI login",
+  "license": "MIT",
+  "author": "knpkv",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/knpkv/npm.git",
+    "directory": "packages/relay"
+  },
+  "type": "module",
+  "sideEffects": false,
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE-THIRD-PARTY.md"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "engines": {
+    "node": ">=26"
+  },
+  "peerDependencies": {
+    "effect": "4.0.0"
+  },
+  "dependencies": {
+    "@libsql/client": "^0.18.0",
+    "typebox": "1.3.27",
+    "@knpkv/ai-claude": "^0.4.3",
+    "@knpkv/ai-codex": "^0.5.3",
+    "@knpkv/ai-runtime": "^0.5.2",
+    "@knpkv/capability": "^0.1.0"
+  },
+  "devDependencies": {
+    "@earendil-works/chord": "1.0.4",
+    "@earendil-works/pi-ai": "1.0.4",
+    "@earendil-works/pi-durable": "1.0.4",
+    "@effect/platform-node": "4.0.0",
+    "@effect/vitest": "4.0.0",
+    "effect": "4.0.0",
+    "esbuild": "0.28.2",
+    "rimraf": "^6.1.3",
+    "typescript": "npm:@typescript/typescript6@^6.0.2",
+    "vitest": "^5.0.3"
+  },
+  "keywords": [
+    "effect",
+    "agent",
+    "relay",
+    "durable",
+    "claude",
+    "codex"
+  ],
+  "scripts": {
+    "build": "rimraf dist && tsc && node scripts/bundle.mjs",
+    "check": "tsc --noEmit && tsc --noEmit -p test/tsconfig.json",
+    "clean": "rimraf dist *.tsbuildinfo",
+    "lint": "eslint \"{src,test}/**/*.ts\"",
+    "test": "vitest run",
+    "test:pack": "pnpm --filter \"@knpkv/relay...\" --sort run build && node scripts/test-packed-package.mjs"
+  }
 }