@xandreed/core 0.3.0 → 0.8.0-next.0

package/dist/session/sessions.entity.d.ts

@@ -0,0 +1,201 @@
+import { Schema } from "effect";
+import { UserMessage } from "../turn/user-message.entity.js";
+/** A session as its owner names it; another owner's address finds nothing. */
+export declare const SessionAddress: Schema.Struct<{
+    readonly id: Schema.brand<Schema.String, "ConversationId">;
+    readonly owner: Schema.Trimmed;
+}>;
+export type SessionAddress = typeof SessionAddress.Type;
+/** Something delivered to a session for a later turn (a background task's result). */
+export declare const InboxItem: Schema.Struct<{
+    /** Stable: delivering the same id twice stores it once. */
+    readonly id: Schema.Trimmed;
+    /** Who sent it and why, for the host and the UI. */
+    readonly source: Schema.$Record<Schema.String, Schema.Unknown>;
+    /** What the turn that takes it shows the model, framed by the sender. */
+    readonly content: Schema.NonEmptyString;
+}>;
+export type InboxItem = typeof InboxItem.Type;
+/** The turn a session has open. */
+export declare const OpenTurn: Schema.Struct<{
+    readonly turn: Schema.Int;
+    readonly runId: Schema.String;
+    readonly key: Schema.String;
+    readonly origin: Schema.Literals<readonly ["user", "inbox"]>;
+    /** The writer holding it (one Sessions instance). */
+    readonly holder: Schema.String;
+    /** Storage time the lease ends; none under process ownership. */
+    readonly expiresAt: Schema.OptionFromNullOr<Schema.Number>;
+}>;
+export type OpenTurn = typeof OpenTurn.Type;
+/** One session as a host lists or shows it. `open` is none once its lease has run out. */
+export declare const SessionView: Schema.Struct<{
+    readonly header: Schema.Struct<{
+        readonly id: Schema.brand<Schema.String, "ConversationId">;
+        readonly owner: Schema.Trimmed;
+        readonly origin: Schema.Trimmed;
+        readonly createdAt: Schema.Number;
+        readonly meta: Schema.$Record<Schema.String, Schema.Unknown>;
+        readonly parent: Schema.OptionFromNullOr<Schema.Struct<{
+            readonly id: Schema.brand<Schema.String, "ConversationId">;
+            readonly through: Schema.Int;
+            readonly turnAtFork: Schema.Int;
+        }>>;
+    }>;
+    readonly seq: Schema.Int;
+    readonly updatedAt: Schema.Number;
+    readonly turns: Schema.Int;
+    readonly title: Schema.OptionFromNullOr<Schema.String>;
+    readonly open: Schema.OptionFromNullOr<Schema.Struct<{
+        readonly turn: Schema.Int;
+        readonly runId: Schema.String;
+        readonly key: Schema.String;
+        readonly origin: Schema.Literals<readonly ["user", "inbox"]>;
+        /** The writer holding it (one Sessions instance). */
+        readonly holder: Schema.String;
+        /** Storage time the lease ends; none under process ownership. */
+        readonly expiresAt: Schema.OptionFromNullOr<Schema.Number>;
+    }>>;
+    /** Inbox items waiting for a turn. */
+    readonly pending: Schema.Int;
+}>;
+export type SessionView = typeof SessionView.Type;
+/** A page of an owner's sessions and where the next page starts. */
+export declare const SessionPage: Schema.Struct<{
+    readonly sessions: Schema.$Array<Schema.Struct<{
+        readonly header: Schema.Struct<{
+            readonly id: Schema.brand<Schema.String, "ConversationId">;
+            readonly owner: Schema.Trimmed;
+            readonly origin: Schema.Trimmed;
+            readonly createdAt: Schema.Number;
+            readonly meta: Schema.$Record<Schema.String, Schema.Unknown>;
+            readonly parent: Schema.OptionFromNullOr<Schema.Struct<{
+                readonly id: Schema.brand<Schema.String, "ConversationId">;
+                readonly through: Schema.Int;
+                readonly turnAtFork: Schema.Int;
+            }>>;
+        }>;
+        readonly seq: Schema.Int;
+        readonly updatedAt: Schema.Number;
+        readonly turns: Schema.Int;
+        readonly title: Schema.OptionFromNullOr<Schema.String>;
+        readonly open: Schema.OptionFromNullOr<Schema.Struct<{
+            readonly turn: Schema.Int;
+            readonly runId: Schema.String;
+            readonly key: Schema.String;
+            readonly origin: Schema.Literals<readonly ["user", "inbox"]>;
+            /** The writer holding it (one Sessions instance). */
+            readonly holder: Schema.String;
+            /** Storage time the lease ends; none under process ownership. */
+            readonly expiresAt: Schema.OptionFromNullOr<Schema.Number>;
+        }>>;
+        /** Inbox items waiting for a turn. */
+        readonly pending: Schema.Int;
+    }>>;
+    readonly next: Schema.OptionFromNullOr<Schema.Struct<{
+        readonly updatedAt: Schema.Number;
+        readonly id: Schema.brand<Schema.String, "ConversationId">;
+    }>>;
+}>;
+export type SessionPage = typeof SessionPage.Type;
+/** How a turn begins: a user's message, or the inbox's pending items. */
+export declare const BeginTurn: Schema.Union<readonly [Schema.TaggedStruct<"User", {
+    readonly userMessage: typeof UserMessage;
+    readonly runId: Schema.String;
+    /** The host's idempotency key (e.g. the client's command id). */
+    readonly key: Schema.String;
+    readonly command: Schema.$Record<Schema.String, Schema.Unknown>;
+}>, Schema.TaggedStruct<"Inbox", {
+    readonly runId: Schema.String;
+}>]>;
+export type BeginTurn = typeof BeginTurn.Type;
+/** An admitted turn, as the turn's code reads it. */
+export declare const AdmittedTurn: Schema.Struct<{
+    readonly session: Schema.Struct<{
+        readonly id: Schema.brand<Schema.String, "ConversationId">;
+        readonly owner: Schema.Trimmed;
+    }>;
+    readonly turn: Schema.Int;
+    readonly runId: Schema.String;
+    readonly key: Schema.String;
+    readonly origin: Schema.Literals<readonly ["user", "inbox"]>;
+    readonly userMessage: typeof UserMessage;
+    readonly command: Schema.$Record<Schema.String, Schema.Unknown>;
+    readonly claimed: Schema.$Array<Schema.Struct<{
+        /** Stable: delivering the same id twice stores it once. */
+        readonly id: Schema.Trimmed;
+        /** Who sent it and why, for the host and the UI. */
+        readonly source: Schema.$Record<Schema.String, Schema.Unknown>;
+        /** What the turn that takes it shows the model, framed by the sender. */
+        readonly content: Schema.NonEmptyString;
+    }>>;
+}>;
+export type AdmittedTurn = typeof AdmittedTurn.Type;
+/** How a turn ended, as its closer records it. */
+export declare const TurnEnding: Schema.Struct<{
+    readonly reason: Schema.Literals<readonly ["completed", "partial", "failed", "cancelled", "interrupted"]>;
+    readonly failure: Schema.OptionFromNullOr<Schema.Struct<{
+        readonly code: Schema.String;
+        readonly message: Schema.String;
+    }>>;
+}>;
+export type TurnEnding = typeof TurnEnding.Type;
+declare const SessionBusy_base: Schema.Class<SessionBusy, Schema.TaggedStruct<"SessionBusy", {
+    readonly session: Schema.brand<Schema.String, "ConversationId">;
+    readonly turn: Schema.Int;
+}>, import("effect/Cause").YieldableError>;
+/** A session already has a turn open: one message at a time (a host answers 409). */
+export declare class SessionBusy extends SessionBusy_base {
+}
+declare const TurnDuplicate_base: Schema.Class<TurnDuplicate, Schema.TaggedStruct<"TurnDuplicate", {
+    readonly session: Schema.brand<Schema.String, "ConversationId">;
+    readonly turn: Schema.Int;
+    readonly open: Schema.Boolean;
+}>, import("effect/Cause").YieldableError>;
+/** The key was begun before, with the same message: that turn is the answer. */
+export declare class TurnDuplicate extends TurnDuplicate_base {
+}
+declare const KeyConflict_base: Schema.Class<KeyConflict, Schema.TaggedStruct<"KeyConflict", {
+    readonly session: Schema.brand<Schema.String, "ConversationId">;
+    readonly key: Schema.String;
+    readonly turn: Schema.Int;
+}>, import("effect/Cause").YieldableError>;
+/** The key was begun before with another message or command. */
+export declare class KeyConflict extends KeyConflict_base {
+}
+declare const NothingPending_base: Schema.Class<NothingPending, Schema.TaggedStruct<"NothingPending", {
+    readonly session: Schema.brand<Schema.String, "ConversationId">;
+}>, import("effect/Cause").YieldableError>;
+/** An inbox turn found nothing to take. */
+export declare class NothingPending extends NothingPending_base {
+}
+declare const InboxFull_base: Schema.Class<InboxFull, Schema.TaggedStruct<"InboxFull", {
+    readonly session: Schema.brand<Schema.String, "ConversationId">;
+    readonly pending: Schema.Int;
+}>, import("effect/Cause").YieldableError>;
+/** The inbox holds as many waiting items as it may. */
+export declare class InboxFull extends InboxFull_base {
+}
+declare const ReservedKind_base: Schema.Class<ReservedKind, Schema.TaggedStruct<"ReservedKind", {
+    readonly kind: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+/** A host tried to record under a kind only the framework writes. */
+export declare class ReservedKind extends ReservedKind_base {
+}
+declare const TurnClosed_base: Schema.Class<TurnClosed, Schema.TaggedStruct<"TurnClosed", {
+    readonly session: Schema.brand<Schema.String, "ConversationId">;
+    readonly turn: Schema.Int;
+    readonly reason: Schema.Literals<readonly ["cancelled", "interrupted", "removed"]>;
+}>, import("effect/Cause").YieldableError>;
+/** The turn was closed by someone else: cancelled, its lease reaped, or its session removed. */
+export declare class TurnClosed extends TurnClosed_base {
+}
+declare const TurnRefused_base: Schema.Class<TurnRefused, Schema.TaggedStruct<"TurnRefused", {
+    readonly session: Schema.brand<Schema.String, "ConversationId">;
+    readonly reason: Schema.String;
+    readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+/** The host would not open the turn (a budget, a quota): nothing was opened or counted. */
+export declare class TurnRefused extends TurnRefused_base {
+}
+export {};

package/dist/session/sessions.entity.js

@@ -0,0 +1,98 @@
+import { Schema } from "effect";
+import { ConversationId } from "../domain/message.entity.js";
+import { UserMessage } from "../turn/user-message.entity.js";
+import { TurnEndReason } from "./session-event.entity.js";
+import { JsonObject, SessionHeader, SessionListCursor } from "./session-log.entity.js";
+export const SessionAddress = Schema.Struct({ id: ConversationId, owner: Schema.Trimmed.check(Schema.isNonEmpty()) }), InboxItem = Schema.Struct({
+  id: Schema.Trimmed.check(Schema.isNonEmpty()),
+  source: JsonObject,
+  content: Schema.NonEmptyString
+}), OpenTurn = Schema.Struct({
+  turn: Schema.Int,
+  runId: Schema.String,
+  key: Schema.String,
+  origin: Schema.Literals(["user", "inbox"]),
+  holder: Schema.String,
+  expiresAt: Schema.OptionFromNullOr(Schema.Number)
+}), SessionView = Schema.Struct({
+  header: SessionHeader,
+  seq: Schema.Int,
+  updatedAt: Schema.Number,
+  turns: Schema.Int,
+  title: Schema.OptionFromNullOr(Schema.String),
+  open: Schema.OptionFromNullOr(OpenTurn),
+  pending: Schema.Int
+}), SessionPage = Schema.Struct({
+  sessions: Schema.Array(SessionView),
+  next: Schema.OptionFromNullOr(SessionListCursor)
+}), BeginTurn = Schema.Union([
+  Schema.TaggedStruct("User", {
+    userMessage: UserMessage,
+    runId: Schema.String,
+    key: Schema.String,
+    command: JsonObject
+  }),
+  Schema.TaggedStruct("Inbox", { runId: Schema.String })
+]), AdmittedTurn = Schema.Struct({
+  session: SessionAddress,
+  turn: Schema.Int,
+  runId: Schema.String,
+  key: Schema.String,
+  origin: Schema.Literals(["user", "inbox"]),
+  userMessage: UserMessage,
+  command: JsonObject,
+  claimed: Schema.Array(InboxItem)
+}), TurnEnding = Schema.Struct({
+  reason: TurnEndReason,
+  failure: Schema.OptionFromNullOr(Schema.Struct({ code: Schema.String, message: Schema.String }))
+});
+
+export class SessionBusy extends Schema.TaggedError()("SessionBusy", {
+  session: ConversationId,
+  turn: Schema.Int
+}) {
+}
+
+export class TurnDuplicate extends Schema.TaggedError()("TurnDuplicate", {
+  session: ConversationId,
+  turn: Schema.Int,
+  open: Schema.Boolean
+}) {
+}
+
+export class KeyConflict extends Schema.TaggedError()("KeyConflict", {
+  session: ConversationId,
+  key: Schema.String,
+  turn: Schema.Int
+}) {
+}
+
+export class NothingPending extends Schema.TaggedError()("NothingPending", {
+  session: ConversationId
+}) {
+}
+
+export class InboxFull extends Schema.TaggedError()("InboxFull", {
+  session: ConversationId,
+  pending: Schema.Int
+}) {
+}
+
+export class ReservedKind extends Schema.TaggedError()("ReservedKind", {
+  kind: Schema.String
+}) {
+}
+
+export class TurnClosed extends Schema.TaggedError()("TurnClosed", {
+  session: ConversationId,
+  turn: Schema.Int,
+  reason: Schema.Literals(["cancelled", "interrupted", "removed"])
+}) {
+}
+
+export class TurnRefused extends Schema.TaggedError()("TurnRefused", {
+  session: ConversationId,
+  reason: Schema.String,
+  message: Schema.String
+}) {
+}

package/dist/session/tasks.entity.d.ts

@@ -0,0 +1,39 @@
+import { Schema } from "effect";
+export declare const TaskMode: Schema.Literals<readonly ["fork", "spawn"]>;
+export type TaskMode = typeof TaskMode.Type;
+/** Where a task stands, read from its child session. */
+export declare const TaskStatus: Schema.Literals<readonly ["pending", "running", "completed", "partial", "failed", "interrupted", "cancelled"]>;
+export type TaskStatus = typeof TaskStatus.Type;
+export declare const TaskView: Schema.Struct<{
+    readonly taskId: Schema.brand<Schema.String, "ConversationId">;
+    readonly parent: Schema.brand<Schema.String, "ConversationId">;
+    readonly child: Schema.brand<Schema.String, "ConversationId">;
+    readonly instructions: Schema.String;
+    readonly mode: Schema.Literals<readonly ["fork", "spawn"]>;
+    readonly status: Schema.Literals<readonly ["pending", "running", "completed", "partial", "failed", "interrupted", "cancelled"]>;
+    /** The child's final reply, once it has one. */
+    readonly reply: Schema.OptionFromNullOr<Schema.String>;
+    /** Why it did not complete (refused, out of time, failed), when that is known. */
+    readonly failure: Schema.OptionFromNullOr<Schema.Struct<{
+        readonly code: Schema.String;
+        readonly message: Schema.String;
+    }>>;
+    /** Whether the result reached the parent's inbox. */
+    readonly delivered: Schema.Boolean;
+}>;
+export type TaskView = typeof TaskView.Type;
+declare const TaskRefused_base: Schema.Class<TaskRefused, Schema.TaggedStruct<"TaskRefused", {
+    readonly session: Schema.brand<Schema.String, "ConversationId">;
+    readonly reason: Schema.Literals<readonly ["depth", "limit"]>;
+    readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+/** A task that may not start: tasks do not start tasks, and a session runs so many at once. */
+export declare class TaskRefused extends TaskRefused_base {
+}
+declare const TaskMissing_base: Schema.Class<TaskMissing, Schema.TaggedStruct<"TaskMissing", {
+    readonly session: Schema.brand<Schema.String, "ConversationId">;
+    readonly taskId: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+export declare class TaskMissing extends TaskMissing_base {
+}
+export {};

package/dist/session/tasks.entity.js

@@ -0,0 +1,26 @@
+import { Schema } from "effect";
+import { ConversationId } from "../domain/message.entity.js";
+export const TaskMode = Schema.Literals(["fork", "spawn"]), TaskStatus = Schema.Literals(["pending", "running", "completed", "partial", "failed", "interrupted", "cancelled"]), TaskView = Schema.Struct({
+  taskId: ConversationId,
+  parent: ConversationId,
+  child: ConversationId,
+  instructions: Schema.String,
+  mode: TaskMode,
+  status: TaskStatus,
+  reply: Schema.OptionFromNullOr(Schema.String),
+  failure: Schema.OptionFromNullOr(Schema.Struct({ code: Schema.String, message: Schema.String })),
+  delivered: Schema.Boolean
+});
+
+export class TaskRefused extends Schema.TaggedError()("TaskRefused", {
+  session: ConversationId,
+  reason: Schema.Literals(["depth", "limit"]),
+  message: Schema.String
+}) {
+}
+
+export class TaskMissing extends Schema.TaggedError()("TaskMissing", {
+  session: ConversationId,
+  taskId: Schema.String
+}) {
+}

package/dist/session/turn-admission.open.adapter.d.ts

@@ -0,0 +1,4 @@
+import { Layer } from "effect";
+import { TurnAdmission } from "../ports/turn-admission.port.js";
+/** Every turn is admitted: for hosts without a budget. */
+export declare const TurnAdmissionOpen: Layer.Layer<TurnAdmission>;

package/dist/session/turn-admission.open.adapter.js

@@ -0,0 +1,3 @@
+import { Layer } from "effect";
+import { TurnAdmission } from "../ports/turn-admission.port.js";
+export const TurnAdmissionOpen = Layer.succeed(TurnAdmission, TurnAdmission.of({ admit: (_turn, open) => open }));

package/dist/spec/SpecDoc.d.ts

@@ -1,4 +1,4 @@
-import { Option, Schema } from "effect";
+import { Schema } from "effect";
 /**
  * The SPEC artifact of the spec-driven pipeline: a rough idea becomes a
  * SpecDoc (drafted by the refiner agent, refined WITH the human, LOCKED by
@@ -14,141 +14,54 @@ import { Option, Schema } from "effect";
  * `usecases/specCodec.ts` and round-trips deterministically.
  */
 /** Kebab-case spec identity — the file's basename, minted once. */
-export declare const SpecSlug: Schema.brand<Schema.filter<typeof Schema.String>, "SpecSlug">;
+export declare const SpecSlug: Schema.brand<Schema.String, "SpecSlug">;
 export type SpecSlug = typeof SpecSlug.Type;
-export declare const SpecStatus: Schema.Literal<["draft", "locked"]>;
+export declare const SpecStatus: Schema.Literals<readonly ["draft", "locked"]>;
 export type SpecStatus = typeof SpecStatus.Type;
-declare const SpecCheck_base: Schema.Class<SpecCheck, {
-    name: Schema.filter<typeof Schema.String>;
-    command: typeof Schema.NonEmptyString;
-}, Schema.Struct.Encoded<{
-    name: Schema.filter<typeof Schema.String>;
-    command: typeof Schema.NonEmptyString;
-}>, never, {
-    readonly name: string;
-} & {
-    readonly command: string;
-}, {}, {}>;
+declare const SpecCheck_base: Schema.Class<SpecCheck, Schema.Struct<{
+    readonly name: Schema.String;
+    readonly command: Schema.NonEmptyString;
+}>, {}>;
 /** A machine-checkable acceptance criterion: a named shell command that must
  *  exit 0. Drivers append one rank-2 command gate per check (`accept:<name>`). */
 export declare class SpecCheck extends SpecCheck_base {
 }
-declare const SpecLimits_base: Schema.Class<SpecLimits, {
-    maxAttempts: Schema.filter<typeof Schema.Int>;
-    budgetMinutes: typeof Schema.Positive;
-}, Schema.Struct.Encoded<{
-    maxAttempts: Schema.filter<typeof Schema.Int>;
-    budgetMinutes: typeof Schema.Positive;
-}>, never, {
-    readonly maxAttempts: number;
-} & {
-    readonly budgetMinutes: number;
-}, {}, {}>;
+declare const SpecLimits_base: Schema.Class<SpecLimits, Schema.Struct<{
+    readonly maxAttempts: Schema.Int;
+    readonly budgetMinutes: Schema.Number;
+}>, {}>;
 /** Forge-loop bounds (mirrors foundry's ForgeLimits, in human units). */
 export declare class SpecLimits extends SpecLimits_base {
 }
-declare const SpecGates_base: Schema.Class<SpecGates, {
-    config: Schema.optionalWith<typeof Schema.NonEmptyString, {
-        as: "Option";
-    }>;
-    testCommand: Schema.optionalWith<typeof Schema.NonEmptyString, {
-        as: "Option";
-    }>;
-    noTest: Schema.optionalWith<typeof Schema.Boolean, {
-        default: () => false;
-    }>;
+declare const SpecGates_base: Schema.Class<SpecGates, Schema.Struct<{
+    readonly config: Schema.OptionFromOptional<Schema.NonEmptyString>;
+    readonly testCommand: Schema.OptionFromOptional<Schema.NonEmptyString>;
+    readonly noTest: Schema.withConstructorDefault<Schema.withDecodingDefaultType<Schema.Boolean, never>>;
     /** The rank-4 LLM judge — ON by default; a spec opts out with `judge: false`. */
-    judge: Schema.optionalWith<typeof Schema.Boolean, {
-        default: () => true;
-    }>;
-}, Schema.Struct.Encoded<{
-    config: Schema.optionalWith<typeof Schema.NonEmptyString, {
-        as: "Option";
-    }>;
-    testCommand: Schema.optionalWith<typeof Schema.NonEmptyString, {
-        as: "Option";
-    }>;
-    noTest: Schema.optionalWith<typeof Schema.Boolean, {
-        default: () => false;
-    }>;
-    /** The rank-4 LLM judge — ON by default; a spec opts out with `judge: false`. */
-    judge: Schema.optionalWith<typeof Schema.Boolean, {
-        default: () => true;
-    }>;
-}>, never, {
-    readonly config: Option.Option<string>;
-} & {
-    readonly testCommand: Option.Option<string>;
-} & {
-    readonly noTest?: boolean;
-} & {
-    readonly judge?: boolean;
-}, {}, {}>;
+    readonly judge: Schema.withConstructorDefault<Schema.withDecodingDefaultType<Schema.Boolean, never>>;
+}>, {}>;
 /** Gate-suite selection overrides; absent fields fall through to the driver's
  *  workspace discovery (precedence: CLI flags > these > discovery). */
 export declare class SpecGates extends SpecGates_base {
 }
-declare const SpecDoc_base: Schema.Class<SpecDoc, {
-    slug: Schema.brand<Schema.filter<typeof Schema.String>, "SpecSlug">;
-    status: Schema.Literal<["draft", "locked"]>;
-    /** ISO timestamps — strings on purpose (stable round-trip, no Date drift). */
-    created: typeof Schema.NonEmptyString;
-    locked: Schema.optionalWith<typeof Schema.NonEmptyString, {
-        as: "Option";
-    }>;
-    /** One imperative paragraph — becomes foundry `Spec.goal`. */
-    goal: typeof Schema.NonEmptyString;
-    /** Rendered verbatim into the implementor brief; also foundry `Spec.acceptance`. */
-    acceptance: Schema.Array$<typeof Schema.NonEmptyString>;
-    /** Hard boundaries for the implementor (brief-only; never enter foundry's Spec). */
-    constraints: Schema.Array$<typeof Schema.NonEmptyString>;
-    /** Explicit scope fences (brief-only). */
-    nonGoals: Schema.Array$<typeof Schema.NonEmptyString>;
-    checks: Schema.Array$<typeof SpecCheck>;
-    limits: typeof SpecLimits;
-    gates: typeof SpecGates;
-}, Schema.Struct.Encoded<{
-    slug: Schema.brand<Schema.filter<typeof Schema.String>, "SpecSlug">;
-    status: Schema.Literal<["draft", "locked"]>;
+declare const SpecDoc_base: Schema.Class<SpecDoc, Schema.Struct<{
+    readonly slug: Schema.brand<Schema.String, "SpecSlug">;
+    readonly status: Schema.Literals<readonly ["draft", "locked"]>;
     /** ISO timestamps — strings on purpose (stable round-trip, no Date drift). */
-    created: typeof Schema.NonEmptyString;
-    locked: Schema.optionalWith<typeof Schema.NonEmptyString, {
-        as: "Option";
-    }>;
+    readonly created: Schema.NonEmptyString;
+    readonly locked: Schema.OptionFromOptional<Schema.NonEmptyString>;
     /** One imperative paragraph — becomes foundry `Spec.goal`. */
-    goal: typeof Schema.NonEmptyString;
+    readonly goal: Schema.NonEmptyString;
     /** Rendered verbatim into the implementor brief; also foundry `Spec.acceptance`. */
-    acceptance: Schema.Array$<typeof Schema.NonEmptyString>;
+    readonly acceptance: Schema.$Array<Schema.NonEmptyString>;
     /** Hard boundaries for the implementor (brief-only; never enter foundry's Spec). */
-    constraints: Schema.Array$<typeof Schema.NonEmptyString>;
+    readonly constraints: Schema.$Array<Schema.NonEmptyString>;
     /** Explicit scope fences (brief-only). */
-    nonGoals: Schema.Array$<typeof Schema.NonEmptyString>;
-    checks: Schema.Array$<typeof SpecCheck>;
-    limits: typeof SpecLimits;
-    gates: typeof SpecGates;
-}>, never, {
-    readonly status: "draft" | "locked";
-} & {
-    readonly locked: Option.Option<string>;
-} & {
-    readonly slug: string & import("effect/Brand").Brand<"SpecSlug">;
-} & {
-    readonly created: string;
-} & {
-    readonly goal: string;
-} & {
-    readonly limits: SpecLimits;
-} & {
-    readonly gates: SpecGates;
-} & {
-    readonly acceptance: readonly string[];
-} & {
-    readonly constraints: readonly string[];
-} & {
-    readonly nonGoals: readonly string[];
-} & {
-    readonly checks: readonly SpecCheck[];
-}, {}, {}>;
+    readonly nonGoals: Schema.$Array<Schema.NonEmptyString>;
+    readonly checks: Schema.$Array<typeof SpecCheck>;
+    readonly limits: typeof SpecLimits;
+    readonly gates: typeof SpecGates;
+}>, {}>;
 export declare class SpecDoc extends SpecDoc_base {
 }
 export declare const DEFAULT_SPEC_LIMITS: SpecLimits;

package/dist/spec/SpecDoc.js

@@ -1,23 +1,23 @@
-import { Option, Schema } from "effect";
-export const SpecSlug = Schema.String.pipe(Schema.pattern(/^[a-z0-9][a-z0-9-]*$/), Schema.brand("SpecSlug")), SpecStatus = Schema.Literal("draft", "locked");
+import { Option, Schema, Effect } from "effect";
+export const SpecSlug = Schema.String.pipe(Schema.check(Schema.isPattern(/^[a-z0-9][a-z0-9-]*$/)), Schema.brand("SpecSlug")), SpecStatus = Schema.Literals(["draft", "locked"]);
 
 export class SpecCheck extends Schema.Class("SpecCheck")({
-  name: Schema.String.pipe(Schema.pattern(/^[a-z0-9][a-z0-9-]*$/)),
+  name: Schema.String.pipe(Schema.check(Schema.isPattern(/^[a-z0-9][a-z0-9-]*$/))),
   command: Schema.NonEmptyString
 }) {
 }
 
 export class SpecLimits extends Schema.Class("SpecLimits")({
-  maxAttempts: Schema.Int.pipe(Schema.between(1, 10)),
-  budgetMinutes: Schema.Positive
+  maxAttempts: Schema.Int.pipe(Schema.check(Schema.isBetween({ minimum: 1, maximum: 10 }))),
+  budgetMinutes: Schema.Number.check(Schema.isGreaterThan(0))
 }) {
 }
 
 export class SpecGates extends Schema.Class("SpecGates")({
-  config: Schema.optionalWith(Schema.NonEmptyString, { as: "Option" }),
-  testCommand: Schema.optionalWith(Schema.NonEmptyString, { as: "Option" }),
-  noTest: Schema.optionalWith(Schema.Boolean, { default: () => !1 }),
-  judge: Schema.optionalWith(Schema.Boolean, { default: () => !0 })
+  config: Schema.OptionFromOptional(Schema.NonEmptyString),
+  testCommand: Schema.OptionFromOptional(Schema.NonEmptyString),
+  noTest: Schema.Boolean.pipe(Schema.withDecodingDefaultType(Effect.sync(() => !1)), Schema.withConstructorDefault(Effect.sync(() => !1))),
+  judge: Schema.Boolean.pipe(Schema.withDecodingDefaultType(Effect.sync(() => !0)), Schema.withConstructorDefault(Effect.sync(() => !0)))
 }) {
 }
 
@@ -25,7 +25,7 @@ export class SpecDoc extends Schema.Class("SpecDoc")({
   slug: SpecSlug,
   status: SpecStatus,
   created: Schema.NonEmptyString,
-  locked: Schema.optionalWith(Schema.NonEmptyString, { as: "Option" }),
+  locked: Schema.OptionFromOptional(Schema.NonEmptyString),
   goal: Schema.NonEmptyString,
   acceptance: Schema.Array(Schema.NonEmptyString),
   constraints: Schema.Array(Schema.NonEmptyString),

package/dist/spec/codec.js

@@ -88,7 +88,7 @@ export const decodeSpecDocText = (slug, text) => Effect.gen(function* () {
       ...fields.judge !== void 0 ? { judge: fields.judge === "true" } : {}
     }
   };
-  return yield* Schema.decodeUnknown(SpecDoc)(candidate).pipe(Effect.mapError((error) => new SpecDocParseError({ message: String(error) })));
+  return yield* Schema.decodeUnknownEffect(SpecDoc)(candidate, { reportInput: !0 }).pipe(Effect.mapError((error) => new SpecDocParseError({ message: String(error) })));
 }), normalizeBullet = (text) => text.replace(/\s+/g, " ").trim(), encodeSpecDocText = (doc) => {
   const frontmatter = [
     "---",